From 0ac4c706e5c3f4f79bf4088da757461a763217d0 Mon Sep 17 00:00:00 2001 From: mame82 Date: Sun, 13 May 2018 20:50:55 +0000 Subject: [PATCH] Added in gRPC-web support and boilerplate code for a client --- P4wnP1_service.go | 2 +- b_proto.sh | 5 + cli_client/cmd_usb.go | 3 +- install.sh | 3 + proto/gopherjs/grpc.pb.gopherjs.go | 1515 ++ service/rpc_server.go | 104 + web_client/build.sh | 4 + web_client/deps.sh | 4 + web_client/index.html | 8 + web_client/install.sh | 9 + web_client/main.go | 42 + www/README.md | 2 + www/index.html | 11 + www/webapp.js | 30006 +++++++++++++++++++++++++++ www/webapp.js.map | 1 + 15 files changed, 31716 insertions(+), 3 deletions(-) create mode 100644 proto/gopherjs/grpc.pb.gopherjs.go create mode 100755 web_client/build.sh create mode 100755 web_client/deps.sh create mode 100644 web_client/index.html create mode 100755 web_client/install.sh create mode 100644 web_client/main.go create mode 100644 www/README.md create mode 100644 www/index.html create mode 100644 www/webapp.js create mode 100644 www/webapp.js.map diff --git a/P4wnP1_service.go b/P4wnP1_service.go index 7930123..60c9284 100644 --- a/P4wnP1_service.go +++ b/P4wnP1_service.go @@ -40,5 +40,5 @@ func main() { service.InitLed(false) //Set LED to manual trigger service.InitDefaultLEDSettings() - service.StartRpcServer("", "50051") //start gRPC service + service.StartRpcServerAndWeb("0.0.0.0", "50051") //start gRPC service } diff --git a/b_proto.sh b/b_proto.sh index 37a3dda..dbd5e6b 100755 --- a/b_proto.sh +++ b/b_proto.sh @@ -1,2 +1,7 @@ #!/bin/bash +# golang version protoc -I proto/ proto/grpc.proto --go_out=plugins=grpc:proto + +# gopherjs version +protoc -I proto/ proto/grpc.proto --gopherjs_out=plugins=grpc:proto/gopherjs + diff --git a/cli_client/cmd_usb.go b/cli_client/cmd_usb.go index b27006e..48f3e1f 100644 --- a/cli_client/cmd_usb.go +++ b/cli_client/cmd_usb.go @@ -144,7 +144,6 @@ func cobraUsbSet(cmd *cobra.Command, args []string) { } } - //ToDo: Implement detailed UMS settings if (cmd.Flags().Lookup("ums").Changed) { if tmpUseUMS == 0 { fmt.Println("Disabeling USB Mass Storage") @@ -171,9 +170,9 @@ func cobraUsbSet(cmd *cobra.Command, args []string) { //Try to set the change config - //ToDo: Adopt parsing of Error Message to other gRPC calls err = ClientSetGadgetSettings(StrRemoteHost, StrRemotePort, *gs) if err != nil { + //ToDo: Adopt parsing of Error Message to other gRPC calls log.Printf("Error setting new gadget settings: %v\n", status.Convert(err).Message()) return } diff --git a/install.sh b/install.sh index f826348..9960764 100755 --- a/install.sh +++ b/install.sh @@ -6,3 +6,6 @@ export PATH=$PATH:/usr/local/go/bin # put into ~/.profile echo export PATH=$PATH:/usr/local/go/bin >> ~/.profile sudo bash -c 'echo export PATH=\$PATH:/usr/local/go/bin >> ~/.profile' go get google.golang.org/grpc + +go get -u github.com/improbable-eng/grpc-web/go/grpcweb +go get -u github.com/gorilla/websocket \ No newline at end of file diff --git a/proto/gopherjs/grpc.pb.gopherjs.go b/proto/gopherjs/grpc.pb.gopherjs.go new file mode 100644 index 0000000..53ca281 --- /dev/null +++ b/proto/gopherjs/grpc.pb.gopherjs.go @@ -0,0 +1,1515 @@ +// Code generated by protoc-gen-gopherjs. DO NOT EDIT. +// source: grpc.proto + +/* + Package P4wnP1_grpc is a generated protocol buffer package. + + It is generated from these files: + grpc.proto + + It has these top-level messages: + LEDSettings + GadgetSettings + GadgetSettingsEthernet + GadgetSettingsUMS + EthernetInterfaceSettings + DHCPServerSettings + DHCPServerRange + DHCPServerStaticHost + WiFiSettings + Empty +*/ +package P4wnP1_grpc + +import jspb "github.com/johanbrandhorst/protobuf/jspb" + +import ( + context "context" + + grpcweb "github.com/johanbrandhorst/protobuf/grpcweb" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the jspb package it is being compiled against. +const _ = jspb.JspbPackageIsVersion2 + +type EthernetInterfaceSettings_Mode int + +const ( + EthernetInterfaceSettings_MANUAL EthernetInterfaceSettings_Mode = 0 + EthernetInterfaceSettings_DHCP_CLIENT EthernetInterfaceSettings_Mode = 1 + EthernetInterfaceSettings_DHCP_SERVER EthernetInterfaceSettings_Mode = 2 +) + +var EthernetInterfaceSettings_Mode_name = map[int]string{ + 0: "MANUAL", + 1: "DHCP_CLIENT", + 2: "DHCP_SERVER", +} +var EthernetInterfaceSettings_Mode_value = map[string]int{ + "MANUAL": 0, + "DHCP_CLIENT": 1, + "DHCP_SERVER": 2, +} + +func (x EthernetInterfaceSettings_Mode) String() string { + return EthernetInterfaceSettings_Mode_name[int(x)] +} + +type WiFiSettings_Mode int + +const ( + WiFiSettings_AP WiFiSettings_Mode = 0 + WiFiSettings_STA WiFiSettings_Mode = 1 + WiFiSettings_STA_FAILOVER_AP WiFiSettings_Mode = 2 +) + +var WiFiSettings_Mode_name = map[int]string{ + 0: "AP", + 1: "STA", + 2: "STA_FAILOVER_AP", +} +var WiFiSettings_Mode_value = map[string]int{ + "AP": 0, + "STA": 1, + "STA_FAILOVER_AP": 2, +} + +func (x WiFiSettings_Mode) String() string { + return WiFiSettings_Mode_name[int(x)] +} + +type WiFiSettings_APAuthMode int + +const ( + WiFiSettings_WPA2_PSK WiFiSettings_APAuthMode = 0 + WiFiSettings_OPEN WiFiSettings_APAuthMode = 1 +) + +var WiFiSettings_APAuthMode_name = map[int]string{ + 0: "WPA2_PSK", + 1: "OPEN", +} +var WiFiSettings_APAuthMode_value = map[string]int{ + "WPA2_PSK": 0, + "OPEN": 1, +} + +func (x WiFiSettings_APAuthMode) String() string { + return WiFiSettings_APAuthMode_name[int(x)] +} + +// LED +type LEDSettings struct { + BlinkCount uint32 +} + +// GetBlinkCount gets the BlinkCount of the LEDSettings. +func (m *LEDSettings) GetBlinkCount() (x uint32) { + if m == nil { + return x + } + return m.BlinkCount +} + +// MarshalToWriter marshals LEDSettings to the provided writer. +func (m *LEDSettings) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if m.BlinkCount != 0 { + writer.WriteUint32(1, m.BlinkCount) + } + + return +} + +// Marshal marshals LEDSettings to a slice of bytes. +func (m *LEDSettings) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a LEDSettings from the provided reader. +func (m *LEDSettings) UnmarshalFromReader(reader jspb.Reader) *LEDSettings { + for reader.Next() { + if m == nil { + m = &LEDSettings{} + } + + switch reader.GetFieldNumber() { + case 1: + m.BlinkCount = reader.ReadUint32() + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a LEDSettings from a slice of bytes. +func (m *LEDSettings) Unmarshal(rawBytes []byte) (*LEDSettings, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +// USB Gadget +type GadgetSettings struct { + Enabled bool + Vid string + Pid string + Manufacturer string + Product string + Serial string + Use_CDC_ECM bool + Use_RNDIS bool + Use_HID_KEYBOARD bool + Use_HID_MOUSE bool + Use_HID_RAW bool + Use_UMS bool + Use_SERIAL bool + RndisSettings *GadgetSettingsEthernet + CdcEcmSettings *GadgetSettingsEthernet + UmsSettings *GadgetSettingsUMS +} + +// GetEnabled gets the Enabled of the GadgetSettings. +func (m *GadgetSettings) GetEnabled() (x bool) { + if m == nil { + return x + } + return m.Enabled +} + +// GetVid gets the Vid of the GadgetSettings. +func (m *GadgetSettings) GetVid() (x string) { + if m == nil { + return x + } + return m.Vid +} + +// GetPid gets the Pid of the GadgetSettings. +func (m *GadgetSettings) GetPid() (x string) { + if m == nil { + return x + } + return m.Pid +} + +// GetManufacturer gets the Manufacturer of the GadgetSettings. +func (m *GadgetSettings) GetManufacturer() (x string) { + if m == nil { + return x + } + return m.Manufacturer +} + +// GetProduct gets the Product of the GadgetSettings. +func (m *GadgetSettings) GetProduct() (x string) { + if m == nil { + return x + } + return m.Product +} + +// GetSerial gets the Serial of the GadgetSettings. +func (m *GadgetSettings) GetSerial() (x string) { + if m == nil { + return x + } + return m.Serial +} + +// GetUse_CDC_ECM gets the Use_CDC_ECM of the GadgetSettings. +func (m *GadgetSettings) GetUse_CDC_ECM() (x bool) { + if m == nil { + return x + } + return m.Use_CDC_ECM +} + +// GetUse_RNDIS gets the Use_RNDIS of the GadgetSettings. +func (m *GadgetSettings) GetUse_RNDIS() (x bool) { + if m == nil { + return x + } + return m.Use_RNDIS +} + +// GetUse_HID_KEYBOARD gets the Use_HID_KEYBOARD of the GadgetSettings. +func (m *GadgetSettings) GetUse_HID_KEYBOARD() (x bool) { + if m == nil { + return x + } + return m.Use_HID_KEYBOARD +} + +// GetUse_HID_MOUSE gets the Use_HID_MOUSE of the GadgetSettings. +func (m *GadgetSettings) GetUse_HID_MOUSE() (x bool) { + if m == nil { + return x + } + return m.Use_HID_MOUSE +} + +// GetUse_HID_RAW gets the Use_HID_RAW of the GadgetSettings. +func (m *GadgetSettings) GetUse_HID_RAW() (x bool) { + if m == nil { + return x + } + return m.Use_HID_RAW +} + +// GetUse_UMS gets the Use_UMS of the GadgetSettings. +func (m *GadgetSettings) GetUse_UMS() (x bool) { + if m == nil { + return x + } + return m.Use_UMS +} + +// GetUse_SERIAL gets the Use_SERIAL of the GadgetSettings. +func (m *GadgetSettings) GetUse_SERIAL() (x bool) { + if m == nil { + return x + } + return m.Use_SERIAL +} + +// GetRndisSettings gets the RndisSettings of the GadgetSettings. +func (m *GadgetSettings) GetRndisSettings() (x *GadgetSettingsEthernet) { + if m == nil { + return x + } + return m.RndisSettings +} + +// GetCdcEcmSettings gets the CdcEcmSettings of the GadgetSettings. +func (m *GadgetSettings) GetCdcEcmSettings() (x *GadgetSettingsEthernet) { + if m == nil { + return x + } + return m.CdcEcmSettings +} + +// GetUmsSettings gets the UmsSettings of the GadgetSettings. +func (m *GadgetSettings) GetUmsSettings() (x *GadgetSettingsUMS) { + if m == nil { + return x + } + return m.UmsSettings +} + +// MarshalToWriter marshals GadgetSettings to the provided writer. +func (m *GadgetSettings) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if m.Enabled { + writer.WriteBool(1, m.Enabled) + } + + if len(m.Vid) > 0 { + writer.WriteString(2, m.Vid) + } + + if len(m.Pid) > 0 { + writer.WriteString(3, m.Pid) + } + + if len(m.Manufacturer) > 0 { + writer.WriteString(4, m.Manufacturer) + } + + if len(m.Product) > 0 { + writer.WriteString(5, m.Product) + } + + if len(m.Serial) > 0 { + writer.WriteString(6, m.Serial) + } + + if m.Use_CDC_ECM { + writer.WriteBool(7, m.Use_CDC_ECM) + } + + if m.Use_RNDIS { + writer.WriteBool(8, m.Use_RNDIS) + } + + if m.Use_HID_KEYBOARD { + writer.WriteBool(9, m.Use_HID_KEYBOARD) + } + + if m.Use_HID_MOUSE { + writer.WriteBool(10, m.Use_HID_MOUSE) + } + + if m.Use_HID_RAW { + writer.WriteBool(11, m.Use_HID_RAW) + } + + if m.Use_UMS { + writer.WriteBool(12, m.Use_UMS) + } + + if m.Use_SERIAL { + writer.WriteBool(13, m.Use_SERIAL) + } + + if m.RndisSettings != nil { + writer.WriteMessage(14, func() { + m.RndisSettings.MarshalToWriter(writer) + }) + } + + if m.CdcEcmSettings != nil { + writer.WriteMessage(15, func() { + m.CdcEcmSettings.MarshalToWriter(writer) + }) + } + + if m.UmsSettings != nil { + writer.WriteMessage(16, func() { + m.UmsSettings.MarshalToWriter(writer) + }) + } + + return +} + +// Marshal marshals GadgetSettings to a slice of bytes. +func (m *GadgetSettings) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a GadgetSettings from the provided reader. +func (m *GadgetSettings) UnmarshalFromReader(reader jspb.Reader) *GadgetSettings { + for reader.Next() { + if m == nil { + m = &GadgetSettings{} + } + + switch reader.GetFieldNumber() { + case 1: + m.Enabled = reader.ReadBool() + case 2: + m.Vid = reader.ReadString() + case 3: + m.Pid = reader.ReadString() + case 4: + m.Manufacturer = reader.ReadString() + case 5: + m.Product = reader.ReadString() + case 6: + m.Serial = reader.ReadString() + case 7: + m.Use_CDC_ECM = reader.ReadBool() + case 8: + m.Use_RNDIS = reader.ReadBool() + case 9: + m.Use_HID_KEYBOARD = reader.ReadBool() + case 10: + m.Use_HID_MOUSE = reader.ReadBool() + case 11: + m.Use_HID_RAW = reader.ReadBool() + case 12: + m.Use_UMS = reader.ReadBool() + case 13: + m.Use_SERIAL = reader.ReadBool() + case 14: + reader.ReadMessage(func() { + m.RndisSettings = m.RndisSettings.UnmarshalFromReader(reader) + }) + case 15: + reader.ReadMessage(func() { + m.CdcEcmSettings = m.CdcEcmSettings.UnmarshalFromReader(reader) + }) + case 16: + reader.ReadMessage(func() { + m.UmsSettings = m.UmsSettings.UnmarshalFromReader(reader) + }) + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a GadgetSettings from a slice of bytes. +func (m *GadgetSettings) Unmarshal(rawBytes []byte) (*GadgetSettings, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +type GadgetSettingsEthernet struct { + HostAddr string + DevAddr string +} + +// GetHostAddr gets the HostAddr of the GadgetSettingsEthernet. +func (m *GadgetSettingsEthernet) GetHostAddr() (x string) { + if m == nil { + return x + } + return m.HostAddr +} + +// GetDevAddr gets the DevAddr of the GadgetSettingsEthernet. +func (m *GadgetSettingsEthernet) GetDevAddr() (x string) { + if m == nil { + return x + } + return m.DevAddr +} + +// MarshalToWriter marshals GadgetSettingsEthernet to the provided writer. +func (m *GadgetSettingsEthernet) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if len(m.HostAddr) > 0 { + writer.WriteString(1, m.HostAddr) + } + + if len(m.DevAddr) > 0 { + writer.WriteString(2, m.DevAddr) + } + + return +} + +// Marshal marshals GadgetSettingsEthernet to a slice of bytes. +func (m *GadgetSettingsEthernet) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a GadgetSettingsEthernet from the provided reader. +func (m *GadgetSettingsEthernet) UnmarshalFromReader(reader jspb.Reader) *GadgetSettingsEthernet { + for reader.Next() { + if m == nil { + m = &GadgetSettingsEthernet{} + } + + switch reader.GetFieldNumber() { + case 1: + m.HostAddr = reader.ReadString() + case 2: + m.DevAddr = reader.ReadString() + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a GadgetSettingsEthernet from a slice of bytes. +func (m *GadgetSettingsEthernet) Unmarshal(rawBytes []byte) (*GadgetSettingsEthernet, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +type GadgetSettingsUMS struct { + Cdrom bool + File string +} + +// GetCdrom gets the Cdrom of the GadgetSettingsUMS. +func (m *GadgetSettingsUMS) GetCdrom() (x bool) { + if m == nil { + return x + } + return m.Cdrom +} + +// GetFile gets the File of the GadgetSettingsUMS. +func (m *GadgetSettingsUMS) GetFile() (x string) { + if m == nil { + return x + } + return m.File +} + +// MarshalToWriter marshals GadgetSettingsUMS to the provided writer. +func (m *GadgetSettingsUMS) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if m.Cdrom { + writer.WriteBool(1, m.Cdrom) + } + + if len(m.File) > 0 { + writer.WriteString(2, m.File) + } + + return +} + +// Marshal marshals GadgetSettingsUMS to a slice of bytes. +func (m *GadgetSettingsUMS) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a GadgetSettingsUMS from the provided reader. +func (m *GadgetSettingsUMS) UnmarshalFromReader(reader jspb.Reader) *GadgetSettingsUMS { + for reader.Next() { + if m == nil { + m = &GadgetSettingsUMS{} + } + + switch reader.GetFieldNumber() { + case 1: + m.Cdrom = reader.ReadBool() + case 2: + m.File = reader.ReadString() + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a GadgetSettingsUMS from a slice of bytes. +func (m *GadgetSettingsUMS) Unmarshal(rawBytes []byte) (*GadgetSettingsUMS, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +type EthernetInterfaceSettings struct { + Name string + Mode EthernetInterfaceSettings_Mode + IpAddress4 string + Netmask4 string + Enabled bool + DhcpServerSettings *DHCPServerSettings +} + +// GetName gets the Name of the EthernetInterfaceSettings. +func (m *EthernetInterfaceSettings) GetName() (x string) { + if m == nil { + return x + } + return m.Name +} + +// GetMode gets the Mode of the EthernetInterfaceSettings. +func (m *EthernetInterfaceSettings) GetMode() (x EthernetInterfaceSettings_Mode) { + if m == nil { + return x + } + return m.Mode +} + +// GetIpAddress4 gets the IpAddress4 of the EthernetInterfaceSettings. +func (m *EthernetInterfaceSettings) GetIpAddress4() (x string) { + if m == nil { + return x + } + return m.IpAddress4 +} + +// GetNetmask4 gets the Netmask4 of the EthernetInterfaceSettings. +func (m *EthernetInterfaceSettings) GetNetmask4() (x string) { + if m == nil { + return x + } + return m.Netmask4 +} + +// GetEnabled gets the Enabled of the EthernetInterfaceSettings. +func (m *EthernetInterfaceSettings) GetEnabled() (x bool) { + if m == nil { + return x + } + return m.Enabled +} + +// GetDhcpServerSettings gets the DhcpServerSettings of the EthernetInterfaceSettings. +func (m *EthernetInterfaceSettings) GetDhcpServerSettings() (x *DHCPServerSettings) { + if m == nil { + return x + } + return m.DhcpServerSettings +} + +// MarshalToWriter marshals EthernetInterfaceSettings to the provided writer. +func (m *EthernetInterfaceSettings) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if len(m.Name) > 0 { + writer.WriteString(1, m.Name) + } + + if int(m.Mode) != 0 { + writer.WriteEnum(2, int(m.Mode)) + } + + if len(m.IpAddress4) > 0 { + writer.WriteString(3, m.IpAddress4) + } + + if len(m.Netmask4) > 0 { + writer.WriteString(4, m.Netmask4) + } + + if m.Enabled { + writer.WriteBool(5, m.Enabled) + } + + if m.DhcpServerSettings != nil { + writer.WriteMessage(6, func() { + m.DhcpServerSettings.MarshalToWriter(writer) + }) + } + + return +} + +// Marshal marshals EthernetInterfaceSettings to a slice of bytes. +func (m *EthernetInterfaceSettings) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a EthernetInterfaceSettings from the provided reader. +func (m *EthernetInterfaceSettings) UnmarshalFromReader(reader jspb.Reader) *EthernetInterfaceSettings { + for reader.Next() { + if m == nil { + m = &EthernetInterfaceSettings{} + } + + switch reader.GetFieldNumber() { + case 1: + m.Name = reader.ReadString() + case 2: + m.Mode = EthernetInterfaceSettings_Mode(reader.ReadEnum()) + case 3: + m.IpAddress4 = reader.ReadString() + case 4: + m.Netmask4 = reader.ReadString() + case 5: + m.Enabled = reader.ReadBool() + case 6: + reader.ReadMessage(func() { + m.DhcpServerSettings = m.DhcpServerSettings.UnmarshalFromReader(reader) + }) + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a EthernetInterfaceSettings from a slice of bytes. +func (m *EthernetInterfaceSettings) Unmarshal(rawBytes []byte) (*EthernetInterfaceSettings, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +// DHCP +type DHCPServerSettings struct { + ListenPort uint32 + ListenInterface string + LeaseFile string + NotAuthoritative bool + DoNotBindInterface bool + CallbackScript string + Ranges []*DHCPServerRange + // repeated DHCPServerOption options = 8; + Options map[uint32]string + StaticHosts []*DHCPServerStaticHost +} + +// GetListenPort gets the ListenPort of the DHCPServerSettings. +func (m *DHCPServerSettings) GetListenPort() (x uint32) { + if m == nil { + return x + } + return m.ListenPort +} + +// GetListenInterface gets the ListenInterface of the DHCPServerSettings. +func (m *DHCPServerSettings) GetListenInterface() (x string) { + if m == nil { + return x + } + return m.ListenInterface +} + +// GetLeaseFile gets the LeaseFile of the DHCPServerSettings. +func (m *DHCPServerSettings) GetLeaseFile() (x string) { + if m == nil { + return x + } + return m.LeaseFile +} + +// GetNotAuthoritative gets the NotAuthoritative of the DHCPServerSettings. +func (m *DHCPServerSettings) GetNotAuthoritative() (x bool) { + if m == nil { + return x + } + return m.NotAuthoritative +} + +// GetDoNotBindInterface gets the DoNotBindInterface of the DHCPServerSettings. +func (m *DHCPServerSettings) GetDoNotBindInterface() (x bool) { + if m == nil { + return x + } + return m.DoNotBindInterface +} + +// GetCallbackScript gets the CallbackScript of the DHCPServerSettings. +func (m *DHCPServerSettings) GetCallbackScript() (x string) { + if m == nil { + return x + } + return m.CallbackScript +} + +// GetRanges gets the Ranges of the DHCPServerSettings. +func (m *DHCPServerSettings) GetRanges() (x []*DHCPServerRange) { + if m == nil { + return x + } + return m.Ranges +} + +// GetOptions gets the Options of the DHCPServerSettings. +func (m *DHCPServerSettings) GetOptions() (x map[uint32]string) { + if m == nil { + return x + } + return m.Options +} + +// GetStaticHosts gets the StaticHosts of the DHCPServerSettings. +func (m *DHCPServerSettings) GetStaticHosts() (x []*DHCPServerStaticHost) { + if m == nil { + return x + } + return m.StaticHosts +} + +// MarshalToWriter marshals DHCPServerSettings to the provided writer. +func (m *DHCPServerSettings) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if m.ListenPort != 0 { + writer.WriteUint32(1, m.ListenPort) + } + + if len(m.ListenInterface) > 0 { + writer.WriteString(2, m.ListenInterface) + } + + if len(m.LeaseFile) > 0 { + writer.WriteString(3, m.LeaseFile) + } + + if m.NotAuthoritative { + writer.WriteBool(4, m.NotAuthoritative) + } + + if m.DoNotBindInterface { + writer.WriteBool(5, m.DoNotBindInterface) + } + + if len(m.CallbackScript) > 0 { + writer.WriteString(6, m.CallbackScript) + } + + for _, msg := range m.Ranges { + writer.WriteMessage(7, func() { + msg.MarshalToWriter(writer) + }) + } + + if len(m.Options) > 0 { + for key, value := range m.Options { + writer.WriteMessage(8, func() { + writer.WriteUint32(1, key) + writer.WriteString(2, value) + }) + } + } + + for _, msg := range m.StaticHosts { + writer.WriteMessage(9, func() { + msg.MarshalToWriter(writer) + }) + } + + return +} + +// Marshal marshals DHCPServerSettings to a slice of bytes. +func (m *DHCPServerSettings) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a DHCPServerSettings from the provided reader. +func (m *DHCPServerSettings) UnmarshalFromReader(reader jspb.Reader) *DHCPServerSettings { + for reader.Next() { + if m == nil { + m = &DHCPServerSettings{} + } + + switch reader.GetFieldNumber() { + case 1: + m.ListenPort = reader.ReadUint32() + case 2: + m.ListenInterface = reader.ReadString() + case 3: + m.LeaseFile = reader.ReadString() + case 4: + m.NotAuthoritative = reader.ReadBool() + case 5: + m.DoNotBindInterface = reader.ReadBool() + case 6: + m.CallbackScript = reader.ReadString() + case 7: + reader.ReadMessage(func() { + m.Ranges = append(m.Ranges, new(DHCPServerRange).UnmarshalFromReader(reader)) + }) + case 8: + if m.Options == nil { + m.Options = map[uint32]string{} + } + reader.ReadMessage(func() { + var key uint32 + var value string + for reader.Next() { + switch reader.GetFieldNumber() { + case 1: + key = reader.ReadUint32() + case 2: + value = reader.ReadString() + } + m.Options[key] = value + } + }) + case 9: + reader.ReadMessage(func() { + m.StaticHosts = append(m.StaticHosts, new(DHCPServerStaticHost).UnmarshalFromReader(reader)) + }) + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a DHCPServerSettings from a slice of bytes. +func (m *DHCPServerSettings) Unmarshal(rawBytes []byte) (*DHCPServerSettings, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +// Could be used for IPv4 or IPv6 (refer dnsmasq docs), nor field for prefix length (default is 64) +type DHCPServerRange struct { + RangeLower string + RangeUpper string + LeaseTime string +} + +// GetRangeLower gets the RangeLower of the DHCPServerRange. +func (m *DHCPServerRange) GetRangeLower() (x string) { + if m == nil { + return x + } + return m.RangeLower +} + +// GetRangeUpper gets the RangeUpper of the DHCPServerRange. +func (m *DHCPServerRange) GetRangeUpper() (x string) { + if m == nil { + return x + } + return m.RangeUpper +} + +// GetLeaseTime gets the LeaseTime of the DHCPServerRange. +func (m *DHCPServerRange) GetLeaseTime() (x string) { + if m == nil { + return x + } + return m.LeaseTime +} + +// MarshalToWriter marshals DHCPServerRange to the provided writer. +func (m *DHCPServerRange) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if len(m.RangeLower) > 0 { + writer.WriteString(1, m.RangeLower) + } + + if len(m.RangeUpper) > 0 { + writer.WriteString(2, m.RangeUpper) + } + + if len(m.LeaseTime) > 0 { + writer.WriteString(3, m.LeaseTime) + } + + return +} + +// Marshal marshals DHCPServerRange to a slice of bytes. +func (m *DHCPServerRange) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a DHCPServerRange from the provided reader. +func (m *DHCPServerRange) UnmarshalFromReader(reader jspb.Reader) *DHCPServerRange { + for reader.Next() { + if m == nil { + m = &DHCPServerRange{} + } + + switch reader.GetFieldNumber() { + case 1: + m.RangeLower = reader.ReadString() + case 2: + m.RangeUpper = reader.ReadString() + case 3: + m.LeaseTime = reader.ReadString() + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a DHCPServerRange from a slice of bytes. +func (m *DHCPServerRange) Unmarshal(rawBytes []byte) (*DHCPServerRange, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +// Used for static leases +type DHCPServerStaticHost struct { + Mac string + Ip string +} + +// GetMac gets the Mac of the DHCPServerStaticHost. +func (m *DHCPServerStaticHost) GetMac() (x string) { + if m == nil { + return x + } + return m.Mac +} + +// GetIp gets the Ip of the DHCPServerStaticHost. +func (m *DHCPServerStaticHost) GetIp() (x string) { + if m == nil { + return x + } + return m.Ip +} + +// MarshalToWriter marshals DHCPServerStaticHost to the provided writer. +func (m *DHCPServerStaticHost) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if len(m.Mac) > 0 { + writer.WriteString(1, m.Mac) + } + + if len(m.Ip) > 0 { + writer.WriteString(2, m.Ip) + } + + return +} + +// Marshal marshals DHCPServerStaticHost to a slice of bytes. +func (m *DHCPServerStaticHost) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a DHCPServerStaticHost from the provided reader. +func (m *DHCPServerStaticHost) UnmarshalFromReader(reader jspb.Reader) *DHCPServerStaticHost { + for reader.Next() { + if m == nil { + m = &DHCPServerStaticHost{} + } + + switch reader.GetFieldNumber() { + case 1: + m.Mac = reader.ReadString() + case 2: + m.Ip = reader.ReadString() + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a DHCPServerStaticHost from a slice of bytes. +func (m *DHCPServerStaticHost) Unmarshal(rawBytes []byte) (*DHCPServerStaticHost, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +// WiFi +type WiFiSettings struct { + Diasabled bool + Reg string + Mode WiFiSettings_Mode + ApSsid string + AuthMode WiFiSettings_APAuthMode + ApChannel uint32 + ApPsk string + ApHideSsid bool + ClientSsid string + ClientPsk string + DisableNexmon bool +} + +// GetDiasabled gets the Diasabled of the WiFiSettings. +func (m *WiFiSettings) GetDiasabled() (x bool) { + if m == nil { + return x + } + return m.Diasabled +} + +// GetReg gets the Reg of the WiFiSettings. +func (m *WiFiSettings) GetReg() (x string) { + if m == nil { + return x + } + return m.Reg +} + +// GetMode gets the Mode of the WiFiSettings. +func (m *WiFiSettings) GetMode() (x WiFiSettings_Mode) { + if m == nil { + return x + } + return m.Mode +} + +// GetApSsid gets the ApSsid of the WiFiSettings. +func (m *WiFiSettings) GetApSsid() (x string) { + if m == nil { + return x + } + return m.ApSsid +} + +// GetAuthMode gets the AuthMode of the WiFiSettings. +func (m *WiFiSettings) GetAuthMode() (x WiFiSettings_APAuthMode) { + if m == nil { + return x + } + return m.AuthMode +} + +// GetApChannel gets the ApChannel of the WiFiSettings. +func (m *WiFiSettings) GetApChannel() (x uint32) { + if m == nil { + return x + } + return m.ApChannel +} + +// GetApPsk gets the ApPsk of the WiFiSettings. +func (m *WiFiSettings) GetApPsk() (x string) { + if m == nil { + return x + } + return m.ApPsk +} + +// GetApHideSsid gets the ApHideSsid of the WiFiSettings. +func (m *WiFiSettings) GetApHideSsid() (x bool) { + if m == nil { + return x + } + return m.ApHideSsid +} + +// GetClientSsid gets the ClientSsid of the WiFiSettings. +func (m *WiFiSettings) GetClientSsid() (x string) { + if m == nil { + return x + } + return m.ClientSsid +} + +// GetClientPsk gets the ClientPsk of the WiFiSettings. +func (m *WiFiSettings) GetClientPsk() (x string) { + if m == nil { + return x + } + return m.ClientPsk +} + +// GetDisableNexmon gets the DisableNexmon of the WiFiSettings. +func (m *WiFiSettings) GetDisableNexmon() (x bool) { + if m == nil { + return x + } + return m.DisableNexmon +} + +// MarshalToWriter marshals WiFiSettings to the provided writer. +func (m *WiFiSettings) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + if m.Diasabled { + writer.WriteBool(1, m.Diasabled) + } + + if len(m.Reg) > 0 { + writer.WriteString(2, m.Reg) + } + + if int(m.Mode) != 0 { + writer.WriteEnum(3, int(m.Mode)) + } + + if len(m.ApSsid) > 0 { + writer.WriteString(4, m.ApSsid) + } + + if int(m.AuthMode) != 0 { + writer.WriteEnum(5, int(m.AuthMode)) + } + + if m.ApChannel != 0 { + writer.WriteUint32(6, m.ApChannel) + } + + if len(m.ApPsk) > 0 { + writer.WriteString(7, m.ApPsk) + } + + if m.ApHideSsid { + writer.WriteBool(8, m.ApHideSsid) + } + + if len(m.ClientSsid) > 0 { + writer.WriteString(9, m.ClientSsid) + } + + if len(m.ClientPsk) > 0 { + writer.WriteString(10, m.ClientPsk) + } + + if m.DisableNexmon { + writer.WriteBool(11, m.DisableNexmon) + } + + return +} + +// Marshal marshals WiFiSettings to a slice of bytes. +func (m *WiFiSettings) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a WiFiSettings from the provided reader. +func (m *WiFiSettings) UnmarshalFromReader(reader jspb.Reader) *WiFiSettings { + for reader.Next() { + if m == nil { + m = &WiFiSettings{} + } + + switch reader.GetFieldNumber() { + case 1: + m.Diasabled = reader.ReadBool() + case 2: + m.Reg = reader.ReadString() + case 3: + m.Mode = WiFiSettings_Mode(reader.ReadEnum()) + case 4: + m.ApSsid = reader.ReadString() + case 5: + m.AuthMode = WiFiSettings_APAuthMode(reader.ReadEnum()) + case 6: + m.ApChannel = reader.ReadUint32() + case 7: + m.ApPsk = reader.ReadString() + case 8: + m.ApHideSsid = reader.ReadBool() + case 9: + m.ClientSsid = reader.ReadString() + case 10: + m.ClientPsk = reader.ReadString() + case 11: + m.DisableNexmon = reader.ReadBool() + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a WiFiSettings from a slice of bytes. +func (m *WiFiSettings) Unmarshal(rawBytes []byte) (*WiFiSettings, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +type Empty struct { +} + +// MarshalToWriter marshals Empty to the provided writer. +func (m *Empty) MarshalToWriter(writer jspb.Writer) { + if m == nil { + return + } + + return +} + +// Marshal marshals Empty to a slice of bytes. +func (m *Empty) Marshal() []byte { + writer := jspb.NewWriter() + m.MarshalToWriter(writer) + return writer.GetResult() +} + +// UnmarshalFromReader unmarshals a Empty from the provided reader. +func (m *Empty) UnmarshalFromReader(reader jspb.Reader) *Empty { + for reader.Next() { + if m == nil { + m = &Empty{} + } + + switch reader.GetFieldNumber() { + default: + reader.SkipField() + } + } + + return m +} + +// Unmarshal unmarshals a Empty from a slice of bytes. +func (m *Empty) Unmarshal(rawBytes []byte) (*Empty, error) { + reader := jspb.NewReader(rawBytes) + + m = m.UnmarshalFromReader(reader) + + if err := reader.Err(); err != nil { + return nil, err + } + + return m, nil +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpcweb.Client + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpcweb package it is being compiled against. +const _ = grpcweb.GrpcWebPackageIsVersion3 + +// Client API for P4WNP1 service + +type P4WNP1Client interface { + GetDeployedGadgetSetting(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*GadgetSettings, error) + DeployGadgetSetting(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*GadgetSettings, error) + GetGadgetSettings(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*GadgetSettings, error) + SetGadgetSettings(ctx context.Context, in *GadgetSettings, opts ...grpcweb.CallOption) (*GadgetSettings, error) + GetLEDSettings(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*LEDSettings, error) + SetLEDSettings(ctx context.Context, in *LEDSettings, opts ...grpcweb.CallOption) (*Empty, error) + MountUMSFile(ctx context.Context, in *GadgetSettingsUMS, opts ...grpcweb.CallOption) (*Empty, error) + DeployEthernetInterfaceSettings(ctx context.Context, in *EthernetInterfaceSettings, opts ...grpcweb.CallOption) (*Empty, error) +} + +type p4WNP1Client struct { + client *grpcweb.Client +} + +// NewP4WNP1Client creates a new gRPC-Web client. +func NewP4WNP1Client(hostname string, opts ...grpcweb.DialOption) P4WNP1Client { + return &p4WNP1Client{ + client: grpcweb.NewClient(hostname, "P4wnP1_grpc.P4WNP1", opts...), + } +} + +func (c *p4WNP1Client) GetDeployedGadgetSetting(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*GadgetSettings, error) { + resp, err := c.client.RPCCall(ctx, "GetDeployedGadgetSetting", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(GadgetSettings).Unmarshal(resp) +} + +func (c *p4WNP1Client) DeployGadgetSetting(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*GadgetSettings, error) { + resp, err := c.client.RPCCall(ctx, "DeployGadgetSetting", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(GadgetSettings).Unmarshal(resp) +} + +func (c *p4WNP1Client) GetGadgetSettings(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*GadgetSettings, error) { + resp, err := c.client.RPCCall(ctx, "GetGadgetSettings", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(GadgetSettings).Unmarshal(resp) +} + +func (c *p4WNP1Client) SetGadgetSettings(ctx context.Context, in *GadgetSettings, opts ...grpcweb.CallOption) (*GadgetSettings, error) { + resp, err := c.client.RPCCall(ctx, "SetGadgetSettings", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(GadgetSettings).Unmarshal(resp) +} + +func (c *p4WNP1Client) GetLEDSettings(ctx context.Context, in *Empty, opts ...grpcweb.CallOption) (*LEDSettings, error) { + resp, err := c.client.RPCCall(ctx, "GetLEDSettings", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(LEDSettings).Unmarshal(resp) +} + +func (c *p4WNP1Client) SetLEDSettings(ctx context.Context, in *LEDSettings, opts ...grpcweb.CallOption) (*Empty, error) { + resp, err := c.client.RPCCall(ctx, "SetLEDSettings", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(Empty).Unmarshal(resp) +} + +func (c *p4WNP1Client) MountUMSFile(ctx context.Context, in *GadgetSettingsUMS, opts ...grpcweb.CallOption) (*Empty, error) { + resp, err := c.client.RPCCall(ctx, "MountUMSFile", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(Empty).Unmarshal(resp) +} + +func (c *p4WNP1Client) DeployEthernetInterfaceSettings(ctx context.Context, in *EthernetInterfaceSettings, opts ...grpcweb.CallOption) (*Empty, error) { + resp, err := c.client.RPCCall(ctx, "DeployEthernetInterfaceSettings", in.Marshal(), opts...) + if err != nil { + return nil, err + } + + return new(Empty).Unmarshal(resp) +} diff --git a/service/rpc_server.go b/service/rpc_server.go index 1bc048a..76727bd 100644 --- a/service/rpc_server.go +++ b/service/rpc_server.go @@ -11,6 +11,12 @@ import ( "encoding/json" "errors" "fmt" + "github.com/improbable-eng/grpc-web/go/grpcweb" + + "net/http" + "strings" + "path" + "time" ) type server struct {} @@ -108,3 +114,101 @@ func StartRpcServer(host string, port string) { log.Fatalf("Failed to serve: %v", err) } } + +func folderReader(fn http.Handler) http.HandlerFunc { + return func(w http.ResponseWriter, req *http.Request) { + if strings.HasSuffix(req.URL.Path, "/") { + // Use contents of index.html for directory, if present. + req.URL.Path = path.Join(req.URL.Path, "index.html") + } + fn.ServeHTTP(w, req) + } +} + +func StartRpcWebServer(host string, port string) { + //Create gRPC Server + s := grpc.NewServer() + pb.RegisterP4WNP1Server(s, &server{}) + + //grpc_web_srv := grpcweb.WrapServer(s, grpcweb.WithWebsockets(true)) //Wrap server to improbable grpc-web with websockets + grpc_web_srv := grpcweb.WrapServer(s) //Wrap server to improbable grpc-web with websockets + + /* + http_handler := func(resp http.ResponseWriter, req *http.Request) { + if req.ProtoMajor == 2 && strings.Contains(req.Header.Get("Content-Type"), "application/grpc") || + websocket.IsWebSocketUpgrade(req) { + grpc_web_srv.ServeHTTP(resp, req) + } else { + //No gRPC request + folderReader(http.FileServer(http.Dir("/home/pi/P4wnP1_go"))).ServeHTTP(resp, req) + } + } + */ + + http_handler := func(resp http.ResponseWriter, req *http.Request) { + grpc_web_srv.ServeHTTP(resp, req) + } + + listen_address := host + ":" + port + http_srv := &http.Server{ + Addr: listen_address, + Handler: http.HandlerFunc(http_handler), + //ReadHeaderTimeout: 5*time.Second, + //IdleTimeout: 120*time.Second, + } + + + //Open TCP listener + log.Printf("P4wnP1 gRPC-web server listening on " + listen_address) + log.Fatal(http_srv.ListenAndServe()) +} + +func StartRpcServerAndWeb(host string, port string) { + listen_address := host + ":" + port + webserver_path := "/home/pi/P4wnP1_go/www" //ToDo: Change this to an absolute path which could be used after installation + + //Create gRPC Server + s := grpc.NewServer() + pb.RegisterP4WNP1Server(s, &server{}) + + //Wrap the server into a gRPC-web server + grpc_web_srv := grpcweb.WrapServer(s) //Wrap server to improbable grpc-web with websockets + //define a handler for a HTTP web server using the gRPC-web proxy + http_gRPC_web_handler := func(resp http.ResponseWriter, req *http.Request) { + if strings.Contains(req.Header.Get("Content-Type"), "application/grpc") || req.Method == "OPTIONS" { + fmt.Printf("gRPC-web req:\n %v\n", req) + grpc_web_srv.ServeHTTP(resp, req) // if content type indicates grpc or REQUEST METHOD IS OPTIONS (pre-flight) serve gRPC-web + } else { + fmt.Printf("legacy web req:\n %v\n", req) + http.FileServer(http.Dir((webserver_path))).ServeHTTP(resp, req) + } + } + + //Open TCP listener + log.Printf("P4wnP1 gRPC server listening on " + listen_address) + lis, err := net.Listen("tcp", listen_address) + if err != nil { + log.Fatalf("failed to listen: %v", err) + } + + // run gRPC server in go routine + go func() { + if err := s.Serve(lis); err != nil { + log.Fatalf("Failed to serve: %v", err) + } + }() + + //Setup our HTTP server + http_srv := &http.Server{ + Addr: host + ":80", //listen on port 80 with webservice + Handler: http.HandlerFunc(http_gRPC_web_handler), + ReadHeaderTimeout: 5*time.Second, + IdleTimeout: 120*time.Second, + } + log.Printf("P4wnP1 gRPC-web server listening on " + http_srv.Addr) + err_http := http_srv.ListenAndServe() + if err_http != nil { + log.Fatal(err) + } + +} diff --git a/web_client/build.sh b/web_client/build.sh new file mode 100755 index 0000000..4626bf7 --- /dev/null +++ b/web_client/build.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +# dependencies for the web app +gopherjs build -o ../www/webapp.js main.go diff --git a/web_client/deps.sh b/web_client/deps.sh new file mode 100755 index 0000000..2ae9da0 --- /dev/null +++ b/web_client/deps.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +# dependencies for the web app +go get -u honnef.co/go/js/dom diff --git a/web_client/index.html b/web_client/index.html new file mode 100644 index 0000000..f027e2e --- /dev/null +++ b/web_client/index.html @@ -0,0 +1,8 @@ + + + gRPC test + + + + + \ No newline at end of file diff --git a/web_client/install.sh b/web_client/install.sh new file mode 100755 index 0000000..c19162c --- /dev/null +++ b/web_client/install.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +# Install gopherjs-gRPC plugin by Johan Brandhorst + +# go and protoc have to be installed already +# $GOPATH/bin has to be in path + +go get -u github.com/gopherjs/gopherjs +go get -u github.com/johanbrandhorst/protobuf/protoc-gen-gopherjs \ No newline at end of file diff --git a/web_client/main.go b/web_client/main.go new file mode 100644 index 0000000..b5e768c --- /dev/null +++ b/web_client/main.go @@ -0,0 +1,42 @@ +package main + +import ( + "context" + "fmt" + "strings" + "time" + + pb "../proto/gopherjs" + dom "honnef.co/go/js/dom" +) + +var ( + document = dom.GetWindow().Document().(dom.HTMLDocument) + serverAddr = "http://raspberrypi.local" +) + +func main() { + fmt.Println("Hello") + + client := pb.NewP4WNP1Client( + "http://raspberrypi.local:80", + ) + fmt.Printf("Address %v\n", strings.TrimSuffix(document.BaseURI(), "/")) + fmt.Printf("Client %v\n", client) + + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + + gs, err := client.GetDeployedGadgetSetting(ctx, &pb.Empty{}) + if err == nil { + str:=fmt.Sprintf("Gs: %v\n", gs) + fmt.Println(str) + div_cont:= dom.GetWindow().Document().GetElementByID("content").(*dom.HTMLDivElement) + new_div := dom.GetWindow().Document().CreateElement("div").(*dom.HTMLDivElement) + new_div.SetTextContent("Result of GetDeployedGadgetSetting gRPC-web call: " + str) + div_cont.AppendChild(new_div) + } else { + fmt.Printf("Error rpc call: %v\n", err) + } + +} diff --git a/www/README.md b/www/README.md new file mode 100644 index 0000000..c08f29d --- /dev/null +++ b/www/README.md @@ -0,0 +1,2 @@ +The only file in this directory which isn't auto-generated is index.html. + diff --git a/www/index.html b/www/index.html new file mode 100644 index 0000000..9d3f45f --- /dev/null +++ b/www/index.html @@ -0,0 +1,11 @@ + + Hello + + + +

Testpage for P4wnP1 service

+

See Javascript console for details, entry script is webapp.js (generated by gopherjs)

+ +
+ + diff --git a/www/webapp.js b/www/webapp.js new file mode 100644 index 0000000..d109caa --- /dev/null +++ b/www/webapp.js @@ -0,0 +1,30006 @@ +"use strict"; +(function() { + +Error.stackTraceLimit = Infinity; + +var $global, $module; +if (typeof window !== "undefined") { /* web page */ + $global = window; +} else if (typeof self !== "undefined") { /* web worker */ + $global = self; +} else if (typeof global !== "undefined") { /* Node.js */ + $global = global; + $global.require = require; +} else { /* others (e.g. Nashorn) */ + $global = this; +} + +if ($global === undefined || $global.Array === undefined) { + throw new Error("no global object found"); +} +if (typeof module !== "undefined") { + $module = module; +} + +var $packages = {}, $idCounter = 0; +var $keys = function(m) { return m ? Object.keys(m) : []; }; +var $flushConsole = function() {}; +var $throwRuntimeError; /* set by package "runtime" */ +var $throwNilPointerError = function() { $throwRuntimeError("invalid memory address or nil pointer dereference"); }; +var $call = function(fn, rcvr, args) { return fn.apply(rcvr, args); }; +var $makeFunc = function(fn) { return function() { return $externalize(fn(this, new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))), $emptyInterface); }; }; +var $unused = function(v) {}; + +var $mapArray = function(array, f) { + var newArray = new array.constructor(array.length); + for (var i = 0; i < array.length; i++) { + newArray[i] = f(array[i]); + } + return newArray; +}; + +var $methodVal = function(recv, name) { + var vals = recv.$methodVals || {}; + recv.$methodVals = vals; /* noop for primitives */ + var f = vals[name]; + if (f !== undefined) { + return f; + } + var method = recv[name]; + f = function() { + $stackDepthOffset--; + try { + return method.apply(recv, arguments); + } finally { + $stackDepthOffset++; + } + }; + vals[name] = f; + return f; +}; + +var $methodExpr = function(typ, name) { + var method = typ.prototype[name]; + if (method.$expr === undefined) { + method.$expr = function() { + $stackDepthOffset--; + try { + if (typ.wrapped) { + arguments[0] = new typ(arguments[0]); + } + return Function.call.apply(method, arguments); + } finally { + $stackDepthOffset++; + } + }; + } + return method.$expr; +}; + +var $ifaceMethodExprs = {}; +var $ifaceMethodExpr = function(name) { + var expr = $ifaceMethodExprs["$" + name]; + if (expr === undefined) { + expr = $ifaceMethodExprs["$" + name] = function() { + $stackDepthOffset--; + try { + return Function.call.apply(arguments[0][name], arguments); + } finally { + $stackDepthOffset++; + } + }; + } + return expr; +}; + +var $subslice = function(slice, low, high, max) { + if (high === undefined) { + high = slice.$length; + } + if (max === undefined) { + max = slice.$capacity; + } + if (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) { + $throwRuntimeError("slice bounds out of range"); + } + var s = new slice.constructor(slice.$array); + s.$offset = slice.$offset + low; + s.$length = high - low; + s.$capacity = max - low; + return s; +}; + +var $substring = function(str, low, high) { + if (low < 0 || high < low || high > str.length) { + $throwRuntimeError("slice bounds out of range"); + } + return str.substring(low, high); +}; + +var $sliceToArray = function(slice) { + if (slice.$array.constructor !== Array) { + return slice.$array.subarray(slice.$offset, slice.$offset + slice.$length); + } + return slice.$array.slice(slice.$offset, slice.$offset + slice.$length); +}; + +var $decodeRune = function(str, pos) { + var c0 = str.charCodeAt(pos); + + if (c0 < 0x80) { + return [c0, 1]; + } + + if (c0 !== c0 || c0 < 0xC0) { + return [0xFFFD, 1]; + } + + var c1 = str.charCodeAt(pos + 1); + if (c1 !== c1 || c1 < 0x80 || 0xC0 <= c1) { + return [0xFFFD, 1]; + } + + if (c0 < 0xE0) { + var r = (c0 & 0x1F) << 6 | (c1 & 0x3F); + if (r <= 0x7F) { + return [0xFFFD, 1]; + } + return [r, 2]; + } + + var c2 = str.charCodeAt(pos + 2); + if (c2 !== c2 || c2 < 0x80 || 0xC0 <= c2) { + return [0xFFFD, 1]; + } + + if (c0 < 0xF0) { + var r = (c0 & 0x0F) << 12 | (c1 & 0x3F) << 6 | (c2 & 0x3F); + if (r <= 0x7FF) { + return [0xFFFD, 1]; + } + if (0xD800 <= r && r <= 0xDFFF) { + return [0xFFFD, 1]; + } + return [r, 3]; + } + + var c3 = str.charCodeAt(pos + 3); + if (c3 !== c3 || c3 < 0x80 || 0xC0 <= c3) { + return [0xFFFD, 1]; + } + + if (c0 < 0xF8) { + var r = (c0 & 0x07) << 18 | (c1 & 0x3F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F); + if (r <= 0xFFFF || 0x10FFFF < r) { + return [0xFFFD, 1]; + } + return [r, 4]; + } + + return [0xFFFD, 1]; +}; + +var $encodeRune = function(r) { + if (r < 0 || r > 0x10FFFF || (0xD800 <= r && r <= 0xDFFF)) { + r = 0xFFFD; + } + if (r <= 0x7F) { + return String.fromCharCode(r); + } + if (r <= 0x7FF) { + return String.fromCharCode(0xC0 | r >> 6, 0x80 | (r & 0x3F)); + } + if (r <= 0xFFFF) { + return String.fromCharCode(0xE0 | r >> 12, 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F)); + } + return String.fromCharCode(0xF0 | r >> 18, 0x80 | (r >> 12 & 0x3F), 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F)); +}; + +var $stringToBytes = function(str) { + var array = new Uint8Array(str.length); + for (var i = 0; i < str.length; i++) { + array[i] = str.charCodeAt(i); + } + return array; +}; + +var $bytesToString = function(slice) { + if (slice.$length === 0) { + return ""; + } + var str = ""; + for (var i = 0; i < slice.$length; i += 10000) { + str += String.fromCharCode.apply(undefined, slice.$array.subarray(slice.$offset + i, slice.$offset + Math.min(slice.$length, i + 10000))); + } + return str; +}; + +var $stringToRunes = function(str) { + var array = new Int32Array(str.length); + var rune, j = 0; + for (var i = 0; i < str.length; i += rune[1], j++) { + rune = $decodeRune(str, i); + array[j] = rune[0]; + } + return array.subarray(0, j); +}; + +var $runesToString = function(slice) { + if (slice.$length === 0) { + return ""; + } + var str = ""; + for (var i = 0; i < slice.$length; i++) { + str += $encodeRune(slice.$array[slice.$offset + i]); + } + return str; +}; + +var $copyString = function(dst, src) { + var n = Math.min(src.length, dst.$length); + for (var i = 0; i < n; i++) { + dst.$array[dst.$offset + i] = src.charCodeAt(i); + } + return n; +}; + +var $copySlice = function(dst, src) { + var n = Math.min(src.$length, dst.$length); + $copyArray(dst.$array, src.$array, dst.$offset, src.$offset, n, dst.constructor.elem); + return n; +}; + +var $copyArray = function(dst, src, dstOffset, srcOffset, n, elem) { + if (n === 0 || (dst === src && dstOffset === srcOffset)) { + return; + } + + if (src.subarray) { + dst.set(src.subarray(srcOffset, srcOffset + n), dstOffset); + return; + } + + switch (elem.kind) { + case $kindArray: + case $kindStruct: + if (dst === src && dstOffset > srcOffset) { + for (var i = n - 1; i >= 0; i--) { + elem.copy(dst[dstOffset + i], src[srcOffset + i]); + } + return; + } + for (var i = 0; i < n; i++) { + elem.copy(dst[dstOffset + i], src[srcOffset + i]); + } + return; + } + + if (dst === src && dstOffset > srcOffset) { + for (var i = n - 1; i >= 0; i--) { + dst[dstOffset + i] = src[srcOffset + i]; + } + return; + } + for (var i = 0; i < n; i++) { + dst[dstOffset + i] = src[srcOffset + i]; + } +}; + +var $clone = function(src, type) { + var clone = type.zero(); + type.copy(clone, src); + return clone; +}; + +var $pointerOfStructConversion = function(obj, type) { + if(obj.$proxies === undefined) { + obj.$proxies = {}; + obj.$proxies[obj.constructor.string] = obj; + } + var proxy = obj.$proxies[type.string]; + if (proxy === undefined) { + var properties = {}; + for (var i = 0; i < type.elem.fields.length; i++) { + (function(fieldProp) { + properties[fieldProp] = { + get: function() { return obj[fieldProp]; }, + set: function(value) { obj[fieldProp] = value; } + }; + })(type.elem.fields[i].prop); + } + proxy = Object.create(type.prototype, properties); + proxy.$val = proxy; + obj.$proxies[type.string] = proxy; + proxy.$proxies = obj.$proxies; + } + return proxy; +}; + +var $append = function(slice) { + return $internalAppend(slice, arguments, 1, arguments.length - 1); +}; + +var $appendSlice = function(slice, toAppend) { + if (toAppend.constructor === String) { + var bytes = $stringToBytes(toAppend); + return $internalAppend(slice, bytes, 0, bytes.length); + } + return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length); +}; + +var $internalAppend = function(slice, array, offset, length) { + if (length === 0) { + return slice; + } + + var newArray = slice.$array; + var newOffset = slice.$offset; + var newLength = slice.$length + length; + var newCapacity = slice.$capacity; + + if (newLength > newCapacity) { + newOffset = 0; + newCapacity = Math.max(newLength, slice.$capacity < 1024 ? slice.$capacity * 2 : Math.floor(slice.$capacity * 5 / 4)); + + if (slice.$array.constructor === Array) { + newArray = slice.$array.slice(slice.$offset, slice.$offset + slice.$length); + newArray.length = newCapacity; + var zero = slice.constructor.elem.zero; + for (var i = slice.$length; i < newCapacity; i++) { + newArray[i] = zero(); + } + } else { + newArray = new slice.$array.constructor(newCapacity); + newArray.set(slice.$array.subarray(slice.$offset, slice.$offset + slice.$length)); + } + } + + $copyArray(newArray, array, newOffset + slice.$length, offset, length, slice.constructor.elem); + + var newSlice = new slice.constructor(newArray); + newSlice.$offset = newOffset; + newSlice.$length = newLength; + newSlice.$capacity = newCapacity; + return newSlice; +}; + +var $equal = function(a, b, type) { + if (type === $jsObjectPtr) { + return a === b; + } + switch (type.kind) { + case $kindComplex64: + case $kindComplex128: + return a.$real === b.$real && a.$imag === b.$imag; + case $kindInt64: + case $kindUint64: + return a.$high === b.$high && a.$low === b.$low; + case $kindArray: + if (a.length !== b.length) { + return false; + } + for (var i = 0; i < a.length; i++) { + if (!$equal(a[i], b[i], type.elem)) { + return false; + } + } + return true; + case $kindStruct: + for (var i = 0; i < type.fields.length; i++) { + var f = type.fields[i]; + if (!$equal(a[f.prop], b[f.prop], f.typ)) { + return false; + } + } + return true; + case $kindInterface: + return $interfaceIsEqual(a, b); + default: + return a === b; + } +}; + +var $interfaceIsEqual = function(a, b) { + if (a === $ifaceNil || b === $ifaceNil) { + return a === b; + } + if (a.constructor !== b.constructor) { + return false; + } + if (a.constructor === $jsObjectPtr) { + return a.object === b.object; + } + if (!a.constructor.comparable) { + $throwRuntimeError("comparing uncomparable type " + a.constructor.string); + } + return $equal(a.$val, b.$val, a.constructor); +}; + +var $min = Math.min; +var $mod = function(x, y) { return x % y; }; +var $parseInt = parseInt; +var $parseFloat = function(f) { + if (f !== undefined && f !== null && f.constructor === Number) { + return f; + } + return parseFloat(f); +}; + +var $froundBuf = new Float32Array(1); +var $fround = Math.fround || function(f) { + $froundBuf[0] = f; + return $froundBuf[0]; +}; + +var $imul = Math.imul || function(a, b) { + var ah = (a >>> 16) & 0xffff; + var al = a & 0xffff; + var bh = (b >>> 16) & 0xffff; + var bl = b & 0xffff; + return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) >> 0); +}; + +var $floatKey = function(f) { + if (f !== f) { + $idCounter++; + return "NaN$" + $idCounter; + } + return String(f); +}; + +var $flatten64 = function(x) { + return x.$high * 4294967296 + x.$low; +}; + +var $shiftLeft64 = function(x, y) { + if (y === 0) { + return x; + } + if (y < 32) { + return new x.constructor(x.$high << y | x.$low >>> (32 - y), (x.$low << y) >>> 0); + } + if (y < 64) { + return new x.constructor(x.$low << (y - 32), 0); + } + return new x.constructor(0, 0); +}; + +var $shiftRightInt64 = function(x, y) { + if (y === 0) { + return x; + } + if (y < 32) { + return new x.constructor(x.$high >> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0); + } + if (y < 64) { + return new x.constructor(x.$high >> 31, (x.$high >> (y - 32)) >>> 0); + } + if (x.$high < 0) { + return new x.constructor(-1, 4294967295); + } + return new x.constructor(0, 0); +}; + +var $shiftRightUint64 = function(x, y) { + if (y === 0) { + return x; + } + if (y < 32) { + return new x.constructor(x.$high >>> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0); + } + if (y < 64) { + return new x.constructor(0, x.$high >>> (y - 32)); + } + return new x.constructor(0, 0); +}; + +var $mul64 = function(x, y) { + var high = 0, low = 0; + if ((y.$low & 1) !== 0) { + high = x.$high; + low = x.$low; + } + for (var i = 1; i < 32; i++) { + if ((y.$low & 1<>> (32 - i); + low += (x.$low << i) >>> 0; + } + } + for (var i = 0; i < 32; i++) { + if ((y.$high & 1< yHigh) || (xHigh === yHigh && xLow > yLow))) { + yHigh = (yHigh << 1 | yLow >>> 31) >>> 0; + yLow = (yLow << 1) >>> 0; + n++; + } + for (var i = 0; i <= n; i++) { + high = high << 1 | low >>> 31; + low = (low << 1) >>> 0; + if ((xHigh > yHigh) || (xHigh === yHigh && xLow >= yLow)) { + xHigh = xHigh - yHigh; + xLow = xLow - yLow; + if (xLow < 0) { + xHigh--; + xLow += 4294967296; + } + low++; + if (low === 4294967296) { + high++; + low = 0; + } + } + yLow = (yLow >>> 1 | yHigh << (32 - 1)) >>> 0; + yHigh = yHigh >>> 1; + } + + if (returnRemainder) { + return new x.constructor(xHigh * rs, xLow * rs); + } + return new x.constructor(high * s, low * s); +}; + +var $divComplex = function(n, d) { + var ninf = n.$real === Infinity || n.$real === -Infinity || n.$imag === Infinity || n.$imag === -Infinity; + var dinf = d.$real === Infinity || d.$real === -Infinity || d.$imag === Infinity || d.$imag === -Infinity; + var nnan = !ninf && (n.$real !== n.$real || n.$imag !== n.$imag); + var dnan = !dinf && (d.$real !== d.$real || d.$imag !== d.$imag); + if(nnan || dnan) { + return new n.constructor(NaN, NaN); + } + if (ninf && !dinf) { + return new n.constructor(Infinity, Infinity); + } + if (!ninf && dinf) { + return new n.constructor(0, 0); + } + if (d.$real === 0 && d.$imag === 0) { + if (n.$real === 0 && n.$imag === 0) { + return new n.constructor(NaN, NaN); + } + return new n.constructor(Infinity, Infinity); + } + var a = Math.abs(d.$real); + var b = Math.abs(d.$imag); + if (a <= b) { + var ratio = d.$real / d.$imag; + var denom = d.$real * ratio + d.$imag; + return new n.constructor((n.$real * ratio + n.$imag) / denom, (n.$imag * ratio - n.$real) / denom); + } + var ratio = d.$imag / d.$real; + var denom = d.$imag * ratio + d.$real; + return new n.constructor((n.$imag * ratio + n.$real) / denom, (n.$imag - n.$real * ratio) / denom); +}; + +var $kindBool = 1; +var $kindInt = 2; +var $kindInt8 = 3; +var $kindInt16 = 4; +var $kindInt32 = 5; +var $kindInt64 = 6; +var $kindUint = 7; +var $kindUint8 = 8; +var $kindUint16 = 9; +var $kindUint32 = 10; +var $kindUint64 = 11; +var $kindUintptr = 12; +var $kindFloat32 = 13; +var $kindFloat64 = 14; +var $kindComplex64 = 15; +var $kindComplex128 = 16; +var $kindArray = 17; +var $kindChan = 18; +var $kindFunc = 19; +var $kindInterface = 20; +var $kindMap = 21; +var $kindPtr = 22; +var $kindSlice = 23; +var $kindString = 24; +var $kindStruct = 25; +var $kindUnsafePointer = 26; + +var $methodSynthesizers = []; +var $addMethodSynthesizer = function(f) { + if ($methodSynthesizers === null) { + f(); + return; + } + $methodSynthesizers.push(f); +}; +var $synthesizeMethods = function() { + $methodSynthesizers.forEach(function(f) { f(); }); + $methodSynthesizers = null; +}; + +var $ifaceKeyFor = function(x) { + if (x === $ifaceNil) { + return 'nil'; + } + var c = x.constructor; + return c.string + '$' + c.keyFor(x.$val); +}; + +var $identity = function(x) { return x; }; + +var $typeIDCounter = 0; + +var $idKey = function(x) { + if (x.$id === undefined) { + $idCounter++; + x.$id = $idCounter; + } + return String(x.$id); +}; + +var $newType = function(size, kind, string, named, pkg, exported, constructor) { + var typ; + switch(kind) { + case $kindBool: + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8: + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindUnsafePointer: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = $identity; + break; + + case $kindString: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = function(x) { return "$" + x; }; + break; + + case $kindFloat32: + case $kindFloat64: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = function(x) { return $floatKey(x); }; + break; + + case $kindInt64: + typ = function(high, low) { + this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >> 0; + this.$low = low >>> 0; + this.$val = this; + }; + typ.keyFor = function(x) { return x.$high + "$" + x.$low; }; + break; + + case $kindUint64: + typ = function(high, low) { + this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >>> 0; + this.$low = low >>> 0; + this.$val = this; + }; + typ.keyFor = function(x) { return x.$high + "$" + x.$low; }; + break; + + case $kindComplex64: + typ = function(real, imag) { + this.$real = $fround(real); + this.$imag = $fround(imag); + this.$val = this; + }; + typ.keyFor = function(x) { return x.$real + "$" + x.$imag; }; + break; + + case $kindComplex128: + typ = function(real, imag) { + this.$real = real; + this.$imag = imag; + this.$val = this; + }; + typ.keyFor = function(x) { return x.$real + "$" + x.$imag; }; + break; + + case $kindArray: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.ptr = $newType(4, $kindPtr, "*" + string, false, "", false, function(array) { + this.$get = function() { return array; }; + this.$set = function(v) { typ.copy(this, v); }; + this.$val = array; + }); + typ.init = function(elem, len) { + typ.elem = elem; + typ.len = len; + typ.comparable = elem.comparable; + typ.keyFor = function(x) { + return Array.prototype.join.call($mapArray(x, function(e) { + return String(elem.keyFor(e)).replace(/\\/g, "\\\\").replace(/\$/g, "\\$"); + }), "$"); + }; + typ.copy = function(dst, src) { + $copyArray(dst, src, 0, 0, src.length, elem); + }; + typ.ptr.init(typ); + Object.defineProperty(typ.ptr.nil, "nilCheck", { get: $throwNilPointerError }); + }; + break; + + case $kindChan: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.keyFor = $idKey; + typ.init = function(elem, sendOnly, recvOnly) { + typ.elem = elem; + typ.sendOnly = sendOnly; + typ.recvOnly = recvOnly; + }; + break; + + case $kindFunc: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.init = function(params, results, variadic) { + typ.params = params; + typ.results = results; + typ.variadic = variadic; + typ.comparable = false; + }; + break; + + case $kindInterface: + typ = { implementedBy: {}, missingMethodFor: {} }; + typ.keyFor = $ifaceKeyFor; + typ.init = function(methods) { + typ.methods = methods; + methods.forEach(function(m) { + $ifaceNil[m.prop] = $throwNilPointerError; + }); + }; + break; + + case $kindMap: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.init = function(key, elem) { + typ.key = key; + typ.elem = elem; + typ.comparable = false; + }; + break; + + case $kindPtr: + typ = constructor || function(getter, setter, target) { + this.$get = getter; + this.$set = setter; + this.$target = target; + this.$val = this; + }; + typ.keyFor = $idKey; + typ.init = function(elem) { + typ.elem = elem; + typ.wrapped = (elem.kind === $kindArray); + typ.nil = new typ($throwNilPointerError, $throwNilPointerError); + }; + break; + + case $kindSlice: + typ = function(array) { + if (array.constructor !== typ.nativeArray) { + array = new typ.nativeArray(array); + } + this.$array = array; + this.$offset = 0; + this.$length = array.length; + this.$capacity = array.length; + this.$val = this; + }; + typ.init = function(elem) { + typ.elem = elem; + typ.comparable = false; + typ.nativeArray = $nativeArray(elem.kind); + typ.nil = new typ([]); + }; + break; + + case $kindStruct: + typ = function(v) { this.$val = v; }; + typ.wrapped = true; + typ.ptr = $newType(4, $kindPtr, "*" + string, false, pkg, exported, constructor); + typ.ptr.elem = typ; + typ.ptr.prototype.$get = function() { return this; }; + typ.ptr.prototype.$set = function(v) { typ.copy(this, v); }; + typ.init = function(pkgPath, fields) { + typ.pkgPath = pkgPath; + typ.fields = fields; + fields.forEach(function(f) { + if (!f.typ.comparable) { + typ.comparable = false; + } + }); + typ.keyFor = function(x) { + var val = x.$val; + return $mapArray(fields, function(f) { + return String(f.typ.keyFor(val[f.prop])).replace(/\\/g, "\\\\").replace(/\$/g, "\\$"); + }).join("$"); + }; + typ.copy = function(dst, src) { + for (var i = 0; i < fields.length; i++) { + var f = fields[i]; + switch (f.typ.kind) { + case $kindArray: + case $kindStruct: + f.typ.copy(dst[f.prop], src[f.prop]); + continue; + default: + dst[f.prop] = src[f.prop]; + continue; + } + } + }; + /* nil value */ + var properties = {}; + fields.forEach(function(f) { + properties[f.prop] = { get: $throwNilPointerError, set: $throwNilPointerError }; + }); + typ.ptr.nil = Object.create(constructor.prototype, properties); + typ.ptr.nil.$val = typ.ptr.nil; + /* methods for embedded fields */ + $addMethodSynthesizer(function() { + var synthesizeMethod = function(target, m, f) { + if (target.prototype[m.prop] !== undefined) { return; } + target.prototype[m.prop] = function() { + var v = this.$val[f.prop]; + if (f.typ === $jsObjectPtr) { + v = new $jsObjectPtr(v); + } + if (v.$val === undefined) { + v = new f.typ(v); + } + return v[m.prop].apply(v, arguments); + }; + }; + fields.forEach(function(f) { + if (f.anonymous) { + $methodSet(f.typ).forEach(function(m) { + synthesizeMethod(typ, m, f); + synthesizeMethod(typ.ptr, m, f); + }); + $methodSet($ptrType(f.typ)).forEach(function(m) { + synthesizeMethod(typ.ptr, m, f); + }); + } + }); + }); + }; + break; + + default: + $panic(new $String("invalid kind: " + kind)); + } + + switch (kind) { + case $kindBool: + case $kindMap: + typ.zero = function() { return false; }; + break; + + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8 : + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindUnsafePointer: + case $kindFloat32: + case $kindFloat64: + typ.zero = function() { return 0; }; + break; + + case $kindString: + typ.zero = function() { return ""; }; + break; + + case $kindInt64: + case $kindUint64: + case $kindComplex64: + case $kindComplex128: + var zero = new typ(0, 0); + typ.zero = function() { return zero; }; + break; + + case $kindPtr: + case $kindSlice: + typ.zero = function() { return typ.nil; }; + break; + + case $kindChan: + typ.zero = function() { return $chanNil; }; + break; + + case $kindFunc: + typ.zero = function() { return $throwNilPointerError; }; + break; + + case $kindInterface: + typ.zero = function() { return $ifaceNil; }; + break; + + case $kindArray: + typ.zero = function() { + var arrayClass = $nativeArray(typ.elem.kind); + if (arrayClass !== Array) { + return new arrayClass(typ.len); + } + var array = new Array(typ.len); + for (var i = 0; i < typ.len; i++) { + array[i] = typ.elem.zero(); + } + return array; + }; + break; + + case $kindStruct: + typ.zero = function() { return new typ.ptr(); }; + break; + + default: + $panic(new $String("invalid kind: " + kind)); + } + + typ.id = $typeIDCounter; + $typeIDCounter++; + typ.size = size; + typ.kind = kind; + typ.string = string; + typ.named = named; + typ.pkg = pkg; + typ.exported = exported; + typ.methods = []; + typ.methodSetCache = null; + typ.comparable = true; + return typ; +}; + +var $methodSet = function(typ) { + if (typ.methodSetCache !== null) { + return typ.methodSetCache; + } + var base = {}; + + var isPtr = (typ.kind === $kindPtr); + if (isPtr && typ.elem.kind === $kindInterface) { + typ.methodSetCache = []; + return []; + } + + var current = [{typ: isPtr ? typ.elem : typ, indirect: isPtr}]; + + var seen = {}; + + while (current.length > 0) { + var next = []; + var mset = []; + + current.forEach(function(e) { + if (seen[e.typ.string]) { + return; + } + seen[e.typ.string] = true; + + if (e.typ.named) { + mset = mset.concat(e.typ.methods); + if (e.indirect) { + mset = mset.concat($ptrType(e.typ).methods); + } + } + + switch (e.typ.kind) { + case $kindStruct: + e.typ.fields.forEach(function(f) { + if (f.anonymous) { + var fTyp = f.typ; + var fIsPtr = (fTyp.kind === $kindPtr); + next.push({typ: fIsPtr ? fTyp.elem : fTyp, indirect: e.indirect || fIsPtr}); + } + }); + break; + + case $kindInterface: + mset = mset.concat(e.typ.methods); + break; + } + }); + + mset.forEach(function(m) { + if (base[m.name] === undefined) { + base[m.name] = m; + } + }); + + current = next; + } + + typ.methodSetCache = []; + Object.keys(base).sort().forEach(function(name) { + typ.methodSetCache.push(base[name]); + }); + return typ.methodSetCache; +}; + +var $Bool = $newType( 1, $kindBool, "bool", true, "", false, null); +var $Int = $newType( 4, $kindInt, "int", true, "", false, null); +var $Int8 = $newType( 1, $kindInt8, "int8", true, "", false, null); +var $Int16 = $newType( 2, $kindInt16, "int16", true, "", false, null); +var $Int32 = $newType( 4, $kindInt32, "int32", true, "", false, null); +var $Int64 = $newType( 8, $kindInt64, "int64", true, "", false, null); +var $Uint = $newType( 4, $kindUint, "uint", true, "", false, null); +var $Uint8 = $newType( 1, $kindUint8, "uint8", true, "", false, null); +var $Uint16 = $newType( 2, $kindUint16, "uint16", true, "", false, null); +var $Uint32 = $newType( 4, $kindUint32, "uint32", true, "", false, null); +var $Uint64 = $newType( 8, $kindUint64, "uint64", true, "", false, null); +var $Uintptr = $newType( 4, $kindUintptr, "uintptr", true, "", false, null); +var $Float32 = $newType( 4, $kindFloat32, "float32", true, "", false, null); +var $Float64 = $newType( 8, $kindFloat64, "float64", true, "", false, null); +var $Complex64 = $newType( 8, $kindComplex64, "complex64", true, "", false, null); +var $Complex128 = $newType(16, $kindComplex128, "complex128", true, "", false, null); +var $String = $newType( 8, $kindString, "string", true, "", false, null); +var $UnsafePointer = $newType( 4, $kindUnsafePointer, "unsafe.Pointer", true, "", false, null); + +var $nativeArray = function(elemKind) { + switch (elemKind) { + case $kindInt: + return Int32Array; + case $kindInt8: + return Int8Array; + case $kindInt16: + return Int16Array; + case $kindInt32: + return Int32Array; + case $kindUint: + return Uint32Array; + case $kindUint8: + return Uint8Array; + case $kindUint16: + return Uint16Array; + case $kindUint32: + return Uint32Array; + case $kindUintptr: + return Uint32Array; + case $kindFloat32: + return Float32Array; + case $kindFloat64: + return Float64Array; + default: + return Array; + } +}; +var $toNativeArray = function(elemKind, array) { + var nativeArray = $nativeArray(elemKind); + if (nativeArray === Array) { + return array; + } + return new nativeArray(array); +}; +var $arrayTypes = {}; +var $arrayType = function(elem, len) { + var typeKey = elem.id + "$" + len; + var typ = $arrayTypes[typeKey]; + if (typ === undefined) { + typ = $newType(12, $kindArray, "[" + len + "]" + elem.string, false, "", false, null); + $arrayTypes[typeKey] = typ; + typ.init(elem, len); + } + return typ; +}; + +var $chanType = function(elem, sendOnly, recvOnly) { + var string = (recvOnly ? "<-" : "") + "chan" + (sendOnly ? "<- " : " ") + elem.string; + var field = sendOnly ? "SendChan" : (recvOnly ? "RecvChan" : "Chan"); + var typ = elem[field]; + if (typ === undefined) { + typ = $newType(4, $kindChan, string, false, "", false, null); + elem[field] = typ; + typ.init(elem, sendOnly, recvOnly); + } + return typ; +}; +var $Chan = function(elem, capacity) { + if (capacity < 0 || capacity > 2147483647) { + $throwRuntimeError("makechan: size out of range"); + } + this.$elem = elem; + this.$capacity = capacity; + this.$buffer = []; + this.$sendQueue = []; + this.$recvQueue = []; + this.$closed = false; +}; +var $chanNil = new $Chan(null, 0); +$chanNil.$sendQueue = $chanNil.$recvQueue = { length: 0, push: function() {}, shift: function() { return undefined; }, indexOf: function() { return -1; } }; + +var $funcTypes = {}; +var $funcType = function(params, results, variadic) { + var typeKey = $mapArray(params, function(p) { return p.id; }).join(",") + "$" + $mapArray(results, function(r) { return r.id; }).join(",") + "$" + variadic; + var typ = $funcTypes[typeKey]; + if (typ === undefined) { + var paramTypes = $mapArray(params, function(p) { return p.string; }); + if (variadic) { + paramTypes[paramTypes.length - 1] = "..." + paramTypes[paramTypes.length - 1].substr(2); + } + var string = "func(" + paramTypes.join(", ") + ")"; + if (results.length === 1) { + string += " " + results[0].string; + } else if (results.length > 1) { + string += " (" + $mapArray(results, function(r) { return r.string; }).join(", ") + ")"; + } + typ = $newType(4, $kindFunc, string, false, "", false, null); + $funcTypes[typeKey] = typ; + typ.init(params, results, variadic); + } + return typ; +}; + +var $interfaceTypes = {}; +var $interfaceType = function(methods) { + var typeKey = $mapArray(methods, function(m) { return m.pkg + "," + m.name + "," + m.typ.id; }).join("$"); + var typ = $interfaceTypes[typeKey]; + if (typ === undefined) { + var string = "interface {}"; + if (methods.length !== 0) { + string = "interface { " + $mapArray(methods, function(m) { + return (m.pkg !== "" ? m.pkg + "." : "") + m.name + m.typ.string.substr(4); + }).join("; ") + " }"; + } + typ = $newType(8, $kindInterface, string, false, "", false, null); + $interfaceTypes[typeKey] = typ; + typ.init(methods); + } + return typ; +}; +var $emptyInterface = $interfaceType([]); +var $ifaceNil = {}; +var $error = $newType(8, $kindInterface, "error", true, "", false, null); +$error.init([{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]); + +var $mapTypes = {}; +var $mapType = function(key, elem) { + var typeKey = key.id + "$" + elem.id; + var typ = $mapTypes[typeKey]; + if (typ === undefined) { + typ = $newType(4, $kindMap, "map[" + key.string + "]" + elem.string, false, "", false, null); + $mapTypes[typeKey] = typ; + typ.init(key, elem); + } + return typ; +}; +var $makeMap = function(keyForFunc, entries) { + var m = {}; + for (var i = 0; i < entries.length; i++) { + var e = entries[i]; + m[keyForFunc(e.k)] = e; + } + return m; +}; + +var $ptrType = function(elem) { + var typ = elem.ptr; + if (typ === undefined) { + typ = $newType(4, $kindPtr, "*" + elem.string, false, "", elem.exported, null); + elem.ptr = typ; + typ.init(elem); + } + return typ; +}; + +var $newDataPointer = function(data, constructor) { + if (constructor.elem.kind === $kindStruct) { + return data; + } + return new constructor(function() { return data; }, function(v) { data = v; }); +}; + +var $indexPtr = function(array, index, constructor) { + array.$ptr = array.$ptr || {}; + return array.$ptr[index] || (array.$ptr[index] = new constructor(function() { return array[index]; }, function(v) { array[index] = v; })); +}; + +var $sliceType = function(elem) { + var typ = elem.slice; + if (typ === undefined) { + typ = $newType(12, $kindSlice, "[]" + elem.string, false, "", false, null); + elem.slice = typ; + typ.init(elem); + } + return typ; +}; +var $makeSlice = function(typ, length, capacity) { + capacity = capacity || length; + if (length < 0 || length > 2147483647) { + $throwRuntimeError("makeslice: len out of range"); + } + if (capacity < 0 || capacity < length || capacity > 2147483647) { + $throwRuntimeError("makeslice: cap out of range"); + } + var array = new typ.nativeArray(capacity); + if (typ.nativeArray === Array) { + for (var i = 0; i < capacity; i++) { + array[i] = typ.elem.zero(); + } + } + var slice = new typ(array); + slice.$length = length; + return slice; +}; + +var $structTypes = {}; +var $structType = function(pkgPath, fields) { + var typeKey = $mapArray(fields, function(f) { return f.name + "," + f.typ.id + "," + f.tag; }).join("$"); + var typ = $structTypes[typeKey]; + if (typ === undefined) { + var string = "struct { " + $mapArray(fields, function(f) { + return f.name + " " + f.typ.string + (f.tag !== "" ? (" \"" + f.tag.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"") : ""); + }).join("; ") + " }"; + if (fields.length === 0) { + string = "struct {}"; + } + typ = $newType(0, $kindStruct, string, false, "", false, function() { + this.$val = this; + for (var i = 0; i < fields.length; i++) { + var f = fields[i]; + var arg = arguments[i]; + this[f.prop] = arg !== undefined ? arg : f.typ.zero(); + } + }); + $structTypes[typeKey] = typ; + typ.init(pkgPath, fields); + } + return typ; +}; + +var $assertType = function(value, type, returnTuple) { + var isInterface = (type.kind === $kindInterface), ok, missingMethod = ""; + if (value === $ifaceNil) { + ok = false; + } else if (!isInterface) { + ok = value.constructor === type; + } else { + var valueTypeString = value.constructor.string; + ok = type.implementedBy[valueTypeString]; + if (ok === undefined) { + ok = true; + var valueMethodSet = $methodSet(value.constructor); + var interfaceMethods = type.methods; + for (var i = 0; i < interfaceMethods.length; i++) { + var tm = interfaceMethods[i]; + var found = false; + for (var j = 0; j < valueMethodSet.length; j++) { + var vm = valueMethodSet[j]; + if (vm.name === tm.name && vm.pkg === tm.pkg && vm.typ === tm.typ) { + found = true; + break; + } + } + if (!found) { + ok = false; + type.missingMethodFor[valueTypeString] = tm.name; + break; + } + } + type.implementedBy[valueTypeString] = ok; + } + if (!ok) { + missingMethod = type.missingMethodFor[valueTypeString]; + } + } + + if (!ok) { + if (returnTuple) { + return [type.zero(), false]; + } + $panic(new $packages["runtime"].TypeAssertionError.ptr("", (value === $ifaceNil ? "" : value.constructor.string), type.string, missingMethod)); + } + + if (!isInterface) { + value = value.$val; + } + if (type === $jsObjectPtr) { + value = value.object; + } + return returnTuple ? [value, true] : value; +}; + +var $stackDepthOffset = 0; +var $getStackDepth = function() { + var err = new Error(); + if (err.stack === undefined) { + return undefined; + } + return $stackDepthOffset + err.stack.split("\n").length; +}; + +var $panicStackDepth = null, $panicValue; +var $callDeferred = function(deferred, jsErr, fromPanic) { + if (!fromPanic && deferred !== null && deferred.index >= $curGoroutine.deferStack.length) { + throw jsErr; + } + if (jsErr !== null) { + var newErr = null; + try { + $curGoroutine.deferStack.push(deferred); + $panic(new $jsErrorPtr(jsErr)); + } catch (err) { + newErr = err; + } + $curGoroutine.deferStack.pop(); + $callDeferred(deferred, newErr); + return; + } + if ($curGoroutine.asleep) { + return; + } + + $stackDepthOffset--; + var outerPanicStackDepth = $panicStackDepth; + var outerPanicValue = $panicValue; + + var localPanicValue = $curGoroutine.panicStack.pop(); + if (localPanicValue !== undefined) { + $panicStackDepth = $getStackDepth(); + $panicValue = localPanicValue; + } + + try { + while (true) { + if (deferred === null) { + deferred = $curGoroutine.deferStack[$curGoroutine.deferStack.length - 1]; + if (deferred === undefined) { + /* The panic reached the top of the stack. Clear it and throw it as a JavaScript error. */ + $panicStackDepth = null; + if (localPanicValue.Object instanceof Error) { + throw localPanicValue.Object; + } + var msg; + if (localPanicValue.constructor === $String) { + msg = localPanicValue.$val; + } else if (localPanicValue.Error !== undefined) { + msg = localPanicValue.Error(); + } else if (localPanicValue.String !== undefined) { + msg = localPanicValue.String(); + } else { + msg = localPanicValue; + } + throw new Error(msg); + } + } + var call = deferred.pop(); + if (call === undefined) { + $curGoroutine.deferStack.pop(); + if (localPanicValue !== undefined) { + deferred = null; + continue; + } + return; + } + var r = call[0].apply(call[2], call[1]); + if (r && r.$blk !== undefined) { + deferred.push([r.$blk, [], r]); + if (fromPanic) { + throw null; + } + return; + } + + if (localPanicValue !== undefined && $panicStackDepth === null) { + throw null; /* error was recovered */ + } + } + } finally { + if (localPanicValue !== undefined) { + if ($panicStackDepth !== null) { + $curGoroutine.panicStack.push(localPanicValue); + } + $panicStackDepth = outerPanicStackDepth; + $panicValue = outerPanicValue; + } + $stackDepthOffset++; + } +}; + +var $panic = function(value) { + $curGoroutine.panicStack.push(value); + $callDeferred(null, null, true); +}; +var $recover = function() { + if ($panicStackDepth === null || ($panicStackDepth !== undefined && $panicStackDepth !== $getStackDepth() - 2)) { + return $ifaceNil; + } + $panicStackDepth = null; + return $panicValue; +}; +var $throw = function(err) { throw err; }; + +var $noGoroutine = { asleep: false, exit: false, deferStack: [], panicStack: [] }; +var $curGoroutine = $noGoroutine, $totalGoroutines = 0, $awakeGoroutines = 0, $checkForDeadlock = true; +var $mainFinished = false; +var $go = function(fun, args) { + $totalGoroutines++; + $awakeGoroutines++; + var $goroutine = function() { + try { + $curGoroutine = $goroutine; + var r = fun.apply(undefined, args); + if (r && r.$blk !== undefined) { + fun = function() { return r.$blk(); }; + args = []; + return; + } + $goroutine.exit = true; + } catch (err) { + if (!$goroutine.exit) { + throw err; + } + } finally { + $curGoroutine = $noGoroutine; + if ($goroutine.exit) { /* also set by runtime.Goexit() */ + $totalGoroutines--; + $goroutine.asleep = true; + } + if ($goroutine.asleep) { + $awakeGoroutines--; + if (!$mainFinished && $awakeGoroutines === 0 && $checkForDeadlock) { + console.error("fatal error: all goroutines are asleep - deadlock!"); + if ($global.process !== undefined) { + $global.process.exit(2); + } + } + } + } + }; + $goroutine.asleep = false; + $goroutine.exit = false; + $goroutine.deferStack = []; + $goroutine.panicStack = []; + $schedule($goroutine); +}; + +var $scheduled = []; +var $runScheduled = function() { + try { + var r; + while ((r = $scheduled.shift()) !== undefined) { + r(); + } + } finally { + if ($scheduled.length > 0) { + setTimeout($runScheduled, 0); + } + } +}; + +var $schedule = function(goroutine) { + if (goroutine.asleep) { + goroutine.asleep = false; + $awakeGoroutines++; + } + $scheduled.push(goroutine); + if ($curGoroutine === $noGoroutine) { + $runScheduled(); + } +}; + +var $setTimeout = function(f, t) { + $awakeGoroutines++; + return setTimeout(function() { + $awakeGoroutines--; + f(); + }, t); +}; + +var $block = function() { + if ($curGoroutine === $noGoroutine) { + $throwRuntimeError("cannot block in JavaScript callback, fix by wrapping code in goroutine"); + } + $curGoroutine.asleep = true; +}; + +var $send = function(chan, value) { + if (chan.$closed) { + $throwRuntimeError("send on closed channel"); + } + var queuedRecv = chan.$recvQueue.shift(); + if (queuedRecv !== undefined) { + queuedRecv([value, true]); + return; + } + if (chan.$buffer.length < chan.$capacity) { + chan.$buffer.push(value); + return; + } + + var thisGoroutine = $curGoroutine; + var closedDuringSend; + chan.$sendQueue.push(function(closed) { + closedDuringSend = closed; + $schedule(thisGoroutine); + return value; + }); + $block(); + return { + $blk: function() { + if (closedDuringSend) { + $throwRuntimeError("send on closed channel"); + } + } + }; +}; +var $recv = function(chan) { + var queuedSend = chan.$sendQueue.shift(); + if (queuedSend !== undefined) { + chan.$buffer.push(queuedSend(false)); + } + var bufferedValue = chan.$buffer.shift(); + if (bufferedValue !== undefined) { + return [bufferedValue, true]; + } + if (chan.$closed) { + return [chan.$elem.zero(), false]; + } + + var thisGoroutine = $curGoroutine; + var f = { $blk: function() { return this.value; } }; + var queueEntry = function(v) { + f.value = v; + $schedule(thisGoroutine); + }; + chan.$recvQueue.push(queueEntry); + $block(); + return f; +}; +var $close = function(chan) { + if (chan.$closed) { + $throwRuntimeError("close of closed channel"); + } + chan.$closed = true; + while (true) { + var queuedSend = chan.$sendQueue.shift(); + if (queuedSend === undefined) { + break; + } + queuedSend(true); /* will panic */ + } + while (true) { + var queuedRecv = chan.$recvQueue.shift(); + if (queuedRecv === undefined) { + break; + } + queuedRecv([chan.$elem.zero(), false]); + } +}; +var $select = function(comms) { + var ready = []; + var selection = -1; + for (var i = 0; i < comms.length; i++) { + var comm = comms[i]; + var chan = comm[0]; + switch (comm.length) { + case 0: /* default */ + selection = i; + break; + case 1: /* recv */ + if (chan.$sendQueue.length !== 0 || chan.$buffer.length !== 0 || chan.$closed) { + ready.push(i); + } + break; + case 2: /* send */ + if (chan.$closed) { + $throwRuntimeError("send on closed channel"); + } + if (chan.$recvQueue.length !== 0 || chan.$buffer.length < chan.$capacity) { + ready.push(i); + } + break; + } + } + + if (ready.length !== 0) { + selection = ready[Math.floor(Math.random() * ready.length)]; + } + if (selection !== -1) { + var comm = comms[selection]; + switch (comm.length) { + case 0: /* default */ + return [selection]; + case 1: /* recv */ + return [selection, $recv(comm[0])]; + case 2: /* send */ + $send(comm[0], comm[1]); + return [selection]; + } + } + + var entries = []; + var thisGoroutine = $curGoroutine; + var f = { $blk: function() { return this.selection; } }; + var removeFromQueues = function() { + for (var i = 0; i < entries.length; i++) { + var entry = entries[i]; + var queue = entry[0]; + var index = queue.indexOf(entry[1]); + if (index !== -1) { + queue.splice(index, 1); + } + } + }; + for (var i = 0; i < comms.length; i++) { + (function(i) { + var comm = comms[i]; + switch (comm.length) { + case 1: /* recv */ + var queueEntry = function(value) { + f.selection = [i, value]; + removeFromQueues(); + $schedule(thisGoroutine); + }; + entries.push([comm[0].$recvQueue, queueEntry]); + comm[0].$recvQueue.push(queueEntry); + break; + case 2: /* send */ + var queueEntry = function() { + if (comm[0].$closed) { + $throwRuntimeError("send on closed channel"); + } + f.selection = [i]; + removeFromQueues(); + $schedule(thisGoroutine); + return comm[1]; + }; + entries.push([comm[0].$sendQueue, queueEntry]); + comm[0].$sendQueue.push(queueEntry); + break; + } + })(i); + } + $block(); + return f; +}; + +var $jsObjectPtr, $jsErrorPtr; + +var $needsExternalization = function(t) { + switch (t.kind) { + case $kindBool: + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8: + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindFloat32: + case $kindFloat64: + return false; + default: + return t !== $jsObjectPtr; + } +}; + +var $externalize = function(v, t) { + if (t === $jsObjectPtr) { + return v; + } + switch (t.kind) { + case $kindBool: + case $kindInt: + case $kindInt8: + case $kindInt16: + case $kindInt32: + case $kindUint: + case $kindUint8: + case $kindUint16: + case $kindUint32: + case $kindUintptr: + case $kindFloat32: + case $kindFloat64: + return v; + case $kindInt64: + case $kindUint64: + return $flatten64(v); + case $kindArray: + if ($needsExternalization(t.elem)) { + return $mapArray(v, function(e) { return $externalize(e, t.elem); }); + } + return v; + case $kindFunc: + return $externalizeFunction(v, t, false); + case $kindInterface: + if (v === $ifaceNil) { + return null; + } + if (v.constructor === $jsObjectPtr) { + return v.$val.object; + } + return $externalize(v.$val, v.constructor); + case $kindMap: + var m = {}; + var keys = $keys(v); + for (var i = 0; i < keys.length; i++) { + var entry = v[keys[i]]; + m[$externalize(entry.k, t.key)] = $externalize(entry.v, t.elem); + } + return m; + case $kindPtr: + if (v === t.nil) { + return null; + } + return $externalize(v.$get(), t.elem); + case $kindSlice: + if ($needsExternalization(t.elem)) { + return $mapArray($sliceToArray(v), function(e) { return $externalize(e, t.elem); }); + } + return $sliceToArray(v); + case $kindString: + if ($isASCII(v)) { + return v; + } + var s = "", r; + for (var i = 0; i < v.length; i += r[1]) { + r = $decodeRune(v, i); + var c = r[0]; + if (c > 0xFFFF) { + var h = Math.floor((c - 0x10000) / 0x400) + 0xD800; + var l = (c - 0x10000) % 0x400 + 0xDC00; + s += String.fromCharCode(h, l); + continue; + } + s += String.fromCharCode(c); + } + return s; + case $kindStruct: + var timePkg = $packages["time"]; + if (timePkg !== undefined && v.constructor === timePkg.Time.ptr) { + var milli = $div64(v.UnixNano(), new $Int64(0, 1000000)); + return new Date($flatten64(milli)); + } + + var noJsObject = {}; + var searchJsObject = function(v, t) { + if (t === $jsObjectPtr) { + return v; + } + switch (t.kind) { + case $kindPtr: + if (v === t.nil) { + return noJsObject; + } + return searchJsObject(v.$get(), t.elem); + case $kindStruct: + var f = t.fields[0]; + return searchJsObject(v[f.prop], f.typ); + case $kindInterface: + return searchJsObject(v.$val, v.constructor); + default: + return noJsObject; + } + }; + var o = searchJsObject(v, t); + if (o !== noJsObject) { + return o; + } + + o = {}; + for (var i = 0; i < t.fields.length; i++) { + var f = t.fields[i]; + if (!f.exported) { + continue; + } + o[f.name] = $externalize(v[f.prop], f.typ); + } + return o; + } + $throwRuntimeError("cannot externalize " + t.string); +}; + +var $externalizeFunction = function(v, t, passThis) { + if (v === $throwNilPointerError) { + return null; + } + if (v.$externalizeWrapper === undefined) { + $checkForDeadlock = false; + v.$externalizeWrapper = function() { + var args = []; + for (var i = 0; i < t.params.length; i++) { + if (t.variadic && i === t.params.length - 1) { + var vt = t.params[i].elem, varargs = []; + for (var j = i; j < arguments.length; j++) { + varargs.push($internalize(arguments[j], vt)); + } + args.push(new (t.params[i])(varargs)); + break; + } + args.push($internalize(arguments[i], t.params[i])); + } + var result = v.apply(passThis ? this : undefined, args); + switch (t.results.length) { + case 0: + return; + case 1: + return $externalize(result, t.results[0]); + default: + for (var i = 0; i < t.results.length; i++) { + result[i] = $externalize(result[i], t.results[i]); + } + return result; + } + }; + } + return v.$externalizeWrapper; +}; + +var $internalize = function(v, t, recv) { + if (t === $jsObjectPtr) { + return v; + } + if (t === $jsObjectPtr.elem) { + $throwRuntimeError("cannot internalize js.Object, use *js.Object instead"); + } + if (v && v.__internal_object__ !== undefined) { + return $assertType(v.__internal_object__, t, false); + } + var timePkg = $packages["time"]; + if (timePkg !== undefined && t === timePkg.Time) { + if (!(v !== null && v !== undefined && v.constructor === Date)) { + $throwRuntimeError("cannot internalize time.Time from " + typeof v + ", must be Date"); + } + return timePkg.Unix(new $Int64(0, 0), new $Int64(0, v.getTime() * 1000000)); + } + switch (t.kind) { + case $kindBool: + return !!v; + case $kindInt: + return parseInt(v); + case $kindInt8: + return parseInt(v) << 24 >> 24; + case $kindInt16: + return parseInt(v) << 16 >> 16; + case $kindInt32: + return parseInt(v) >> 0; + case $kindUint: + return parseInt(v); + case $kindUint8: + return parseInt(v) << 24 >>> 24; + case $kindUint16: + return parseInt(v) << 16 >>> 16; + case $kindUint32: + case $kindUintptr: + return parseInt(v) >>> 0; + case $kindInt64: + case $kindUint64: + return new t(0, v); + case $kindFloat32: + case $kindFloat64: + return parseFloat(v); + case $kindArray: + if (v.length !== t.len) { + $throwRuntimeError("got array with wrong size from JavaScript native"); + } + return $mapArray(v, function(e) { return $internalize(e, t.elem); }); + case $kindFunc: + return function() { + var args = []; + for (var i = 0; i < t.params.length; i++) { + if (t.variadic && i === t.params.length - 1) { + var vt = t.params[i].elem, varargs = arguments[i]; + for (var j = 0; j < varargs.$length; j++) { + args.push($externalize(varargs.$array[varargs.$offset + j], vt)); + } + break; + } + args.push($externalize(arguments[i], t.params[i])); + } + var result = v.apply(recv, args); + switch (t.results.length) { + case 0: + return; + case 1: + return $internalize(result, t.results[0]); + default: + for (var i = 0; i < t.results.length; i++) { + result[i] = $internalize(result[i], t.results[i]); + } + return result; + } + }; + case $kindInterface: + if (t.methods.length !== 0) { + $throwRuntimeError("cannot internalize " + t.string); + } + if (v === null) { + return $ifaceNil; + } + if (v === undefined) { + return new $jsObjectPtr(undefined); + } + switch (v.constructor) { + case Int8Array: + return new ($sliceType($Int8))(v); + case Int16Array: + return new ($sliceType($Int16))(v); + case Int32Array: + return new ($sliceType($Int))(v); + case Uint8Array: + return new ($sliceType($Uint8))(v); + case Uint16Array: + return new ($sliceType($Uint16))(v); + case Uint32Array: + return new ($sliceType($Uint))(v); + case Float32Array: + return new ($sliceType($Float32))(v); + case Float64Array: + return new ($sliceType($Float64))(v); + case Array: + return $internalize(v, $sliceType($emptyInterface)); + case Boolean: + return new $Bool(!!v); + case Date: + if (timePkg === undefined) { + /* time package is not present, internalize as &js.Object{Date} so it can be externalized into original Date. */ + return new $jsObjectPtr(v); + } + return new timePkg.Time($internalize(v, timePkg.Time)); + case Function: + var funcType = $funcType([$sliceType($emptyInterface)], [$jsObjectPtr], true); + return new funcType($internalize(v, funcType)); + case Number: + return new $Float64(parseFloat(v)); + case String: + return new $String($internalize(v, $String)); + default: + if ($global.Node && v instanceof $global.Node) { + return new $jsObjectPtr(v); + } + var mapType = $mapType($String, $emptyInterface); + return new mapType($internalize(v, mapType)); + } + case $kindMap: + var m = {}; + var keys = $keys(v); + for (var i = 0; i < keys.length; i++) { + var k = $internalize(keys[i], t.key); + m[t.key.keyFor(k)] = { k: k, v: $internalize(v[keys[i]], t.elem) }; + } + return m; + case $kindPtr: + if (t.elem.kind === $kindStruct) { + return $internalize(v, t.elem); + } + case $kindSlice: + return new t($mapArray(v, function(e) { return $internalize(e, t.elem); })); + case $kindString: + v = String(v); + if ($isASCII(v)) { + return v; + } + var s = ""; + var i = 0; + while (i < v.length) { + var h = v.charCodeAt(i); + if (0xD800 <= h && h <= 0xDBFF) { + var l = v.charCodeAt(i + 1); + var c = (h - 0xD800) * 0x400 + l - 0xDC00 + 0x10000; + s += $encodeRune(c); + i += 2; + continue; + } + s += $encodeRune(h); + i++; + } + return s; + case $kindStruct: + var noJsObject = {}; + var searchJsObject = function(t) { + if (t === $jsObjectPtr) { + return v; + } + if (t === $jsObjectPtr.elem) { + $throwRuntimeError("cannot internalize js.Object, use *js.Object instead"); + } + switch (t.kind) { + case $kindPtr: + return searchJsObject(t.elem); + case $kindStruct: + var f = t.fields[0]; + var o = searchJsObject(f.typ); + if (o !== noJsObject) { + var n = new t.ptr(); + n[f.prop] = o; + return n; + } + return noJsObject; + default: + return noJsObject; + } + }; + var o = searchJsObject(t); + if (o !== noJsObject) { + return o; + } + } + $throwRuntimeError("cannot internalize " + t.string); +}; + +/* $isASCII reports whether string s contains only ASCII characters. */ +var $isASCII = function(s) { + for (var i = 0; i < s.length; i++) { + if (s.charCodeAt(i) >= 128) { + return false; + } + } + return true; +}; + +$packages["github.com/gopherjs/gopherjs/js"] = (function() { + var $pkg = {}, $init, Object, Error, sliceType, sliceType$1, ptrType, ptrType$1, MakeFunc, Keys, init; + Object = $pkg.Object = $newType(0, $kindStruct, "js.Object", true, "github.com/gopherjs/gopherjs/js", true, function(object_) { + this.$val = this; + if (arguments.length === 0) { + this.object = null; + return; + } + this.object = object_; + }); + Error = $pkg.Error = $newType(0, $kindStruct, "js.Error", true, "github.com/gopherjs/gopherjs/js", true, function(Object_) { + this.$val = this; + if (arguments.length === 0) { + this.Object = null; + return; + } + this.Object = Object_; + }); + sliceType = $sliceType($emptyInterface); + sliceType$1 = $sliceType($String); + ptrType = $ptrType(Object); + ptrType$1 = $ptrType(Error); + Object.ptr.prototype.Get = function(key) { + var key, o; + o = this; + return o.object[$externalize(key, $String)]; + }; + Object.prototype.Get = function(key) { return this.$val.Get(key); }; + Object.ptr.prototype.Set = function(key, value) { + var key, o, value; + o = this; + o.object[$externalize(key, $String)] = $externalize(value, $emptyInterface); + }; + Object.prototype.Set = function(key, value) { return this.$val.Set(key, value); }; + Object.ptr.prototype.Delete = function(key) { + var key, o; + o = this; + delete o.object[$externalize(key, $String)]; + }; + Object.prototype.Delete = function(key) { return this.$val.Delete(key); }; + Object.ptr.prototype.Length = function() { + var o; + o = this; + return $parseInt(o.object.length); + }; + Object.prototype.Length = function() { return this.$val.Length(); }; + Object.ptr.prototype.Index = function(i) { + var i, o; + o = this; + return o.object[i]; + }; + Object.prototype.Index = function(i) { return this.$val.Index(i); }; + Object.ptr.prototype.SetIndex = function(i, value) { + var i, o, value; + o = this; + o.object[i] = $externalize(value, $emptyInterface); + }; + Object.prototype.SetIndex = function(i, value) { return this.$val.SetIndex(i, value); }; + Object.ptr.prototype.Call = function(name, args) { + var args, name, o, obj; + o = this; + return (obj = o.object, obj[$externalize(name, $String)].apply(obj, $externalize(args, sliceType))); + }; + Object.prototype.Call = function(name, args) { return this.$val.Call(name, args); }; + Object.ptr.prototype.Invoke = function(args) { + var args, o; + o = this; + return o.object.apply(undefined, $externalize(args, sliceType)); + }; + Object.prototype.Invoke = function(args) { return this.$val.Invoke(args); }; + Object.ptr.prototype.New = function(args) { + var args, o; + o = this; + return new ($global.Function.prototype.bind.apply(o.object, [undefined].concat($externalize(args, sliceType)))); + }; + Object.prototype.New = function(args) { return this.$val.New(args); }; + Object.ptr.prototype.Bool = function() { + var o; + o = this; + return !!(o.object); + }; + Object.prototype.Bool = function() { return this.$val.Bool(); }; + Object.ptr.prototype.String = function() { + var o; + o = this; + return $internalize(o.object, $String); + }; + Object.prototype.String = function() { return this.$val.String(); }; + Object.ptr.prototype.Int = function() { + var o; + o = this; + return $parseInt(o.object) >> 0; + }; + Object.prototype.Int = function() { return this.$val.Int(); }; + Object.ptr.prototype.Int64 = function() { + var o; + o = this; + return $internalize(o.object, $Int64); + }; + Object.prototype.Int64 = function() { return this.$val.Int64(); }; + Object.ptr.prototype.Uint64 = function() { + var o; + o = this; + return $internalize(o.object, $Uint64); + }; + Object.prototype.Uint64 = function() { return this.$val.Uint64(); }; + Object.ptr.prototype.Float = function() { + var o; + o = this; + return $parseFloat(o.object); + }; + Object.prototype.Float = function() { return this.$val.Float(); }; + Object.ptr.prototype.Interface = function() { + var o; + o = this; + return $internalize(o.object, $emptyInterface); + }; + Object.prototype.Interface = function() { return this.$val.Interface(); }; + Object.ptr.prototype.Unsafe = function() { + var o; + o = this; + return o.object; + }; + Object.prototype.Unsafe = function() { return this.$val.Unsafe(); }; + Error.ptr.prototype.Error = function() { + var err; + err = this; + return "JavaScript error: " + $internalize(err.Object.message, $String); + }; + Error.prototype.Error = function() { return this.$val.Error(); }; + Error.ptr.prototype.Stack = function() { + var err; + err = this; + return $internalize(err.Object.stack, $String); + }; + Error.prototype.Stack = function() { return this.$val.Stack(); }; + MakeFunc = function(fn) { + var fn; + return $makeFunc(fn); + }; + $pkg.MakeFunc = MakeFunc; + Keys = function(o) { + var a, i, o, s; + if (o === null || o === undefined) { + return sliceType$1.nil; + } + a = $global.Object.keys(o); + s = $makeSlice(sliceType$1, $parseInt(a.length)); + i = 0; + while (true) { + if (!(i < $parseInt(a.length))) { break; } + ((i < 0 || i >= s.$length) ? ($throwRuntimeError("index out of range"), undefined) : s.$array[s.$offset + i] = $internalize(a[i], $String)); + i = i + (1) >> 0; + } + return s; + }; + $pkg.Keys = Keys; + init = function() { + var e; + e = new Error.ptr(null); + $unused(e); + }; + ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String, $emptyInterface], [], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [ptrType], false)}, {prop: "SetIndex", name: "SetIndex", pkg: "", typ: $funcType([$Int, $emptyInterface], [], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([$String, sliceType], [ptrType], true)}, {prop: "Invoke", name: "Invoke", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "New", name: "New", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Unsafe", name: "Unsafe", pkg: "", typ: $funcType([], [$Uintptr], false)}]; + ptrType$1.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Stack", name: "Stack", pkg: "", typ: $funcType([], [$String], false)}]; + Object.init("github.com/gopherjs/gopherjs/js", [{prop: "object", name: "object", anonymous: false, exported: false, typ: ptrType, tag: ""}]); + Error.init("", [{prop: "Object", name: "Object", anonymous: true, exported: true, typ: ptrType, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["runtime/internal/sys"] = (function() { + var $pkg = {}, $init; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["runtime"] = (function() { + var $pkg = {}, $init, js, sys, TypeAssertionError, errorString, ptrType$4, init, GOROOT, Goexit, SetFinalizer, KeepAlive, throw$1; + js = $packages["github.com/gopherjs/gopherjs/js"]; + sys = $packages["runtime/internal/sys"]; + TypeAssertionError = $pkg.TypeAssertionError = $newType(0, $kindStruct, "runtime.TypeAssertionError", true, "runtime", true, function(interfaceString_, concreteString_, assertedString_, missingMethod_) { + this.$val = this; + if (arguments.length === 0) { + this.interfaceString = ""; + this.concreteString = ""; + this.assertedString = ""; + this.missingMethod = ""; + return; + } + this.interfaceString = interfaceString_; + this.concreteString = concreteString_; + this.assertedString = assertedString_; + this.missingMethod = missingMethod_; + }); + errorString = $pkg.errorString = $newType(8, $kindString, "runtime.errorString", true, "runtime", false, null); + ptrType$4 = $ptrType(TypeAssertionError); + init = function() { + var e, jsPkg; + jsPkg = $packages[$externalize("github.com/gopherjs/gopherjs/js", $String)]; + $jsObjectPtr = jsPkg.Object.ptr; + $jsErrorPtr = jsPkg.Error.ptr; + $throwRuntimeError = throw$1; + e = $ifaceNil; + e = new TypeAssertionError.ptr("", "", "", ""); + $unused(e); + }; + GOROOT = function() { + var goroot, process; + process = $global.process; + if (process === undefined) { + return "/"; + } + goroot = process.env.GOROOT; + if (!(goroot === undefined)) { + return $internalize(goroot, $String); + } + return "/usr/local/go"; + }; + $pkg.GOROOT = GOROOT; + Goexit = function() { + $curGoroutine.exit = $externalize(true, $Bool); + $throw(null); + }; + $pkg.Goexit = Goexit; + SetFinalizer = function(x, f) { + var f, x; + }; + $pkg.SetFinalizer = SetFinalizer; + KeepAlive = function(param) { + var param; + }; + $pkg.KeepAlive = KeepAlive; + throw$1 = function(s) { + var s; + $panic(new errorString((s))); + }; + TypeAssertionError.ptr.prototype.RuntimeError = function() { + }; + TypeAssertionError.prototype.RuntimeError = function() { return this.$val.RuntimeError(); }; + TypeAssertionError.ptr.prototype.Error = function() { + var e, inter; + e = this; + inter = e.interfaceString; + if (inter === "") { + inter = "interface"; + } + if (e.concreteString === "") { + return "interface conversion: " + inter + " is nil, not " + e.assertedString; + } + if (e.missingMethod === "") { + return "interface conversion: " + inter + " is " + e.concreteString + ", not " + e.assertedString; + } + return "interface conversion: " + e.concreteString + " is not " + e.assertedString + ": missing method " + e.missingMethod; + }; + TypeAssertionError.prototype.Error = function() { return this.$val.Error(); }; + errorString.prototype.RuntimeError = function() { + var e; + e = this.$val; + }; + $ptrType(errorString).prototype.RuntimeError = function() { return new errorString(this.$get()).RuntimeError(); }; + errorString.prototype.Error = function() { + var e; + e = this.$val; + return "runtime error: " + (e); + }; + $ptrType(errorString).prototype.Error = function() { return new errorString(this.$get()).Error(); }; + ptrType$4.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + errorString.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + TypeAssertionError.init("runtime", [{prop: "interfaceString", name: "interfaceString", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "concreteString", name: "concreteString", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "assertedString", name: "assertedString", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "missingMethod", name: "missingMethod", anonymous: false, exported: false, typ: $String, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sys.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["errors"] = (function() { + var $pkg = {}, $init, errorString, ptrType, New; + errorString = $pkg.errorString = $newType(0, $kindStruct, "errors.errorString", true, "errors", false, function(s_) { + this.$val = this; + if (arguments.length === 0) { + this.s = ""; + return; + } + this.s = s_; + }); + ptrType = $ptrType(errorString); + New = function(text) { + var text; + return new errorString.ptr(text); + }; + $pkg.New = New; + errorString.ptr.prototype.Error = function() { + var e; + e = this; + return e.s; + }; + errorString.prototype.Error = function() { return this.$val.Error(); }; + ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + errorString.init("errors", [{prop: "s", name: "s", anonymous: false, exported: false, typ: $String, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/race"] = (function() { + var $pkg = {}, $init, Acquire, Release, ReleaseMerge, ReadRange, WriteRange; + Acquire = function(addr) { + var addr; + }; + $pkg.Acquire = Acquire; + Release = function(addr) { + var addr; + }; + $pkg.Release = Release; + ReleaseMerge = function(addr) { + var addr; + }; + $pkg.ReleaseMerge = ReleaseMerge; + ReadRange = function(addr, len) { + var addr, len; + }; + $pkg.ReadRange = ReadRange; + WriteRange = function(addr, len) { + var addr, len; + }; + $pkg.WriteRange = WriteRange; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["sync/atomic"] = (function() { + var $pkg = {}, $init, js, Value, ptrType, CompareAndSwapInt32, CompareAndSwapUint64, CompareAndSwapPointer, AddInt32, LoadUint64, LoadPointer, StorePointer; + js = $packages["github.com/gopherjs/gopherjs/js"]; + Value = $pkg.Value = $newType(0, $kindStruct, "atomic.Value", true, "sync/atomic", true, function(v_) { + this.$val = this; + if (arguments.length === 0) { + this.v = $ifaceNil; + return; + } + this.v = v_; + }); + ptrType = $ptrType(Value); + CompareAndSwapInt32 = function(addr, old, new$1) { + var addr, new$1, old; + if (addr.$get() === old) { + addr.$set(new$1); + return true; + } + return false; + }; + $pkg.CompareAndSwapInt32 = CompareAndSwapInt32; + CompareAndSwapUint64 = function(addr, old, new$1) { + var addr, new$1, old, x; + if ((x = addr.$get(), (x.$high === old.$high && x.$low === old.$low))) { + addr.$set(new$1); + return true; + } + return false; + }; + $pkg.CompareAndSwapUint64 = CompareAndSwapUint64; + CompareAndSwapPointer = function(addr, old, new$1) { + var addr, new$1, old; + if (addr.$get() === old) { + addr.$set(new$1); + return true; + } + return false; + }; + $pkg.CompareAndSwapPointer = CompareAndSwapPointer; + AddInt32 = function(addr, delta) { + var addr, delta, new$1; + new$1 = addr.$get() + delta >> 0; + addr.$set(new$1); + return new$1; + }; + $pkg.AddInt32 = AddInt32; + LoadUint64 = function(addr) { + var addr; + return addr.$get(); + }; + $pkg.LoadUint64 = LoadUint64; + LoadPointer = function(addr) { + var addr; + return addr.$get(); + }; + $pkg.LoadPointer = LoadPointer; + StorePointer = function(addr, val) { + var addr, val; + addr.$set(val); + }; + $pkg.StorePointer = StorePointer; + Value.ptr.prototype.Load = function() { + var v, x; + x = $ifaceNil; + v = this; + x = v.v; + return x; + }; + Value.prototype.Load = function() { return this.$val.Load(); }; + Value.ptr.prototype.Store = function(x) { + var v, x; + v = this; + if ($interfaceIsEqual(x, $ifaceNil)) { + $panic(new $String("sync/atomic: store of nil value into Value")); + } + if (!($interfaceIsEqual(v.v, $ifaceNil)) && !(x.constructor === v.v.constructor)) { + $panic(new $String("sync/atomic: store of inconsistently typed value into Value")); + } + v.v = x; + }; + Value.prototype.Store = function(x) { return this.$val.Store(x); }; + ptrType.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface], [], false)}]; + Value.init("sync/atomic", [{prop: "v", name: "v", anonymous: false, exported: false, typ: $emptyInterface, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["sync"] = (function() { + var $pkg = {}, $init, js, race, runtime, atomic, Pool, Map, readOnly, entry, Mutex, poolLocalInternal, poolLocal, notifyList, ptrType, sliceType, ptrType$1, chanType, sliceType$1, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, sliceType$4, funcType, funcType$1, ptrType$15, mapType, ptrType$16, arrayType$2, semWaiters, semAwoken, expunged, allPools, runtime_registerPoolCleanup, runtime_SemacquireMutex, runtime_Semrelease, runtime_notifyListCheck, runtime_canSpin, runtime_nanotime, throw$1, newEntry, poolCleanup, init, indexLocal, init$1, runtime_doSpin; + js = $packages["github.com/gopherjs/gopherjs/js"]; + race = $packages["internal/race"]; + runtime = $packages["runtime"]; + atomic = $packages["sync/atomic"]; + Pool = $pkg.Pool = $newType(0, $kindStruct, "sync.Pool", true, "sync", true, function(local_, localSize_, store_, New_) { + this.$val = this; + if (arguments.length === 0) { + this.local = 0; + this.localSize = 0; + this.store = sliceType$4.nil; + this.New = $throwNilPointerError; + return; + } + this.local = local_; + this.localSize = localSize_; + this.store = store_; + this.New = New_; + }); + Map = $pkg.Map = $newType(0, $kindStruct, "sync.Map", true, "sync", true, function(mu_, read_, dirty_, misses_) { + this.$val = this; + if (arguments.length === 0) { + this.mu = new Mutex.ptr(0, 0); + this.read = new atomic.Value.ptr($ifaceNil); + this.dirty = false; + this.misses = 0; + return; + } + this.mu = mu_; + this.read = read_; + this.dirty = dirty_; + this.misses = misses_; + }); + readOnly = $pkg.readOnly = $newType(0, $kindStruct, "sync.readOnly", true, "sync", false, function(m_, amended_) { + this.$val = this; + if (arguments.length === 0) { + this.m = false; + this.amended = false; + return; + } + this.m = m_; + this.amended = amended_; + }); + entry = $pkg.entry = $newType(0, $kindStruct, "sync.entry", true, "sync", false, function(p_) { + this.$val = this; + if (arguments.length === 0) { + this.p = 0; + return; + } + this.p = p_; + }); + Mutex = $pkg.Mutex = $newType(0, $kindStruct, "sync.Mutex", true, "sync", true, function(state_, sema_) { + this.$val = this; + if (arguments.length === 0) { + this.state = 0; + this.sema = 0; + return; + } + this.state = state_; + this.sema = sema_; + }); + poolLocalInternal = $pkg.poolLocalInternal = $newType(0, $kindStruct, "sync.poolLocalInternal", true, "sync", false, function(private$0_, shared_, Mutex_) { + this.$val = this; + if (arguments.length === 0) { + this.private$0 = $ifaceNil; + this.shared = sliceType$4.nil; + this.Mutex = new Mutex.ptr(0, 0); + return; + } + this.private$0 = private$0_; + this.shared = shared_; + this.Mutex = Mutex_; + }); + poolLocal = $pkg.poolLocal = $newType(0, $kindStruct, "sync.poolLocal", true, "sync", false, function(poolLocalInternal_, pad_) { + this.$val = this; + if (arguments.length === 0) { + this.poolLocalInternal = new poolLocalInternal.ptr($ifaceNil, sliceType$4.nil, new Mutex.ptr(0, 0)); + this.pad = arrayType$2.zero(); + return; + } + this.poolLocalInternal = poolLocalInternal_; + this.pad = pad_; + }); + notifyList = $pkg.notifyList = $newType(0, $kindStruct, "sync.notifyList", true, "sync", false, function(wait_, notify_, lock_, head_, tail_) { + this.$val = this; + if (arguments.length === 0) { + this.wait = 0; + this.notify = 0; + this.lock = 0; + this.head = 0; + this.tail = 0; + return; + } + this.wait = wait_; + this.notify = notify_; + this.lock = lock_; + this.head = head_; + this.tail = tail_; + }); + ptrType = $ptrType(Pool); + sliceType = $sliceType(ptrType); + ptrType$1 = $ptrType($Uint32); + chanType = $chanType($Bool, false, false); + sliceType$1 = $sliceType(chanType); + ptrType$3 = $ptrType($emptyInterface); + ptrType$4 = $ptrType(entry); + ptrType$5 = $ptrType($UnsafePointer); + ptrType$6 = $ptrType($Int32); + ptrType$7 = $ptrType(poolLocal); + sliceType$4 = $sliceType($emptyInterface); + funcType = $funcType([], [$emptyInterface], false); + funcType$1 = $funcType([$emptyInterface, $emptyInterface], [$Bool], false); + ptrType$15 = $ptrType(Map); + mapType = $mapType($emptyInterface, ptrType$4); + ptrType$16 = $ptrType(Mutex); + arrayType$2 = $arrayType($Uint8, 100); + Pool.ptr.prototype.Get = function() { + var _r, p, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if (p.store.$length === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (p.store.$length === 0) { */ case 1: + /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(p.New === $throwNilPointerError)) { */ case 3: + _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 2: + x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])); + p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0)); + $s = -1; return x$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Pool.prototype.Get = function() { return this.$val.Get(); }; + Pool.ptr.prototype.Put = function(x) { + var p, x; + p = this; + if ($interfaceIsEqual(x, $ifaceNil)) { + return; + } + p.store = $append(p.store, x); + }; + Pool.prototype.Put = function(x) { return this.$val.Put(x); }; + runtime_registerPoolCleanup = function(cleanup) { + var cleanup; + }; + runtime_SemacquireMutex = function(s, lifo) { + var _entry, _entry$1, _entry$2, _entry$3, _entry$4, _key, _key$1, _key$2, _r, ch, lifo, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _r = $f._r; ch = $f.ch; lifo = $f.lifo; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if (((s.$get() - (_entry = semAwoken[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : 0) >>> 0)) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (((s.$get() - (_entry = semAwoken[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : 0) >>> 0)) === 0) { */ case 1: + ch = new $Chan($Bool, 0); + if (lifo) { + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: $appendSlice(new sliceType$1([ch]), (_entry$1 = semWaiters[ptrType$1.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : sliceType$1.nil)) }; + } else { + _key$1 = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: $append((_entry$2 = semWaiters[ptrType$1.keyFor(s)], _entry$2 !== undefined ? _entry$2.v : sliceType$1.nil), ch) }; + } + _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r[0]; + _key$2 = s; (semAwoken || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$2)] = { k: _key$2, v: (_entry$3 = semAwoken[ptrType$1.keyFor(s)], _entry$3 !== undefined ? _entry$3.v : 0) - (1) >>> 0 }; + if ((_entry$4 = semAwoken[ptrType$1.keyFor(s)], _entry$4 !== undefined ? _entry$4.v : 0) === 0) { + delete semAwoken[ptrType$1.keyFor(s)]; + } + /* } */ case 2: + s.$set(s.$get() - (1) >>> 0); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_SemacquireMutex }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._r = _r; $f.ch = ch; $f.lifo = lifo; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_Semrelease = function(s, handoff) { + var _entry, _entry$1, _key, _key$1, ch, handoff, s, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _key = $f._key; _key$1 = $f._key$1; ch = $f.ch; handoff = $f.handoff; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s.$set(s.$get() + (1) >>> 0); + w = (_entry = semWaiters[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : sliceType$1.nil); + if (w.$length === 0) { + $s = -1; return; + } + ch = (0 >= w.$length ? ($throwRuntimeError("index out of range"), undefined) : w.$array[w.$offset + 0]); + w = $subslice(w, 1); + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: w }; + if (w.$length === 0) { + delete semWaiters[ptrType$1.keyFor(s)]; + } + _key$1 = s; (semAwoken || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: (_entry$1 = semAwoken[ptrType$1.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : 0) + (1) >>> 0 }; + $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._key = _key; $f._key$1 = _key$1; $f.ch = ch; $f.handoff = handoff; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_notifyListCheck = function(size) { + var size; + }; + runtime_canSpin = function(i) { + var i; + return false; + }; + runtime_nanotime = function() { + return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000)); + }; + throw$1 = function(s) { + var s; + $throwRuntimeError($externalize(s, $String)); + }; + newEntry = function(i) { + var i, i$24ptr; + return new entry.ptr(((i$24ptr || (i$24ptr = new ptrType$3(function() { return i; }, function($v) { i = $v; }))))); + }; + Map.ptr.prototype.Load = function(key) { + var _entry, _entry$1, _entry$2, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, e, key, m, ok, read, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; e = $f.e; key = $f.key; m = $f.m; ok = $f.ok; read = $f.read; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + value = $ifaceNil; + ok = false; + m = this; + _tuple = $assertType(m.read.Load(), readOnly, true); + read = $clone(_tuple[0], readOnly); + _tuple$1 = (_entry = read.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [ptrType$4.nil, false]); + e = _tuple$1[0]; + ok = _tuple$1[1]; + /* */ if (!ok && read.amended) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!ok && read.amended) { */ case 1: + $r = m.mu.Lock(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tuple$2 = $assertType(m.read.Load(), readOnly, true); + readOnly.copy(read, _tuple$2[0]); + _tuple$3 = (_entry$1 = read.m[$emptyInterface.keyFor(key)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$4.nil, false]); + e = _tuple$3[0]; + ok = _tuple$3[1]; + if (!ok && read.amended) { + _tuple$4 = (_entry$2 = m.dirty[$emptyInterface.keyFor(key)], _entry$2 !== undefined ? [_entry$2.v, true] : [ptrType$4.nil, false]); + e = _tuple$4[0]; + ok = _tuple$4[1]; + m.missLocked(); + } + $r = m.mu.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (!ok) { + _tmp = $ifaceNil; + _tmp$1 = false; + value = _tmp; + ok = _tmp$1; + $s = -1; return [value, ok]; + } + _tuple$5 = e.load(); + value = _tuple$5[0]; + ok = _tuple$5[1]; + $s = -1; return [value, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Load }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.e = e; $f.key = key; $f.m = m; $f.ok = ok; $f.read = read; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + Map.prototype.Load = function(key) { return this.$val.Load(key); }; + entry.ptr.prototype.load = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, e, ok, p, value; + value = $ifaceNil; + ok = false; + e = this; + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + if (p === 0 || p === expunged) { + _tmp = $ifaceNil; + _tmp$1 = false; + value = _tmp; + ok = _tmp$1; + return [value, ok]; + } + _tmp$2 = (p).$get(); + _tmp$3 = true; + value = _tmp$2; + ok = _tmp$3; + return [value, ok]; + }; + entry.prototype.load = function() { return this.$val.load(); }; + Map.ptr.prototype.Store = function(key, value) { + var _entry, _entry$1, _entry$2, _key, _key$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, e, e$1, e$2, key, m, ok, ok$1, ok$2, read, value, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _key = $f._key; _key$1 = $f._key$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; e = $f.e; e$1 = $f.e$1; e$2 = $f.e$2; key = $f.key; m = $f.m; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; read = $f.read; value = $f.value; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + value = [value]; + m = this; + _tuple = $assertType(m.read.Load(), readOnly, true); + read = $clone(_tuple[0], readOnly); + _tuple$1 = (_entry = read.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [ptrType$4.nil, false]); + e = _tuple$1[0]; + ok = _tuple$1[1]; + if (ok && e.tryStore((value.$ptr || (value.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, value))))) { + $s = -1; return; + } + $r = m.mu.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tuple$2 = $assertType(m.read.Load(), readOnly, true); + readOnly.copy(read, _tuple$2[0]); + _tuple$3 = (_entry$1 = read.m[$emptyInterface.keyFor(key)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$4.nil, false]); + e$1 = _tuple$3[0]; + ok$1 = _tuple$3[1]; + if (ok$1) { + if (e$1.unexpungeLocked()) { + _key = key; (m.dirty || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: e$1 }; + } + e$1.storeLocked((value.$ptr || (value.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, value)))); + } else { + _tuple$4 = (_entry$2 = m.dirty[$emptyInterface.keyFor(key)], _entry$2 !== undefined ? [_entry$2.v, true] : [ptrType$4.nil, false]); + e$2 = _tuple$4[0]; + ok$2 = _tuple$4[1]; + if (ok$2) { + e$2.storeLocked((value.$ptr || (value.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, value)))); + } else { + if (!read.amended) { + m.dirtyLocked(); + m.read.Store((x = new readOnly.ptr(read.m, true), new x.constructor.elem(x))); + } + _key$1 = key; (m.dirty || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key$1)] = { k: _key$1, v: newEntry(value[0]) }; + } + } + $r = m.mu.Unlock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Store }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._key = _key; $f._key$1 = _key$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.e = e; $f.e$1 = e$1; $f.e$2 = e$2; $f.key = key; $f.m = m; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.read = read; $f.value = value; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Map.prototype.Store = function(key, value) { return this.$val.Store(key, value); }; + entry.ptr.prototype.tryStore = function(i) { + var e, i, p; + e = this; + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + if (p === expunged) { + return false; + } + while (true) { + if (atomic.CompareAndSwapPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e))), p, (i))) { + return true; + } + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + if (p === expunged) { + return false; + } + } + }; + entry.prototype.tryStore = function(i) { return this.$val.tryStore(i); }; + entry.ptr.prototype.unexpungeLocked = function() { + var e, wasExpunged; + wasExpunged = false; + e = this; + wasExpunged = atomic.CompareAndSwapPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e))), expunged, 0); + return wasExpunged; + }; + entry.prototype.unexpungeLocked = function() { return this.$val.unexpungeLocked(); }; + entry.ptr.prototype.storeLocked = function(i) { + var e, i; + e = this; + atomic.StorePointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e))), (i)); + }; + entry.prototype.storeLocked = function(i) { return this.$val.storeLocked(i); }; + Map.ptr.prototype.LoadOrStore = function(key, value) { + var _entry, _entry$1, _entry$2, _key, _key$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, actual, actual$1, e, e$1, e$2, key, loaded, loaded$1, m, ok, ok$1, ok$2, ok$3, read, value, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _key = $f._key; _key$1 = $f._key$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; actual = $f.actual; actual$1 = $f.actual$1; e = $f.e; e$1 = $f.e$1; e$2 = $f.e$2; key = $f.key; loaded = $f.loaded; loaded$1 = $f.loaded$1; m = $f.m; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; ok$3 = $f.ok$3; read = $f.read; value = $f.value; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + actual = $ifaceNil; + loaded = false; + m = this; + _tuple = $assertType(m.read.Load(), readOnly, true); + read = $clone(_tuple[0], readOnly); + _tuple$1 = (_entry = read.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [ptrType$4.nil, false]); + e = _tuple$1[0]; + ok = _tuple$1[1]; + if (ok) { + _tuple$2 = e.tryLoadOrStore(value); + actual$1 = _tuple$2[0]; + loaded$1 = _tuple$2[1]; + ok$1 = _tuple$2[2]; + if (ok$1) { + _tmp = actual$1; + _tmp$1 = loaded$1; + actual = _tmp; + loaded = _tmp$1; + $s = -1; return [actual, loaded]; + } + } + $r = m.mu.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tuple$3 = $assertType(m.read.Load(), readOnly, true); + readOnly.copy(read, _tuple$3[0]); + _tuple$4 = (_entry$1 = read.m[$emptyInterface.keyFor(key)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$4.nil, false]); + e$1 = _tuple$4[0]; + ok$2 = _tuple$4[1]; + if (ok$2) { + if (e$1.unexpungeLocked()) { + _key = key; (m.dirty || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: e$1 }; + } + _tuple$5 = e$1.tryLoadOrStore(value); + actual = _tuple$5[0]; + loaded = _tuple$5[1]; + } else { + _tuple$6 = (_entry$2 = m.dirty[$emptyInterface.keyFor(key)], _entry$2 !== undefined ? [_entry$2.v, true] : [ptrType$4.nil, false]); + e$2 = _tuple$6[0]; + ok$3 = _tuple$6[1]; + if (ok$3) { + _tuple$7 = e$2.tryLoadOrStore(value); + actual = _tuple$7[0]; + loaded = _tuple$7[1]; + m.missLocked(); + } else { + if (!read.amended) { + m.dirtyLocked(); + m.read.Store((x = new readOnly.ptr(read.m, true), new x.constructor.elem(x))); + } + _key$1 = key; (m.dirty || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key$1)] = { k: _key$1, v: newEntry(value) }; + _tmp$2 = value; + _tmp$3 = false; + actual = _tmp$2; + loaded = _tmp$3; + } + } + $r = m.mu.Unlock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tmp$4 = actual; + _tmp$5 = loaded; + actual = _tmp$4; + loaded = _tmp$5; + $s = -1; return [actual, loaded]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.LoadOrStore }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._key = _key; $f._key$1 = _key$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.actual = actual; $f.actual$1 = actual$1; $f.e = e; $f.e$1 = e$1; $f.e$2 = e$2; $f.key = key; $f.loaded = loaded; $f.loaded$1 = loaded$1; $f.m = m; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.read = read; $f.value = value; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Map.prototype.LoadOrStore = function(key, value) { return this.$val.LoadOrStore(key, value); }; + entry.ptr.prototype.tryLoadOrStore = function(i) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, actual, e, i, ic, ic$24ptr, loaded, ok, p; + actual = $ifaceNil; + loaded = false; + ok = false; + e = this; + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + if (p === expunged) { + _tmp = $ifaceNil; + _tmp$1 = false; + _tmp$2 = false; + actual = _tmp; + loaded = _tmp$1; + ok = _tmp$2; + return [actual, loaded, ok]; + } + if (!(p === 0)) { + _tmp$3 = (p).$get(); + _tmp$4 = true; + _tmp$5 = true; + actual = _tmp$3; + loaded = _tmp$4; + ok = _tmp$5; + return [actual, loaded, ok]; + } + ic = i; + while (true) { + if (atomic.CompareAndSwapPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e))), 0, ((ic$24ptr || (ic$24ptr = new ptrType$3(function() { return ic; }, function($v) { ic = $v; })))))) { + _tmp$6 = i; + _tmp$7 = false; + _tmp$8 = true; + actual = _tmp$6; + loaded = _tmp$7; + ok = _tmp$8; + return [actual, loaded, ok]; + } + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + if (p === expunged) { + _tmp$9 = $ifaceNil; + _tmp$10 = false; + _tmp$11 = false; + actual = _tmp$9; + loaded = _tmp$10; + ok = _tmp$11; + return [actual, loaded, ok]; + } + if (!(p === 0)) { + _tmp$12 = (p).$get(); + _tmp$13 = true; + _tmp$14 = true; + actual = _tmp$12; + loaded = _tmp$13; + ok = _tmp$14; + return [actual, loaded, ok]; + } + } + }; + entry.prototype.tryLoadOrStore = function(i) { return this.$val.tryLoadOrStore(i); }; + Map.ptr.prototype.Delete = function(key) { + var _entry, _entry$1, _tuple, _tuple$1, _tuple$2, _tuple$3, e, key, m, ok, read, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; e = $f.e; key = $f.key; m = $f.m; ok = $f.ok; read = $f.read; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + _tuple = $assertType(m.read.Load(), readOnly, true); + read = $clone(_tuple[0], readOnly); + _tuple$1 = (_entry = read.m[$emptyInterface.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [ptrType$4.nil, false]); + e = _tuple$1[0]; + ok = _tuple$1[1]; + /* */ if (!ok && read.amended) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!ok && read.amended) { */ case 1: + $r = m.mu.Lock(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tuple$2 = $assertType(m.read.Load(), readOnly, true); + readOnly.copy(read, _tuple$2[0]); + _tuple$3 = (_entry$1 = read.m[$emptyInterface.keyFor(key)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$4.nil, false]); + e = _tuple$3[0]; + ok = _tuple$3[1]; + if (!ok && read.amended) { + delete m.dirty[$emptyInterface.keyFor(key)]; + } + $r = m.mu.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + if (ok) { + e.delete$(); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Delete }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.e = e; $f.key = key; $f.m = m; $f.ok = ok; $f.read = read; $f.$s = $s; $f.$r = $r; return $f; + }; + Map.prototype.Delete = function(key) { return this.$val.Delete(key); }; + entry.ptr.prototype.delete$ = function() { + var e, hadValue, p; + hadValue = false; + e = this; + while (true) { + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + if (p === 0 || p === expunged) { + hadValue = false; + return hadValue; + } + if (atomic.CompareAndSwapPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e))), p, 0)) { + hadValue = true; + return hadValue; + } + } + }; + entry.prototype.delete$ = function() { return this.$val.delete$(); }; + Map.ptr.prototype.Range = function(f) { + var _entry, _i, _keys, _r, _ref, _tuple, _tuple$1, _tuple$2, e, f, k, m, ok, read, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; e = $f.e; f = $f.f; k = $f.k; m = $f.m; ok = $f.ok; read = $f.read; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + _tuple = $assertType(m.read.Load(), readOnly, true); + read = $clone(_tuple[0], readOnly); + /* */ if (read.amended) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (read.amended) { */ case 1: + $r = m.mu.Lock(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tuple$1 = $assertType(m.read.Load(), readOnly, true); + readOnly.copy(read, _tuple$1[0]); + if (read.amended) { + readOnly.copy(read, new readOnly.ptr(m.dirty, false)); + m.read.Store(new read.constructor.elem(read)); + m.dirty = false; + m.misses = 0; + } + $r = m.mu.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + _ref = read.m; + _i = 0; + _keys = $keys(_ref); + /* while (true) { */ case 5: + /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 6; continue; } + _entry = _ref[_keys[_i]]; + if (_entry === undefined) { + _i++; + /* continue; */ $s = 5; continue; + } + k = _entry.k; + e = _entry.v; + _tuple$2 = e.load(); + v = _tuple$2[0]; + ok = _tuple$2[1]; + /* */ if (!ok) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!ok) { */ case 7: + _i++; + /* continue; */ $s = 5; continue; + /* } */ case 8: + _r = f(k, v); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!_r) { */ case 9: + /* break; */ $s = 6; continue; + /* } */ case 10: + _i++; + /* } */ $s = 5; continue; case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Range }; } $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.e = e; $f.f = f; $f.k = k; $f.m = m; $f.ok = ok; $f.read = read; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Map.prototype.Range = function(f) { return this.$val.Range(f); }; + Map.ptr.prototype.missLocked = function() { + var m, x; + m = this; + m.misses = m.misses + (1) >> 0; + if (m.misses < $keys(m.dirty).length) { + return; + } + m.read.Store((x = new readOnly.ptr(m.dirty, false), new x.constructor.elem(x))); + m.dirty = false; + m.misses = 0; + }; + Map.prototype.missLocked = function() { return this.$val.missLocked(); }; + Map.ptr.prototype.dirtyLocked = function() { + var _entry, _i, _key, _keys, _ref, _tuple, e, k, m, read, x; + m = this; + if (!(m.dirty === false)) { + return; + } + _tuple = $assertType(m.read.Load(), readOnly, true); + read = $clone(_tuple[0], readOnly); + m.dirty = (x = $keys(read.m).length, ((x < 0 || x > 2147483647) ? $throwRuntimeError("makemap: size out of range") : {})); + _ref = read.m; + _i = 0; + _keys = $keys(_ref); + while (true) { + if (!(_i < _keys.length)) { break; } + _entry = _ref[_keys[_i]]; + if (_entry === undefined) { + _i++; + continue; + } + k = _entry.k; + e = _entry.v; + if (!e.tryExpungeLocked()) { + _key = k; (m.dirty || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key)] = { k: _key, v: e }; + } + _i++; + } + }; + Map.prototype.dirtyLocked = function() { return this.$val.dirtyLocked(); }; + entry.ptr.prototype.tryExpungeLocked = function() { + var e, isExpunged, p; + isExpunged = false; + e = this; + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + while (true) { + if (!(p === 0)) { break; } + if (atomic.CompareAndSwapPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e))), 0, expunged)) { + isExpunged = true; + return isExpunged; + } + p = atomic.LoadPointer((e.$ptr_p || (e.$ptr_p = new ptrType$5(function() { return this.$target.p; }, function($v) { this.$target.p = $v; }, e)))); + } + isExpunged = p === expunged; + return isExpunged; + }; + entry.prototype.tryExpungeLocked = function() { return this.$val.tryExpungeLocked(); }; + Mutex.ptr.prototype.Lock = function() { + var awoke, delta, iter, m, new$1, old, queueLifo, starving, waitStartTime, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; awoke = $f.awoke; delta = $f.delta; iter = $f.iter; m = $f.m; new$1 = $f.new$1; old = $f.old; queueLifo = $f.queueLifo; starving = $f.starving; waitStartTime = $f.waitStartTime; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), 0, 1)) { + if (false) { + race.Acquire((m)); + } + $s = -1; return; + } + waitStartTime = new $Int64(0, 0); + starving = false; + awoke = false; + iter = 0; + old = m.state; + /* while (true) { */ case 1: + /* */ if (((old & 5) === 1) && runtime_canSpin(iter)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (((old & 5) === 1) && runtime_canSpin(iter)) { */ case 3: + if (!awoke && ((old & 2) === 0) && !(((old >> 3 >> 0) === 0)) && atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, old | 2)) { + awoke = true; + } + runtime_doSpin(); + iter = iter + (1) >> 0; + old = m.state; + /* continue; */ $s = 1; continue; + /* } */ case 4: + new$1 = old; + if ((old & 4) === 0) { + new$1 = new$1 | (1); + } + if (!(((old & 5) === 0))) { + new$1 = new$1 + (8) >> 0; + } + if (starving && !(((old & 1) === 0))) { + new$1 = new$1 | (4); + } + if (awoke) { + if ((new$1 & 2) === 0) { + throw$1("sync: inconsistent mutex state"); + } + new$1 = (new$1 & ~(2)) >> 0; + } + /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 5: + if ((old & 5) === 0) { + /* break; */ $s = 2; continue; + } + queueLifo = !((waitStartTime.$high === 0 && waitStartTime.$low === 0)); + if ((waitStartTime.$high === 0 && waitStartTime.$low === 0)) { + waitStartTime = runtime_nanotime(); + } + $r = runtime_SemacquireMutex((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), queueLifo); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + starving = starving || (x = (x$1 = runtime_nanotime(), new $Int64(x$1.$high - waitStartTime.$high, x$1.$low - waitStartTime.$low)), (x.$high > 0 || (x.$high === 0 && x.$low > 1000000))); + old = m.state; + if (!(((old & 4) === 0))) { + if (!(((old & 3) === 0)) || ((old >> 3 >> 0) === 0)) { + throw$1("sync: inconsistent mutex state"); + } + delta = -7; + if (!starving || ((old >> 3 >> 0) === 1)) { + delta = delta - (4) >> 0; + } + atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), delta); + /* break; */ $s = 2; continue; + } + awoke = true; + iter = 0; + $s = 7; continue; + /* } else { */ case 6: + old = m.state; + /* } */ case 7: + /* } */ $s = 1; continue; case 2: + if (false) { + race.Acquire((m)); + } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Lock }; } $f.awoke = awoke; $f.delta = delta; $f.iter = iter; $f.m = m; $f.new$1 = new$1; $f.old = old; $f.queueLifo = queueLifo; $f.starving = starving; $f.waitStartTime = waitStartTime; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Mutex.prototype.Lock = function() { return this.$val.Lock(); }; + Mutex.ptr.prototype.Unlock = function() { + var m, new$1, old, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; m = $f.m; new$1 = $f.new$1; old = $f.old; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = this; + if (false) { + $unused(m.state); + race.Release((m)); + } + new$1 = atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), -1); + if ((((new$1 + 1 >> 0)) & 1) === 0) { + throw$1("sync: unlock of unlocked mutex"); + } + /* */ if ((new$1 & 4) === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((new$1 & 4) === 0) { */ case 1: + old = new$1; + /* while (true) { */ case 4: + if (((old >> 3 >> 0) === 0) || !(((old & 7) === 0))) { + $s = -1; return; + } + new$1 = ((old - 8 >> 0)) | 2; + /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$6(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 6: + $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), false); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 7: + old = m.state; + /* } */ $s = 4; continue; case 5: + $s = 3; continue; + /* } else { */ case 2: + $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m))), true); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Unlock }; } $f.m = m; $f.new$1 = new$1; $f.old = old; $f.$s = $s; $f.$r = $r; return $f; + }; + Mutex.prototype.Unlock = function() { return this.$val.Unlock(); }; + poolCleanup = function() { + var _i, _i$1, _ref, _ref$1, i, i$1, j, l, p, x; + _ref = allPools; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + p = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= allPools.$length) ? ($throwRuntimeError("index out of range"), undefined) : allPools.$array[allPools.$offset + i] = ptrType.nil); + i$1 = 0; + while (true) { + if (!(i$1 < ((p.localSize >> 0)))) { break; } + l = indexLocal(p.local, i$1); + l.poolLocalInternal.private$0 = $ifaceNil; + _ref$1 = l.poolLocalInternal.shared; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + j = _i$1; + (x = l.poolLocalInternal.shared, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j] = $ifaceNil)); + _i$1++; + } + l.poolLocalInternal.shared = sliceType$4.nil; + i$1 = i$1 + (1) >> 0; + } + p.local = 0; + p.localSize = 0; + _i++; + } + allPools = new sliceType([]); + }; + init = function() { + runtime_registerPoolCleanup(poolCleanup); + }; + indexLocal = function(l, i) { + var i, l, lp; + lp = (((l) + ($imul(((i >>> 0)), 128) >>> 0) >>> 0)); + return ($pointerOfStructConversion(lp, ptrType$7)); + }; + init$1 = function() { + var n; + n = new notifyList.ptr(0, 0, 0, 0, 0); + runtime_notifyListCheck(20); + }; + runtime_doSpin = function() { + $throwRuntimeError("native function not implemented: sync.runtime_doSpin"); + }; + ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "getSlow", name: "getSlow", pkg: "sync", typ: $funcType([], [$emptyInterface], false)}, {prop: "pin", name: "pin", pkg: "sync", typ: $funcType([], [ptrType$7], false)}, {prop: "pinSlow", name: "pinSlow", pkg: "sync", typ: $funcType([], [ptrType$7], false)}]; + ptrType$15.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface, $Bool], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [], false)}, {prop: "LoadOrStore", name: "LoadOrStore", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [$emptyInterface, $Bool], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "Range", name: "Range", pkg: "", typ: $funcType([funcType$1], [], false)}, {prop: "missLocked", name: "missLocked", pkg: "sync", typ: $funcType([], [], false)}, {prop: "dirtyLocked", name: "dirtyLocked", pkg: "sync", typ: $funcType([], [], false)}]; + ptrType$4.methods = [{prop: "load", name: "load", pkg: "sync", typ: $funcType([], [$emptyInterface, $Bool], false)}, {prop: "tryStore", name: "tryStore", pkg: "sync", typ: $funcType([ptrType$3], [$Bool], false)}, {prop: "unexpungeLocked", name: "unexpungeLocked", pkg: "sync", typ: $funcType([], [$Bool], false)}, {prop: "storeLocked", name: "storeLocked", pkg: "sync", typ: $funcType([ptrType$3], [], false)}, {prop: "tryLoadOrStore", name: "tryLoadOrStore", pkg: "sync", typ: $funcType([$emptyInterface], [$emptyInterface, $Bool, $Bool], false)}, {prop: "delete$", name: "delete", pkg: "sync", typ: $funcType([], [$Bool], false)}, {prop: "tryExpungeLocked", name: "tryExpungeLocked", pkg: "sync", typ: $funcType([], [$Bool], false)}]; + ptrType$16.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; + Pool.init("sync", [{prop: "local", name: "local", anonymous: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "localSize", name: "localSize", anonymous: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "store", name: "store", anonymous: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "New", name: "New", anonymous: false, exported: true, typ: funcType, tag: ""}]); + Map.init("sync", [{prop: "mu", name: "mu", anonymous: false, exported: false, typ: Mutex, tag: ""}, {prop: "read", name: "read", anonymous: false, exported: false, typ: atomic.Value, tag: ""}, {prop: "dirty", name: "dirty", anonymous: false, exported: false, typ: mapType, tag: ""}, {prop: "misses", name: "misses", anonymous: false, exported: false, typ: $Int, tag: ""}]); + readOnly.init("sync", [{prop: "m", name: "m", anonymous: false, exported: false, typ: mapType, tag: ""}, {prop: "amended", name: "amended", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + entry.init("sync", [{prop: "p", name: "p", anonymous: false, exported: false, typ: $UnsafePointer, tag: ""}]); + Mutex.init("sync", [{prop: "state", name: "state", anonymous: false, exported: false, typ: $Int32, tag: ""}, {prop: "sema", name: "sema", anonymous: false, exported: false, typ: $Uint32, tag: ""}]); + poolLocalInternal.init("sync", [{prop: "private$0", name: "private", anonymous: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "shared", name: "shared", anonymous: false, exported: false, typ: sliceType$4, tag: ""}, {prop: "Mutex", name: "Mutex", anonymous: true, exported: true, typ: Mutex, tag: ""}]); + poolLocal.init("sync", [{prop: "poolLocalInternal", name: "poolLocalInternal", anonymous: true, exported: false, typ: poolLocalInternal, tag: ""}, {prop: "pad", name: "pad", anonymous: false, exported: false, typ: arrayType$2, tag: ""}]); + notifyList.init("sync", [{prop: "wait", name: "wait", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "notify", name: "notify", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "lock", name: "lock", anonymous: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "head", name: "head", anonymous: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "tail", name: "tail", anonymous: false, exported: false, typ: $UnsafePointer, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = race.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + allPools = sliceType.nil; + semWaiters = {}; + semAwoken = {}; + expunged = (new Uint8Array(8)); + init(); + init$1(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["io"] = (function() { + var $pkg = {}, $init, errors, sync, atomic, RuneScanner, errWhence, errOffset; + errors = $packages["errors"]; + sync = $packages["sync"]; + atomic = $packages["sync/atomic"]; + RuneScanner = $pkg.RuneScanner = $newType(8, $kindInterface, "io.RuneScanner", true, "io", true, null); + RuneScanner.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrShortWrite = errors.New("short write"); + $pkg.ErrShortBuffer = errors.New("short buffer"); + $pkg.EOF = errors.New("EOF"); + $pkg.ErrUnexpectedEOF = errors.New("unexpected EOF"); + $pkg.ErrNoProgress = errors.New("multiple Read calls return no data or error"); + errWhence = errors.New("Seek: invalid whence"); + errOffset = errors.New("Seek: invalid offset"); + $pkg.ErrClosedPipe = errors.New("io: read/write on closed pipe"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["math"] = (function() { + var $pkg = {}, $init, js, arrayType, arrayType$1, arrayType$2, structType, math, buf, init, Float32bits, Float64bits; + js = $packages["github.com/gopherjs/gopherjs/js"]; + arrayType = $arrayType($Uint32, 2); + arrayType$1 = $arrayType($Float32, 2); + arrayType$2 = $arrayType($Float64, 1); + structType = $structType("math", [{prop: "uint32array", name: "uint32array", anonymous: false, exported: false, typ: arrayType, tag: ""}, {prop: "float32array", name: "float32array", anonymous: false, exported: false, typ: arrayType$1, tag: ""}, {prop: "float64array", name: "float64array", anonymous: false, exported: false, typ: arrayType$2, tag: ""}]); + init = function() { + var ab; + ab = new ($global.ArrayBuffer)(8); + buf.uint32array = new ($global.Uint32Array)(ab); + buf.float32array = new ($global.Float32Array)(ab); + buf.float64array = new ($global.Float64Array)(ab); + }; + Float32bits = function(f) { + var f; + buf.float32array[0] = f; + return buf.uint32array[0]; + }; + $pkg.Float32bits = Float32bits; + Float64bits = function(f) { + var f, x, x$1; + buf.float64array[0] = f; + return (x = $shiftLeft64((new $Uint64(0, buf.uint32array[1])), 32), x$1 = (new $Uint64(0, buf.uint32array[0])), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + }; + $pkg.Float64bits = Float64bits; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + buf = new structType.ptr(arrayType.zero(), arrayType$1.zero(), arrayType$2.zero()); + math = $global.Math; + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["syscall"] = (function() { + var $pkg = {}, $init, js, race, runtime, sync, SockaddrLinklayer, SockaddrNetlink, mmapper, Errno, Sockaddr, SockaddrInet4, SockaddrInet6, SockaddrUnix, Timespec, Stat_t, RawSockaddrInet4, RawSockaddrInet6, RawSockaddrUnix, RawSockaddrLinklayer, RawSockaddrNetlink, RawSockaddr, RawSockaddrAny, _Socklen, Linger, Iovec, IPMreq, IPMreqn, IPv6Mreq, Msghdr, sliceType, sliceType$1, ptrType$2, ptrType$4, arrayType$1, ptrType$8, arrayType$2, ptrType$11, arrayType$4, arrayType$7, arrayType$8, arrayType$9, arrayType$10, ptrType$18, ptrType$19, structType, ptrType$22, ptrType$24, ptrType$25, mapType, funcType$2, funcType$3, ptrType$26, ptrType$27, ptrType$28, ptrType$29, arrayType$15, ptrType$31, warningPrinted, lineBuffer, syscallModule, alreadyTriedToLoad, minusOne, envs, mapper, errEAGAIN, errEINVAL, errENOENT, ioSync, ioSync$24ptr, errors, init, printWarning, printToConsole, indexByte, runtime_envs, syscall, Syscall, Syscall6, BytePtrFromString, readInt, readIntBE, readIntLE, ParseDirent, CloseOnExec, SetNonblock, msanRead, msanWrite, itoa, uitoa, anyToSockaddr, Accept, Accept4, SetsockoptIPMreqn, Recvmsg, SendmsgN, ReadDirent, direntIno, direntReclen, direntNamlen, errnoErr, Read, Write, GetsockoptInt, Recvfrom, Sendto, SetsockoptByte, SetsockoptInt, SetsockoptInet4Addr, SetsockoptIPMreq, SetsockoptIPv6Mreq, SetsockoptLinger, Close, Fchdir, Fchmod, fcntl, Fsync, Getdents, read, write, munmap, Fchown, Fstat, Ftruncate, Lstat, Pread, Pwrite, Seek, Shutdown, accept, accept4, getsockopt, setsockopt, recvfrom, sendto, recvmsg, sendmsg, mmap; + js = $packages["github.com/gopherjs/gopherjs/js"]; + race = $packages["internal/race"]; + runtime = $packages["runtime"]; + sync = $packages["sync"]; + SockaddrLinklayer = $pkg.SockaddrLinklayer = $newType(0, $kindStruct, "syscall.SockaddrLinklayer", true, "syscall", true, function(Protocol_, Ifindex_, Hatype_, Pkttype_, Halen_, Addr_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Protocol = 0; + this.Ifindex = 0; + this.Hatype = 0; + this.Pkttype = 0; + this.Halen = 0; + this.Addr = arrayType$1.zero(); + this.raw = new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero()); + return; + } + this.Protocol = Protocol_; + this.Ifindex = Ifindex_; + this.Hatype = Hatype_; + this.Pkttype = Pkttype_; + this.Halen = Halen_; + this.Addr = Addr_; + this.raw = raw_; + }); + SockaddrNetlink = $pkg.SockaddrNetlink = $newType(0, $kindStruct, "syscall.SockaddrNetlink", true, "syscall", true, function(Family_, Pad_, Pid_, Groups_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Pad = 0; + this.Pid = 0; + this.Groups = 0; + this.raw = new RawSockaddrNetlink.ptr(0, 0, 0, 0); + return; + } + this.Family = Family_; + this.Pad = Pad_; + this.Pid = Pid_; + this.Groups = Groups_; + this.raw = raw_; + }); + mmapper = $pkg.mmapper = $newType(0, $kindStruct, "syscall.mmapper", true, "syscall", false, function(Mutex_, active_, mmap_, munmap_) { + this.$val = this; + if (arguments.length === 0) { + this.Mutex = new sync.Mutex.ptr(0, 0); + this.active = false; + this.mmap = $throwNilPointerError; + this.munmap = $throwNilPointerError; + return; + } + this.Mutex = Mutex_; + this.active = active_; + this.mmap = mmap_; + this.munmap = munmap_; + }); + Errno = $pkg.Errno = $newType(4, $kindUintptr, "syscall.Errno", true, "syscall", true, null); + Sockaddr = $pkg.Sockaddr = $newType(8, $kindInterface, "syscall.Sockaddr", true, "syscall", true, null); + SockaddrInet4 = $pkg.SockaddrInet4 = $newType(0, $kindStruct, "syscall.SockaddrInet4", true, "syscall", true, function(Port_, Addr_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Port = 0; + this.Addr = arrayType$8.zero(); + this.raw = new RawSockaddrInet4.ptr(0, 0, arrayType$8.zero(), arrayType$1.zero()); + return; + } + this.Port = Port_; + this.Addr = Addr_; + this.raw = raw_; + }); + SockaddrInet6 = $pkg.SockaddrInet6 = $newType(0, $kindStruct, "syscall.SockaddrInet6", true, "syscall", true, function(Port_, ZoneId_, Addr_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Port = 0; + this.ZoneId = 0; + this.Addr = arrayType$2.zero(); + this.raw = new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0); + return; + } + this.Port = Port_; + this.ZoneId = ZoneId_; + this.Addr = Addr_; + this.raw = raw_; + }); + SockaddrUnix = $pkg.SockaddrUnix = $newType(0, $kindStruct, "syscall.SockaddrUnix", true, "syscall", true, function(Name_, raw_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.raw = new RawSockaddrUnix.ptr(0, arrayType$7.zero()); + return; + } + this.Name = Name_; + this.raw = raw_; + }); + Timespec = $pkg.Timespec = $newType(0, $kindStruct, "syscall.Timespec", true, "syscall", true, function(Sec_, Nsec_) { + this.$val = this; + if (arguments.length === 0) { + this.Sec = new $Int64(0, 0); + this.Nsec = new $Int64(0, 0); + return; + } + this.Sec = Sec_; + this.Nsec = Nsec_; + }); + Stat_t = $pkg.Stat_t = $newType(0, $kindStruct, "syscall.Stat_t", true, "syscall", true, function(Dev_, Ino_, Nlink_, Mode_, Uid_, Gid_, X__pad0_, Rdev_, Size_, Blksize_, Blocks_, Atim_, Mtim_, Ctim_, X__unused_) { + this.$val = this; + if (arguments.length === 0) { + this.Dev = new $Uint64(0, 0); + this.Ino = new $Uint64(0, 0); + this.Nlink = new $Uint64(0, 0); + this.Mode = 0; + this.Uid = 0; + this.Gid = 0; + this.X__pad0 = 0; + this.Rdev = new $Uint64(0, 0); + this.Size = new $Int64(0, 0); + this.Blksize = new $Int64(0, 0); + this.Blocks = new $Int64(0, 0); + this.Atim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); + this.Mtim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); + this.Ctim = new Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)); + this.X__unused = arrayType$15.zero(); + return; + } + this.Dev = Dev_; + this.Ino = Ino_; + this.Nlink = Nlink_; + this.Mode = Mode_; + this.Uid = Uid_; + this.Gid = Gid_; + this.X__pad0 = X__pad0_; + this.Rdev = Rdev_; + this.Size = Size_; + this.Blksize = Blksize_; + this.Blocks = Blocks_; + this.Atim = Atim_; + this.Mtim = Mtim_; + this.Ctim = Ctim_; + this.X__unused = X__unused_; + }); + RawSockaddrInet4 = $pkg.RawSockaddrInet4 = $newType(0, $kindStruct, "syscall.RawSockaddrInet4", true, "syscall", true, function(Family_, Port_, Addr_, Zero_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Port = 0; + this.Addr = arrayType$8.zero(); + this.Zero = arrayType$1.zero(); + return; + } + this.Family = Family_; + this.Port = Port_; + this.Addr = Addr_; + this.Zero = Zero_; + }); + RawSockaddrInet6 = $pkg.RawSockaddrInet6 = $newType(0, $kindStruct, "syscall.RawSockaddrInet6", true, "syscall", true, function(Family_, Port_, Flowinfo_, Addr_, Scope_id_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Port = 0; + this.Flowinfo = 0; + this.Addr = arrayType$2.zero(); + this.Scope_id = 0; + return; + } + this.Family = Family_; + this.Port = Port_; + this.Flowinfo = Flowinfo_; + this.Addr = Addr_; + this.Scope_id = Scope_id_; + }); + RawSockaddrUnix = $pkg.RawSockaddrUnix = $newType(0, $kindStruct, "syscall.RawSockaddrUnix", true, "syscall", true, function(Family_, Path_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Path = arrayType$7.zero(); + return; + } + this.Family = Family_; + this.Path = Path_; + }); + RawSockaddrLinklayer = $pkg.RawSockaddrLinklayer = $newType(0, $kindStruct, "syscall.RawSockaddrLinklayer", true, "syscall", true, function(Family_, Protocol_, Ifindex_, Hatype_, Pkttype_, Halen_, Addr_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Protocol = 0; + this.Ifindex = 0; + this.Hatype = 0; + this.Pkttype = 0; + this.Halen = 0; + this.Addr = arrayType$1.zero(); + return; + } + this.Family = Family_; + this.Protocol = Protocol_; + this.Ifindex = Ifindex_; + this.Hatype = Hatype_; + this.Pkttype = Pkttype_; + this.Halen = Halen_; + this.Addr = Addr_; + }); + RawSockaddrNetlink = $pkg.RawSockaddrNetlink = $newType(0, $kindStruct, "syscall.RawSockaddrNetlink", true, "syscall", true, function(Family_, Pad_, Pid_, Groups_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Pad = 0; + this.Pid = 0; + this.Groups = 0; + return; + } + this.Family = Family_; + this.Pad = Pad_; + this.Pid = Pid_; + this.Groups = Groups_; + }); + RawSockaddr = $pkg.RawSockaddr = $newType(0, $kindStruct, "syscall.RawSockaddr", true, "syscall", true, function(Family_, Data_) { + this.$val = this; + if (arguments.length === 0) { + this.Family = 0; + this.Data = arrayType$9.zero(); + return; + } + this.Family = Family_; + this.Data = Data_; + }); + RawSockaddrAny = $pkg.RawSockaddrAny = $newType(0, $kindStruct, "syscall.RawSockaddrAny", true, "syscall", true, function(Addr_, Pad_) { + this.$val = this; + if (arguments.length === 0) { + this.Addr = new RawSockaddr.ptr(0, arrayType$9.zero()); + this.Pad = arrayType$10.zero(); + return; + } + this.Addr = Addr_; + this.Pad = Pad_; + }); + _Socklen = $pkg._Socklen = $newType(4, $kindUint32, "syscall._Socklen", true, "syscall", false, null); + Linger = $pkg.Linger = $newType(0, $kindStruct, "syscall.Linger", true, "syscall", true, function(Onoff_, Linger_) { + this.$val = this; + if (arguments.length === 0) { + this.Onoff = 0; + this.Linger = 0; + return; + } + this.Onoff = Onoff_; + this.Linger = Linger_; + }); + Iovec = $pkg.Iovec = $newType(0, $kindStruct, "syscall.Iovec", true, "syscall", true, function(Base_, Len_) { + this.$val = this; + if (arguments.length === 0) { + this.Base = ptrType$2.nil; + this.Len = new $Uint64(0, 0); + return; + } + this.Base = Base_; + this.Len = Len_; + }); + IPMreq = $pkg.IPMreq = $newType(0, $kindStruct, "syscall.IPMreq", true, "syscall", true, function(Multiaddr_, Interface_) { + this.$val = this; + if (arguments.length === 0) { + this.Multiaddr = arrayType$8.zero(); + this.Interface = arrayType$8.zero(); + return; + } + this.Multiaddr = Multiaddr_; + this.Interface = Interface_; + }); + IPMreqn = $pkg.IPMreqn = $newType(0, $kindStruct, "syscall.IPMreqn", true, "syscall", true, function(Multiaddr_, Address_, Ifindex_) { + this.$val = this; + if (arguments.length === 0) { + this.Multiaddr = arrayType$8.zero(); + this.Address = arrayType$8.zero(); + this.Ifindex = 0; + return; + } + this.Multiaddr = Multiaddr_; + this.Address = Address_; + this.Ifindex = Ifindex_; + }); + IPv6Mreq = $pkg.IPv6Mreq = $newType(0, $kindStruct, "syscall.IPv6Mreq", true, "syscall", true, function(Multiaddr_, Interface_) { + this.$val = this; + if (arguments.length === 0) { + this.Multiaddr = arrayType$2.zero(); + this.Interface = 0; + return; + } + this.Multiaddr = Multiaddr_; + this.Interface = Interface_; + }); + Msghdr = $pkg.Msghdr = $newType(0, $kindStruct, "syscall.Msghdr", true, "syscall", true, function(Name_, Namelen_, Pad_cgo_0_, Iov_, Iovlen_, Control_, Controllen_, Flags_, Pad_cgo_1_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ptrType$2.nil; + this.Namelen = 0; + this.Pad_cgo_0 = arrayType$8.zero(); + this.Iov = ptrType$19.nil; + this.Iovlen = new $Uint64(0, 0); + this.Control = ptrType$2.nil; + this.Controllen = new $Uint64(0, 0); + this.Flags = 0; + this.Pad_cgo_1 = arrayType$8.zero(); + return; + } + this.Name = Name_; + this.Namelen = Namelen_; + this.Pad_cgo_0 = Pad_cgo_0_; + this.Iov = Iov_; + this.Iovlen = Iovlen_; + this.Control = Control_; + this.Controllen = Controllen_; + this.Flags = Flags_; + this.Pad_cgo_1 = Pad_cgo_1_; + }); + sliceType = $sliceType($Uint8); + sliceType$1 = $sliceType($String); + ptrType$2 = $ptrType($Uint8); + ptrType$4 = $ptrType($Int32); + arrayType$1 = $arrayType($Uint8, 8); + ptrType$8 = $ptrType($Uint16); + arrayType$2 = $arrayType($Uint8, 16); + ptrType$11 = $ptrType(SockaddrNetlink); + arrayType$4 = $arrayType($Uint8, 32); + arrayType$7 = $arrayType($Int8, 108); + arrayType$8 = $arrayType($Uint8, 4); + arrayType$9 = $arrayType($Int8, 14); + arrayType$10 = $arrayType($Int8, 96); + ptrType$18 = $ptrType(_Socklen); + ptrType$19 = $ptrType(Iovec); + structType = $structType("syscall", [{prop: "addr", name: "addr", anonymous: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "len", name: "len", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "cap", name: "cap", anonymous: false, exported: false, typ: $Int, tag: ""}]); + ptrType$22 = $ptrType($Int64); + ptrType$24 = $ptrType(SockaddrLinklayer); + ptrType$25 = $ptrType(mmapper); + mapType = $mapType(ptrType$2, sliceType); + funcType$2 = $funcType([$Uintptr, $Uintptr, $Int, $Int, $Int, $Int64], [$Uintptr, $error], false); + funcType$3 = $funcType([$Uintptr, $Uintptr], [$error], false); + ptrType$26 = $ptrType(SockaddrInet4); + ptrType$27 = $ptrType(SockaddrInet6); + ptrType$28 = $ptrType(SockaddrUnix); + ptrType$29 = $ptrType(Timespec); + arrayType$15 = $arrayType($Int64, 3); + ptrType$31 = $ptrType(Msghdr); + init = function() { + $flushConsole = (function() { + if (!((lineBuffer.$length === 0))) { + $global.console.log($externalize(($bytesToString(lineBuffer)), $String)); + lineBuffer = sliceType.nil; + } + }); + }; + printWarning = function() { + if (!warningPrinted) { + $global.console.error($externalize("warning: system calls not available, see https://github.com/gopherjs/gopherjs/blob/master/doc/syscalls.md", $String)); + } + warningPrinted = true; + }; + printToConsole = function(b) { + var b, goPrintToConsole, i; + goPrintToConsole = $global.goPrintToConsole; + if (!(goPrintToConsole === undefined)) { + goPrintToConsole(b); + return; + } + lineBuffer = $appendSlice(lineBuffer, b); + while (true) { + i = indexByte(lineBuffer, 10); + if (i === -1) { + break; + } + $global.console.log($externalize(($bytesToString($subslice(lineBuffer, 0, i))), $String)); + lineBuffer = $subslice(lineBuffer, (i + 1 >> 0)); + } + }; + indexByte = function(s, c) { + var _i, _ref, b, c, i, s; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (b === c) { + return i; + } + _i++; + } + return -1; + }; + runtime_envs = function() { + var envkeys, envs$1, i, jsEnv, key, process; + process = $global.process; + if (process === undefined) { + return sliceType$1.nil; + } + jsEnv = process.env; + envkeys = $global.Object.keys(jsEnv); + envs$1 = $makeSlice(sliceType$1, $parseInt(envkeys.length)); + i = 0; + while (true) { + if (!(i < $parseInt(envkeys.length))) { break; } + key = $internalize(envkeys[i], $String); + ((i < 0 || i >= envs$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : envs$1.$array[envs$1.$offset + i] = key + "=" + $internalize(jsEnv[$externalize(key, $String)], $String)); + i = i + (1) >> 0; + } + return envs$1; + }; + syscall = function(name) { + var name, require, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([(function() { + $recover(); + }), []]); + if (syscallModule === null) { + if (alreadyTriedToLoad) { + return null; + } + alreadyTriedToLoad = true; + require = $global.require; + if (require === undefined) { + $panic(new $String("")); + } + syscallModule = require($externalize("syscall", $String)); + } + return syscallModule[$externalize(name, $String)]; + /* */ } catch(err) { $err = err; return null; } finally { $callDeferred($deferred, $err); } + }; + Syscall = function(trap, a1, a2, a3) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, a1, a2, a3, array, err, f, r, r1, r2, slice, trap; + r1 = 0; + r2 = 0; + err = 0; + f = syscall("Syscall"); + if (!(f === null)) { + r = f(trap, a1, a2, a3); + _tmp = ((($parseInt(r[0]) >> 0) >>> 0)); + _tmp$1 = ((($parseInt(r[1]) >> 0) >>> 0)); + _tmp$2 = ((($parseInt(r[2]) >> 0) >>> 0)); + r1 = _tmp; + r2 = _tmp$1; + err = _tmp$2; + return [r1, r2, err]; + } + if ((trap === 1) && ((a1 === 1) || (a1 === 2))) { + array = a2; + slice = $makeSlice(sliceType, $parseInt(array.length)); + slice.$array = array; + printToConsole(slice); + _tmp$3 = (($parseInt(array.length) >>> 0)); + _tmp$4 = 0; + _tmp$5 = 0; + r1 = _tmp$3; + r2 = _tmp$4; + err = _tmp$5; + return [r1, r2, err]; + } + if (trap === 231) { + runtime.Goexit(); + } + printWarning(); + _tmp$6 = ((minusOne >>> 0)); + _tmp$7 = 0; + _tmp$8 = 13; + r1 = _tmp$6; + r2 = _tmp$7; + err = _tmp$8; + return [r1, r2, err]; + }; + $pkg.Syscall = Syscall; + Syscall6 = function(trap, a1, a2, a3, a4, a5, a6) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, a1, a2, a3, a4, a5, a6, err, f, r, r1, r2, trap; + r1 = 0; + r2 = 0; + err = 0; + f = syscall("Syscall6"); + if (!(f === null)) { + r = f(trap, a1, a2, a3, a4, a5, a6); + _tmp = ((($parseInt(r[0]) >> 0) >>> 0)); + _tmp$1 = ((($parseInt(r[1]) >> 0) >>> 0)); + _tmp$2 = ((($parseInt(r[2]) >> 0) >>> 0)); + r1 = _tmp; + r2 = _tmp$1; + err = _tmp$2; + return [r1, r2, err]; + } + if (!((trap === 202))) { + printWarning(); + } + _tmp$3 = ((minusOne >>> 0)); + _tmp$4 = 0; + _tmp$5 = 13; + r1 = _tmp$3; + r2 = _tmp$4; + err = _tmp$5; + return [r1, r2, err]; + }; + $pkg.Syscall6 = Syscall6; + BytePtrFromString = function(s) { + var _i, _ref, array, b, i, s; + array = new ($global.Uint8Array)(s.length + 1 >> 0); + _ref = (new sliceType($stringToBytes(s))); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + b = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (b === 0) { + return [ptrType$2.nil, new Errno(22)]; + } + array[i] = b; + _i++; + } + array[s.length] = 0; + return [((array)), $ifaceNil]; + }; + $pkg.BytePtrFromString = BytePtrFromString; + readInt = function(b, off, size) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, off, ok, size, u; + u = new $Uint64(0, 0); + ok = false; + if (b.$length < (((off + size >>> 0) >> 0))) { + _tmp = new $Uint64(0, 0); + _tmp$1 = false; + u = _tmp; + ok = _tmp$1; + return [u, ok]; + } + if (false) { + _tmp$2 = readIntBE($subslice(b, off), size); + _tmp$3 = true; + u = _tmp$2; + ok = _tmp$3; + return [u, ok]; + } + _tmp$4 = readIntLE($subslice(b, off), size); + _tmp$5 = true; + u = _tmp$4; + ok = _tmp$5; + return [u, ok]; + }; + readIntBE = function(b, size) { + var _1, b, size, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + _1 = size; + if (_1 === (1)) { + return (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))); + } else if (_1 === (2)) { + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + return (x = (new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), x$1 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 8), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)); + } else if (_1 === (4)) { + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + return (x$2 = (x$3 = (x$4 = (new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), x$5 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 8), new $Uint64(x$4.$high | x$5.$high, (x$4.$low | x$5.$low) >>> 0)), x$6 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 16), new $Uint64(x$3.$high | x$6.$high, (x$3.$low | x$6.$low) >>> 0)), x$7 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 24), new $Uint64(x$2.$high | x$7.$high, (x$2.$low | x$7.$low) >>> 0)); + } else if (_1 === (8)) { + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + return (x$8 = (x$9 = (x$10 = (x$11 = (x$12 = (x$13 = (x$14 = (new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), x$15 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 8), new $Uint64(x$14.$high | x$15.$high, (x$14.$low | x$15.$low) >>> 0)), x$16 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 16), new $Uint64(x$13.$high | x$16.$high, (x$13.$low | x$16.$low) >>> 0)), x$17 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 24), new $Uint64(x$12.$high | x$17.$high, (x$12.$low | x$17.$low) >>> 0)), x$18 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 32), new $Uint64(x$11.$high | x$18.$high, (x$11.$low | x$18.$low) >>> 0)), x$19 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 40), new $Uint64(x$10.$high | x$19.$high, (x$10.$low | x$19.$low) >>> 0)), x$20 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 48), new $Uint64(x$9.$high | x$20.$high, (x$9.$low | x$20.$low) >>> 0)), x$21 = $shiftLeft64((new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), 56), new $Uint64(x$8.$high | x$21.$high, (x$8.$low | x$21.$low) >>> 0)); + } else { + $panic(new $String("syscall: readInt with unsupported size")); + } + }; + readIntLE = function(b, size) { + var _1, b, size, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + _1 = size; + if (_1 === (1)) { + return (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))); + } else if (_1 === (2)) { + $unused((1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1])); + return (x = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$1 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)); + } else if (_1 === (4)) { + $unused((3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3])); + return (x$2 = (x$3 = (x$4 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$5 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$4.$high | x$5.$high, (x$4.$low | x$5.$low) >>> 0)), x$6 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$3.$high | x$6.$high, (x$3.$low | x$6.$low) >>> 0)), x$7 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$2.$high | x$7.$high, (x$2.$low | x$7.$low) >>> 0)); + } else if (_1 === (8)) { + $unused((7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7])); + return (x$8 = (x$9 = (x$10 = (x$11 = (x$12 = (x$13 = (x$14 = (new $Uint64(0, (0 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 0]))), x$15 = $shiftLeft64((new $Uint64(0, (1 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 1]))), 8), new $Uint64(x$14.$high | x$15.$high, (x$14.$low | x$15.$low) >>> 0)), x$16 = $shiftLeft64((new $Uint64(0, (2 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 2]))), 16), new $Uint64(x$13.$high | x$16.$high, (x$13.$low | x$16.$low) >>> 0)), x$17 = $shiftLeft64((new $Uint64(0, (3 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 3]))), 24), new $Uint64(x$12.$high | x$17.$high, (x$12.$low | x$17.$low) >>> 0)), x$18 = $shiftLeft64((new $Uint64(0, (4 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 4]))), 32), new $Uint64(x$11.$high | x$18.$high, (x$11.$low | x$18.$low) >>> 0)), x$19 = $shiftLeft64((new $Uint64(0, (5 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 5]))), 40), new $Uint64(x$10.$high | x$19.$high, (x$10.$low | x$19.$low) >>> 0)), x$20 = $shiftLeft64((new $Uint64(0, (6 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 6]))), 48), new $Uint64(x$9.$high | x$20.$high, (x$9.$low | x$20.$low) >>> 0)), x$21 = $shiftLeft64((new $Uint64(0, (7 >= b.$length ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + 7]))), 56), new $Uint64(x$8.$high | x$21.$high, (x$8.$low | x$21.$low) >>> 0)); + } else { + $panic(new $String("syscall: readInt with unsupported size")); + } + }; + ParseDirent = function(buf, max, names) { + var _i, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _tuple$2, buf, c, consumed, count, i, ino, max, name, names, namlen, newnames, ok, origlen, rec, reclen, x, x$1, x$2; + consumed = 0; + count = 0; + newnames = sliceType$1.nil; + origlen = buf.$length; + count = 0; + while (true) { + if (!(!((max === 0)) && buf.$length > 0)) { break; } + _tuple = direntReclen(buf); + reclen = _tuple[0]; + ok = _tuple[1]; + if (!ok || (x = (new $Uint64(0, buf.$length)), (reclen.$high > x.$high || (reclen.$high === x.$high && reclen.$low > x.$low)))) { + _tmp = origlen; + _tmp$1 = count; + _tmp$2 = names; + consumed = _tmp; + count = _tmp$1; + newnames = _tmp$2; + return [consumed, count, newnames]; + } + rec = $subslice(buf, 0, $flatten64(reclen)); + buf = $subslice(buf, $flatten64(reclen)); + _tuple$1 = direntIno(rec); + ino = _tuple$1[0]; + ok = _tuple$1[1]; + if (!ok) { + break; + } + if ((ino.$high === 0 && ino.$low === 0)) { + continue; + } + _tuple$2 = direntNamlen(rec); + namlen = _tuple$2[0]; + ok = _tuple$2[1]; + if (!ok || (x$1 = new $Uint64(0 + namlen.$high, 19 + namlen.$low), x$2 = (new $Uint64(0, rec.$length)), (x$1.$high > x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) { + break; + } + name = $subslice(rec, 19, $flatten64(new $Uint64(0 + namlen.$high, 19 + namlen.$low))); + _ref = name; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (c === 0) { + name = $subslice(name, 0, i); + break; + } + _i++; + } + if (($bytesToString(name)) === "." || ($bytesToString(name)) === "..") { + continue; + } + max = max - (1) >> 0; + count = count + (1) >> 0; + names = $append(names, ($bytesToString(name))); + } + _tmp$3 = origlen - buf.$length >> 0; + _tmp$4 = count; + _tmp$5 = names; + consumed = _tmp$3; + count = _tmp$4; + newnames = _tmp$5; + return [consumed, count, newnames]; + }; + $pkg.ParseDirent = ParseDirent; + CloseOnExec = function(fd) { + var fd; + fcntl(fd, 2, 1); + }; + $pkg.CloseOnExec = CloseOnExec; + SetNonblock = function(fd, nonblocking) { + var _tuple, _tuple$1, err, fd, flag, nonblocking; + err = $ifaceNil; + _tuple = fcntl(fd, 3, 0); + flag = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + err = err; + return err; + } + if (nonblocking) { + flag = flag | (2048); + } else { + flag = (flag & ~(2048)) >> 0; + } + _tuple$1 = fcntl(fd, 4, flag); + err = _tuple$1[1]; + err = err; + return err; + }; + $pkg.SetNonblock = SetNonblock; + msanRead = function(addr, len) { + var addr, len; + }; + msanWrite = function(addr, len) { + var addr, len; + }; + itoa = function(val) { + var val; + if (val < 0) { + return "-" + uitoa(((-val >>> 0))); + } + return uitoa(((val >>> 0))); + }; + uitoa = function(val) { + var _q, _r, buf, i, val; + buf = arrayType$4.zero(); + i = 31; + while (true) { + if (!(val >= 10)) { break; } + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = ((((_r = val % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24))); + i = i - (1) >> 0; + val = (_q = val / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + } + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = (((val + 48 >>> 0) << 24 >>> 24))); + return ($bytesToString($subslice(new sliceType(buf), i))); + }; + Timespec.ptr.prototype.Unix = function() { + var _tmp, _tmp$1, nsec, sec, ts; + sec = new $Int64(0, 0); + nsec = new $Int64(0, 0); + ts = this; + _tmp = (ts.Sec); + _tmp$1 = (ts.Nsec); + sec = _tmp; + nsec = _tmp$1; + return [sec, nsec]; + }; + Timespec.prototype.Unix = function() { return this.$val.Unix(); }; + Timespec.ptr.prototype.Nano = function() { + var ts, x, x$1; + ts = this; + return (x = $mul64((ts.Sec), new $Int64(0, 1000000000)), x$1 = (ts.Nsec), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)); + }; + Timespec.prototype.Nano = function() { return this.$val.Nano(); }; + SockaddrInet4.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, p, sa, x, x$1, x$2; + sa = this; + if (sa.Port < 0 || sa.Port > 65535) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 2; + p = (((x = sa.raw, (x.$ptr_Port || (x.$ptr_Port = new ptrType$8(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, x)))))); + p.nilCheck, p[0] = (((sa.Port >> 8 >> 0) << 24 >>> 24)); + p.nilCheck, p[1] = ((sa.Port << 24 >>> 24)); + i = 0; + while (true) { + if (!(i < 4)) { break; } + (x$2 = sa.raw.Addr, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = (x$1 = sa.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])))); + i = i + (1) >> 0; + } + _array = new Uint8Array(16); + return [(_array), 16, $ifaceNil]; + }; + SockaddrInet4.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrInet6.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, p, sa, x, x$1, x$2; + sa = this; + if (sa.Port < 0 || sa.Port > 65535) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 10; + p = (((x = sa.raw, (x.$ptr_Port || (x.$ptr_Port = new ptrType$8(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, x)))))); + p.nilCheck, p[0] = (((sa.Port >> 8 >> 0) << 24 >>> 24)); + p.nilCheck, p[1] = ((sa.Port << 24 >>> 24)); + sa.raw.Scope_id = sa.ZoneId; + i = 0; + while (true) { + if (!(i < 16)) { break; } + (x$2 = sa.raw.Addr, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = (x$1 = sa.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])))); + i = i + (1) >> 0; + } + _array = new Uint8Array(28); + return [(_array), 28, $ifaceNil]; + }; + SockaddrInet6.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrUnix.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, n, name, sa, sl, x; + sa = this; + name = sa.Name; + n = name.length; + if (n > 108) { + return [0, 0, new Errno(22)]; + } + if ((n === 108) && !((name.charCodeAt(0) === 64))) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 1; + i = 0; + while (true) { + if (!(i < n)) { break; } + (x = sa.raw.Path, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i] = ((name.charCodeAt(i) << 24 >> 24)))); + i = i + (1) >> 0; + } + sl = 2; + if (n > 0) { + sl = sl + ((((n >>> 0)) + 1 >>> 0)) >>> 0; + } + if (sa.raw.Path[0] === 64) { + sa.raw.Path[0] = 0; + sl = sl - (1) >>> 0; + } + _array = new Uint8Array(110); + return [(_array), sl, $ifaceNil]; + }; + SockaddrUnix.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrLinklayer.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, i, sa, x, x$1; + sa = this; + if (sa.Ifindex < 0 || sa.Ifindex > 2147483647) { + return [0, 0, new Errno(22)]; + } + sa.raw.Family = 17; + sa.raw.Protocol = sa.Protocol; + sa.raw.Ifindex = ((sa.Ifindex >> 0)); + sa.raw.Hatype = sa.Hatype; + sa.raw.Pkttype = sa.Pkttype; + sa.raw.Halen = sa.Halen; + i = 0; + while (true) { + if (!(i < 8)) { break; } + (x$1 = sa.raw.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i] = (x = sa.Addr, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])))); + i = i + (1) >> 0; + } + _array = new Uint8Array(20); + return [(_array), 20, $ifaceNil]; + }; + SockaddrLinklayer.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + SockaddrNetlink.ptr.prototype.sockaddr = function() { + var _array, _struct, _view, sa; + sa = this; + sa.raw.Family = 16; + sa.raw.Pad = sa.Pad; + sa.raw.Pid = sa.Pid; + sa.raw.Groups = sa.Groups; + _array = new Uint8Array(12); + return [(_array), 12, $ifaceNil]; + }; + SockaddrNetlink.prototype.sockaddr = function() { return this.$val.sockaddr(); }; + anyToSockaddr = function(rsa) { + var _1, _array, _array$1, _array$2, _array$3, _array$4, _array$5, _array$6, _array$7, _array$8, _array$9, _struct, _struct$1, _struct$2, _struct$3, _struct$4, _struct$5, _struct$6, _struct$7, _struct$8, _struct$9, _view, _view$1, _view$2, _view$3, _view$4, _view$5, _view$6, _view$7, _view$8, _view$9, bytes, i, i$1, i$2, n, p, p$1, pp, pp$1, pp$2, pp$3, pp$4, rsa, sa, sa$1, sa$2, sa$3, sa$4, x, x$1, x$2, x$3, x$4, x$5, x$6; + _1 = rsa.Addr.Family; + if (_1 === (16)) { + _array$1 = new Uint8Array(112); + pp = ((_array = (_array$1), _struct = new RawSockaddrNetlink.ptr(0, 0, 0, 0), _view = new DataView(_array.buffer, _array.byteOffset), _struct.Family = _view.getUint16(0, true), _struct.Pad = _view.getUint16(2, true), _struct.Pid = _view.getUint32(4, true), _struct.Groups = _view.getUint32(8, true), _struct)); + _struct$1 = rsa, _view$1 = new DataView(_array$1.buffer, _array$1.byteOffset), _struct$1.Addr.Family = _view$1.getUint16(0, true), _struct$1.Addr.Data = new ($nativeArray($kindInt8))(_array$1.buffer, $min(_array$1.byteOffset + 2, _array$1.buffer.byteLength)), _struct$1.Pad = new ($nativeArray($kindInt8))(_array$1.buffer, $min(_array$1.byteOffset + 16, _array$1.buffer.byteLength)); + sa = new SockaddrNetlink.ptr(0, 0, 0, 0, new RawSockaddrNetlink.ptr(0, 0, 0, 0)); + sa.Family = pp.Family; + sa.Pad = pp.Pad; + sa.Pid = pp.Pid; + sa.Groups = pp.Groups; + return [sa, $ifaceNil]; + } else if (_1 === (17)) { + _array$3 = new Uint8Array(112); + pp$1 = ((_array$2 = (_array$3), _struct$2 = new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero()), _view$2 = new DataView(_array$2.buffer, _array$2.byteOffset), _struct$2.Family = _view$2.getUint16(0, true), _struct$2.Protocol = _view$2.getUint16(2, true), _struct$2.Ifindex = _view$2.getInt32(4, true), _struct$2.Hatype = _view$2.getUint16(8, true), _struct$2.Pkttype = _view$2.getUint8(10, true), _struct$2.Halen = _view$2.getUint8(11, true), _struct$2.Addr = new ($nativeArray($kindUint8))(_array$2.buffer, $min(_array$2.byteOffset + 12, _array$2.buffer.byteLength)), _struct$2)); + _struct$3 = rsa, _view$3 = new DataView(_array$3.buffer, _array$3.byteOffset), _struct$3.Addr.Family = _view$3.getUint16(0, true), _struct$3.Addr.Data = new ($nativeArray($kindInt8))(_array$3.buffer, $min(_array$3.byteOffset + 2, _array$3.buffer.byteLength)), _struct$3.Pad = new ($nativeArray($kindInt8))(_array$3.buffer, $min(_array$3.byteOffset + 16, _array$3.buffer.byteLength)); + sa$1 = new SockaddrLinklayer.ptr(0, 0, 0, 0, 0, arrayType$1.zero(), new RawSockaddrLinklayer.ptr(0, 0, 0, 0, 0, 0, arrayType$1.zero())); + sa$1.Protocol = pp$1.Protocol; + sa$1.Ifindex = ((pp$1.Ifindex >> 0)); + sa$1.Hatype = pp$1.Hatype; + sa$1.Pkttype = pp$1.Pkttype; + sa$1.Halen = pp$1.Halen; + i = 0; + while (true) { + if (!(i < 8)) { break; } + (x$1 = sa$1.Addr, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i] = (x = pp$1.Addr, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])))); + i = i + (1) >> 0; + } + return [sa$1, $ifaceNil]; + } else if (_1 === (1)) { + _array$5 = new Uint8Array(112); + pp$2 = ((_array$4 = (_array$5), _struct$4 = new RawSockaddrUnix.ptr(0, arrayType$7.zero()), _view$4 = new DataView(_array$4.buffer, _array$4.byteOffset), _struct$4.Family = _view$4.getUint16(0, true), _struct$4.Path = new ($nativeArray($kindInt8))(_array$4.buffer, $min(_array$4.byteOffset + 2, _array$4.buffer.byteLength)), _struct$4)); + _struct$5 = rsa, _view$5 = new DataView(_array$5.buffer, _array$5.byteOffset), _struct$5.Addr.Family = _view$5.getUint16(0, true), _struct$5.Addr.Data = new ($nativeArray($kindInt8))(_array$5.buffer, $min(_array$5.byteOffset + 2, _array$5.buffer.byteLength)), _struct$5.Pad = new ($nativeArray($kindInt8))(_array$5.buffer, $min(_array$5.byteOffset + 16, _array$5.buffer.byteLength)); + sa$2 = new SockaddrUnix.ptr("", new RawSockaddrUnix.ptr(0, arrayType$7.zero())); + if (pp$2.Path[0] === 0) { + pp$2.Path[0] = 64; + } + n = 0; + while (true) { + if (!(n < 108 && !(((x$2 = pp$2.Path, ((n < 0 || n >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[n])) === 0)))) { break; } + n = n + (1) >> 0; + } + bytes = $subslice(new sliceType((($sliceToArray(new sliceType(pp$2.Path))))), 0, n); + sa$2.Name = ($bytesToString(bytes)); + return [sa$2, $ifaceNil]; + } else if (_1 === (2)) { + _array$7 = new Uint8Array(112); + pp$3 = ((_array$6 = (_array$7), _struct$6 = new RawSockaddrInet4.ptr(0, 0, arrayType$8.zero(), arrayType$1.zero()), _view$6 = new DataView(_array$6.buffer, _array$6.byteOffset), _struct$6.Family = _view$6.getUint16(0, true), _struct$6.Port = _view$6.getUint16(2, true), _struct$6.Addr = new ($nativeArray($kindUint8))(_array$6.buffer, $min(_array$6.byteOffset + 4, _array$6.buffer.byteLength)), _struct$6.Zero = new ($nativeArray($kindUint8))(_array$6.buffer, $min(_array$6.byteOffset + 8, _array$6.buffer.byteLength)), _struct$6)); + _struct$7 = rsa, _view$7 = new DataView(_array$7.buffer, _array$7.byteOffset), _struct$7.Addr.Family = _view$7.getUint16(0, true), _struct$7.Addr.Data = new ($nativeArray($kindInt8))(_array$7.buffer, $min(_array$7.byteOffset + 2, _array$7.buffer.byteLength)), _struct$7.Pad = new ($nativeArray($kindInt8))(_array$7.buffer, $min(_array$7.byteOffset + 16, _array$7.buffer.byteLength)); + sa$3 = new SockaddrInet4.ptr(0, arrayType$8.zero(), new RawSockaddrInet4.ptr(0, 0, arrayType$8.zero(), arrayType$1.zero())); + p = (((pp$3.$ptr_Port || (pp$3.$ptr_Port = new ptrType$8(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, pp$3))))); + sa$3.Port = ((((p.nilCheck, p[0]) >> 0)) << 8 >> 0) + (((p.nilCheck, p[1]) >> 0)) >> 0; + i$1 = 0; + while (true) { + if (!(i$1 < 4)) { break; } + (x$4 = sa$3.Addr, ((i$1 < 0 || i$1 >= x$4.length) ? ($throwRuntimeError("index out of range"), undefined) : x$4[i$1] = (x$3 = pp$3.Addr, ((i$1 < 0 || i$1 >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[i$1])))); + i$1 = i$1 + (1) >> 0; + } + return [sa$3, $ifaceNil]; + } else if (_1 === (10)) { + _array$9 = new Uint8Array(112); + pp$4 = ((_array$8 = (_array$9), _struct$8 = new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0), _view$8 = new DataView(_array$8.buffer, _array$8.byteOffset), _struct$8.Family = _view$8.getUint16(0, true), _struct$8.Port = _view$8.getUint16(2, true), _struct$8.Flowinfo = _view$8.getUint32(4, true), _struct$8.Addr = new ($nativeArray($kindUint8))(_array$8.buffer, $min(_array$8.byteOffset + 8, _array$8.buffer.byteLength)), _struct$8.Scope_id = _view$8.getUint32(24, true), _struct$8)); + _struct$9 = rsa, _view$9 = new DataView(_array$9.buffer, _array$9.byteOffset), _struct$9.Addr.Family = _view$9.getUint16(0, true), _struct$9.Addr.Data = new ($nativeArray($kindInt8))(_array$9.buffer, $min(_array$9.byteOffset + 2, _array$9.buffer.byteLength)), _struct$9.Pad = new ($nativeArray($kindInt8))(_array$9.buffer, $min(_array$9.byteOffset + 16, _array$9.buffer.byteLength)); + sa$4 = new SockaddrInet6.ptr(0, 0, arrayType$2.zero(), new RawSockaddrInet6.ptr(0, 0, 0, arrayType$2.zero(), 0)); + p$1 = (((pp$4.$ptr_Port || (pp$4.$ptr_Port = new ptrType$8(function() { return this.$target.Port; }, function($v) { this.$target.Port = $v; }, pp$4))))); + sa$4.Port = ((((p$1.nilCheck, p$1[0]) >> 0)) << 8 >> 0) + (((p$1.nilCheck, p$1[1]) >> 0)) >> 0; + sa$4.ZoneId = pp$4.Scope_id; + i$2 = 0; + while (true) { + if (!(i$2 < 16)) { break; } + (x$6 = sa$4.Addr, ((i$2 < 0 || i$2 >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[i$2] = (x$5 = pp$4.Addr, ((i$2 < 0 || i$2 >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i$2])))); + i$2 = i$2 + (1) >> 0; + } + return [sa$4, $ifaceNil]; + } + return [$ifaceNil, new Errno(97)]; + }; + Accept = function(fd) { + var _tuple, _tuple$1, err, fd, len, len$24ptr, nfd, rsa, sa; + nfd = 0; + sa = $ifaceNil; + err = $ifaceNil; + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$9.zero()), arrayType$10.zero()); + len = 112; + _tuple = accept(fd, rsa, (len$24ptr || (len$24ptr = new ptrType$18(function() { return len; }, function($v) { len = $v; })))); + nfd = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [nfd, sa, err]; + } + _tuple$1 = anyToSockaddr(rsa); + sa = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + Close(nfd); + nfd = 0; + } + return [nfd, sa, err]; + }; + $pkg.Accept = Accept; + Accept4 = function(fd, flags) { + var _tuple, _tuple$1, err, fd, flags, len, len$24ptr, nfd, rsa, sa; + nfd = 0; + sa = $ifaceNil; + err = $ifaceNil; + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$9.zero()), arrayType$10.zero()); + len = 112; + _tuple = accept4(fd, rsa, (len$24ptr || (len$24ptr = new ptrType$18(function() { return len; }, function($v) { len = $v; }))), flags); + nfd = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [nfd, sa, err]; + } + if (len > 112) { + $panic(new $String("RawSockaddrAny too small")); + } + _tuple$1 = anyToSockaddr(rsa); + sa = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + Close(nfd); + nfd = 0; + } + return [nfd, sa, err]; + }; + $pkg.Accept4 = Accept4; + SetsockoptIPMreqn = function(fd, level, opt, mreq) { + var _array, _struct, _view, err, fd, level, mreq, opt; + err = $ifaceNil; + _array = new Uint8Array(12); + err = setsockopt(fd, level, opt, (_array), 12); + _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Address = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 4, _array.buffer.byteLength)), _struct.Ifindex = _view.getInt32(8, true); + return err; + }; + $pkg.SetsockoptIPMreqn = SetsockoptIPMreqn; + Recvmsg = function(fd, p, oob, flags) { + var _array, _struct, _tuple, _tuple$1, _tuple$2, _view, dummy, dummy$24ptr, err, fd, flags, from, iov, msg, n, oob, oobn, p, recvflags, rsa, sockType; + n = 0; + oobn = 0; + recvflags = 0; + from = $ifaceNil; + err = $ifaceNil; + msg = new Msghdr.ptr(ptrType$2.nil, 0, arrayType$8.zero(), ptrType$19.nil, new $Uint64(0, 0), ptrType$2.nil, new $Uint64(0, 0), 0, arrayType$8.zero()); + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$9.zero()), arrayType$10.zero()); + _array = new Uint8Array(112); + msg.Name = ((_array)); + _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + msg.Namelen = 112; + iov = new Iovec.ptr(ptrType$2.nil, new $Uint64(0, 0)); + if (p.$length > 0) { + iov.Base = $indexPtr(p.$array, p.$offset + 0, ptrType$2); + iov.SetLen(p.$length); + } + dummy = 0; + if (oob.$length > 0) { + sockType = 0; + _tuple = GetsockoptInt(fd, 1, 3); + sockType = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [n, oobn, recvflags, from, err]; + } + if (!((sockType === 2)) && (p.$length === 0)) { + iov.Base = (dummy$24ptr || (dummy$24ptr = new ptrType$2(function() { return dummy; }, function($v) { dummy = $v; }))); + iov.SetLen(1); + } + msg.Control = $indexPtr(oob.$array, oob.$offset + 0, ptrType$2); + msg.SetControllen(oob.$length); + } + msg.Iov = iov; + msg.Iovlen = new $Uint64(0, 1); + _tuple$1 = recvmsg(fd, msg, flags); + n = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [n, oobn, recvflags, from, err]; + } + oobn = ((msg.Controllen.$low >> 0)); + recvflags = ((msg.Flags >> 0)); + if (!((rsa.Addr.Family === 0))) { + _tuple$2 = anyToSockaddr(rsa); + from = _tuple$2[0]; + err = _tuple$2[1]; + } + return [n, oobn, recvflags, from, err]; + }; + $pkg.Recvmsg = Recvmsg; + SendmsgN = function(fd, p, oob, to, flags) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, dummy, err, err$1, fd, flags, iov, msg, n, oob, p, ptr, salen, sockType, to, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; dummy = $f.dummy; err = $f.err; err$1 = $f.err$1; fd = $f.fd; flags = $f.flags; iov = $f.iov; msg = $f.msg; n = $f.n; oob = $f.oob; p = $f.p; ptr = $f.ptr; salen = $f.salen; sockType = $f.sockType; to = $f.to; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + dummy = [dummy]; + iov = [iov]; + msg = [msg]; + n = 0; + err = $ifaceNil; + ptr = 0; + salen = 0; + /* */ if (!($interfaceIsEqual(to, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(to, $ifaceNil))) { */ case 1: + err$1 = $ifaceNil; + _r = to.sockaddr(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ptr = _tuple[0]; + salen = _tuple[1]; + err$1 = _tuple[2]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + /* } */ case 2: + msg[0] = new Msghdr.ptr(ptrType$2.nil, 0, arrayType$8.zero(), ptrType$19.nil, new $Uint64(0, 0), ptrType$2.nil, new $Uint64(0, 0), 0, arrayType$8.zero()); + msg[0].Name = (ptr); + msg[0].Namelen = ((salen >>> 0)); + iov[0] = new Iovec.ptr(ptrType$2.nil, new $Uint64(0, 0)); + if (p.$length > 0) { + iov[0].Base = $indexPtr(p.$array, p.$offset + 0, ptrType$2); + iov[0].SetLen(p.$length); + } + dummy[0] = 0; + if (oob.$length > 0) { + sockType = 0; + _tuple$1 = GetsockoptInt(fd, 1, 3); + sockType = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$2 = 0; + _tmp$3 = err; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + if (!((sockType === 2)) && (p.$length === 0)) { + iov[0].Base = (dummy.$ptr || (dummy.$ptr = new ptrType$2(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, dummy))); + iov[0].SetLen(1); + } + msg[0].Control = $indexPtr(oob.$array, oob.$offset + 0, ptrType$2); + msg[0].SetControllen(oob.$length); + } + msg[0].Iov = iov[0]; + msg[0].Iovlen = new $Uint64(0, 1); + _tuple$2 = sendmsg(fd, msg[0], flags); + n = _tuple$2[0]; + err = _tuple$2[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + _tmp$4 = 0; + _tmp$5 = err; + n = _tmp$4; + err = _tmp$5; + $s = -1; return [n, err]; + } + if (oob.$length > 0 && (p.$length === 0)) { + n = 0; + } + _tmp$6 = n; + _tmp$7 = $ifaceNil; + n = _tmp$6; + err = _tmp$7; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: SendmsgN }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.dummy = dummy; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.flags = flags; $f.iov = iov; $f.msg = msg; $f.n = n; $f.oob = oob; $f.p = p; $f.ptr = ptr; $f.salen = salen; $f.sockType = sockType; $f.to = to; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.SendmsgN = SendmsgN; + ReadDirent = function(fd, buf) { + var _tuple, buf, err, fd, n; + n = 0; + err = $ifaceNil; + _tuple = Getdents(fd, buf); + n = _tuple[0]; + err = _tuple[1]; + return [n, err]; + }; + $pkg.ReadDirent = ReadDirent; + direntIno = function(buf) { + var buf; + return readInt(buf, 0, 8); + }; + direntReclen = function(buf) { + var buf; + return readInt(buf, 16, 2); + }; + direntNamlen = function(buf) { + var _tuple, buf, ok, reclen; + _tuple = direntReclen(buf); + reclen = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + return [new $Uint64(0, 0), false]; + } + return [new $Uint64(reclen.$high - 0, reclen.$low - 19), true]; + }; + Iovec.ptr.prototype.SetLen = function(length) { + var iov, length; + iov = this; + iov.Len = (new $Uint64(0, length)); + }; + Iovec.prototype.SetLen = function(length) { return this.$val.SetLen(length); }; + Msghdr.ptr.prototype.SetControllen = function(length) { + var length, msghdr; + msghdr = this; + msghdr.Controllen = (new $Uint64(0, length)); + }; + Msghdr.prototype.SetControllen = function(length) { return this.$val.SetControllen(length); }; + mmapper.ptr.prototype.Mmap = function(fd, offset, length, prot, flags) { + var _key, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, addr, b, data, err, errno, fd, flags, length, m, offset, p, prot, sl, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _key = $f._key; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; addr = $f.addr; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; fd = $f.fd; flags = $f.flags; length = $f.length; m = $f.m; offset = $f.offset; p = $f.p; prot = $f.prot; sl = $f.sl; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + sl = [sl]; + data = sliceType.nil; + err = $ifaceNil; + m = this; + if (length <= 0) { + _tmp = sliceType.nil; + _tmp$1 = new Errno(22); + data = _tmp; + err = _tmp$1; + $s = -1; return [data, err]; + } + _r = m.mmap(0, ((length >>> 0)), prot, flags, fd, offset); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + addr = _tuple[0]; + errno = _tuple[1]; + if (!($interfaceIsEqual(errno, $ifaceNil))) { + _tmp$2 = sliceType.nil; + _tmp$3 = errno; + data = _tmp$2; + err = _tmp$3; + $s = -1; return [data, err]; + } + sl[0] = new structType.ptr(addr, length, length); + b = sl[0]; + p = $indexPtr(b.$array, b.$offset + (b.$capacity - 1 >> 0), ptrType$2); + $r = m.Mutex.Lock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(m.Mutex, "Unlock"), []]); + _key = p; (m.active || $throwRuntimeError("assignment to entry in nil map"))[ptrType$2.keyFor(_key)] = { k: _key, v: b }; + _tmp$4 = b; + _tmp$5 = $ifaceNil; + data = _tmp$4; + err = _tmp$5; + $s = -1; return [data, err]; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [data, err]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Mmap }; } $f._key = _key; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.addr = addr; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.fd = fd; $f.flags = flags; $f.length = length; $f.m = m; $f.offset = offset; $f.p = p; $f.prot = prot; $f.sl = sl; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + mmapper.prototype.Mmap = function(fd, offset, length, prot, flags) { return this.$val.Mmap(fd, offset, length, prot, flags); }; + mmapper.ptr.prototype.Munmap = function(data) { + var _entry, _r, b, data, err, errno, m, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _r = $f._r; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; m = $f.m; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + err = $ifaceNil; + m = this; + if ((data.$length === 0) || !((data.$length === data.$capacity))) { + err = new Errno(22); + $s = -1; return err; + } + p = $indexPtr(data.$array, data.$offset + (data.$capacity - 1 >> 0), ptrType$2); + $r = m.Mutex.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(m.Mutex, "Unlock"), []]); + b = (_entry = m.active[ptrType$2.keyFor(p)], _entry !== undefined ? _entry.v : sliceType.nil); + if (b === sliceType.nil || !($indexPtr(b.$array, b.$offset + 0, ptrType$2) === $indexPtr(data.$array, data.$offset + 0, ptrType$2))) { + err = new Errno(22); + $s = -1; return err; + } + _r = m.munmap((($sliceToArray(b))), ((b.$length >>> 0))); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + errno = _r; + if (!($interfaceIsEqual(errno, $ifaceNil))) { + err = errno; + $s = -1; return err; + } + delete m.active[ptrType$2.keyFor(p)]; + err = $ifaceNil; + $s = -1; return err; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Munmap }; } $f._entry = _entry; $f._r = _r; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.m = m; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + mmapper.prototype.Munmap = function(data) { return this.$val.Munmap(data); }; + Errno.prototype.Error = function() { + var e, s; + e = this.$val; + if (0 <= ((e >> 0)) && ((e >> 0)) < 133) { + s = ((e < 0 || e >= errors.length) ? ($throwRuntimeError("index out of range"), undefined) : errors[e]); + if (!(s === "")) { + return s; + } + } + return "errno " + itoa(((e >> 0))); + }; + $ptrType(Errno).prototype.Error = function() { return new Errno(this.$get()).Error(); }; + Errno.prototype.Temporary = function() { + var e; + e = this.$val; + return (e === 4) || (e === 24) || (e === 104) || (e === 103) || new Errno(e).Timeout(); + }; + $ptrType(Errno).prototype.Temporary = function() { return new Errno(this.$get()).Temporary(); }; + Errno.prototype.Timeout = function() { + var e; + e = this.$val; + return (e === 11) || (e === 11) || (e === 110); + }; + $ptrType(Errno).prototype.Timeout = function() { return new Errno(this.$get()).Timeout(); }; + errnoErr = function(e) { + var _1, e; + _1 = e; + if (_1 === (0)) { + return $ifaceNil; + } else if (_1 === (11)) { + return errEAGAIN; + } else if (_1 === (22)) { + return errEINVAL; + } else if (_1 === (2)) { + return errENOENT; + } + return new Errno(e); + }; + Read = function(fd, p) { + var _tuple, err, fd, n, p; + n = 0; + err = $ifaceNil; + _tuple = read(fd, p); + n = _tuple[0]; + err = _tuple[1]; + if (false) { + if (n > 0) { + race.WriteRange(($sliceToArray(p)), n); + } + if ($interfaceIsEqual(err, $ifaceNil)) { + race.Acquire(((ioSync$24ptr || (ioSync$24ptr = new ptrType$22(function() { return ioSync; }, function($v) { ioSync = $v; }))))); + } + } + if (false && n > 0) { + msanWrite(($sliceToArray(p)), n); + } + return [n, err]; + }; + $pkg.Read = Read; + Write = function(fd, p) { + var _tuple, err, fd, n, p; + n = 0; + err = $ifaceNil; + if (false) { + race.ReleaseMerge(((ioSync$24ptr || (ioSync$24ptr = new ptrType$22(function() { return ioSync; }, function($v) { ioSync = $v; }))))); + } + _tuple = write(fd, p); + n = _tuple[0]; + err = _tuple[1]; + if (false && n > 0) { + race.ReadRange(($sliceToArray(p)), n); + } + if (false && n > 0) { + msanRead(($sliceToArray(p)), n); + } + return [n, err]; + }; + $pkg.Write = Write; + GetsockoptInt = function(fd, level, opt) { + var _tmp, _tmp$1, err, fd, level, n, n$24ptr, opt, vallen, vallen$24ptr, value; + value = 0; + err = $ifaceNil; + n = 0; + vallen = 4; + err = getsockopt(fd, level, opt, ((n$24ptr || (n$24ptr = new ptrType$4(function() { return n; }, function($v) { n = $v; })))), (vallen$24ptr || (vallen$24ptr = new ptrType$18(function() { return vallen; }, function($v) { vallen = $v; })))); + _tmp = ((n >> 0)); + _tmp$1 = err; + value = _tmp; + err = _tmp$1; + return [value, err]; + }; + $pkg.GetsockoptInt = GetsockoptInt; + Recvfrom = function(fd, p, flags) { + var _tuple, _tuple$1, err, fd, flags, from, len, len$24ptr, n, p, rsa; + n = 0; + from = $ifaceNil; + err = $ifaceNil; + rsa = new RawSockaddrAny.ptr(new RawSockaddr.ptr(0, arrayType$9.zero()), arrayType$10.zero()); + len = 112; + _tuple = recvfrom(fd, p, flags, rsa, (len$24ptr || (len$24ptr = new ptrType$18(function() { return len; }, function($v) { len = $v; })))); + n = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [n, from, err]; + } + if (!((rsa.Addr.Family === 0))) { + _tuple$1 = anyToSockaddr(rsa); + from = _tuple$1[0]; + err = _tuple$1[1]; + } + return [n, from, err]; + }; + $pkg.Recvfrom = Recvfrom; + Sendto = function(fd, p, flags, to) { + var _r, _tuple, err, fd, flags, n, p, ptr, to, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; fd = $f.fd; flags = $f.flags; n = $f.n; p = $f.p; ptr = $f.ptr; to = $f.to; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + err = $ifaceNil; + _r = to.sockaddr(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ptr = _tuple[0]; + n = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + err = err; + $s = -1; return err; + } + err = sendto(fd, p, flags, ptr, n); + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sendto }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.fd = fd; $f.flags = flags; $f.n = n; $f.p = p; $f.ptr = ptr; $f.to = to; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sendto = Sendto; + SetsockoptByte = function(fd, level, opt, value) { + var err, fd, level, opt, value, value$24ptr; + err = $ifaceNil; + err = setsockopt(fd, level, opt, ((value$24ptr || (value$24ptr = new ptrType$2(function() { return value; }, function($v) { value = $v; })))), 1); + return err; + }; + $pkg.SetsockoptByte = SetsockoptByte; + SetsockoptInt = function(fd, level, opt, value) { + var err, fd, level, n, n$24ptr, opt, value; + err = $ifaceNil; + n = ((value >> 0)); + err = setsockopt(fd, level, opt, ((n$24ptr || (n$24ptr = new ptrType$4(function() { return n; }, function($v) { n = $v; })))), 4); + return err; + }; + $pkg.SetsockoptInt = SetsockoptInt; + SetsockoptInet4Addr = function(fd, level, opt, value) { + var err, fd, level, opt, value; + err = $ifaceNil; + err = setsockopt(fd, level, opt, ($sliceToArray(new sliceType(value))), 4); + return err; + }; + $pkg.SetsockoptInet4Addr = SetsockoptInet4Addr; + SetsockoptIPMreq = function(fd, level, opt, mreq) { + var _array, _struct, _view, err, fd, level, mreq, opt; + err = $ifaceNil; + _array = new Uint8Array(8); + err = setsockopt(fd, level, opt, (_array), 8); + _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Interface = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 4, _array.buffer.byteLength)); + return err; + }; + $pkg.SetsockoptIPMreq = SetsockoptIPMreq; + SetsockoptIPv6Mreq = function(fd, level, opt, mreq) { + var _array, _struct, _view, err, fd, level, mreq, opt; + err = $ifaceNil; + _array = new Uint8Array(20); + err = setsockopt(fd, level, opt, (_array), 20); + _struct = mreq, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Multiaddr = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 0, _array.buffer.byteLength)), _struct.Interface = _view.getUint32(16, true); + return err; + }; + $pkg.SetsockoptIPv6Mreq = SetsockoptIPv6Mreq; + SetsockoptLinger = function(fd, level, opt, l) { + var _array, _struct, _view, err, fd, l, level, opt; + err = $ifaceNil; + _array = new Uint8Array(8); + err = setsockopt(fd, level, opt, (_array), 8); + _struct = l, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Onoff = _view.getInt32(0, true), _struct.Linger = _view.getInt32(4, true); + return err; + }; + $pkg.SetsockoptLinger = SetsockoptLinger; + Close = function(fd) { + var _tuple, e1, err, fd; + err = $ifaceNil; + _tuple = Syscall(3, ((fd >>> 0)), 0, 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Close = Close; + Fchdir = function(fd) { + var _tuple, e1, err, fd; + err = $ifaceNil; + _tuple = Syscall(81, ((fd >>> 0)), 0, 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fchdir = Fchdir; + Fchmod = function(fd, mode) { + var _tuple, e1, err, fd, mode; + err = $ifaceNil; + _tuple = Syscall(91, ((fd >>> 0)), ((mode >>> 0)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fchmod = Fchmod; + fcntl = function(fd, cmd, arg) { + var _tuple, arg, cmd, e1, err, fd, r0, val; + val = 0; + err = $ifaceNil; + _tuple = Syscall(72, ((fd >>> 0)), ((cmd >>> 0)), ((arg >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + val = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [val, err]; + }; + Fsync = function(fd) { + var _tuple, e1, err, fd; + err = $ifaceNil; + _tuple = Syscall(74, ((fd >>> 0)), 0, 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fsync = Fsync; + Getdents = function(fd, buf) { + var _p0, _tuple, buf, e1, err, fd, n, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (buf.$length > 0) { + _p0 = ($sliceToArray(buf)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall(217, ((fd >>> 0)), (_p0), ((buf.$length >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + $pkg.Getdents = Getdents; + read = function(fd, p) { + var _p0, _tuple, e1, err, fd, n, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall(0, ((fd >>> 0)), (_p0), ((p.$length >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + write = function(fd, p) { + var _p0, _tuple, e1, err, fd, n, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall(1, ((fd >>> 0)), (_p0), ((p.$length >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + munmap = function(addr, length) { + var _tuple, addr, e1, err, length; + err = $ifaceNil; + _tuple = Syscall(11, (addr), (length), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + Fchown = function(fd, uid, gid) { + var _tuple, e1, err, fd, gid, uid; + err = $ifaceNil; + _tuple = Syscall(93, ((fd >>> 0)), ((uid >>> 0)), ((gid >>> 0))); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fchown = Fchown; + Fstat = function(fd, stat) { + var _array, _struct, _tuple, _view, e1, err, fd, stat; + err = $ifaceNil; + _array = new Uint8Array(144); + _tuple = Syscall(5, ((fd >>> 0)), ((_array)), 0); + _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Nlink = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Mode = _view.getUint32(24, true), _struct.Uid = _view.getUint32(28, true), _struct.Gid = _view.getUint32(32, true), _struct.X__pad0 = _view.getInt32(36, true), _struct.Rdev = new $Uint64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Size = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Blksize = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Blocks = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Atim.Sec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Atim.Nsec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Mtim.Sec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Mtim.Nsec = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Ctim.Sec = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Ctim.Nsec = new $Int64(_view.getUint32(116, true), _view.getUint32(112, true)), _struct.X__unused = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 120, _array.buffer.byteLength)); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Fstat = Fstat; + Ftruncate = function(fd, length) { + var _tuple, e1, err, fd, length; + err = $ifaceNil; + _tuple = Syscall(77, ((fd >>> 0)), ((length.$low >>> 0)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Ftruncate = Ftruncate; + Lstat = function(path, stat) { + var _array, _p0, _struct, _tuple, _tuple$1, _view, e1, err, path, stat; + err = $ifaceNil; + _p0 = ptrType$2.nil; + _tuple = BytePtrFromString(path); + _p0 = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + _array = new Uint8Array(144); + _tuple$1 = Syscall(6, ((_p0)), ((_array)), 0); + _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Nlink = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Mode = _view.getUint32(24, true), _struct.Uid = _view.getUint32(28, true), _struct.Gid = _view.getUint32(32, true), _struct.X__pad0 = _view.getInt32(36, true), _struct.Rdev = new $Uint64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Size = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Blksize = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Blocks = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Atim.Sec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Atim.Nsec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Mtim.Sec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Mtim.Nsec = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Ctim.Sec = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Ctim.Nsec = new $Int64(_view.getUint32(116, true), _view.getUint32(112, true)), _struct.X__unused = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 120, _array.buffer.byteLength)); + e1 = _tuple$1[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Lstat = Lstat; + Pread = function(fd, p, offset) { + var _p0, _tuple, e1, err, fd, n, offset, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall6(17, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((offset.$low >>> 0)), 0, 0); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + $pkg.Pread = Pread; + Pwrite = function(fd, p, offset) { + var _p0, _tuple, e1, err, fd, n, offset, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall6(18, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((offset.$low >>> 0)), 0, 0); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + $pkg.Pwrite = Pwrite; + Seek = function(fd, offset, whence) { + var _tuple, e1, err, fd, off, offset, r0, whence; + off = new $Int64(0, 0); + err = $ifaceNil; + _tuple = Syscall(8, ((fd >>> 0)), ((offset.$low >>> 0)), ((whence >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + off = (new $Int64(0, r0.constructor === Number ? r0 : 1)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [off, err]; + }; + $pkg.Seek = Seek; + Shutdown = function(fd, how) { + var _tuple, e1, err, fd, how; + err = $ifaceNil; + _tuple = Syscall(48, ((fd >>> 0)), ((how >>> 0)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Shutdown = Shutdown; + accept = function(s, rsa, addrlen) { + var _array, _struct, _tuple, _view, addrlen, e1, err, fd, r0, rsa, s; + fd = 0; + err = $ifaceNil; + _array = new Uint8Array(112); + _tuple = Syscall(43, ((s >>> 0)), ((_array)), ((addrlen))); + _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + fd = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [fd, err]; + }; + accept4 = function(s, rsa, addrlen, flags) { + var _array, _struct, _tuple, _view, addrlen, e1, err, fd, flags, r0, rsa, s; + fd = 0; + err = $ifaceNil; + _array = new Uint8Array(112); + _tuple = Syscall6(288, ((s >>> 0)), ((_array)), ((addrlen)), ((flags >>> 0)), 0, 0); + _struct = rsa, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + fd = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [fd, err]; + }; + getsockopt = function(s, level, name, val, vallen) { + var _tuple, e1, err, level, name, s, val, vallen; + err = $ifaceNil; + _tuple = Syscall6(55, ((s >>> 0)), ((level >>> 0)), ((name >>> 0)), (val), ((vallen)), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + setsockopt = function(s, level, name, val, vallen) { + var _tuple, e1, err, level, name, s, val, vallen; + err = $ifaceNil; + _tuple = Syscall6(54, ((s >>> 0)), ((level >>> 0)), ((name >>> 0)), (val), (vallen), 0); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + recvfrom = function(fd, p, flags, from, fromlen) { + var _array, _p0, _struct, _tuple, _view, e1, err, fd, flags, from, fromlen, n, p, r0; + n = 0; + err = $ifaceNil; + _p0 = 0; + if (p.$length > 0) { + _p0 = ($sliceToArray(p)); + } else { + _p0 = (new Uint8Array(0)); + } + _array = new Uint8Array(112); + _tuple = Syscall6(45, ((fd >>> 0)), (_p0), ((p.$length >>> 0)), ((flags >>> 0)), ((_array)), ((fromlen))); + _struct = from, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Addr.Family = _view.getUint16(0, true), _struct.Addr.Data = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 2, _array.buffer.byteLength)), _struct.Pad = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 16, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + sendto = function(s, buf, flags, to, addrlen) { + var _p0, _tuple, addrlen, buf, e1, err, flags, s, to; + err = $ifaceNil; + _p0 = 0; + if (buf.$length > 0) { + _p0 = ($sliceToArray(buf)); + } else { + _p0 = (new Uint8Array(0)); + } + _tuple = Syscall6(44, ((s >>> 0)), (_p0), ((buf.$length >>> 0)), ((flags >>> 0)), (to), ((addrlen >>> 0))); + e1 = _tuple[2]; + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + recvmsg = function(s, msg, flags) { + var _array, _struct, _tuple, _view, e1, err, flags, msg, n, r0, s; + n = 0; + err = $ifaceNil; + _array = new Uint8Array(48); + _tuple = Syscall(47, ((s >>> 0)), ((_array)), ((flags >>> 0))); + _struct = msg, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Namelen = _view.getUint32(4, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 8, _array.buffer.byteLength)), _struct.Iovlen = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Controllen = new $Uint64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Flags = _view.getInt32(40, true), _struct.Pad_cgo_1 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 44, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + sendmsg = function(s, msg, flags) { + var _array, _struct, _tuple, _view, e1, err, flags, msg, n, r0, s; + n = 0; + err = $ifaceNil; + _array = new Uint8Array(48); + _tuple = Syscall(46, ((s >>> 0)), ((_array)), ((flags >>> 0))); + _struct = msg, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Namelen = _view.getUint32(4, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 8, _array.buffer.byteLength)), _struct.Iovlen = new $Uint64(_view.getUint32(20, true), _view.getUint32(16, true)), _struct.Controllen = new $Uint64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Flags = _view.getInt32(40, true), _struct.Pad_cgo_1 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 44, _array.buffer.byteLength)); + r0 = _tuple[0]; + e1 = _tuple[2]; + n = ((r0 >> 0)); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [n, err]; + }; + mmap = function(addr, length, prot, flags, fd, offset) { + var _tuple, addr, e1, err, fd, flags, length, offset, prot, r0, xaddr; + xaddr = 0; + err = $ifaceNil; + _tuple = Syscall6(9, (addr), (length), ((prot >>> 0)), ((flags >>> 0)), ((fd >>> 0)), ((offset.$low >>> 0))); + r0 = _tuple[0]; + e1 = _tuple[2]; + xaddr = (r0); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return [xaddr, err]; + }; + ptrType$24.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$11.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$25.methods = [{prop: "Mmap", name: "Mmap", pkg: "", typ: $funcType([$Int, $Int64, $Int, $Int, $Int], [sliceType, $error], false)}, {prop: "Munmap", name: "Munmap", pkg: "", typ: $funcType([sliceType], [$error], false)}]; + Errno.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$26.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$27.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$28.methods = [{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]; + ptrType$29.methods = [{prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64, $Int64], false)}, {prop: "Nano", name: "Nano", pkg: "", typ: $funcType([], [$Int64], false)}]; + ptrType$19.methods = [{prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}]; + ptrType$31.methods = [{prop: "SetControllen", name: "SetControllen", pkg: "", typ: $funcType([$Int], [], false)}]; + SockaddrLinklayer.init("syscall", [{prop: "Protocol", name: "Protocol", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Ifindex", name: "Ifindex", anonymous: false, exported: true, typ: $Int, tag: ""}, {prop: "Hatype", name: "Hatype", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pkttype", name: "Pkttype", anonymous: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Halen", name: "Halen", anonymous: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: arrayType$1, tag: ""}, {prop: "raw", name: "raw", anonymous: false, exported: false, typ: RawSockaddrLinklayer, tag: ""}]); + SockaddrNetlink.init("syscall", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pad", name: "Pad", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pid", name: "Pid", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Groups", name: "Groups", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "raw", name: "raw", anonymous: false, exported: false, typ: RawSockaddrNetlink, tag: ""}]); + mmapper.init("syscall", [{prop: "Mutex", name: "Mutex", anonymous: true, exported: true, typ: sync.Mutex, tag: ""}, {prop: "active", name: "active", anonymous: false, exported: false, typ: mapType, tag: ""}, {prop: "mmap", name: "mmap", anonymous: false, exported: false, typ: funcType$2, tag: ""}, {prop: "munmap", name: "munmap", anonymous: false, exported: false, typ: funcType$3, tag: ""}]); + Sockaddr.init([{prop: "sockaddr", name: "sockaddr", pkg: "syscall", typ: $funcType([], [$UnsafePointer, _Socklen, $error], false)}]); + SockaddrInet4.init("syscall", [{prop: "Port", name: "Port", anonymous: false, exported: true, typ: $Int, tag: ""}, {prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: arrayType$8, tag: ""}, {prop: "raw", name: "raw", anonymous: false, exported: false, typ: RawSockaddrInet4, tag: ""}]); + SockaddrInet6.init("syscall", [{prop: "Port", name: "Port", anonymous: false, exported: true, typ: $Int, tag: ""}, {prop: "ZoneId", name: "ZoneId", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "raw", name: "raw", anonymous: false, exported: false, typ: RawSockaddrInet6, tag: ""}]); + SockaddrUnix.init("syscall", [{prop: "Name", name: "Name", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "raw", name: "raw", anonymous: false, exported: false, typ: RawSockaddrUnix, tag: ""}]); + Timespec.init("", [{prop: "Sec", name: "Sec", anonymous: false, exported: true, typ: $Int64, tag: ""}, {prop: "Nsec", name: "Nsec", anonymous: false, exported: true, typ: $Int64, tag: ""}]); + Stat_t.init("", [{prop: "Dev", name: "Dev", anonymous: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Ino", name: "Ino", anonymous: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Nlink", name: "Nlink", anonymous: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Mode", name: "Mode", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Uid", name: "Uid", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Gid", name: "Gid", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "X__pad0", name: "X__pad0", anonymous: false, exported: true, typ: $Int32, tag: ""}, {prop: "Rdev", name: "Rdev", anonymous: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Size", name: "Size", anonymous: false, exported: true, typ: $Int64, tag: ""}, {prop: "Blksize", name: "Blksize", anonymous: false, exported: true, typ: $Int64, tag: ""}, {prop: "Blocks", name: "Blocks", anonymous: false, exported: true, typ: $Int64, tag: ""}, {prop: "Atim", name: "Atim", anonymous: false, exported: true, typ: Timespec, tag: ""}, {prop: "Mtim", name: "Mtim", anonymous: false, exported: true, typ: Timespec, tag: ""}, {prop: "Ctim", name: "Ctim", anonymous: false, exported: true, typ: Timespec, tag: ""}, {prop: "X__unused", name: "X__unused", anonymous: false, exported: true, typ: arrayType$15, tag: ""}]); + RawSockaddrInet4.init("", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Port", name: "Port", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: arrayType$8, tag: ""}, {prop: "Zero", name: "Zero", anonymous: false, exported: true, typ: arrayType$1, tag: ""}]); + RawSockaddrInet6.init("", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Port", name: "Port", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Flowinfo", name: "Flowinfo", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "Scope_id", name: "Scope_id", anonymous: false, exported: true, typ: $Uint32, tag: ""}]); + RawSockaddrUnix.init("", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Path", name: "Path", anonymous: false, exported: true, typ: arrayType$7, tag: ""}]); + RawSockaddrLinklayer.init("", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Protocol", name: "Protocol", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Ifindex", name: "Ifindex", anonymous: false, exported: true, typ: $Int32, tag: ""}, {prop: "Hatype", name: "Hatype", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pkttype", name: "Pkttype", anonymous: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Halen", name: "Halen", anonymous: false, exported: true, typ: $Uint8, tag: ""}, {prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: arrayType$1, tag: ""}]); + RawSockaddrNetlink.init("", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pad", name: "Pad", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Pid", name: "Pid", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Groups", name: "Groups", anonymous: false, exported: true, typ: $Uint32, tag: ""}]); + RawSockaddr.init("", [{prop: "Family", name: "Family", anonymous: false, exported: true, typ: $Uint16, tag: ""}, {prop: "Data", name: "Data", anonymous: false, exported: true, typ: arrayType$9, tag: ""}]); + RawSockaddrAny.init("", [{prop: "Addr", name: "Addr", anonymous: false, exported: true, typ: RawSockaddr, tag: ""}, {prop: "Pad", name: "Pad", anonymous: false, exported: true, typ: arrayType$10, tag: ""}]); + Linger.init("", [{prop: "Onoff", name: "Onoff", anonymous: false, exported: true, typ: $Int32, tag: ""}, {prop: "Linger", name: "Linger", anonymous: false, exported: true, typ: $Int32, tag: ""}]); + Iovec.init("", [{prop: "Base", name: "Base", anonymous: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Len", name: "Len", anonymous: false, exported: true, typ: $Uint64, tag: ""}]); + IPMreq.init("", [{prop: "Multiaddr", name: "Multiaddr", anonymous: false, exported: true, typ: arrayType$8, tag: ""}, {prop: "Interface", name: "Interface", anonymous: false, exported: true, typ: arrayType$8, tag: ""}]); + IPMreqn.init("", [{prop: "Multiaddr", name: "Multiaddr", anonymous: false, exported: true, typ: arrayType$8, tag: ""}, {prop: "Address", name: "Address", anonymous: false, exported: true, typ: arrayType$8, tag: ""}, {prop: "Ifindex", name: "Ifindex", anonymous: false, exported: true, typ: $Int32, tag: ""}]); + IPv6Mreq.init("", [{prop: "Multiaddr", name: "Multiaddr", anonymous: false, exported: true, typ: arrayType$2, tag: ""}, {prop: "Interface", name: "Interface", anonymous: false, exported: true, typ: $Uint32, tag: ""}]); + Msghdr.init("", [{prop: "Name", name: "Name", anonymous: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Namelen", name: "Namelen", anonymous: false, exported: true, typ: $Uint32, tag: ""}, {prop: "Pad_cgo_0", name: "Pad_cgo_0", anonymous: false, exported: true, typ: arrayType$8, tag: ""}, {prop: "Iov", name: "Iov", anonymous: false, exported: true, typ: ptrType$19, tag: ""}, {prop: "Iovlen", name: "Iovlen", anonymous: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Control", name: "Control", anonymous: false, exported: true, typ: ptrType$2, tag: ""}, {prop: "Controllen", name: "Controllen", anonymous: false, exported: true, typ: $Uint64, tag: ""}, {prop: "Flags", name: "Flags", anonymous: false, exported: true, typ: $Int32, tag: ""}, {prop: "Pad_cgo_1", name: "Pad_cgo_1", anonymous: false, exported: true, typ: arrayType$8, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = race.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + lineBuffer = sliceType.nil; + syscallModule = null; + ioSync = new $Int64(0, 0); + warningPrinted = false; + alreadyTriedToLoad = false; + minusOne = -1; + envs = runtime_envs(); + $pkg.Stdin = 0; + $pkg.Stdout = 1; + $pkg.Stderr = 2; + errEAGAIN = new Errno(11); + errEINVAL = new Errno(22); + errENOENT = new Errno(2); + errors = $toNativeArray($kindString, ["", "operation not permitted", "no such file or directory", "no such process", "interrupted system call", "input/output error", "no such device or address", "argument list too long", "exec format error", "bad file descriptor", "no child processes", "resource temporarily unavailable", "cannot allocate memory", "permission denied", "bad address", "block device required", "device or resource busy", "file exists", "invalid cross-device link", "no such device", "not a directory", "is a directory", "invalid argument", "too many open files in system", "too many open files", "inappropriate ioctl for device", "text file busy", "file too large", "no space left on device", "illegal seek", "read-only file system", "too many links", "broken pipe", "numerical argument out of domain", "numerical result out of range", "resource deadlock avoided", "file name too long", "no locks available", "function not implemented", "directory not empty", "too many levels of symbolic links", "", "no message of desired type", "identifier removed", "channel number out of range", "level 2 not synchronized", "level 3 halted", "level 3 reset", "link number out of range", "protocol driver not attached", "no CSI structure available", "level 2 halted", "invalid exchange", "invalid request descriptor", "exchange full", "no anode", "invalid request code", "invalid slot", "", "bad font file format", "device not a stream", "no data available", "timer expired", "out of streams resources", "machine is not on the network", "package not installed", "object is remote", "link has been severed", "advertise error", "srmount error", "communication error on send", "protocol error", "multihop attempted", "RFS specific error", "bad message", "value too large for defined data type", "name not unique on network", "file descriptor in bad state", "remote address changed", "can not access a needed shared library", "accessing a corrupted shared library", ".lib section in a.out corrupted", "attempting to link in too many shared libraries", "cannot exec a shared library directly", "invalid or incomplete multibyte or wide character", "interrupted system call should be restarted", "streams pipe error", "too many users", "socket operation on non-socket", "destination address required", "message too long", "protocol wrong type for socket", "protocol not available", "protocol not supported", "socket type not supported", "operation not supported", "protocol family not supported", "address family not supported by protocol", "address already in use", "cannot assign requested address", "network is down", "network is unreachable", "network dropped connection on reset", "software caused connection abort", "connection reset by peer", "no buffer space available", "transport endpoint is already connected", "transport endpoint is not connected", "cannot send after transport endpoint shutdown", "too many references: cannot splice", "connection timed out", "connection refused", "host is down", "no route to host", "operation already in progress", "operation now in progress", "stale NFS file handle", "structure needs cleaning", "not a XENIX named type file", "no XENIX semaphores available", "is a named type file", "remote I/O error", "disk quota exceeded", "no medium found", "wrong medium type", "operation canceled", "required key not available", "key has expired", "key has been revoked", "key was rejected by service", "owner died", "state not recoverable", "operation not possible due to RF-kill"]); + mapper = new mmapper.ptr(new sync.Mutex.ptr(0, 0), {}, mmap, munmap); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/gopherjs/gopherjs/nosync"] = (function() { + var $pkg = {}, $init, Once, funcType$1, ptrType$4; + Once = $pkg.Once = $newType(0, $kindStruct, "nosync.Once", true, "github.com/gopherjs/gopherjs/nosync", true, function(doing_, done_) { + this.$val = this; + if (arguments.length === 0) { + this.doing = false; + this.done = false; + return; + } + this.doing = doing_; + this.done = done_; + }); + funcType$1 = $funcType([], [], false); + ptrType$4 = $ptrType(Once); + Once.ptr.prototype.Do = function(f) { + var f, o, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; f = $f.f; o = $f.o; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + o = [o]; + o[0] = this; + if (o[0].done) { + $s = -1; return; + } + if (o[0].doing) { + $panic(new $String("nosync: Do called within f")); + } + o[0].doing = true; + $deferred.push([(function(o) { return function() { + o[0].doing = false; + o[0].done = true; + }; })(o), []]); + $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.f = f; $f.o = o; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + Once.prototype.Do = function(f) { return this.$val.Do(f); }; + ptrType$4.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType$1], [], false)}]; + Once.init("github.com/gopherjs/gopherjs/nosync", [{prop: "doing", name: "doing", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "done", name: "done", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["time"] = (function() { + var $pkg = {}, $init, errors, js, nosync, runtime, syscall, runtimeTimer, ParseError, Timer, Time, Month, Weekday, Duration, Location, zone, zoneTrans, sliceType, sliceType$1, ptrType, sliceType$2, arrayType, sliceType$3, arrayType$1, arrayType$2, ptrType$2, funcType, arrayType$3, funcType$1, ptrType$3, ptrType$4, ptrType$5, chanType$1, ptrType$7, zoneSources, std0x, longDayNames, shortDayNames, shortMonthNames, longMonthNames, atoiError, errBad, errLeadingInt, months, days, daysBefore, utcLoc, utcLoc$24ptr, localLoc, localLoc$24ptr, localOnce, errLocation, badData, init, initLocal, runtimeNano, now, startTimer, stopTimer, indexByte, startsWithLowerCase, nextStdChunk, match, lookup, appendInt, atoi, formatNano, quote, isDigit, getnum, cutspace, skip, Parse, parse, parseTimeZone, parseGMT, parseNanoseconds, leadingInt, when, AfterFunc, goFunc, absWeekday, absClock, fmtFrac, fmtInt, lessThanHalf, Until, absDate, daysIn, Now, unixTime, Unix, isLeap, norm, Date, div, FixedZone; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + runtime = $packages["runtime"]; + syscall = $packages["syscall"]; + runtimeTimer = $pkg.runtimeTimer = $newType(0, $kindStruct, "time.runtimeTimer", true, "time", false, function(i_, when_, period_, f_, arg_, timeout_, active_) { + this.$val = this; + if (arguments.length === 0) { + this.i = 0; + this.when = new $Int64(0, 0); + this.period = new $Int64(0, 0); + this.f = $throwNilPointerError; + this.arg = $ifaceNil; + this.timeout = null; + this.active = false; + return; + } + this.i = i_; + this.when = when_; + this.period = period_; + this.f = f_; + this.arg = arg_; + this.timeout = timeout_; + this.active = active_; + }); + ParseError = $pkg.ParseError = $newType(0, $kindStruct, "time.ParseError", true, "time", true, function(Layout_, Value_, LayoutElem_, ValueElem_, Message_) { + this.$val = this; + if (arguments.length === 0) { + this.Layout = ""; + this.Value = ""; + this.LayoutElem = ""; + this.ValueElem = ""; + this.Message = ""; + return; + } + this.Layout = Layout_; + this.Value = Value_; + this.LayoutElem = LayoutElem_; + this.ValueElem = ValueElem_; + this.Message = Message_; + }); + Timer = $pkg.Timer = $newType(0, $kindStruct, "time.Timer", true, "time", true, function(C_, r_) { + this.$val = this; + if (arguments.length === 0) { + this.C = $chanNil; + this.r = new runtimeTimer.ptr(0, new $Int64(0, 0), new $Int64(0, 0), $throwNilPointerError, $ifaceNil, null, false); + return; + } + this.C = C_; + this.r = r_; + }); + Time = $pkg.Time = $newType(0, $kindStruct, "time.Time", true, "time", true, function(wall_, ext_, loc_) { + this.$val = this; + if (arguments.length === 0) { + this.wall = new $Uint64(0, 0); + this.ext = new $Int64(0, 0); + this.loc = ptrType$2.nil; + return; + } + this.wall = wall_; + this.ext = ext_; + this.loc = loc_; + }); + Month = $pkg.Month = $newType(4, $kindInt, "time.Month", true, "time", true, null); + Weekday = $pkg.Weekday = $newType(4, $kindInt, "time.Weekday", true, "time", true, null); + Duration = $pkg.Duration = $newType(8, $kindInt64, "time.Duration", true, "time", true, null); + Location = $pkg.Location = $newType(0, $kindStruct, "time.Location", true, "time", true, function(name_, zone_, tx_, cacheStart_, cacheEnd_, cacheZone_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.zone = sliceType.nil; + this.tx = sliceType$1.nil; + this.cacheStart = new $Int64(0, 0); + this.cacheEnd = new $Int64(0, 0); + this.cacheZone = ptrType.nil; + return; + } + this.name = name_; + this.zone = zone_; + this.tx = tx_; + this.cacheStart = cacheStart_; + this.cacheEnd = cacheEnd_; + this.cacheZone = cacheZone_; + }); + zone = $pkg.zone = $newType(0, $kindStruct, "time.zone", true, "time", false, function(name_, offset_, isDST_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.offset = 0; + this.isDST = false; + return; + } + this.name = name_; + this.offset = offset_; + this.isDST = isDST_; + }); + zoneTrans = $pkg.zoneTrans = $newType(0, $kindStruct, "time.zoneTrans", true, "time", false, function(when_, index_, isstd_, isutc_) { + this.$val = this; + if (arguments.length === 0) { + this.when = new $Int64(0, 0); + this.index = 0; + this.isstd = false; + this.isutc = false; + return; + } + this.when = when_; + this.index = index_; + this.isstd = isstd_; + this.isutc = isutc_; + }); + sliceType = $sliceType(zone); + sliceType$1 = $sliceType(zoneTrans); + ptrType = $ptrType(zone); + sliceType$2 = $sliceType($String); + arrayType = $arrayType($Uint8, 20); + sliceType$3 = $sliceType($Uint8); + arrayType$1 = $arrayType($Uint8, 9); + arrayType$2 = $arrayType($Uint8, 64); + ptrType$2 = $ptrType(Location); + funcType = $funcType([], [], false); + arrayType$3 = $arrayType($Uint8, 32); + funcType$1 = $funcType([$emptyInterface, $Uintptr], [], false); + ptrType$3 = $ptrType(js.Object); + ptrType$4 = $ptrType(ParseError); + ptrType$5 = $ptrType(Timer); + chanType$1 = $chanType(Time, false, true); + ptrType$7 = $ptrType(Time); + init = function() { + $unused(Unix(new $Int64(0, 0), new $Int64(0, 0))); + }; + initLocal = function() { + var d, i, j, s; + d = new ($global.Date)(); + s = $internalize(d, $String); + i = indexByte(s, 40); + j = indexByte(s, 41); + if ((i === -1) || (j === -1)) { + localLoc.name = "UTC"; + return; + } + localLoc.name = $substring(s, (i + 1 >> 0), j); + localLoc.zone = new sliceType([new zone.ptr(localLoc.name, $imul(($parseInt(d.getTimezoneOffset()) >> 0), -60), false)]); + }; + runtimeNano = function() { + return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000)); + }; + now = function() { + var _tmp, _tmp$1, _tmp$2, mono, n, nsec, sec, x; + sec = new $Int64(0, 0); + nsec = 0; + mono = new $Int64(0, 0); + n = runtimeNano(); + _tmp = $div64(n, new $Int64(0, 1000000000), false); + _tmp$1 = (((x = $div64(n, new $Int64(0, 1000000000), true), x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); + _tmp$2 = n; + sec = _tmp; + nsec = _tmp$1; + mono = _tmp$2; + return [sec, nsec, mono]; + }; + startTimer = function(t) { + var diff, t, x, x$1; + t.active = true; + diff = $div64(((x = t.when, x$1 = runtimeNano(), new $Int64(x.$high - x$1.$high, x.$low - x$1.$low))), new $Int64(0, 1000000), false); + if ((diff.$high > 0 || (diff.$high === 0 && diff.$low > 2147483647))) { + return; + } + if ((diff.$high < 0 || (diff.$high === 0 && diff.$low < 0))) { + diff = new $Int64(0, 0); + } + t.timeout = $setTimeout((function() { + var x$2, x$3, x$4; + t.active = false; + if (!((x$2 = t.period, (x$2.$high === 0 && x$2.$low === 0)))) { + t.when = (x$3 = t.when, x$4 = t.period, new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low)); + startTimer(t); + } + $go(t.f, [t.arg, 0]); + }), $externalize(new $Int64(diff.$high + 0, diff.$low + 1), $Int64)); + }; + stopTimer = function(t) { + var t, wasActive; + $global.clearTimeout(t.timeout); + wasActive = t.active; + t.active = false; + return wasActive; + }; + indexByte = function(s, c) { + var c, s; + return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0; + }; + startsWithLowerCase = function(str) { + var c, str; + if (str.length === 0) { + return false; + } + c = str.charCodeAt(0); + return 97 <= c && c <= 122; + }; + nextStdChunk = function(layout) { + var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$51, _tmp$52, _tmp$53, _tmp$54, _tmp$55, _tmp$56, _tmp$57, _tmp$58, _tmp$59, _tmp$6, _tmp$60, _tmp$61, _tmp$62, _tmp$63, _tmp$64, _tmp$65, _tmp$66, _tmp$67, _tmp$68, _tmp$69, _tmp$7, _tmp$70, _tmp$71, _tmp$72, _tmp$73, _tmp$74, _tmp$75, _tmp$76, _tmp$77, _tmp$78, _tmp$79, _tmp$8, _tmp$80, _tmp$81, _tmp$82, _tmp$83, _tmp$84, _tmp$85, _tmp$86, _tmp$9, c, ch, i, j, layout, prefix, std, std$1, suffix, x; + prefix = ""; + std = 0; + suffix = ""; + i = 0; + while (true) { + if (!(i < layout.length)) { break; } + c = ((layout.charCodeAt(i) >> 0)); + _1 = c; + if (_1 === (74)) { + if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "Jan") { + if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "January") { + _tmp = $substring(layout, 0, i); + _tmp$1 = 257; + _tmp$2 = $substring(layout, (i + 7 >> 0)); + prefix = _tmp; + std = _tmp$1; + suffix = _tmp$2; + return [prefix, std, suffix]; + } + if (!startsWithLowerCase($substring(layout, (i + 3 >> 0)))) { + _tmp$3 = $substring(layout, 0, i); + _tmp$4 = 258; + _tmp$5 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$3; + std = _tmp$4; + suffix = _tmp$5; + return [prefix, std, suffix]; + } + } + } else if (_1 === (77)) { + if (layout.length >= (i + 3 >> 0)) { + if ($substring(layout, i, (i + 3 >> 0)) === "Mon") { + if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "Monday") { + _tmp$6 = $substring(layout, 0, i); + _tmp$7 = 261; + _tmp$8 = $substring(layout, (i + 6 >> 0)); + prefix = _tmp$6; + std = _tmp$7; + suffix = _tmp$8; + return [prefix, std, suffix]; + } + if (!startsWithLowerCase($substring(layout, (i + 3 >> 0)))) { + _tmp$9 = $substring(layout, 0, i); + _tmp$10 = 262; + _tmp$11 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$9; + std = _tmp$10; + suffix = _tmp$11; + return [prefix, std, suffix]; + } + } + if ($substring(layout, i, (i + 3 >> 0)) === "MST") { + _tmp$12 = $substring(layout, 0, i); + _tmp$13 = 21; + _tmp$14 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$12; + std = _tmp$13; + suffix = _tmp$14; + return [prefix, std, suffix]; + } + } + } else if (_1 === (48)) { + if (layout.length >= (i + 2 >> 0) && 49 <= layout.charCodeAt((i + 1 >> 0)) && layout.charCodeAt((i + 1 >> 0)) <= 54) { + _tmp$15 = $substring(layout, 0, i); + _tmp$16 = (x = layout.charCodeAt((i + 1 >> 0)) - 49 << 24 >>> 24, ((x < 0 || x >= std0x.length) ? ($throwRuntimeError("index out of range"), undefined) : std0x[x])); + _tmp$17 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$15; + std = _tmp$16; + suffix = _tmp$17; + return [prefix, std, suffix]; + } + } else if (_1 === (49)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 53)) { + _tmp$18 = $substring(layout, 0, i); + _tmp$19 = 522; + _tmp$20 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$18; + std = _tmp$19; + suffix = _tmp$20; + return [prefix, std, suffix]; + } + _tmp$21 = $substring(layout, 0, i); + _tmp$22 = 259; + _tmp$23 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$21; + std = _tmp$22; + suffix = _tmp$23; + return [prefix, std, suffix]; + } else if (_1 === (50)) { + if (layout.length >= (i + 4 >> 0) && $substring(layout, i, (i + 4 >> 0)) === "2006") { + _tmp$24 = $substring(layout, 0, i); + _tmp$25 = 273; + _tmp$26 = $substring(layout, (i + 4 >> 0)); + prefix = _tmp$24; + std = _tmp$25; + suffix = _tmp$26; + return [prefix, std, suffix]; + } + _tmp$27 = $substring(layout, 0, i); + _tmp$28 = 263; + _tmp$29 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$27; + std = _tmp$28; + suffix = _tmp$29; + return [prefix, std, suffix]; + } else if (_1 === (95)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 50)) { + if (layout.length >= (i + 5 >> 0) && $substring(layout, (i + 1 >> 0), (i + 5 >> 0)) === "2006") { + _tmp$30 = $substring(layout, 0, (i + 1 >> 0)); + _tmp$31 = 273; + _tmp$32 = $substring(layout, (i + 5 >> 0)); + prefix = _tmp$30; + std = _tmp$31; + suffix = _tmp$32; + return [prefix, std, suffix]; + } + _tmp$33 = $substring(layout, 0, i); + _tmp$34 = 264; + _tmp$35 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$33; + std = _tmp$34; + suffix = _tmp$35; + return [prefix, std, suffix]; + } + } else if (_1 === (51)) { + _tmp$36 = $substring(layout, 0, i); + _tmp$37 = 523; + _tmp$38 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$36; + std = _tmp$37; + suffix = _tmp$38; + return [prefix, std, suffix]; + } else if (_1 === (52)) { + _tmp$39 = $substring(layout, 0, i); + _tmp$40 = 525; + _tmp$41 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$39; + std = _tmp$40; + suffix = _tmp$41; + return [prefix, std, suffix]; + } else if (_1 === (53)) { + _tmp$42 = $substring(layout, 0, i); + _tmp$43 = 527; + _tmp$44 = $substring(layout, (i + 1 >> 0)); + prefix = _tmp$42; + std = _tmp$43; + suffix = _tmp$44; + return [prefix, std, suffix]; + } else if (_1 === (80)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 77)) { + _tmp$45 = $substring(layout, 0, i); + _tmp$46 = 531; + _tmp$47 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$45; + std = _tmp$46; + suffix = _tmp$47; + return [prefix, std, suffix]; + } + } else if (_1 === (112)) { + if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 109)) { + _tmp$48 = $substring(layout, 0, i); + _tmp$49 = 532; + _tmp$50 = $substring(layout, (i + 2 >> 0)); + prefix = _tmp$48; + std = _tmp$49; + suffix = _tmp$50; + return [prefix, std, suffix]; + } + } else if (_1 === (45)) { + if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "-070000") { + _tmp$51 = $substring(layout, 0, i); + _tmp$52 = 28; + _tmp$53 = $substring(layout, (i + 7 >> 0)); + prefix = _tmp$51; + std = _tmp$52; + suffix = _tmp$53; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 9 >> 0) && $substring(layout, i, (i + 9 >> 0)) === "-07:00:00") { + _tmp$54 = $substring(layout, 0, i); + _tmp$55 = 31; + _tmp$56 = $substring(layout, (i + 9 >> 0)); + prefix = _tmp$54; + std = _tmp$55; + suffix = _tmp$56; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 5 >> 0) && $substring(layout, i, (i + 5 >> 0)) === "-0700") { + _tmp$57 = $substring(layout, 0, i); + _tmp$58 = 27; + _tmp$59 = $substring(layout, (i + 5 >> 0)); + prefix = _tmp$57; + std = _tmp$58; + suffix = _tmp$59; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "-07:00") { + _tmp$60 = $substring(layout, 0, i); + _tmp$61 = 30; + _tmp$62 = $substring(layout, (i + 6 >> 0)); + prefix = _tmp$60; + std = _tmp$61; + suffix = _tmp$62; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "-07") { + _tmp$63 = $substring(layout, 0, i); + _tmp$64 = 29; + _tmp$65 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$63; + std = _tmp$64; + suffix = _tmp$65; + return [prefix, std, suffix]; + } + } else if (_1 === (90)) { + if (layout.length >= (i + 7 >> 0) && $substring(layout, i, (i + 7 >> 0)) === "Z070000") { + _tmp$66 = $substring(layout, 0, i); + _tmp$67 = 23; + _tmp$68 = $substring(layout, (i + 7 >> 0)); + prefix = _tmp$66; + std = _tmp$67; + suffix = _tmp$68; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 9 >> 0) && $substring(layout, i, (i + 9 >> 0)) === "Z07:00:00") { + _tmp$69 = $substring(layout, 0, i); + _tmp$70 = 26; + _tmp$71 = $substring(layout, (i + 9 >> 0)); + prefix = _tmp$69; + std = _tmp$70; + suffix = _tmp$71; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 5 >> 0) && $substring(layout, i, (i + 5 >> 0)) === "Z0700") { + _tmp$72 = $substring(layout, 0, i); + _tmp$73 = 22; + _tmp$74 = $substring(layout, (i + 5 >> 0)); + prefix = _tmp$72; + std = _tmp$73; + suffix = _tmp$74; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 6 >> 0) && $substring(layout, i, (i + 6 >> 0)) === "Z07:00") { + _tmp$75 = $substring(layout, 0, i); + _tmp$76 = 25; + _tmp$77 = $substring(layout, (i + 6 >> 0)); + prefix = _tmp$75; + std = _tmp$76; + suffix = _tmp$77; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 3 >> 0) && $substring(layout, i, (i + 3 >> 0)) === "Z07") { + _tmp$78 = $substring(layout, 0, i); + _tmp$79 = 24; + _tmp$80 = $substring(layout, (i + 3 >> 0)); + prefix = _tmp$78; + std = _tmp$79; + suffix = _tmp$80; + return [prefix, std, suffix]; + } + } else if (_1 === (46)) { + if ((i + 1 >> 0) < layout.length && ((layout.charCodeAt((i + 1 >> 0)) === 48) || (layout.charCodeAt((i + 1 >> 0)) === 57))) { + ch = layout.charCodeAt((i + 1 >> 0)); + j = i + 1 >> 0; + while (true) { + if (!(j < layout.length && (layout.charCodeAt(j) === ch))) { break; } + j = j + (1) >> 0; + } + if (!isDigit(layout, j)) { + std$1 = 32; + if (layout.charCodeAt((i + 1 >> 0)) === 57) { + std$1 = 33; + } + std$1 = std$1 | ((((j - ((i + 1 >> 0)) >> 0)) << 16 >> 0)); + _tmp$81 = $substring(layout, 0, i); + _tmp$82 = std$1; + _tmp$83 = $substring(layout, j); + prefix = _tmp$81; + std = _tmp$82; + suffix = _tmp$83; + return [prefix, std, suffix]; + } + } + } + i = i + (1) >> 0; + } + _tmp$84 = layout; + _tmp$85 = 0; + _tmp$86 = ""; + prefix = _tmp$84; + std = _tmp$85; + suffix = _tmp$86; + return [prefix, std, suffix]; + }; + match = function(s1, s2) { + var c1, c2, i, s1, s2; + i = 0; + while (true) { + if (!(i < s1.length)) { break; } + c1 = s1.charCodeAt(i); + c2 = s2.charCodeAt(i); + if (!((c1 === c2))) { + c1 = (c1 | (32)) >>> 0; + c2 = (c2 | (32)) >>> 0; + if (!((c1 === c2)) || c1 < 97 || c1 > 122) { + return false; + } + } + i = i + (1) >> 0; + } + return true; + }; + lookup = function(tab, val) { + var _i, _ref, i, tab, v, val; + _ref = tab; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (val.length >= v.length && match($substring(val, 0, v.length), v)) { + return [i, $substring(val, v.length), $ifaceNil]; + } + _i++; + } + return [-1, val, errBad]; + }; + appendInt = function(b, x, width) { + var _q, b, buf, i, q, u, w, width, x; + u = ((x >>> 0)); + if (x < 0) { + b = $append(b, 45); + u = ((-x >>> 0)); + } + buf = arrayType.zero(); + i = 20; + while (true) { + if (!(u >= 10)) { break; } + i = i - (1) >> 0; + q = (_q = u / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = ((((48 + u >>> 0) - (q * 10 >>> 0) >>> 0) << 24 >>> 24))); + u = q; + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i] = (((48 + u >>> 0) << 24 >>> 24))); + w = 20 - i >> 0; + while (true) { + if (!(w < width)) { break; } + b = $append(b, 48); + w = w + (1) >> 0; + } + return $appendSlice(b, $subslice(new sliceType$3(buf), i)); + }; + atoi = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, err, neg, q, rem, s, x; + x = 0; + err = $ifaceNil; + neg = false; + if (!(s === "") && ((s.charCodeAt(0) === 45) || (s.charCodeAt(0) === 43))) { + neg = s.charCodeAt(0) === 45; + s = $substring(s, 1); + } + _tuple = leadingInt(s); + q = _tuple[0]; + rem = _tuple[1]; + err = _tuple[2]; + x = (((q.$low + ((q.$high >> 31) * 4294967296)) >> 0)); + if (!($interfaceIsEqual(err, $ifaceNil)) || !(rem === "")) { + _tmp = 0; + _tmp$1 = atoiError; + x = _tmp; + err = _tmp$1; + return [x, err]; + } + if (neg) { + x = -x; + } + _tmp$2 = x; + _tmp$3 = $ifaceNil; + x = _tmp$2; + err = _tmp$3; + return [x, err]; + }; + formatNano = function(b, nanosec, n, trim) { + var _q, _r, b, buf, n, nanosec, start, trim, u, x; + u = nanosec; + buf = arrayType$1.zero(); + start = 9; + while (true) { + if (!(start > 0)) { break; } + start = start - (1) >> 0; + ((start < 0 || start >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[start] = ((((_r = u % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24))); + u = (_q = u / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + } + if (n > 9) { + n = 9; + } + if (trim) { + while (true) { + if (!(n > 0 && ((x = n - 1 >> 0, ((x < 0 || x >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[x])) === 48))) { break; } + n = n - (1) >> 0; + } + if (n === 0) { + return b; + } + } + b = $append(b, 46); + return $appendSlice(b, $subslice(new sliceType$3(buf), 0, n)); + }; + Time.ptr.prototype.String = function() { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, buf, m0, m1, m2, s, sign, t, wid, x, x$1, x$2, x$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; buf = $f.buf; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; s = $f.s; sign = $f.sign; t = $f.t; wid = $f.wid; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Format("2006-01-02 15:04:05.999999999 -0700 MST"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = _r; + if (!((x = (x$1 = t.wall, new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + m2 = ((x$2 = t.ext, new $Uint64(x$2.$high, x$2.$low))); + sign = 43; + if ((x$3 = t.ext, (x$3.$high < 0 || (x$3.$high === 0 && x$3.$low < 0)))) { + sign = 45; + m2 = new $Uint64(-m2.$high, -m2.$low); + } + _tmp = $div64(m2, new $Uint64(0, 1000000000), false); + _tmp$1 = $div64(m2, new $Uint64(0, 1000000000), true); + m1 = _tmp; + m2 = _tmp$1; + _tmp$2 = $div64(m1, new $Uint64(0, 1000000000), false); + _tmp$3 = $div64(m1, new $Uint64(0, 1000000000), true); + m0 = _tmp$2; + m1 = _tmp$3; + buf = sliceType$3.nil; + buf = $appendSlice(buf, " m="); + buf = $append(buf, sign); + wid = 0; + if (!((m0.$high === 0 && m0.$low === 0))) { + buf = appendInt(buf, ((m0.$low >> 0)), 0); + wid = 9; + } + buf = appendInt(buf, ((m1.$low >> 0)), wid); + buf = $append(buf, 46); + buf = appendInt(buf, ((m2.$low >> 0)), 9); + s = s + (($bytesToString(buf))); + } + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.String }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.buf = buf; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.s = s; $f.sign = sign; $f.t = t; $f.wid = wid; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.String = function() { return this.$val.String(); }; + Time.ptr.prototype.Format = function(layout) { + var _r, b, buf, layout, max, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; b = $f.b; buf = $f.buf; layout = $f.layout; max = $f.max; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + b = sliceType$3.nil; + max = layout.length + 10 >> 0; + if (max < 64) { + buf = arrayType$2.zero(); + b = $subslice(new sliceType$3(buf), 0, 0); + } else { + b = $makeSlice(sliceType$3, 0, max); + } + _r = $clone(t, Time).AppendFormat(b, layout); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + b = _r; + $s = -1; return ($bytesToString(b)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Format }; } $f._r = _r; $f.b = b; $f.buf = buf; $f.layout = layout; $f.max = max; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Format = function(layout) { return this.$val.Format(layout); }; + Time.ptr.prototype.AppendFormat = function(b, layout) { + var _1, _q, _q$1, _q$2, _q$3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, _tuple$1, _tuple$2, _tuple$3, abs, absoffset, b, day, hour, hr, hr$1, layout, m, min, month, name, offset, prefix, s, sec, std, suffix, t, y, year, zone$1, zone$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; abs = $f.abs; absoffset = $f.absoffset; b = $f.b; day = $f.day; hour = $f.hour; hr = $f.hr; hr$1 = $f.hr$1; layout = $f.layout; m = $f.m; min = $f.min; month = $f.month; name = $f.name; offset = $f.offset; prefix = $f.prefix; s = $f.s; sec = $f.sec; std = $f.std; suffix = $f.suffix; t = $f.t; y = $f.y; year = $f.year; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).locabs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + name = _tuple[0]; + offset = _tuple[1]; + abs = _tuple[2]; + year = -1; + month = 0; + day = 0; + hour = -1; + min = 0; + sec = 0; + while (true) { + if (!(!(layout === ""))) { break; } + _tuple$1 = nextStdChunk(layout); + prefix = _tuple$1[0]; + std = _tuple$1[1]; + suffix = _tuple$1[2]; + if (!(prefix === "")) { + b = $appendSlice(b, prefix); + } + if (std === 0) { + break; + } + layout = suffix; + if (year < 0 && !(((std & 256) === 0))) { + _tuple$2 = absDate(abs, true); + year = _tuple$2[0]; + month = _tuple$2[1]; + day = _tuple$2[2]; + } + if (hour < 0 && !(((std & 512) === 0))) { + _tuple$3 = absClock(abs); + hour = _tuple$3[0]; + min = _tuple$3[1]; + sec = _tuple$3[2]; + } + switch (0) { default: + _1 = std & 65535; + if (_1 === (274)) { + y = year; + if (y < 0) { + y = -y; + } + b = appendInt(b, (_r$1 = y % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")), 2); + } else if (_1 === (273)) { + b = appendInt(b, year, 4); + } else if (_1 === (258)) { + b = $appendSlice(b, $substring(new Month(month).String(), 0, 3)); + } else if (_1 === (257)) { + m = new Month(month).String(); + b = $appendSlice(b, m); + } else if (_1 === (259)) { + b = appendInt(b, ((month >> 0)), 0); + } else if (_1 === (260)) { + b = appendInt(b, ((month >> 0)), 2); + } else if (_1 === (262)) { + b = $appendSlice(b, $substring(new Weekday(absWeekday(abs)).String(), 0, 3)); + } else if (_1 === (261)) { + s = new Weekday(absWeekday(abs)).String(); + b = $appendSlice(b, s); + } else if (_1 === (263)) { + b = appendInt(b, day, 0); + } else if (_1 === (264)) { + if (day < 10) { + b = $append(b, 32); + } + b = appendInt(b, day, 0); + } else if (_1 === (265)) { + b = appendInt(b, day, 2); + } else if (_1 === (522)) { + b = appendInt(b, hour, 2); + } else if (_1 === (523)) { + hr = (_r$2 = hour % 12, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")); + if (hr === 0) { + hr = 12; + } + b = appendInt(b, hr, 0); + } else if (_1 === (524)) { + hr$1 = (_r$3 = hour % 12, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); + if (hr$1 === 0) { + hr$1 = 12; + } + b = appendInt(b, hr$1, 2); + } else if (_1 === (525)) { + b = appendInt(b, min, 0); + } else if (_1 === (526)) { + b = appendInt(b, min, 2); + } else if (_1 === (527)) { + b = appendInt(b, sec, 0); + } else if (_1 === (528)) { + b = appendInt(b, sec, 2); + } else if (_1 === (531)) { + if (hour >= 12) { + b = $appendSlice(b, "PM"); + } else { + b = $appendSlice(b, "AM"); + } + } else if (_1 === (532)) { + if (hour >= 12) { + b = $appendSlice(b, "pm"); + } else { + b = $appendSlice(b, "am"); + } + } else if ((_1 === (22)) || (_1 === (25)) || (_1 === (23)) || (_1 === (24)) || (_1 === (26)) || (_1 === (27)) || (_1 === (30)) || (_1 === (28)) || (_1 === (29)) || (_1 === (31))) { + if ((offset === 0) && ((std === 22) || (std === 25) || (std === 23) || (std === 24) || (std === 26))) { + b = $append(b, 90); + break; + } + zone$1 = (_q = offset / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + absoffset = offset; + if (zone$1 < 0) { + b = $append(b, 45); + zone$1 = -zone$1; + absoffset = -absoffset; + } else { + b = $append(b, 43); + } + b = appendInt(b, (_q$1 = zone$1 / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), 2); + if ((std === 25) || (std === 30) || (std === 26) || (std === 31)) { + b = $append(b, 58); + } + if (!((std === 29)) && !((std === 24))) { + b = appendInt(b, (_r$4 = zone$1 % 60, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")), 2); + } + if ((std === 23) || (std === 28) || (std === 31) || (std === 26)) { + if ((std === 31) || (std === 26)) { + b = $append(b, 58); + } + b = appendInt(b, (_r$5 = absoffset % 60, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")), 2); + } + } else if (_1 === (21)) { + if (!(name === "")) { + b = $appendSlice(b, name); + break; + } + zone$2 = (_q$2 = offset / 60, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")); + if (zone$2 < 0) { + b = $append(b, 45); + zone$2 = -zone$2; + } else { + b = $append(b, 43); + } + b = appendInt(b, (_q$3 = zone$2 / 60, (_q$3 === _q$3 && _q$3 !== 1/0 && _q$3 !== -1/0) ? _q$3 >> 0 : $throwRuntimeError("integer divide by zero")), 2); + b = appendInt(b, (_r$6 = zone$2 % 60, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")), 2); + } else if ((_1 === (32)) || (_1 === (33))) { + b = formatNano(b, (($clone(t, Time).Nanosecond() >>> 0)), std >> 16 >> 0, (std & 65535) === 33); + } + } + } + $s = -1; return b; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AppendFormat }; } $f._1 = _1; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.abs = abs; $f.absoffset = absoffset; $f.b = b; $f.day = day; $f.hour = hour; $f.hr = hr; $f.hr$1 = hr$1; $f.layout = layout; $f.m = m; $f.min = min; $f.month = month; $f.name = name; $f.offset = offset; $f.prefix = prefix; $f.s = s; $f.sec = sec; $f.std = std; $f.suffix = suffix; $f.t = t; $f.y = y; $f.year = year; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.AppendFormat = function(b, layout) { return this.$val.AppendFormat(b, layout); }; + quote = function(s) { + var s; + return "\"" + s + "\""; + }; + ParseError.ptr.prototype.Error = function() { + var e; + e = this; + if (e.Message === "") { + return "parsing time " + quote(e.Value) + " as " + quote(e.Layout) + ": cannot parse " + quote(e.ValueElem) + " as " + quote(e.LayoutElem); + } + return "parsing time " + quote(e.Value) + e.Message; + }; + ParseError.prototype.Error = function() { return this.$val.Error(); }; + isDigit = function(s, i) { + var c, i, s; + if (s.length <= i) { + return false; + } + c = s.charCodeAt(i); + return 48 <= c && c <= 57; + }; + getnum = function(s, fixed) { + var fixed, s; + if (!isDigit(s, 0)) { + return [0, s, errBad]; + } + if (!isDigit(s, 1)) { + if (fixed) { + return [0, s, errBad]; + } + return [(((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0)), $substring(s, 1), $ifaceNil]; + } + return [($imul((((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0)), 10)) + (((s.charCodeAt(1) - 48 << 24 >>> 24) >> 0)) >> 0, $substring(s, 2), $ifaceNil]; + }; + cutspace = function(s) { + var s; + while (true) { + if (!(s.length > 0 && (s.charCodeAt(0) === 32))) { break; } + s = $substring(s, 1); + } + return s; + }; + skip = function(value, prefix) { + var prefix, value; + while (true) { + if (!(prefix.length > 0)) { break; } + if (prefix.charCodeAt(0) === 32) { + if (value.length > 0 && !((value.charCodeAt(0) === 32))) { + return [value, errBad]; + } + prefix = cutspace(prefix); + value = cutspace(value); + continue; + } + if ((value.length === 0) || !((value.charCodeAt(0) === prefix.charCodeAt(0)))) { + return [value, errBad]; + } + prefix = $substring(prefix, 1); + value = $substring(value, 1); + } + return [value, $ifaceNil]; + }; + Parse = function(layout, value) { + var _r, layout, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; layout = $f.layout; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = parse(layout, value, $pkg.UTC, $pkg.Local); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f._r = _r; $f.layout = layout; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Parse = Parse; + parse = function(layout, value, defaultLocation, local) { + var _1, _2, _3, _4, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$10, _tuple$11, _tuple$12, _tuple$13, _tuple$14, _tuple$15, _tuple$16, _tuple$17, _tuple$18, _tuple$19, _tuple$2, _tuple$20, _tuple$21, _tuple$22, _tuple$23, _tuple$24, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, alayout, amSet, avalue, day, defaultLocation, err, hour, hour$1, hr, i, layout, local, min, min$1, mm, month, n, n$1, name, ndigit, nsec, offset, offset$1, ok, ok$1, p, pmSet, prefix, rangeErrString, sec, seconds, sign, ss, std, stdstr, suffix, t, t$1, value, x, x$1, year, z, zoneName, zoneOffset, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$28 = $f._tmp$28; _tmp$29 = $f._tmp$29; _tmp$3 = $f._tmp$3; _tmp$30 = $f._tmp$30; _tmp$31 = $f._tmp$31; _tmp$32 = $f._tmp$32; _tmp$33 = $f._tmp$33; _tmp$34 = $f._tmp$34; _tmp$35 = $f._tmp$35; _tmp$36 = $f._tmp$36; _tmp$37 = $f._tmp$37; _tmp$38 = $f._tmp$38; _tmp$39 = $f._tmp$39; _tmp$4 = $f._tmp$4; _tmp$40 = $f._tmp$40; _tmp$41 = $f._tmp$41; _tmp$42 = $f._tmp$42; _tmp$43 = $f._tmp$43; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$12 = $f._tuple$12; _tuple$13 = $f._tuple$13; _tuple$14 = $f._tuple$14; _tuple$15 = $f._tuple$15; _tuple$16 = $f._tuple$16; _tuple$17 = $f._tuple$17; _tuple$18 = $f._tuple$18; _tuple$19 = $f._tuple$19; _tuple$2 = $f._tuple$2; _tuple$20 = $f._tuple$20; _tuple$21 = $f._tuple$21; _tuple$22 = $f._tuple$22; _tuple$23 = $f._tuple$23; _tuple$24 = $f._tuple$24; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; alayout = $f.alayout; amSet = $f.amSet; avalue = $f.avalue; day = $f.day; defaultLocation = $f.defaultLocation; err = $f.err; hour = $f.hour; hour$1 = $f.hour$1; hr = $f.hr; i = $f.i; layout = $f.layout; local = $f.local; min = $f.min; min$1 = $f.min$1; mm = $f.mm; month = $f.month; n = $f.n; n$1 = $f.n$1; name = $f.name; ndigit = $f.ndigit; nsec = $f.nsec; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; pmSet = $f.pmSet; prefix = $f.prefix; rangeErrString = $f.rangeErrString; sec = $f.sec; seconds = $f.seconds; sign = $f.sign; ss = $f.ss; std = $f.std; stdstr = $f.stdstr; suffix = $f.suffix; t = $f.t; t$1 = $f.t$1; value = $f.value; x = $f.x; x$1 = $f.x$1; year = $f.year; z = $f.z; zoneName = $f.zoneName; zoneOffset = $f.zoneOffset; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tmp = layout; + _tmp$1 = value; + alayout = _tmp; + avalue = _tmp$1; + rangeErrString = ""; + amSet = false; + pmSet = false; + year = 0; + month = 1; + day = 1; + hour = 0; + min = 0; + sec = 0; + nsec = 0; + z = ptrType$2.nil; + zoneOffset = -1; + zoneName = ""; + while (true) { + err = $ifaceNil; + _tuple = nextStdChunk(layout); + prefix = _tuple[0]; + std = _tuple[1]; + suffix = _tuple[2]; + stdstr = $substring(layout, prefix.length, (layout.length - suffix.length >> 0)); + _tuple$1 = skip(value, prefix); + value = _tuple$1[0]; + err = _tuple$1[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, prefix, value, "")]; + } + if (std === 0) { + if (!((value.length === 0))) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, "", value, ": extra text: " + value)]; + } + break; + } + layout = suffix; + p = ""; + switch (0) { default: + _1 = std & 65535; + if (_1 === (274)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$2 = $substring(value, 0, 2); + _tmp$3 = $substring(value, 2); + p = _tmp$2; + value = _tmp$3; + _tuple$2 = atoi(p); + year = _tuple$2[0]; + err = _tuple$2[1]; + if (year >= 69) { + year = year + (1900) >> 0; + } else { + year = year + (2000) >> 0; + } + } else if (_1 === (273)) { + if (value.length < 4 || !isDigit(value, 0)) { + err = errBad; + break; + } + _tmp$4 = $substring(value, 0, 4); + _tmp$5 = $substring(value, 4); + p = _tmp$4; + value = _tmp$5; + _tuple$3 = atoi(p); + year = _tuple$3[0]; + err = _tuple$3[1]; + } else if (_1 === (258)) { + _tuple$4 = lookup(shortMonthNames, value); + month = _tuple$4[0]; + value = _tuple$4[1]; + err = _tuple$4[2]; + month = month + (1) >> 0; + } else if (_1 === (257)) { + _tuple$5 = lookup(longMonthNames, value); + month = _tuple$5[0]; + value = _tuple$5[1]; + err = _tuple$5[2]; + month = month + (1) >> 0; + } else if ((_1 === (259)) || (_1 === (260))) { + _tuple$6 = getnum(value, std === 260); + month = _tuple$6[0]; + value = _tuple$6[1]; + err = _tuple$6[2]; + if (month <= 0 || 12 < month) { + rangeErrString = "month"; + } + } else if (_1 === (262)) { + _tuple$7 = lookup(shortDayNames, value); + value = _tuple$7[1]; + err = _tuple$7[2]; + } else if (_1 === (261)) { + _tuple$8 = lookup(longDayNames, value); + value = _tuple$8[1]; + err = _tuple$8[2]; + } else if ((_1 === (263)) || (_1 === (264)) || (_1 === (265))) { + if ((std === 264) && value.length > 0 && (value.charCodeAt(0) === 32)) { + value = $substring(value, 1); + } + _tuple$9 = getnum(value, std === 265); + day = _tuple$9[0]; + value = _tuple$9[1]; + err = _tuple$9[2]; + if (day < 0) { + rangeErrString = "day"; + } + } else if (_1 === (522)) { + _tuple$10 = getnum(value, false); + hour = _tuple$10[0]; + value = _tuple$10[1]; + err = _tuple$10[2]; + if (hour < 0 || 24 <= hour) { + rangeErrString = "hour"; + } + } else if ((_1 === (523)) || (_1 === (524))) { + _tuple$11 = getnum(value, std === 524); + hour = _tuple$11[0]; + value = _tuple$11[1]; + err = _tuple$11[2]; + if (hour < 0 || 12 < hour) { + rangeErrString = "hour"; + } + } else if ((_1 === (525)) || (_1 === (526))) { + _tuple$12 = getnum(value, std === 526); + min = _tuple$12[0]; + value = _tuple$12[1]; + err = _tuple$12[2]; + if (min < 0 || 60 <= min) { + rangeErrString = "minute"; + } + } else if ((_1 === (527)) || (_1 === (528))) { + _tuple$13 = getnum(value, std === 528); + sec = _tuple$13[0]; + value = _tuple$13[1]; + err = _tuple$13[2]; + if (sec < 0 || 60 <= sec) { + rangeErrString = "second"; + break; + } + if (value.length >= 2 && (value.charCodeAt(0) === 46) && isDigit(value, 1)) { + _tuple$14 = nextStdChunk(layout); + std = _tuple$14[1]; + std = std & (65535); + if ((std === 32) || (std === 33)) { + break; + } + n = 2; + while (true) { + if (!(n < value.length && isDigit(value, n))) { break; } + n = n + (1) >> 0; + } + _tuple$15 = parseNanoseconds(value, n); + nsec = _tuple$15[0]; + rangeErrString = _tuple$15[1]; + err = _tuple$15[2]; + value = $substring(value, n); + } + } else if (_1 === (531)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$6 = $substring(value, 0, 2); + _tmp$7 = $substring(value, 2); + p = _tmp$6; + value = _tmp$7; + _2 = p; + if (_2 === ("PM")) { + pmSet = true; + } else if (_2 === ("AM")) { + amSet = true; + } else { + err = errBad; + } + } else if (_1 === (532)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$8 = $substring(value, 0, 2); + _tmp$9 = $substring(value, 2); + p = _tmp$8; + value = _tmp$9; + _3 = p; + if (_3 === ("pm")) { + pmSet = true; + } else if (_3 === ("am")) { + amSet = true; + } else { + err = errBad; + } + } else if ((_1 === (22)) || (_1 === (25)) || (_1 === (23)) || (_1 === (24)) || (_1 === (26)) || (_1 === (27)) || (_1 === (29)) || (_1 === (30)) || (_1 === (28)) || (_1 === (31))) { + if (((std === 22) || (std === 24) || (std === 25)) && value.length >= 1 && (value.charCodeAt(0) === 90)) { + value = $substring(value, 1); + z = $pkg.UTC; + break; + } + _tmp$10 = ""; + _tmp$11 = ""; + _tmp$12 = ""; + _tmp$13 = ""; + sign = _tmp$10; + hour$1 = _tmp$11; + min$1 = _tmp$12; + seconds = _tmp$13; + if ((std === 25) || (std === 30)) { + if (value.length < 6) { + err = errBad; + break; + } + if (!((value.charCodeAt(3) === 58))) { + err = errBad; + break; + } + _tmp$14 = $substring(value, 0, 1); + _tmp$15 = $substring(value, 1, 3); + _tmp$16 = $substring(value, 4, 6); + _tmp$17 = "00"; + _tmp$18 = $substring(value, 6); + sign = _tmp$14; + hour$1 = _tmp$15; + min$1 = _tmp$16; + seconds = _tmp$17; + value = _tmp$18; + } else if ((std === 29) || (std === 24)) { + if (value.length < 3) { + err = errBad; + break; + } + _tmp$19 = $substring(value, 0, 1); + _tmp$20 = $substring(value, 1, 3); + _tmp$21 = "00"; + _tmp$22 = "00"; + _tmp$23 = $substring(value, 3); + sign = _tmp$19; + hour$1 = _tmp$20; + min$1 = _tmp$21; + seconds = _tmp$22; + value = _tmp$23; + } else if ((std === 26) || (std === 31)) { + if (value.length < 9) { + err = errBad; + break; + } + if (!((value.charCodeAt(3) === 58)) || !((value.charCodeAt(6) === 58))) { + err = errBad; + break; + } + _tmp$24 = $substring(value, 0, 1); + _tmp$25 = $substring(value, 1, 3); + _tmp$26 = $substring(value, 4, 6); + _tmp$27 = $substring(value, 7, 9); + _tmp$28 = $substring(value, 9); + sign = _tmp$24; + hour$1 = _tmp$25; + min$1 = _tmp$26; + seconds = _tmp$27; + value = _tmp$28; + } else if ((std === 23) || (std === 28)) { + if (value.length < 7) { + err = errBad; + break; + } + _tmp$29 = $substring(value, 0, 1); + _tmp$30 = $substring(value, 1, 3); + _tmp$31 = $substring(value, 3, 5); + _tmp$32 = $substring(value, 5, 7); + _tmp$33 = $substring(value, 7); + sign = _tmp$29; + hour$1 = _tmp$30; + min$1 = _tmp$31; + seconds = _tmp$32; + value = _tmp$33; + } else { + if (value.length < 5) { + err = errBad; + break; + } + _tmp$34 = $substring(value, 0, 1); + _tmp$35 = $substring(value, 1, 3); + _tmp$36 = $substring(value, 3, 5); + _tmp$37 = "00"; + _tmp$38 = $substring(value, 5); + sign = _tmp$34; + hour$1 = _tmp$35; + min$1 = _tmp$36; + seconds = _tmp$37; + value = _tmp$38; + } + _tmp$39 = 0; + _tmp$40 = 0; + _tmp$41 = 0; + hr = _tmp$39; + mm = _tmp$40; + ss = _tmp$41; + _tuple$16 = atoi(hour$1); + hr = _tuple$16[0]; + err = _tuple$16[1]; + if ($interfaceIsEqual(err, $ifaceNil)) { + _tuple$17 = atoi(min$1); + mm = _tuple$17[0]; + err = _tuple$17[1]; + } + if ($interfaceIsEqual(err, $ifaceNil)) { + _tuple$18 = atoi(seconds); + ss = _tuple$18[0]; + err = _tuple$18[1]; + } + zoneOffset = ($imul(((($imul(hr, 60)) + mm >> 0)), 60)) + ss >> 0; + _4 = sign.charCodeAt(0); + if (_4 === (43)) { + } else if (_4 === (45)) { + zoneOffset = -zoneOffset; + } else { + err = errBad; + } + } else if (_1 === (21)) { + if (value.length >= 3 && $substring(value, 0, 3) === "UTC") { + z = $pkg.UTC; + value = $substring(value, 3); + break; + } + _tuple$19 = parseTimeZone(value); + n$1 = _tuple$19[0]; + ok = _tuple$19[1]; + if (!ok) { + err = errBad; + break; + } + _tmp$42 = $substring(value, 0, n$1); + _tmp$43 = $substring(value, n$1); + zoneName = _tmp$42; + value = _tmp$43; + } else if (_1 === (32)) { + ndigit = 1 + ((std >> 16 >> 0)) >> 0; + if (value.length < ndigit) { + err = errBad; + break; + } + _tuple$20 = parseNanoseconds(value, ndigit); + nsec = _tuple$20[0]; + rangeErrString = _tuple$20[1]; + err = _tuple$20[2]; + value = $substring(value, ndigit); + } else if (_1 === (33)) { + if (value.length < 2 || !((value.charCodeAt(0) === 46)) || value.charCodeAt(1) < 48 || 57 < value.charCodeAt(1)) { + break; + } + i = 0; + while (true) { + if (!(i < 9 && (i + 1 >> 0) < value.length && 48 <= value.charCodeAt((i + 1 >> 0)) && value.charCodeAt((i + 1 >> 0)) <= 57)) { break; } + i = i + (1) >> 0; + } + _tuple$21 = parseNanoseconds(value, 1 + i >> 0); + nsec = _tuple$21[0]; + rangeErrString = _tuple$21[1]; + err = _tuple$21[2]; + value = $substring(value, (1 + i >> 0)); + } + } + if (!(rangeErrString === "")) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range")]; + } + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, stdstr, value, "")]; + } + } + if (pmSet && hour < 12) { + hour = hour + (12) >> 0; + } else if (amSet && (hour === 12)) { + hour = 0; + } + if (day < 1 || day > daysIn(((month >> 0)), year)) { + $s = -1; return [new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil), new ParseError.ptr(alayout, avalue, "", value, ": day out of range")]; + } + /* */ if (!(z === ptrType$2.nil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(z === ptrType$2.nil)) { */ case 1: + _r = Date(year, ((month >> 0)), day, hour, min, sec, nsec, z); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return [_r, $ifaceNil]; + /* } */ case 2: + /* */ if (!((zoneOffset === -1))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!((zoneOffset === -1))) { */ case 4: + _r$1 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + t = $clone(_r$1, Time); + t.addSec((x = (new $Int64(0, zoneOffset)), new $Int64(-x.$high, -x.$low))); + _r$2 = local.lookup(t.unixSec()); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$22 = _r$2; + name = _tuple$22[0]; + offset = _tuple$22[1]; + if ((offset === zoneOffset) && (zoneName === "" || name === zoneName)) { + t.setLoc(local); + $s = -1; return [t, $ifaceNil]; + } + t.setLoc(FixedZone(zoneName, zoneOffset)); + $s = -1; return [t, $ifaceNil]; + /* } */ case 5: + /* */ if (!(zoneName === "")) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!(zoneName === "")) { */ case 8: + _r$3 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + t$1 = $clone(_r$3, Time); + _r$4 = local.lookupName(zoneName, t$1.unixSec()); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _tuple$23 = _r$4; + offset$1 = _tuple$23[0]; + ok$1 = _tuple$23[1]; + if (ok$1) { + t$1.addSec((x$1 = (new $Int64(0, offset$1)), new $Int64(-x$1.$high, -x$1.$low))); + t$1.setLoc(local); + $s = -1; return [t$1, $ifaceNil]; + } + if (zoneName.length > 3 && $substring(zoneName, 0, 3) === "GMT") { + _tuple$24 = atoi($substring(zoneName, 3)); + offset$1 = _tuple$24[0]; + offset$1 = $imul(offset$1, (3600)); + } + t$1.setLoc(FixedZone(zoneName, offset$1)); + $s = -1; return [t$1, $ifaceNil]; + /* } */ case 9: + _r$5 = Date(year, ((month >> 0)), day, hour, min, sec, nsec, defaultLocation); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return [_r$5, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parse }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$28 = _tmp$28; $f._tmp$29 = _tmp$29; $f._tmp$3 = _tmp$3; $f._tmp$30 = _tmp$30; $f._tmp$31 = _tmp$31; $f._tmp$32 = _tmp$32; $f._tmp$33 = _tmp$33; $f._tmp$34 = _tmp$34; $f._tmp$35 = _tmp$35; $f._tmp$36 = _tmp$36; $f._tmp$37 = _tmp$37; $f._tmp$38 = _tmp$38; $f._tmp$39 = _tmp$39; $f._tmp$4 = _tmp$4; $f._tmp$40 = _tmp$40; $f._tmp$41 = _tmp$41; $f._tmp$42 = _tmp$42; $f._tmp$43 = _tmp$43; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$12 = _tuple$12; $f._tuple$13 = _tuple$13; $f._tuple$14 = _tuple$14; $f._tuple$15 = _tuple$15; $f._tuple$16 = _tuple$16; $f._tuple$17 = _tuple$17; $f._tuple$18 = _tuple$18; $f._tuple$19 = _tuple$19; $f._tuple$2 = _tuple$2; $f._tuple$20 = _tuple$20; $f._tuple$21 = _tuple$21; $f._tuple$22 = _tuple$22; $f._tuple$23 = _tuple$23; $f._tuple$24 = _tuple$24; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.alayout = alayout; $f.amSet = amSet; $f.avalue = avalue; $f.day = day; $f.defaultLocation = defaultLocation; $f.err = err; $f.hour = hour; $f.hour$1 = hour$1; $f.hr = hr; $f.i = i; $f.layout = layout; $f.local = local; $f.min = min; $f.min$1 = min$1; $f.mm = mm; $f.month = month; $f.n = n; $f.n$1 = n$1; $f.name = name; $f.ndigit = ndigit; $f.nsec = nsec; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.pmSet = pmSet; $f.prefix = prefix; $f.rangeErrString = rangeErrString; $f.sec = sec; $f.seconds = seconds; $f.sign = sign; $f.ss = ss; $f.std = std; $f.stdstr = stdstr; $f.suffix = suffix; $f.t = t; $f.t$1 = t$1; $f.value = value; $f.x = x; $f.x$1 = x$1; $f.year = year; $f.z = z; $f.zoneName = zoneName; $f.zoneOffset = zoneOffset; $f.$s = $s; $f.$r = $r; return $f; + }; + parseTimeZone = function(value) { + var _1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c, length, nUpper, ok, value; + length = 0; + ok = false; + if (value.length < 3) { + _tmp = 0; + _tmp$1 = false; + length = _tmp; + ok = _tmp$1; + return [length, ok]; + } + if (value.length >= 4 && ($substring(value, 0, 4) === "ChST" || $substring(value, 0, 4) === "MeST")) { + _tmp$2 = 4; + _tmp$3 = true; + length = _tmp$2; + ok = _tmp$3; + return [length, ok]; + } + if ($substring(value, 0, 3) === "GMT") { + length = parseGMT(value); + _tmp$4 = length; + _tmp$5 = true; + length = _tmp$4; + ok = _tmp$5; + return [length, ok]; + } + nUpper = 0; + nUpper = 0; + while (true) { + if (!(nUpper < 6)) { break; } + if (nUpper >= value.length) { + break; + } + c = value.charCodeAt(nUpper); + if (c < 65 || 90 < c) { + break; + } + nUpper = nUpper + (1) >> 0; + } + _1 = nUpper; + if ((_1 === (0)) || (_1 === (1)) || (_1 === (2)) || (_1 === (6))) { + _tmp$6 = 0; + _tmp$7 = false; + length = _tmp$6; + ok = _tmp$7; + return [length, ok]; + } else if (_1 === (5)) { + if (value.charCodeAt(4) === 84) { + _tmp$8 = 5; + _tmp$9 = true; + length = _tmp$8; + ok = _tmp$9; + return [length, ok]; + } + } else if (_1 === (4)) { + if ((value.charCodeAt(3) === 84) || $substring(value, 0, 4) === "WITA") { + _tmp$10 = 4; + _tmp$11 = true; + length = _tmp$10; + ok = _tmp$11; + return [length, ok]; + } + } else if (_1 === (3)) { + _tmp$12 = 3; + _tmp$13 = true; + length = _tmp$12; + ok = _tmp$13; + return [length, ok]; + } + _tmp$14 = 0; + _tmp$15 = false; + length = _tmp$14; + ok = _tmp$15; + return [length, ok]; + }; + parseGMT = function(value) { + var _tuple, err, rem, sign, value, x; + value = $substring(value, 3); + if (value.length === 0) { + return 3; + } + sign = value.charCodeAt(0); + if (!((sign === 45)) && !((sign === 43))) { + return 3; + } + _tuple = leadingInt($substring(value, 1)); + x = _tuple[0]; + rem = _tuple[1]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return 3; + } + if (sign === 45) { + x = new $Int64(-x.$high, -x.$low); + } + if ((x.$high === 0 && x.$low === 0) || (x.$high < -1 || (x.$high === -1 && x.$low < 4294967282)) || (0 < x.$high || (0 === x.$high && 12 < x.$low))) { + return 3; + } + return (3 + value.length >> 0) - rem.length >> 0; + }; + parseNanoseconds = function(value, nbytes) { + var _tuple, err, i, nbytes, ns, rangeErrString, scaleDigits, value; + ns = 0; + rangeErrString = ""; + err = $ifaceNil; + if (!((value.charCodeAt(0) === 46))) { + err = errBad; + return [ns, rangeErrString, err]; + } + _tuple = atoi($substring(value, 1, nbytes)); + ns = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [ns, rangeErrString, err]; + } + if (ns < 0 || 1000000000 <= ns) { + rangeErrString = "fractional second"; + return [ns, rangeErrString, err]; + } + scaleDigits = 10 - nbytes >> 0; + i = 0; + while (true) { + if (!(i < scaleDigits)) { break; } + ns = $imul(ns, (10)); + i = i + (1) >> 0; + } + return [ns, rangeErrString, err]; + }; + leadingInt = function(s) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, c, err, i, rem, s, x, x$1, x$2, x$3; + x = new $Int64(0, 0); + rem = ""; + err = $ifaceNil; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + c = s.charCodeAt(i); + if (c < 48 || c > 57) { + break; + } + if ((x.$high > 214748364 || (x.$high === 214748364 && x.$low > 3435973836))) { + _tmp = new $Int64(0, 0); + _tmp$1 = ""; + _tmp$2 = errLeadingInt; + x = _tmp; + rem = _tmp$1; + err = _tmp$2; + return [x, rem, err]; + } + x = (x$1 = (x$2 = $mul64(x, new $Int64(0, 10)), x$3 = (new $Int64(0, c)), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)), new $Int64(x$1.$high - 0, x$1.$low - 48)); + if ((x.$high < 0 || (x.$high === 0 && x.$low < 0))) { + _tmp$3 = new $Int64(0, 0); + _tmp$4 = ""; + _tmp$5 = errLeadingInt; + x = _tmp$3; + rem = _tmp$4; + err = _tmp$5; + return [x, rem, err]; + } + i = i + (1) >> 0; + } + _tmp$6 = x; + _tmp$7 = $substring(s, i); + _tmp$8 = $ifaceNil; + x = _tmp$6; + rem = _tmp$7; + err = _tmp$8; + return [x, rem, err]; + }; + when = function(d) { + var d, t, x, x$1; + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return runtimeNano(); + } + t = (x = runtimeNano(), x$1 = (new $Int64(d.$high, d.$low)), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)); + if ((t.$high < 0 || (t.$high === 0 && t.$low < 0))) { + t = new $Int64(2147483647, 4294967295); + } + return t; + }; + Timer.ptr.prototype.Stop = function() { + var t; + t = this; + if (t.r.f === $throwNilPointerError) { + $panic(new $String("time: Stop called on uninitialized Timer")); + } + return stopTimer(t.r); + }; + Timer.prototype.Stop = function() { return this.$val.Stop(); }; + Timer.ptr.prototype.Reset = function(d) { + var active, d, t, w; + t = this; + if (t.r.f === $throwNilPointerError) { + $panic(new $String("time: Reset called on uninitialized Timer")); + } + w = when(d); + active = stopTimer(t.r); + t.r.when = w; + startTimer(t.r); + return active; + }; + Timer.prototype.Reset = function(d) { return this.$val.Reset(d); }; + AfterFunc = function(d, f) { + var d, f, t; + t = new Timer.ptr($chanNil, new runtimeTimer.ptr(0, when(d), new $Int64(0, 0), goFunc, new funcType(f), null, false)); + startTimer(t.r); + return t; + }; + $pkg.AfterFunc = AfterFunc; + goFunc = function(arg, seq) { + var arg, seq; + $go($assertType(arg, funcType), []); + }; + Time.ptr.prototype.nsec = function() { + var t, x; + t = this; + return (((x = t.wall, new $Uint64(x.$high & 0, (x.$low & 1073741823) >>> 0)).$low >> 0)); + }; + Time.prototype.nsec = function() { return this.$val.nsec(); }; + Time.ptr.prototype.sec = function() { + var t, x, x$1, x$2, x$3; + t = this; + if (!((x = (x$1 = t.wall, new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + return (x$2 = ((x$3 = $shiftRightUint64($shiftLeft64(t.wall, 1), 31), new $Int64(x$3.$high, x$3.$low))), new $Int64(13 + x$2.$high, 3618733952 + x$2.$low)); + } + return (t.ext); + }; + Time.prototype.sec = function() { return this.$val.sec(); }; + Time.ptr.prototype.unixSec = function() { + var t, x; + t = this; + return (x = t.sec(), new $Int64(x.$high + -15, x.$low + 2288912640)); + }; + Time.prototype.unixSec = function() { return this.$val.unixSec(); }; + Time.ptr.prototype.addSec = function(d) { + var d, dsec, sec, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8; + t = this; + if (!((x = (x$1 = t.wall, new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + sec = ((x$2 = $shiftRightUint64($shiftLeft64(t.wall, 1), 31), new $Int64(x$2.$high, x$2.$low))); + dsec = new $Int64(sec.$high + d.$high, sec.$low + d.$low); + if ((0 < dsec.$high || (0 === dsec.$high && 0 <= dsec.$low)) && (dsec.$high < 1 || (dsec.$high === 1 && dsec.$low <= 4294967295))) { + t.wall = (x$3 = (x$4 = (x$5 = t.wall, new $Uint64(x$5.$high & 0, (x$5.$low & 1073741823) >>> 0)), x$6 = $shiftLeft64((new $Uint64(dsec.$high, dsec.$low)), 30), new $Uint64(x$4.$high | x$6.$high, (x$4.$low | x$6.$low) >>> 0)), new $Uint64(x$3.$high | 2147483648, (x$3.$low | 0) >>> 0)); + return; + } + t.stripMono(); + } + t.ext = (x$7 = t.ext, x$8 = d, new $Int64(x$7.$high + x$8.$high, x$7.$low + x$8.$low)); + }; + Time.prototype.addSec = function(d) { return this.$val.addSec(d); }; + Time.ptr.prototype.setLoc = function(loc) { + var loc, t; + t = this; + if (loc === utcLoc) { + loc = ptrType$2.nil; + } + t.stripMono(); + t.loc = loc; + }; + Time.prototype.setLoc = function(loc) { return this.$val.setLoc(loc); }; + Time.ptr.prototype.stripMono = function() { + var t, x, x$1, x$2, x$3; + t = this; + if (!((x = (x$1 = t.wall, new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + t.ext = t.sec(); + t.wall = (x$2 = t.wall, x$3 = new $Uint64(0, 1073741823), new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)); + } + }; + Time.prototype.stripMono = function() { return this.$val.stripMono(); }; + Time.ptr.prototype.After = function(u) { + var t, ts, u, us, x, x$1, x$2, x$3, x$4, x$5; + t = this; + if (!((x = (x$1 = (x$2 = t.wall, x$3 = u.wall, new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)), new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + return (x$4 = t.ext, x$5 = u.ext, (x$4.$high > x$5.$high || (x$4.$high === x$5.$high && x$4.$low > x$5.$low))); + } + ts = t.sec(); + us = u.sec(); + return (ts.$high > us.$high || (ts.$high === us.$high && ts.$low > us.$low)) || (ts.$high === us.$high && ts.$low === us.$low) && t.nsec() > u.nsec(); + }; + Time.prototype.After = function(u) { return this.$val.After(u); }; + Time.ptr.prototype.Before = function(u) { + var t, u, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + if (!((x = (x$1 = (x$2 = t.wall, x$3 = u.wall, new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)), new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + return (x$4 = t.ext, x$5 = u.ext, (x$4.$high < x$5.$high || (x$4.$high === x$5.$high && x$4.$low < x$5.$low))); + } + return (x$6 = t.sec(), x$7 = u.sec(), (x$6.$high < x$7.$high || (x$6.$high === x$7.$high && x$6.$low < x$7.$low))) || (x$8 = t.sec(), x$9 = u.sec(), (x$8.$high === x$9.$high && x$8.$low === x$9.$low)) && t.nsec() < u.nsec(); + }; + Time.prototype.Before = function(u) { return this.$val.Before(u); }; + Time.ptr.prototype.Equal = function(u) { + var t, u, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; + t = this; + if (!((x = (x$1 = (x$2 = t.wall, x$3 = u.wall, new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)), new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + return (x$4 = t.ext, x$5 = u.ext, (x$4.$high === x$5.$high && x$4.$low === x$5.$low)); + } + return (x$6 = t.sec(), x$7 = u.sec(), (x$6.$high === x$7.$high && x$6.$low === x$7.$low)) && (t.nsec() === u.nsec()); + }; + Time.prototype.Equal = function(u) { return this.$val.Equal(u); }; + Month.prototype.String = function() { + var buf, m, n, x; + m = this.$val; + if (1 <= m && m <= 12) { + return (x = m - 1 >> 0, ((x < 0 || x >= months.length) ? ($throwRuntimeError("index out of range"), undefined) : months[x])); + } + buf = $makeSlice(sliceType$3, 20); + n = fmtInt(buf, (new $Uint64(0, m))); + return "%!Month(" + ($bytesToString($subslice(buf, n))) + ")"; + }; + $ptrType(Month).prototype.String = function() { return new Month(this.$get()).String(); }; + Weekday.prototype.String = function() { + var d; + d = this.$val; + return ((d < 0 || d >= days.length) ? ($throwRuntimeError("index out of range"), undefined) : days[d]); + }; + $ptrType(Weekday).prototype.String = function() { return new Weekday(this.$get()).String(); }; + Time.ptr.prototype.IsZero = function() { + var t, x; + t = this; + return (x = t.sec(), (x.$high === 0 && x.$low === 0)) && (t.nsec() === 0); + }; + Time.prototype.IsZero = function() { return this.$val.IsZero(); }; + Time.ptr.prototype.abs = function() { + var _r, _r$1, _tuple, l, offset, sec, t, x, x$1, x$2, x$3, x$4, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; l = $f.l; offset = $f.offset; sec = $f.sec; t = $f.t; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + l = t.loc; + /* */ if (l === ptrType$2.nil || l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === ptrType$2.nil || l === localLoc) { */ case 1: + _r = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + /* } */ case 2: + sec = t.unixSec(); + /* */ if (!(l === utcLoc)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!(l === utcLoc)) { */ case 4: + /* */ if (!(l.cacheZone === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (!(l.cacheZone === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) { */ case 6: + sec = (x$2 = (new $Int64(0, l.cacheZone.offset)), new $Int64(sec.$high + x$2.$high, sec.$low + x$2.$low)); + $s = 8; continue; + /* } else { */ case 7: + _r$1 = l.lookup(sec); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + offset = _tuple[1]; + sec = (x$3 = (new $Int64(0, offset)), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low)); + /* } */ case 8: + /* } */ case 5: + $s = -1; return ((x$4 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$4.$high, x$4.$low))); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.abs }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.l = l; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.abs = function() { return this.$val.abs(); }; + Time.ptr.prototype.locabs = function() { + var _r, _r$1, _tuple, abs, l, name, offset, sec, t, x, x$1, x$2, x$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; abs = $f.abs; l = $f.l; name = $f.name; offset = $f.offset; sec = $f.sec; t = $f.t; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + abs = new $Uint64(0, 0); + t = this; + l = t.loc; + /* */ if (l === ptrType$2.nil || l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === ptrType$2.nil || l === localLoc) { */ case 1: + _r = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + /* } */ case 2: + sec = t.unixSec(); + /* */ if (!(l === utcLoc)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!(l === utcLoc)) { */ case 4: + /* */ if (!(l.cacheZone === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!(l.cacheZone === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) { */ case 7: + name = l.cacheZone.name; + offset = l.cacheZone.offset; + $s = 9; continue; + /* } else { */ case 8: + _r$1 = l.lookup(sec); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + name = _tuple[0]; + offset = _tuple[1]; + /* } */ case 9: + sec = (x$2 = (new $Int64(0, offset)), new $Int64(sec.$high + x$2.$high, sec.$low + x$2.$low)); + $s = 6; continue; + /* } else { */ case 5: + name = "UTC"; + /* } */ case 6: + abs = ((x$3 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$3.$high, x$3.$low))); + $s = -1; return [name, offset, abs]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.locabs }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.abs = abs; $f.l = l; $f.name = name; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.locabs = function() { return this.$val.locabs(); }; + Time.ptr.prototype.Date = function() { + var _r, _tuple, day, month, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; day = $f.day; month = $f.month; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + year = 0; + month = 0; + day = 0; + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + $s = -1; return [year, month, day]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Date }; } $f._r = _r; $f._tuple = _tuple; $f.day = day; $f.month = month; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Date = function() { return this.$val.Date(); }; + Time.ptr.prototype.Year = function() { + var _r, _tuple, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + $s = -1; return year; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Year }; } $f._r = _r; $f._tuple = _tuple; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Year = function() { return this.$val.Year(); }; + Time.ptr.prototype.Month = function() { + var _r, _tuple, month, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; month = $f.month; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + month = _tuple[1]; + $s = -1; return month; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Month }; } $f._r = _r; $f._tuple = _tuple; $f.month = month; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Month = function() { return this.$val.Month(); }; + Time.ptr.prototype.Day = function() { + var _r, _tuple, day, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; day = $f.day; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + day = _tuple[2]; + $s = -1; return day; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Day }; } $f._r = _r; $f._tuple = _tuple; $f.day = day; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Day = function() { return this.$val.Day(); }; + Time.ptr.prototype.Weekday = function() { + var _r, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = absWeekday(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Weekday }; } $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Weekday = function() { return this.$val.Weekday(); }; + absWeekday = function(abs) { + var _q, abs, sec; + sec = $div64((new $Uint64(abs.$high + 0, abs.$low + 86400)), new $Uint64(0, 604800), true); + return (((_q = ((sec.$low >> 0)) / 86400, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); + }; + Time.ptr.prototype.ISOWeek = function() { + var _q, _r, _r$1, _r$2, _r$3, _r$4, _tuple, day, dec31wday, jan1wday, month, t, wday, week, yday, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; day = $f.day; dec31wday = $f.dec31wday; jan1wday = $f.jan1wday; month = $f.month; t = $f.t; wday = $f.wday; week = $f.week; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + year = 0; + week = 0; + t = this; + _r = $clone(t, Time).date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + yday = _tuple[3]; + _r$2 = $clone(t, Time).Weekday(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + wday = (_r$1 = (((_r$2 + 6 >> 0) >> 0)) % 7, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")); + week = (_q = (((yday - wday >> 0) + 7 >> 0)) / 7, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + jan1wday = (_r$3 = (((wday - yday >> 0) + 371 >> 0)) % 7, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); + if (1 <= jan1wday && jan1wday <= 3) { + week = week + (1) >> 0; + } + if (week === 0) { + year = year - (1) >> 0; + week = 52; + if ((jan1wday === 4) || ((jan1wday === 5) && isLeap(year))) { + week = week + (1) >> 0; + } + } + if ((month === 12) && day >= 29 && wday < 3) { + dec31wday = (_r$4 = (((wday + 31 >> 0) - day >> 0)) % 7, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")); + if (0 <= dec31wday && dec31wday <= 2) { + year = year + (1) >> 0; + week = 1; + } + } + $s = -1; return [year, week]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.ISOWeek }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.day = day; $f.dec31wday = dec31wday; $f.jan1wday = jan1wday; $f.month = month; $f.t = t; $f.wday = wday; $f.week = week; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.ISOWeek = function() { return this.$val.ISOWeek(); }; + Time.ptr.prototype.Clock = function() { + var _r, _r$1, _tuple, hour, min, sec, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; hour = $f.hour; min = $f.min; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + hour = 0; + min = 0; + sec = 0; + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = absClock(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + hour = _tuple[0]; + min = _tuple[1]; + sec = _tuple[2]; + $s = -1; return [hour, min, sec]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Clock }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.hour = hour; $f.min = min; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Clock = function() { return this.$val.Clock(); }; + absClock = function(abs) { + var _q, _q$1, abs, hour, min, sec; + hour = 0; + min = 0; + sec = 0; + sec = (($div64(abs, new $Uint64(0, 86400), true).$low >> 0)); + hour = (_q = sec / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + sec = sec - (($imul(hour, 3600))) >> 0; + min = (_q$1 = sec / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + sec = sec - (($imul(min, 60))) >> 0; + return [hour, min, sec]; + }; + Time.ptr.prototype.Hour = function() { + var _q, _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (_q = (($div64(_r, new $Uint64(0, 86400), true).$low >> 0)) / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Hour }; } $f._q = _q; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Hour = function() { return this.$val.Hour(); }; + Time.ptr.prototype.Minute = function() { + var _q, _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (_q = (($div64(_r, new $Uint64(0, 3600), true).$low >> 0)) / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Minute }; } $f._q = _q; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Minute = function() { return this.$val.Minute(); }; + Time.ptr.prototype.Second = function() { + var _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return (($div64(_r, new $Uint64(0, 60), true).$low >> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Second }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Second = function() { return this.$val.Second(); }; + Time.ptr.prototype.Nanosecond = function() { + var t; + t = this; + return ((t.nsec() >> 0)); + }; + Time.prototype.Nanosecond = function() { return this.$val.Nanosecond(); }; + Time.ptr.prototype.YearDay = function() { + var _r, _tuple, t, yday, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; t = $f.t; yday = $f.yday; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + yday = _tuple[3]; + $s = -1; return yday + 1 >> 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.YearDay }; } $f._r = _r; $f._tuple = _tuple; $f.t = t; $f.yday = yday; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.YearDay = function() { return this.$val.YearDay(); }; + Duration.prototype.String = function() { + var _tuple, _tuple$1, buf, d, neg, prec, u, w; + d = this; + buf = arrayType$3.zero(); + w = 32; + u = (new $Uint64(d.$high, d.$low)); + neg = (d.$high < 0 || (d.$high === 0 && d.$low < 0)); + if (neg) { + u = new $Uint64(-u.$high, -u.$low); + } + if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000000))) { + prec = 0; + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 115); + w = w - (1) >> 0; + if ((u.$high === 0 && u.$low === 0)) { + return "0s"; + } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000))) { + prec = 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 110); + } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000))) { + prec = 3; + w = w - (1) >> 0; + $copyString($subslice(new sliceType$3(buf), w), "\xC2\xB5"); + } else { + prec = 6; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 109); + } + _tuple = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, prec); + w = _tuple[0]; + u = _tuple[1]; + w = fmtInt($subslice(new sliceType$3(buf), 0, w), u); + } else { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 115); + _tuple$1 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, 9); + w = _tuple$1[0]; + u = _tuple$1[1]; + w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true)); + u = $div64(u, (new $Uint64(0, 60)), false); + if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 109); + w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true)); + u = $div64(u, (new $Uint64(0, 60)), false); + if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 104); + w = fmtInt($subslice(new sliceType$3(buf), 0, w), u); + } + } + } + if (neg) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); + } + return ($bytesToString($subslice(new sliceType$3(buf), w))); + }; + $ptrType(Duration).prototype.String = function() { return this.$get().String(); }; + fmtFrac = function(buf, v, prec) { + var _tmp, _tmp$1, buf, digit, i, nv, nw, prec, print, v, w; + nw = 0; + nv = new $Uint64(0, 0); + w = buf.$length; + print = false; + i = 0; + while (true) { + if (!(i < prec)) { break; } + digit = $div64(v, new $Uint64(0, 10), true); + print = print || !((digit.$high === 0 && digit.$low === 0)); + if (print) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = (((digit.$low << 24 >>> 24)) + 48 << 24 >>> 24)); + } + v = $div64(v, (new $Uint64(0, 10)), false); + i = i + (1) >> 0; + } + if (print) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); + } + _tmp = w; + _tmp$1 = v; + nw = _tmp; + nv = _tmp$1; + return [nw, nv]; + }; + fmtInt = function(buf, v) { + var buf, v, w; + w = buf.$length; + if ((v.$high === 0 && v.$low === 0)) { + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 48); + } else { + while (true) { + if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } + w = w - (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = ((($div64(v, new $Uint64(0, 10), true).$low << 24 >>> 24)) + 48 << 24 >>> 24)); + v = $div64(v, (new $Uint64(0, 10)), false); + } + } + return w; + }; + Duration.prototype.Nanoseconds = function() { + var d; + d = this; + return (new $Int64(d.$high, d.$low)); + }; + $ptrType(Duration).prototype.Nanoseconds = function() { return this.$get().Nanoseconds(); }; + Duration.prototype.Seconds = function() { + var d, nsec, sec; + d = this; + sec = $div64(d, new Duration(0, 1000000000), false); + nsec = $div64(d, new Duration(0, 1000000000), true); + return ($flatten64(sec)) + ($flatten64(nsec)) / 1e+09; + }; + $ptrType(Duration).prototype.Seconds = function() { return this.$get().Seconds(); }; + Duration.prototype.Minutes = function() { + var d, min, nsec; + d = this; + min = $div64(d, new Duration(13, 4165425152), false); + nsec = $div64(d, new Duration(13, 4165425152), true); + return ($flatten64(min)) + ($flatten64(nsec)) / 6e+10; + }; + $ptrType(Duration).prototype.Minutes = function() { return this.$get().Minutes(); }; + Duration.prototype.Hours = function() { + var d, hour, nsec; + d = this; + hour = $div64(d, new Duration(838, 817405952), false); + nsec = $div64(d, new Duration(838, 817405952), true); + return ($flatten64(hour)) + ($flatten64(nsec)) / 3.6e+12; + }; + $ptrType(Duration).prototype.Hours = function() { return this.$get().Hours(); }; + Duration.prototype.Truncate = function(m) { + var d, m, x; + d = this; + if ((m.$high < 0 || (m.$high === 0 && m.$low <= 0))) { + return d; + } + return (x = $div64(d, m, true), new Duration(d.$high - x.$high, d.$low - x.$low)); + }; + $ptrType(Duration).prototype.Truncate = function(m) { return this.$get().Truncate(m); }; + lessThanHalf = function(x, y) { + var x, x$1, x$2, x$3, x$4, y; + return (x$1 = (x$2 = (new $Uint64(x.$high, x.$low)), x$3 = (new $Uint64(x.$high, x.$low)), new $Uint64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)), x$4 = (new $Uint64(y.$high, y.$low)), (x$1.$high < x$4.$high || (x$1.$high === x$4.$high && x$1.$low < x$4.$low))); + }; + Duration.prototype.Round = function(m) { + var d, d1, d1$1, m, r, x, x$1; + d = this; + if ((m.$high < 0 || (m.$high === 0 && m.$low <= 0))) { + return d; + } + r = $div64(d, m, true); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0))) { + r = new Duration(-r.$high, -r.$low); + if (lessThanHalf(r, m)) { + return new Duration(d.$high + r.$high, d.$low + r.$low); + } + d1 = (x = new Duration(d.$high - m.$high, d.$low - m.$low), new Duration(x.$high + r.$high, x.$low + r.$low)); + if ((d1.$high < d.$high || (d1.$high === d.$high && d1.$low < d.$low))) { + return d1; + } + return new Duration(-2147483648, 0); + } + if (lessThanHalf(r, m)) { + return new Duration(d.$high - r.$high, d.$low - r.$low); + } + d1$1 = (x$1 = new Duration(d.$high + m.$high, d.$low + m.$low), new Duration(x$1.$high - r.$high, x$1.$low - r.$low)); + if ((d1$1.$high > d.$high || (d1$1.$high === d.$high && d1$1.$low > d.$low))) { + return d1$1; + } + return new Duration(2147483647, 4294967295); + }; + $ptrType(Duration).prototype.Round = function(m) { return this.$get().Round(m); }; + Time.ptr.prototype.Add = function(d) { + var d, dsec, nsec, t, te, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + dsec = ((x = $div64(d, new Duration(0, 1000000000), false), new $Int64(x.$high, x.$low))); + nsec = t.nsec() + (((x$1 = $div64(d, new Duration(0, 1000000000), true), x$1.$low + ((x$1.$high >> 31) * 4294967296)) >> 0)) >> 0; + if (nsec >= 1000000000) { + dsec = (x$2 = new $Int64(0, 1), new $Int64(dsec.$high + x$2.$high, dsec.$low + x$2.$low)); + nsec = nsec - (1000000000) >> 0; + } else if (nsec < 0) { + dsec = (x$3 = new $Int64(0, 1), new $Int64(dsec.$high - x$3.$high, dsec.$low - x$3.$low)); + nsec = nsec + (1000000000) >> 0; + } + t.wall = (x$4 = (x$5 = t.wall, new $Uint64(x$5.$high & ~0, (x$5.$low & ~1073741823) >>> 0)), x$6 = (new $Uint64(0, nsec)), new $Uint64(x$4.$high | x$6.$high, (x$4.$low | x$6.$low) >>> 0)); + t.addSec(dsec); + if (!((x$7 = (x$8 = t.wall, new $Uint64(x$8.$high & 2147483648, (x$8.$low & 0) >>> 0)), (x$7.$high === 0 && x$7.$low === 0)))) { + te = (x$9 = t.ext, x$10 = (new $Int64(d.$high, d.$low)), new $Int64(x$9.$high + x$10.$high, x$9.$low + x$10.$low)); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0)) && (x$11 = (t.ext), (te.$high > x$11.$high || (te.$high === x$11.$high && te.$low > x$11.$low))) || (d.$high > 0 || (d.$high === 0 && d.$low > 0)) && (x$12 = (t.ext), (te.$high < x$12.$high || (te.$high === x$12.$high && te.$low < x$12.$low)))) { + t.stripMono(); + } else { + t.ext = te; + } + } + return t; + }; + Time.prototype.Add = function(d) { return this.$val.Add(d); }; + Time.ptr.prototype.Sub = function(u) { + var d, d$1, t, te, u, ue, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + t = this; + if (!((x = (x$1 = (x$2 = t.wall, x$3 = u.wall, new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)), new $Uint64(x$1.$high & 2147483648, (x$1.$low & 0) >>> 0)), (x.$high === 0 && x.$low === 0)))) { + te = (t.ext); + ue = (u.ext); + d = ((x$4 = new $Int64(te.$high - ue.$high, te.$low - ue.$low), new Duration(x$4.$high, x$4.$low))); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0)) && (te.$high > ue.$high || (te.$high === ue.$high && te.$low > ue.$low))) { + return new Duration(2147483647, 4294967295); + } + if ((d.$high > 0 || (d.$high === 0 && d.$low > 0)) && (te.$high < ue.$high || (te.$high === ue.$high && te.$low < ue.$low))) { + return new Duration(-2147483648, 0); + } + return d; + } + d$1 = (x$5 = $mul64(((x$6 = (x$7 = t.sec(), x$8 = u.sec(), new $Int64(x$7.$high - x$8.$high, x$7.$low - x$8.$low)), new Duration(x$6.$high, x$6.$low))), new Duration(0, 1000000000)), x$9 = (new Duration(0, (t.nsec() - u.nsec() >> 0))), new Duration(x$5.$high + x$9.$high, x$5.$low + x$9.$low)); + if ($clone($clone(u, Time).Add(d$1), Time).Equal($clone(t, Time))) { + return d$1; + } else if ($clone(t, Time).Before($clone(u, Time))) { + return new Duration(-2147483648, 0); + } else { + return new Duration(2147483647, 4294967295); + } + }; + Time.prototype.Sub = function(u) { return this.$val.Sub(u); }; + Until = function(t) { + var t; + return $clone(t, Time).Sub($clone(Now(), Time)); + }; + $pkg.Until = Until; + Time.ptr.prototype.AddDate = function(years, months$1, days$1) { + var _r, _r$1, _r$2, _tuple, _tuple$1, day, days$1, hour, min, month, months$1, sec, t, year, years, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; day = $f.day; days$1 = $f.days$1; hour = $f.hour; min = $f.min; month = $f.month; months$1 = $f.months$1; sec = $f.sec; t = $f.t; year = $f.year; years = $f.years; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Date(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + _r$1 = $clone(t, Time).Clock(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + hour = _tuple$1[0]; + min = _tuple$1[1]; + sec = _tuple$1[2]; + _r$2 = Date(year + years >> 0, month + ((months$1 >> 0)) >> 0, day + days$1 >> 0, hour, min, sec, ((t.nsec() >> 0)), $clone(t, Time).Location()); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AddDate }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.day = day; $f.days$1 = days$1; $f.hour = hour; $f.min = min; $f.month = month; $f.months$1 = months$1; $f.sec = sec; $f.t = t; $f.year = year; $f.years = years; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.AddDate = function(years, months$1, days$1) { return this.$val.AddDate(years, months$1, days$1); }; + Time.ptr.prototype.date = function(full) { + var _r, _r$1, _tuple, day, full, month, t, yday, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; day = $f.day; full = $f.full; month = $f.month; t = $f.t; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + year = 0; + month = 0; + day = 0; + yday = 0; + t = this; + _r = $clone(t, Time).abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = absDate(_r, full); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + year = _tuple[0]; + month = _tuple[1]; + day = _tuple[2]; + yday = _tuple[3]; + $s = -1; return [year, month, day, yday]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.date }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.day = day; $f.full = full; $f.month = month; $f.t = t; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.date = function(full) { return this.$val.date(full); }; + absDate = function(abs, full) { + var _q, abs, begin, d, day, end, full, month, n, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, yday, year; + year = 0; + month = 0; + day = 0; + yday = 0; + d = $div64(abs, new $Uint64(0, 86400), false); + n = $div64(d, new $Uint64(0, 146097), false); + y = $mul64(new $Uint64(0, 400), n); + d = (x = $mul64(new $Uint64(0, 146097), n), new $Uint64(d.$high - x.$high, d.$low - x.$low)); + n = $div64(d, new $Uint64(0, 36524), false); + n = (x$1 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$1.$high, n.$low - x$1.$low)); + y = (x$2 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high + x$2.$high, y.$low + x$2.$low)); + d = (x$3 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high - x$3.$high, d.$low - x$3.$low)); + n = $div64(d, new $Uint64(0, 1461), false); + y = (x$4 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high + x$4.$high, y.$low + x$4.$low)); + d = (x$5 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high - x$5.$high, d.$low - x$5.$low)); + n = $div64(d, new $Uint64(0, 365), false); + n = (x$6 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$6.$high, n.$low - x$6.$low)); + y = (x$7 = n, new $Uint64(y.$high + x$7.$high, y.$low + x$7.$low)); + d = (x$8 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high - x$8.$high, d.$low - x$8.$low)); + year = (((x$9 = (x$10 = (new $Int64(y.$high, y.$low)), new $Int64(x$10.$high + -69, x$10.$low + 4075721025)), x$9.$low + ((x$9.$high >> 31) * 4294967296)) >> 0)); + yday = ((d.$low >> 0)); + if (!full) { + return [year, month, day, yday]; + } + day = yday; + if (isLeap(year)) { + if (day > 59) { + day = day - (1) >> 0; + } else if ((day === 59)) { + month = 2; + day = 29; + return [year, month, day, yday]; + } + } + month = (((_q = day / 31, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)); + end = (((x$11 = month + 1 >> 0, ((x$11 < 0 || x$11 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$11])) >> 0)); + begin = 0; + if (day >= end) { + month = month + (1) >> 0; + begin = end; + } else { + begin = ((((month < 0 || month >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[month]) >> 0)); + } + month = month + (1) >> 0; + day = (day - begin >> 0) + 1 >> 0; + return [year, month, day, yday]; + }; + daysIn = function(m, year) { + var m, x, year; + if ((m === 2) && isLeap(year)) { + return 29; + } + return (((((m < 0 || m >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[m]) - (x = m - 1 >> 0, ((x < 0 || x >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x])) >> 0) >> 0)); + }; + Now = function() { + var _tuple, mono, nsec, sec, x, x$1, x$2, x$3, x$4; + _tuple = now(); + sec = _tuple[0]; + nsec = _tuple[1]; + mono = _tuple[2]; + sec = (x = new $Int64(0, 2682288000), new $Int64(sec.$high + x.$high, sec.$low + x.$low)); + if (!((x$1 = $shiftRightUint64((new $Uint64(sec.$high, sec.$low)), 33), (x$1.$high === 0 && x$1.$low === 0)))) { + return new Time.ptr((new $Uint64(0, nsec)), new $Int64(sec.$high + 13, sec.$low + 3618733952), $pkg.Local); + } + return new Time.ptr((x$2 = (x$3 = $shiftLeft64((new $Uint64(sec.$high, sec.$low)), 30), new $Uint64(2147483648 | x$3.$high, (0 | x$3.$low) >>> 0)), x$4 = (new $Uint64(0, nsec)), new $Uint64(x$2.$high | x$4.$high, (x$2.$low | x$4.$low) >>> 0)), mono, $pkg.Local); + }; + $pkg.Now = Now; + unixTime = function(sec, nsec) { + var nsec, sec; + return new Time.ptr((new $Uint64(0, nsec)), new $Int64(sec.$high + 14, sec.$low + 2006054656), $pkg.Local); + }; + Time.ptr.prototype.UTC = function() { + var t; + t = this; + t.setLoc(utcLoc); + return t; + }; + Time.prototype.UTC = function() { return this.$val.UTC(); }; + Time.ptr.prototype.Local = function() { + var t; + t = this; + t.setLoc($pkg.Local); + return t; + }; + Time.prototype.Local = function() { return this.$val.Local(); }; + Time.ptr.prototype.In = function(loc) { + var loc, t; + t = this; + if (loc === ptrType$2.nil) { + $panic(new $String("time: missing Location in call to Time.In")); + } + t.setLoc(loc); + return t; + }; + Time.prototype.In = function(loc) { return this.$val.In(loc); }; + Time.ptr.prototype.Location = function() { + var l, t; + t = this; + l = t.loc; + if (l === ptrType$2.nil) { + l = $pkg.UTC; + } + return l; + }; + Time.prototype.Location = function() { return this.$val.Location(); }; + Time.ptr.prototype.Zone = function() { + var _r, _tuple, name, offset, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; name = $f.name; offset = $f.offset; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + t = this; + _r = t.loc.lookup(t.unixSec()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + name = _tuple[0]; + offset = _tuple[1]; + $s = -1; return [name, offset]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Zone }; } $f._r = _r; $f._tuple = _tuple; $f.name = name; $f.offset = offset; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Zone = function() { return this.$val.Zone(); }; + Time.ptr.prototype.Unix = function() { + var t; + t = this; + return t.unixSec(); + }; + Time.prototype.Unix = function() { return this.$val.Unix(); }; + Time.ptr.prototype.UnixNano = function() { + var t, x, x$1; + t = this; + return (x = $mul64((t.unixSec()), new $Int64(0, 1000000000)), x$1 = (new $Int64(0, t.nsec())), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)); + }; + Time.prototype.UnixNano = function() { return this.$val.UnixNano(); }; + Time.ptr.prototype.MarshalBinary = function() { + var _q, _r, _r$1, _tuple, enc, nsec, offset, offsetMin, sec, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; enc = $f.enc; nsec = $f.nsec; offset = $f.offset; offsetMin = $f.offsetMin; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + offsetMin = 0; + /* */ if ($clone(t, Time).Location() === $pkg.UTC) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($clone(t, Time).Location() === $pkg.UTC) { */ case 1: + offsetMin = -1; + $s = 3; continue; + /* } else { */ case 2: + _r = $clone(t, Time).Zone(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + offset = _tuple[1]; + if (!(((_r$1 = offset % 60, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0))) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalBinary: zone offset has fractional minute")]; + } + offset = (_q = offset / (60), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + if (offset < -32768 || (offset === -1) || offset > 32767) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalBinary: unexpected zone offset")]; + } + offsetMin = ((offset << 16 >> 16)); + /* } */ case 3: + sec = t.sec(); + nsec = t.nsec(); + enc = new sliceType$3([1, (($shiftRightInt64(sec, 56).$low << 24 >>> 24)), (($shiftRightInt64(sec, 48).$low << 24 >>> 24)), (($shiftRightInt64(sec, 40).$low << 24 >>> 24)), (($shiftRightInt64(sec, 32).$low << 24 >>> 24)), (($shiftRightInt64(sec, 24).$low << 24 >>> 24)), (($shiftRightInt64(sec, 16).$low << 24 >>> 24)), (($shiftRightInt64(sec, 8).$low << 24 >>> 24)), ((sec.$low << 24 >>> 24)), (((nsec >> 24 >> 0) << 24 >>> 24)), (((nsec >> 16 >> 0) << 24 >>> 24)), (((nsec >> 8 >> 0) << 24 >>> 24)), ((nsec << 24 >>> 24)), (((offsetMin >> 8 << 16 >> 16) << 24 >>> 24)), ((offsetMin << 24 >>> 24))]); + $s = -1; return [enc, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalBinary }; } $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.enc = enc; $f.nsec = nsec; $f.offset = offset; $f.offsetMin = offsetMin; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.MarshalBinary = function() { return this.$val.MarshalBinary(); }; + Time.ptr.prototype.UnmarshalBinary = function(data) { + var _r, _tuple, buf, data, localoff, nsec, offset, sec, t, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; buf = $f.buf; data = $f.data; localoff = $f.localoff; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; t = $f.t; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + buf = data; + if (buf.$length === 0) { + $s = -1; return errors.New("Time.UnmarshalBinary: no data"); + } + if (!(((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) === 1))) { + $s = -1; return errors.New("Time.UnmarshalBinary: unsupported version"); + } + if (!((buf.$length === 15))) { + $s = -1; return errors.New("Time.UnmarshalBinary: invalid length"); + } + buf = $subslice(buf, 1); + sec = (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = (new $Int64(0, (7 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 7]))), x$7 = $shiftLeft64((new $Int64(0, (6 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 6]))), 8), new $Int64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64((new $Int64(0, (5 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 5]))), 16), new $Int64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64((new $Int64(0, (4 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 4]))), 24), new $Int64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64((new $Int64(0, (3 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 3]))), 32), new $Int64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64((new $Int64(0, (2 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 2]))), 40), new $Int64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64((new $Int64(0, (1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]))), 48), new $Int64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64((new $Int64(0, (0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]))), 56), new $Int64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); + buf = $subslice(buf, 8); + nsec = (((((3 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 3]) >> 0)) | ((((2 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 2]) >> 0)) << 8 >> 0)) | ((((1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]) >> 0)) << 16 >> 0)) | ((((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) >> 0)) << 24 >> 0); + buf = $subslice(buf, 4); + offset = $imul(((((((1 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 1]) << 16 >> 16)) | ((((0 >= buf.$length ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + 0]) << 16 >> 16)) << 8 << 16 >> 16)) >> 0)), 60); + Time.copy(t, new Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$2.nil)); + t.wall = (new $Uint64(0, nsec)); + t.ext = sec; + /* */ if (offset === -60) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (offset === -60) { */ case 1: + t.setLoc(utcLoc); + $s = 3; continue; + /* } else { */ case 2: + _r = $pkg.Local.lookup(t.unixSec()); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + localoff = _tuple[1]; + if (offset === localoff) { + t.setLoc($pkg.Local); + } else { + t.setLoc(FixedZone("", offset)); + } + /* } */ case 3: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalBinary }; } $f._r = _r; $f._tuple = _tuple; $f.buf = buf; $f.data = data; $f.localoff = localoff; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalBinary = function(data) { return this.$val.UnmarshalBinary(data); }; + Time.ptr.prototype.GobEncode = function() { + var _r, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).MarshalBinary(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobEncode }; } $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.GobEncode = function() { return this.$val.GobEncode(); }; + Time.ptr.prototype.GobDecode = function(data) { + var _r, data, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; data = $f.data; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = t.UnmarshalBinary(data); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobDecode }; } $f._r = _r; $f.data = data; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.GobDecode = function(data) { return this.$val.GobDecode(data); }; + Time.ptr.prototype.MarshalJSON = function() { + var _r, _r$1, b, t, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + y = _r; + if (y < 0 || y >= 10000) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")]; + } + b = $makeSlice(sliceType$3, 0, 37); + b = $append(b, 34); + _r$1 = $clone(t, Time).AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + b = _r$1; + b = $append(b, 34); + $s = -1; return [b, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalJSON }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); }; + Time.ptr.prototype.UnmarshalJSON = function(data) { + var _r, _tuple, data, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (($bytesToString(data)) === "null") { + $s = -1; return $ifaceNil; + } + err = $ifaceNil; + _r = Parse("\"2006-01-02T15:04:05Z07:00\"", ($bytesToString(data))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + Time.copy(t, _tuple[0]); + err = _tuple[1]; + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalJSON }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalJSON = function(data) { return this.$val.UnmarshalJSON(data); }; + Time.ptr.prototype.MarshalText = function() { + var _r, _r$1, b, t, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = $clone(t, Time).Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + y = _r; + if (y < 0 || y >= 10000) { + $s = -1; return [sliceType$3.nil, errors.New("Time.MarshalText: year outside of range [0,9999]")]; + } + b = $makeSlice(sliceType$3, 0, 35); + _r$1 = $clone(t, Time).AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return [_r$1, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalText }; } $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.MarshalText = function() { return this.$val.MarshalText(); }; + Time.ptr.prototype.UnmarshalText = function(data) { + var _r, _tuple, data, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; data = $f.data; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + err = $ifaceNil; + _r = Parse("2006-01-02T15:04:05Z07:00", ($bytesToString(data))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + Time.copy(t, _tuple[0]); + err = _tuple[1]; + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalText }; } $f._r = _r; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalText = function(data) { return this.$val.UnmarshalText(data); }; + Unix = function(sec, nsec) { + var n, nsec, sec, x, x$1, x$2, x$3; + if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0)) || (nsec.$high > 0 || (nsec.$high === 0 && nsec.$low >= 1000000000))) { + n = $div64(nsec, new $Int64(0, 1000000000), false); + sec = (x = n, new $Int64(sec.$high + x.$high, sec.$low + x.$low)); + nsec = (x$1 = $mul64(n, new $Int64(0, 1000000000)), new $Int64(nsec.$high - x$1.$high, nsec.$low - x$1.$low)); + if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0))) { + nsec = (x$2 = new $Int64(0, 1000000000), new $Int64(nsec.$high + x$2.$high, nsec.$low + x$2.$low)); + sec = (x$3 = new $Int64(0, 1), new $Int64(sec.$high - x$3.$high, sec.$low - x$3.$low)); + } + } + return unixTime(sec, (((nsec.$low + ((nsec.$high >> 31) * 4294967296)) >> 0))); + }; + $pkg.Unix = Unix; + isLeap = function(year) { + var _r, _r$1, _r$2, year; + return ((_r = year % 4, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0) && (!(((_r$1 = year % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0)) || ((_r$2 = year % 400, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0)); + }; + norm = function(hi, lo, base) { + var _q, _q$1, _tmp, _tmp$1, base, hi, lo, n, n$1, nhi, nlo; + nhi = 0; + nlo = 0; + if (lo < 0) { + n = (_q = ((-lo - 1 >> 0)) / base, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0; + hi = hi - (n) >> 0; + lo = lo + (($imul(n, base))) >> 0; + } + if (lo >= base) { + n$1 = (_q$1 = lo / base, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + hi = hi + (n$1) >> 0; + lo = lo - (($imul(n$1, base))) >> 0; + } + _tmp = hi; + _tmp$1 = lo; + nhi = _tmp; + nlo = _tmp$1; + return [nhi, nlo]; + }; + Date = function(year, month, day, hour, min, sec, nsec, loc) { + var _r, _r$1, _r$2, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, abs, d, day, end, hour, loc, m, min, month, n, nsec, offset, sec, start, t, unix, utc, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; abs = $f.abs; d = $f.d; day = $f.day; end = $f.end; hour = $f.hour; loc = $f.loc; m = $f.m; min = $f.min; month = $f.month; n = $f.n; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; start = $f.start; t = $f.t; unix = $f.unix; utc = $f.utc; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (loc === ptrType$2.nil) { + $panic(new $String("time: missing Location in call to Date")); + } + m = ((month >> 0)) - 1 >> 0; + _tuple = norm(year, m, 12); + year = _tuple[0]; + m = _tuple[1]; + month = ((m >> 0)) + 1 >> 0; + _tuple$1 = norm(sec, nsec, 1000000000); + sec = _tuple$1[0]; + nsec = _tuple$1[1]; + _tuple$2 = norm(min, sec, 60); + min = _tuple$2[0]; + sec = _tuple$2[1]; + _tuple$3 = norm(hour, min, 60); + hour = _tuple$3[0]; + min = _tuple$3[1]; + _tuple$4 = norm(day, hour, 24); + day = _tuple$4[0]; + hour = _tuple$4[1]; + y = ((x = (x$1 = (new $Int64(0, year)), new $Int64(x$1.$high - -69, x$1.$low - 4075721025)), new $Uint64(x.$high, x.$low))); + n = $div64(y, new $Uint64(0, 400), false); + y = (x$2 = $mul64(new $Uint64(0, 400), n), new $Uint64(y.$high - x$2.$high, y.$low - x$2.$low)); + d = $mul64(new $Uint64(0, 146097), n); + n = $div64(y, new $Uint64(0, 100), false); + y = (x$3 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high - x$3.$high, y.$low - x$3.$low)); + d = (x$4 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high + x$4.$high, d.$low + x$4.$low)); + n = $div64(y, new $Uint64(0, 4), false); + y = (x$5 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high - x$5.$high, y.$low - x$5.$low)); + d = (x$6 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high + x$6.$high, d.$low + x$6.$low)); + n = y; + d = (x$7 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high + x$7.$high, d.$low + x$7.$low)); + d = (x$8 = (new $Uint64(0, (x$9 = month - 1 >> 0, ((x$9 < 0 || x$9 >= daysBefore.length) ? ($throwRuntimeError("index out of range"), undefined) : daysBefore[x$9])))), new $Uint64(d.$high + x$8.$high, d.$low + x$8.$low)); + if (isLeap(year) && month >= 3) { + d = (x$10 = new $Uint64(0, 1), new $Uint64(d.$high + x$10.$high, d.$low + x$10.$low)); + } + d = (x$11 = (new $Uint64(0, (day - 1 >> 0))), new $Uint64(d.$high + x$11.$high, d.$low + x$11.$low)); + abs = $mul64(d, new $Uint64(0, 86400)); + abs = (x$12 = (new $Uint64(0, ((($imul(hour, 3600)) + ($imul(min, 60)) >> 0) + sec >> 0))), new $Uint64(abs.$high + x$12.$high, abs.$low + x$12.$low)); + unix = (x$13 = (new $Int64(abs.$high, abs.$low)), new $Int64(x$13.$high + -2147483647, x$13.$low + 3844486912)); + _r = loc.lookup(unix); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$5 = _r; + offset = _tuple$5[1]; + start = _tuple$5[3]; + end = _tuple$5[4]; + /* */ if (!((offset === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((offset === 0))) { */ case 2: + utc = (x$14 = (new $Int64(0, offset)), new $Int64(unix.$high - x$14.$high, unix.$low - x$14.$low)); + /* */ if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { $s = 5; continue; } + /* */ if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { */ case 5: + _r$1 = loc.lookup(new $Int64(start.$high - 0, start.$low - 1)); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$6 = _r$1; + offset = _tuple$6[1]; + $s = 7; continue; + /* } else if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { */ case 6: + _r$2 = loc.lookup(end); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$7 = _r$2; + offset = _tuple$7[1]; + /* } */ case 7: + case 4: + unix = (x$15 = (new $Int64(0, offset)), new $Int64(unix.$high - x$15.$high, unix.$low - x$15.$low)); + /* } */ case 3: + t = $clone(unixTime(unix, ((nsec >> 0))), Time); + t.setLoc(loc); + $s = -1; return t; + /* */ } return; } if ($f === undefined) { $f = { $blk: Date }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.abs = abs; $f.d = d; $f.day = day; $f.end = end; $f.hour = hour; $f.loc = loc; $f.m = m; $f.min = min; $f.month = month; $f.n = n; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.start = start; $f.t = t; $f.unix = unix; $f.utc = utc; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Date = Date; + Time.ptr.prototype.Truncate = function(d) { + var _tuple, d, r, t; + t = this; + t.stripMono(); + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return t; + } + _tuple = div($clone(t, Time), d); + r = _tuple[1]; + return $clone(t, Time).Add(new Duration(-r.$high, -r.$low)); + }; + Time.prototype.Truncate = function(d) { return this.$val.Truncate(d); }; + Time.ptr.prototype.Round = function(d) { + var _tuple, d, r, t; + t = this; + t.stripMono(); + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return t; + } + _tuple = div($clone(t, Time), d); + r = _tuple[1]; + if (lessThanHalf(r, d)) { + return $clone(t, Time).Add(new Duration(-r.$high, -r.$low)); + } + return $clone(t, Time).Add(new Duration(d.$high - r.$high, d.$low - r.$low)); + }; + Time.prototype.Round = function(d) { return this.$val.Round(d); }; + div = function(t, d) { + var _q, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, d, d0, d1, d1$1, neg, nsec, qmod2, r, sec, sec$1, t, tmp, u0, u0x, u1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + qmod2 = 0; + r = new Duration(0, 0); + neg = false; + nsec = t.nsec(); + sec = t.sec(); + if ((sec.$high < 0 || (sec.$high === 0 && sec.$low < 0))) { + neg = true; + sec = new $Int64(-sec.$high, -sec.$low); + nsec = -nsec; + if (nsec < 0) { + nsec = nsec + (1000000000) >> 0; + sec = (x = new $Int64(0, 1), new $Int64(sec.$high - x.$high, sec.$low - x.$low)); + } + } + if ((d.$high < 0 || (d.$high === 0 && d.$low < 1000000000)) && (x$1 = $div64(new Duration(0, 1000000000), (new Duration(d.$high + d.$high, d.$low + d.$low)), true), (x$1.$high === 0 && x$1.$low === 0))) { + qmod2 = (((_q = nsec / (((d.$low + ((d.$high >> 31) * 4294967296)) >> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0)) & 1; + r = (new Duration(0, (_r = nsec % (((d.$low + ((d.$high >> 31) * 4294967296)) >> 0)), _r === _r ? _r : $throwRuntimeError("integer divide by zero")))); + } else if ((x$2 = $div64(d, new Duration(0, 1000000000), true), (x$2.$high === 0 && x$2.$low === 0))) { + d1 = ((x$3 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$3.$high, x$3.$low))); + qmod2 = (((x$4 = $div64(sec, d1, false), x$4.$low + ((x$4.$high >> 31) * 4294967296)) >> 0)) & 1; + r = (x$5 = $mul64(((x$6 = $div64(sec, d1, true), new Duration(x$6.$high, x$6.$low))), new Duration(0, 1000000000)), x$7 = (new Duration(0, nsec)), new Duration(x$5.$high + x$7.$high, x$5.$low + x$7.$low)); + } else { + sec$1 = (new $Uint64(sec.$high, sec.$low)); + tmp = $mul64(($shiftRightUint64(sec$1, 32)), new $Uint64(0, 1000000000)); + u1 = $shiftRightUint64(tmp, 32); + u0 = $shiftLeft64(tmp, 32); + tmp = $mul64((new $Uint64(sec$1.$high & 0, (sec$1.$low & 4294967295) >>> 0)), new $Uint64(0, 1000000000)); + _tmp = u0; + _tmp$1 = new $Uint64(u0.$high + tmp.$high, u0.$low + tmp.$low); + u0x = _tmp; + u0 = _tmp$1; + if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { + u1 = (x$8 = new $Uint64(0, 1), new $Uint64(u1.$high + x$8.$high, u1.$low + x$8.$low)); + } + _tmp$2 = u0; + _tmp$3 = (x$9 = (new $Uint64(0, nsec)), new $Uint64(u0.$high + x$9.$high, u0.$low + x$9.$low)); + u0x = _tmp$2; + u0 = _tmp$3; + if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { + u1 = (x$10 = new $Uint64(0, 1), new $Uint64(u1.$high + x$10.$high, u1.$low + x$10.$low)); + } + d1$1 = (new $Uint64(d.$high, d.$low)); + while (true) { + if (!(!((x$11 = $shiftRightUint64(d1$1, 63), (x$11.$high === 0 && x$11.$low === 1))))) { break; } + d1$1 = $shiftLeft64(d1$1, (1)); + } + d0 = new $Uint64(0, 0); + while (true) { + qmod2 = 0; + if ((u1.$high > d1$1.$high || (u1.$high === d1$1.$high && u1.$low > d1$1.$low)) || (u1.$high === d1$1.$high && u1.$low === d1$1.$low) && (u0.$high > d0.$high || (u0.$high === d0.$high && u0.$low >= d0.$low))) { + qmod2 = 1; + _tmp$4 = u0; + _tmp$5 = new $Uint64(u0.$high - d0.$high, u0.$low - d0.$low); + u0x = _tmp$4; + u0 = _tmp$5; + if ((u0.$high > u0x.$high || (u0.$high === u0x.$high && u0.$low > u0x.$low))) { + u1 = (x$12 = new $Uint64(0, 1), new $Uint64(u1.$high - x$12.$high, u1.$low - x$12.$low)); + } + u1 = (x$13 = d1$1, new $Uint64(u1.$high - x$13.$high, u1.$low - x$13.$low)); + } + if ((d1$1.$high === 0 && d1$1.$low === 0) && (x$14 = (new $Uint64(d.$high, d.$low)), (d0.$high === x$14.$high && d0.$low === x$14.$low))) { + break; + } + d0 = $shiftRightUint64(d0, (1)); + d0 = (x$15 = $shiftLeft64((new $Uint64(d1$1.$high & 0, (d1$1.$low & 1) >>> 0)), 63), new $Uint64(d0.$high | x$15.$high, (d0.$low | x$15.$low) >>> 0)); + d1$1 = $shiftRightUint64(d1$1, (1)); + } + r = (new Duration(u0.$high, u0.$low)); + } + if (neg && !((r.$high === 0 && r.$low === 0))) { + qmod2 = (qmod2 ^ (1)) >> 0; + r = new Duration(d.$high - r.$high, d.$low - r.$low); + } + return [qmod2, r]; + }; + Location.ptr.prototype.get = function() { + var l, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + if (l === ptrType$2.nil) { + $s = -1; return utcLoc; + } + /* */ if (l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === localLoc) { */ case 1: + $r = localOnce.Do(initLocal); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return l; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.get }; } $f.l = l; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.get = function() { return this.$val.get(); }; + Location.ptr.prototype.String = function() { + var _r, l, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r.name; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.String }; } $f._r = _r; $f.l = l; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.String = function() { return this.$val.String(); }; + FixedZone = function(name, offset) { + var l, name, offset, x; + l = new Location.ptr(name, new sliceType([new zone.ptr(name, offset, false)]), new sliceType$1([new zoneTrans.ptr(new $Int64(-2147483648, 0), 0, false, false)]), new $Int64(-2147483648, 0), new $Int64(2147483647, 4294967295), ptrType.nil); + l.cacheZone = (x = l.zone, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + return l; + }; + $pkg.FixedZone = FixedZone; + Location.ptr.prototype.lookup = function(sec) { + var _q, _r, end, hi, isDST, l, lim, lo, m, name, offset, sec, start, tx, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, zone$1, zone$2, zone$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _q = $f._q; _r = $f._r; end = $f.end; hi = $f.hi; isDST = $f.isDST; l = $f.l; lim = $f.lim; lo = $f.lo; m = $f.m; name = $f.name; offset = $f.offset; sec = $f.sec; start = $f.start; tx = $f.tx; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; zone$1 = $f.zone$1; zone$2 = $f.zone$2; zone$3 = $f.zone$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + isDST = false; + start = new $Int64(0, 0); + end = new $Int64(0, 0); + l = this; + _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + if (l.zone.$length === 0) { + name = "UTC"; + offset = 0; + isDST = false; + start = new $Int64(-2147483648, 0); + end = new $Int64(2147483647, 4294967295); + $s = -1; return [name, offset, isDST, start, end]; + } + zone$1 = l.cacheZone; + if (!(zone$1 === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) { + name = zone$1.name; + offset = zone$1.offset; + isDST = zone$1.isDST; + start = l.cacheStart; + end = l.cacheEnd; + $s = -1; return [name, offset, isDST, start, end]; + } + if ((l.tx.$length === 0) || (x$2 = (x$3 = l.tx, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])).when, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { + zone$2 = (x$4 = l.zone, x$5 = l.lookupFirstZone(), ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])); + name = zone$2.name; + offset = zone$2.offset; + isDST = zone$2.isDST; + start = new $Int64(-2147483648, 0); + if (l.tx.$length > 0) { + end = (x$6 = l.tx, (0 >= x$6.$length ? ($throwRuntimeError("index out of range"), undefined) : x$6.$array[x$6.$offset + 0])).when; + } else { + end = new $Int64(2147483647, 4294967295); + } + $s = -1; return [name, offset, isDST, start, end]; + } + tx = l.tx; + end = new $Int64(2147483647, 4294967295); + lo = 0; + hi = tx.$length; + while (true) { + if (!((hi - lo >> 0) > 1)) { break; } + m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + lim = ((m < 0 || m >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + m]).when; + if ((sec.$high < lim.$high || (sec.$high === lim.$high && sec.$low < lim.$low))) { + end = lim; + hi = m; + } else { + lo = m; + } + } + zone$3 = (x$7 = l.zone, x$8 = ((lo < 0 || lo >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + lo]).index, ((x$8 < 0 || x$8 >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + x$8])); + name = zone$3.name; + offset = zone$3.offset; + isDST = zone$3.isDST; + start = ((lo < 0 || lo >= tx.$length) ? ($throwRuntimeError("index out of range"), undefined) : tx.$array[tx.$offset + lo]).when; + $s = -1; return [name, offset, isDST, start, end]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookup }; } $f._q = _q; $f._r = _r; $f.end = end; $f.hi = hi; $f.isDST = isDST; $f.l = l; $f.lim = lim; $f.lo = lo; $f.m = m; $f.name = name; $f.offset = offset; $f.sec = sec; $f.start = start; $f.tx = tx; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.zone$3 = zone$3; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.lookup = function(sec) { return this.$val.lookup(sec); }; + Location.ptr.prototype.lookupFirstZone = function() { + var _i, _ref, l, x, x$1, x$2, x$3, x$4, x$5, zi, zi$1; + l = this; + if (!l.firstZoneUsed()) { + return 0; + } + if (l.tx.$length > 0 && (x = l.zone, x$1 = (x$2 = l.tx, (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0])).index, ((x$1 < 0 || x$1 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + x$1])).isDST) { + zi = (((x$3 = l.tx, (0 >= x$3.$length ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + 0])).index >> 0)) - 1 >> 0; + while (true) { + if (!(zi >= 0)) { break; } + if (!(x$4 = l.zone, ((zi < 0 || zi >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + zi])).isDST) { + return zi; + } + zi = zi - (1) >> 0; + } + } + _ref = l.zone; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + zi$1 = _i; + if (!(x$5 = l.zone, ((zi$1 < 0 || zi$1 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + zi$1])).isDST) { + return zi$1; + } + _i++; + } + return 0; + }; + Location.prototype.lookupFirstZone = function() { return this.$val.lookupFirstZone(); }; + Location.ptr.prototype.firstZoneUsed = function() { + var _i, _ref, l, tx; + l = this; + _ref = l.tx; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + tx = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), zoneTrans); + if (tx.index === 0) { + return true; + } + _i++; + } + return false; + }; + Location.prototype.firstZoneUsed = function() { return this.$val.firstZoneUsed(); }; + Location.ptr.prototype.lookupName = function(name, unix) { + var _i, _i$1, _r, _r$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, i, i$1, l, nam, name, offset, offset$1, ok, unix, x, x$1, x$2, zone$1, zone$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; i = $f.i; i$1 = $f.i$1; l = $f.l; nam = $f.nam; name = $f.name; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; unix = $f.unix; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + offset = 0; + ok = false; + l = this; + _r = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + l = _r; + _ref = l.zone; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + i = _i; + zone$1 = (x = l.zone, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + /* */ if (zone$1.name === name) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (zone$1.name === name) { */ case 4: + _r$1 = l.lookup((x$1 = (new $Int64(0, zone$1.offset)), new $Int64(unix.$high - x$1.$high, unix.$low - x$1.$low))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + nam = _tuple[0]; + offset$1 = _tuple[1]; + if (nam === zone$1.name) { + _tmp = offset$1; + _tmp$1 = true; + offset = _tmp; + ok = _tmp$1; + $s = -1; return [offset, ok]; + } + /* } */ case 5: + _i++; + /* } */ $s = 2; continue; case 3: + _ref$1 = l.zone; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + zone$2 = (x$2 = l.zone, ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1])); + if (zone$2.name === name) { + _tmp$2 = zone$2.offset; + _tmp$3 = true; + offset = _tmp$2; + ok = _tmp$3; + $s = -1; return [offset, ok]; + } + _i$1++; + } + $s = -1; return [offset, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookupName }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.i = i; $f.i$1 = i$1; $f.l = l; $f.nam = nam; $f.name = name; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.unix = unix; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.lookupName = function(name, unix) { return this.$val.lookupName(name, unix); }; + ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$5.methods = [{prop: "Stop", name: "Stop", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([Duration], [$Bool], false)}]; + Time.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "AppendFormat", name: "AppendFormat", pkg: "", typ: $funcType([sliceType$3, $String], [sliceType$3], false)}, {prop: "After", name: "After", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Before", name: "Before", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Equal", name: "Equal", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "IsZero", name: "IsZero", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "abs", name: "abs", pkg: "time", typ: $funcType([], [$Uint64], false)}, {prop: "locabs", name: "locabs", pkg: "time", typ: $funcType([], [$String, $Int, $Uint64], false)}, {prop: "Date", name: "Date", pkg: "", typ: $funcType([], [$Int, Month, $Int], false)}, {prop: "Year", name: "Year", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Month", name: "Month", pkg: "", typ: $funcType([], [Month], false)}, {prop: "Day", name: "Day", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Weekday", name: "Weekday", pkg: "", typ: $funcType([], [Weekday], false)}, {prop: "ISOWeek", name: "ISOWeek", pkg: "", typ: $funcType([], [$Int, $Int], false)}, {prop: "Clock", name: "Clock", pkg: "", typ: $funcType([], [$Int, $Int, $Int], false)}, {prop: "Hour", name: "Hour", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Minute", name: "Minute", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Second", name: "Second", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Nanosecond", name: "Nanosecond", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "YearDay", name: "YearDay", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([Time], [Duration], false)}, {prop: "AddDate", name: "AddDate", pkg: "", typ: $funcType([$Int, $Int, $Int], [Time], false)}, {prop: "date", name: "date", pkg: "time", typ: $funcType([$Bool], [$Int, Month, $Int, $Int], false)}, {prop: "UTC", name: "UTC", pkg: "", typ: $funcType([], [Time], false)}, {prop: "Local", name: "Local", pkg: "", typ: $funcType([], [Time], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([ptrType$2], [Time], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$2], false)}, {prop: "Zone", name: "Zone", pkg: "", typ: $funcType([], [$String, $Int], false)}, {prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "UnixNano", name: "UnixNano", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Time], false)}]; + ptrType$7.methods = [{prop: "nsec", name: "nsec", pkg: "time", typ: $funcType([], [$Int32], false)}, {prop: "sec", name: "sec", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "unixSec", name: "unixSec", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "addSec", name: "addSec", pkg: "time", typ: $funcType([$Int64], [], false)}, {prop: "setLoc", name: "setLoc", pkg: "time", typ: $funcType([ptrType$2], [], false)}, {prop: "stripMono", name: "stripMono", pkg: "time", typ: $funcType([], [], false)}, {prop: "setMono", name: "setMono", pkg: "time", typ: $funcType([$Int64], [], false)}, {prop: "mono", name: "mono", pkg: "time", typ: $funcType([], [$Int64], false)}, {prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$3], [$error], false)}]; + Month.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + Weekday.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + Duration.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Nanoseconds", name: "Nanoseconds", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seconds", name: "Seconds", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Minutes", name: "Minutes", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Hours", name: "Hours", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Duration], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Duration], false)}]; + ptrType$2.methods = [{prop: "get", name: "get", pkg: "time", typ: $funcType([], [ptrType$2], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "lookup", name: "lookup", pkg: "time", typ: $funcType([$Int64], [$String, $Int, $Bool, $Int64, $Int64], false)}, {prop: "lookupFirstZone", name: "lookupFirstZone", pkg: "time", typ: $funcType([], [$Int], false)}, {prop: "firstZoneUsed", name: "firstZoneUsed", pkg: "time", typ: $funcType([], [$Bool], false)}, {prop: "lookupName", name: "lookupName", pkg: "time", typ: $funcType([$String, $Int64], [$Int, $Bool], false)}]; + runtimeTimer.init("time", [{prop: "i", name: "i", anonymous: false, exported: false, typ: $Int32, tag: ""}, {prop: "when", name: "when", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "period", name: "period", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "f", name: "f", anonymous: false, exported: false, typ: funcType$1, tag: ""}, {prop: "arg", name: "arg", anonymous: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "timeout", name: "timeout", anonymous: false, exported: false, typ: ptrType$3, tag: ""}, {prop: "active", name: "active", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + ParseError.init("", [{prop: "Layout", name: "Layout", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Value", name: "Value", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "LayoutElem", name: "LayoutElem", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "ValueElem", name: "ValueElem", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Message", name: "Message", anonymous: false, exported: true, typ: $String, tag: ""}]); + Timer.init("time", [{prop: "C", name: "C", anonymous: false, exported: true, typ: chanType$1, tag: ""}, {prop: "r", name: "r", anonymous: false, exported: false, typ: runtimeTimer, tag: ""}]); + Time.init("time", [{prop: "wall", name: "wall", anonymous: false, exported: false, typ: $Uint64, tag: ""}, {prop: "ext", name: "ext", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "loc", name: "loc", anonymous: false, exported: false, typ: ptrType$2, tag: ""}]); + Location.init("time", [{prop: "name", name: "name", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "zone", name: "zone", anonymous: false, exported: false, typ: sliceType, tag: ""}, {prop: "tx", name: "tx", anonymous: false, exported: false, typ: sliceType$1, tag: ""}, {prop: "cacheStart", name: "cacheStart", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "cacheEnd", name: "cacheEnd", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "cacheZone", name: "cacheZone", anonymous: false, exported: false, typ: ptrType, tag: ""}]); + zone.init("time", [{prop: "name", name: "name", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "offset", name: "offset", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "isDST", name: "isDST", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + zoneTrans.init("time", [{prop: "when", name: "when", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "index", name: "index", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "isstd", name: "isstd", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "isutc", name: "isutc", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = nosync.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + localLoc = new Location.ptr("", sliceType.nil, sliceType$1.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil); + localOnce = new nosync.Once.ptr(false, false); + zoneSources = new sliceType$2([runtime.GOROOT() + "/lib/time/zoneinfo.zip"]); + std0x = $toNativeArray($kindInt, [260, 265, 524, 526, 528, 274]); + longDayNames = new sliceType$2(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]); + shortDayNames = new sliceType$2(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]); + shortMonthNames = new sliceType$2(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]); + longMonthNames = new sliceType$2(["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]); + atoiError = errors.New("time: invalid number"); + errBad = errors.New("bad value for field"); + errLeadingInt = errors.New("time: bad [0-9]*"); + months = $toNativeArray($kindString, ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]); + days = $toNativeArray($kindString, ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]); + daysBefore = $toNativeArray($kindInt32, [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]); + utcLoc = new Location.ptr("UTC", sliceType.nil, sliceType$1.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil); + $pkg.UTC = utcLoc; + $pkg.Local = localLoc; + errLocation = errors.New("time: invalid location name"); + badData = errors.New("malformed time zone information"); + $unused(new sliceType$2(["/usr/share/zoneinfo/", "/usr/share/lib/zoneinfo/", "/usr/lib/locale/TZ/", runtime.GOROOT() + "/lib/time/zoneinfo.zip"])); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/poll"] = (function() { + var $pkg = {}, $init, errors, io, runtime, atomic, syscall, time, pollDesc, TimeoutError, fdMutex, FD, ptrType, chanType, sliceType, ptrType$1, arrayType, sliceType$1, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, sliceType$2, ptrType$9, funcType, funcType$1, ptrType$10, ptrType$11, ptrType$12, ptrType$13, sliceType$3, ptrType$14, semWaiters, runtime_Semacquire, runtime_Semrelease, errClosing, consume, accept; + errors = $packages["errors"]; + io = $packages["io"]; + runtime = $packages["runtime"]; + atomic = $packages["sync/atomic"]; + syscall = $packages["syscall"]; + time = $packages["time"]; + pollDesc = $pkg.pollDesc = $newType(0, $kindStruct, "poll.pollDesc", true, "internal/poll", false, function(closing_) { + this.$val = this; + if (arguments.length === 0) { + this.closing = false; + return; + } + this.closing = closing_; + }); + TimeoutError = $pkg.TimeoutError = $newType(0, $kindStruct, "poll.TimeoutError", true, "internal/poll", true, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + fdMutex = $pkg.fdMutex = $newType(0, $kindStruct, "poll.fdMutex", true, "internal/poll", false, function(state_, rsema_, wsema_) { + this.$val = this; + if (arguments.length === 0) { + this.state = new $Uint64(0, 0); + this.rsema = 0; + this.wsema = 0; + return; + } + this.state = state_; + this.rsema = rsema_; + this.wsema = wsema_; + }); + FD = $pkg.FD = $newType(0, $kindStruct, "poll.FD", true, "internal/poll", true, function(fdmu_, Sysfd_, pd_, iovecs_, csema_, IsStream_, ZeroReadIsEOF_, isFile_, isBlocking_) { + this.$val = this; + if (arguments.length === 0) { + this.fdmu = new fdMutex.ptr(new $Uint64(0, 0), 0, 0); + this.Sysfd = 0; + this.pd = new pollDesc.ptr(false); + this.iovecs = ptrType$3.nil; + this.csema = 0; + this.IsStream = false; + this.ZeroReadIsEOF = false; + this.isFile = false; + this.isBlocking = false; + return; + } + this.fdmu = fdmu_; + this.Sysfd = Sysfd_; + this.pd = pd_; + this.iovecs = iovecs_; + this.csema = csema_; + this.IsStream = IsStream_; + this.ZeroReadIsEOF = ZeroReadIsEOF_; + this.isFile = isFile_; + this.isBlocking = isBlocking_; + }); + ptrType = $ptrType($Uint32); + chanType = $chanType($Bool, false, false); + sliceType = $sliceType(chanType); + ptrType$1 = $ptrType($Uint64); + arrayType = $arrayType($Uint8, 4); + sliceType$1 = $sliceType(syscall.Iovec); + ptrType$3 = $ptrType(sliceType$1); + ptrType$4 = $ptrType($Uint8); + ptrType$5 = $ptrType(FD); + ptrType$6 = $ptrType(pollDesc); + ptrType$7 = $ptrType(TimeoutError); + ptrType$8 = $ptrType(fdMutex); + sliceType$2 = $sliceType($Uint8); + ptrType$9 = $ptrType(syscall.Stat_t); + funcType = $funcType([$Uintptr], [], false); + funcType$1 = $funcType([$Uintptr], [$Bool], false); + ptrType$10 = $ptrType(syscall.Linger); + ptrType$11 = $ptrType(syscall.IPMreqn); + ptrType$12 = $ptrType(syscall.IPMreq); + ptrType$13 = $ptrType(syscall.IPv6Mreq); + sliceType$3 = $sliceType(sliceType$2); + ptrType$14 = $ptrType(sliceType$3); + pollDesc.ptr.prototype.init = function(fd) { + var fd, pd; + pd = this; + return $ifaceNil; + }; + pollDesc.prototype.init = function(fd) { return this.$val.init(fd); }; + pollDesc.ptr.prototype.close = function() { + var pd; + pd = this; + }; + pollDesc.prototype.close = function() { return this.$val.close(); }; + pollDesc.ptr.prototype.evict = function() { + var pd; + pd = this; + pd.closing = true; + }; + pollDesc.prototype.evict = function() { return this.$val.evict(); }; + pollDesc.ptr.prototype.prepare = function(mode, isFile) { + var isFile, mode, pd; + pd = this; + if (pd.closing) { + return errClosing(isFile); + } + return $ifaceNil; + }; + pollDesc.prototype.prepare = function(mode, isFile) { return this.$val.prepare(mode, isFile); }; + pollDesc.ptr.prototype.prepareRead = function(isFile) { + var isFile, pd; + pd = this; + return pd.prepare(114, isFile); + }; + pollDesc.prototype.prepareRead = function(isFile) { return this.$val.prepareRead(isFile); }; + pollDesc.ptr.prototype.prepareWrite = function(isFile) { + var isFile, pd; + pd = this; + return pd.prepare(119, isFile); + }; + pollDesc.prototype.prepareWrite = function(isFile) { return this.$val.prepareWrite(isFile); }; + pollDesc.ptr.prototype.wait = function(mode, isFile) { + var isFile, mode, pd; + pd = this; + if (pd.closing) { + return errClosing(isFile); + } + return $pkg.ErrTimeout; + }; + pollDesc.prototype.wait = function(mode, isFile) { return this.$val.wait(mode, isFile); }; + pollDesc.ptr.prototype.waitRead = function(isFile) { + var isFile, pd; + pd = this; + return pd.wait(114, isFile); + }; + pollDesc.prototype.waitRead = function(isFile) { return this.$val.waitRead(isFile); }; + pollDesc.ptr.prototype.waitWrite = function(isFile) { + var isFile, pd; + pd = this; + return pd.wait(119, isFile); + }; + pollDesc.prototype.waitWrite = function(isFile) { return this.$val.waitWrite(isFile); }; + pollDesc.ptr.prototype.pollable = function() { + return true; + }; + pollDesc.prototype.pollable = function() { return this.$val.pollable(); }; + FD.ptr.prototype.SetDeadline = function(t) { + var t; + return $ifaceNil; + }; + FD.prototype.SetDeadline = function(t) { return this.$val.SetDeadline(t); }; + FD.ptr.prototype.SetReadDeadline = function(t) { + var t; + return $ifaceNil; + }; + FD.prototype.SetReadDeadline = function(t) { return this.$val.SetReadDeadline(t); }; + FD.ptr.prototype.SetWriteDeadline = function(t) { + var t; + return $ifaceNil; + }; + FD.prototype.SetWriteDeadline = function(t) { return this.$val.SetWriteDeadline(t); }; + runtime_Semacquire = function(s) { + var _entry, _key, _r, ch, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _key = $f._key; _r = $f._r; ch = $f.ch; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if (s.$get() === 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (s.$get() === 0) { */ case 1: + ch = new $Chan($Bool, 0); + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: $append((_entry = semWaiters[ptrType.keyFor(s)], _entry !== undefined ? _entry.v : sliceType.nil), ch) }; + _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r[0]; + /* } */ case 2: + s.$set(s.$get() - (1) >>> 0); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semacquire }; } $f._entry = _entry; $f._key = _key; $f._r = _r; $f.ch = ch; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_Semrelease = function(s) { + var _entry, _key, ch, s, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _key = $f._key; ch = $f.ch; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s.$set(s.$get() + (1) >>> 0); + w = (_entry = semWaiters[ptrType.keyFor(s)], _entry !== undefined ? _entry.v : sliceType.nil); + if (w.$length === 0) { + $s = -1; return; + } + ch = (0 >= w.$length ? ($throwRuntimeError("index out of range"), undefined) : w.$array[w.$offset + 0]); + w = $subslice(w, 1); + _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: w }; + if (w.$length === 0) { + delete semWaiters[ptrType.keyFor(s)]; + } + $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f._entry = _entry; $f._key = _key; $f.ch = ch; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + errClosing = function(isFile) { + var isFile; + if (isFile) { + return $pkg.ErrFileClosing; + } + return $pkg.ErrNetClosing; + }; + TimeoutError.ptr.prototype.Error = function() { + var e; + e = this; + return "i/o timeout"; + }; + TimeoutError.prototype.Error = function() { return this.$val.Error(); }; + TimeoutError.ptr.prototype.Timeout = function() { + var e; + e = this; + return true; + }; + TimeoutError.prototype.Timeout = function() { return this.$val.Timeout(); }; + TimeoutError.ptr.prototype.Temporary = function() { + var e; + e = this; + return true; + }; + TimeoutError.prototype.Temporary = function() { return this.$val.Temporary(); }; + consume = function(v, n) { + var ln0, n, v, x, x$1, x$2, x$3; + while (true) { + if (!(v.$get().$length > 0)) { break; } + ln0 = (new $Int64(0, (x = v.$get(), (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])).$length)); + if ((ln0.$high > n.$high || (ln0.$high === n.$high && ln0.$low > n.$low))) { + (x$2 = v.$get(), (0 >= x$2.$length ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + 0] = $subslice((x$1 = v.$get(), (0 >= x$1.$length ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + 0])), $flatten64(n)))); + return; + } + n = (x$3 = ln0, new $Int64(n.$high - x$3.$high, n.$low - x$3.$low)); + v.$set($subslice((v.$get()), 1)); + } + }; + fdMutex.ptr.prototype.incref = function() { + var mu, new$1, old, x, x$1; + mu = this; + while (true) { + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { + return false; + } + new$1 = new $Uint64(old.$high + 0, old.$low + 8); + if ((x$1 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { + return true; + } + } + }; + fdMutex.prototype.incref = function() { return this.$val.incref(); }; + fdMutex.ptr.prototype.increfAndClose = function() { + var mu, new$1, old, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; mu = $f.mu; new$1 = $f.new$1; old = $f.old; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + mu = this; + /* while (true) { */ case 1: + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { + $s = -1; return false; + } + new$1 = (x$1 = new $Uint64(old.$high | 0, (old.$low | 1) >>> 0), new $Uint64(x$1.$high + 0, x$1.$low + 8)); + if ((x$2 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$2.$high === 0 && x$2.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + new$1 = (x$3 = new $Uint64(2147483647, 4286578688), new $Uint64(new$1.$high & ~x$3.$high, (new$1.$low & ~x$3.$low) >>> 0)); + /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: + /* while (true) { */ case 5: + /* if (!(!((x$4 = new $Uint64(old.$high & 2047, (old.$low & 4286578688) >>> 0), (x$4.$high === 0 && x$4.$low === 0))))) { break; } */ if(!(!((x$4 = new $Uint64(old.$high & 2047, (old.$low & 4286578688) >>> 0), (x$4.$high === 0 && x$4.$low === 0))))) { $s = 6; continue; } + old = (x$5 = new $Uint64(0, 8388608), new $Uint64(old.$high - x$5.$high, old.$low - x$5.$low)); + $r = runtime_Semrelease((mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ $s = 5; continue; case 6: + /* while (true) { */ case 8: + /* if (!(!((x$6 = new $Uint64(old.$high & 2147481600, (old.$low & 0) >>> 0), (x$6.$high === 0 && x$6.$low === 0))))) { break; } */ if(!(!((x$6 = new $Uint64(old.$high & 2147481600, (old.$low & 0) >>> 0), (x$6.$high === 0 && x$6.$low === 0))))) { $s = 9; continue; } + old = (x$7 = new $Uint64(2048, 0), new $Uint64(old.$high - x$7.$high, old.$low - x$7.$low)); + $r = runtime_Semrelease((mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu)))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ $s = 8; continue; case 9: + $s = -1; return true; + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.increfAndClose }; } $f.mu = mu; $f.new$1 = new$1; $f.old = old; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f; + }; + fdMutex.prototype.increfAndClose = function() { return this.$val.increfAndClose(); }; + fdMutex.ptr.prototype.decref = function() { + var mu, new$1, old, x, x$1; + mu = this; + while (true) { + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if ((x = new $Uint64(old.$high & 0, (old.$low & 8388600) >>> 0), (x.$high === 0 && x.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + new$1 = new $Uint64(old.$high - 0, old.$low - 8); + if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { + return (x$1 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388601) >>> 0), (x$1.$high === 0 && x$1.$low === 1)); + } + } + }; + fdMutex.prototype.decref = function() { return this.$val.decref(); }; + fdMutex.ptr.prototype.rwlock = function(read) { + var _tmp, _tmp$1, _tmp$2, mu, mutexBit, mutexMask, mutexSema, mutexWait, new$1, old, read, x, x$1, x$2, x$3, x$4, x$5, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; mu = $f.mu; mutexBit = $f.mutexBit; mutexMask = $f.mutexMask; mutexSema = $f.mutexSema; mutexWait = $f.mutexWait; new$1 = $f.new$1; old = $f.old; read = $f.read; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + mu = this; + _tmp = new $Uint64(0, 0); + _tmp$1 = new $Uint64(0, 0); + _tmp$2 = new $Uint64(0, 0); + mutexBit = _tmp; + mutexWait = _tmp$1; + mutexMask = _tmp$2; + mutexSema = ptrType.nil; + if (read) { + mutexBit = new $Uint64(0, 2); + mutexWait = new $Uint64(0, 8388608); + mutexMask = new $Uint64(2047, 4286578688); + mutexSema = (mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu))); + } else { + mutexBit = new $Uint64(0, 4); + mutexWait = new $Uint64(2048, 0); + mutexMask = new $Uint64(2147481600, 0); + mutexSema = (mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu))); + } + /* while (true) { */ case 1: + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if (!((x = new $Uint64(old.$high & 0, (old.$low & 1) >>> 0), (x.$high === 0 && x.$low === 0)))) { + $s = -1; return false; + } + new$1 = new $Uint64(0, 0); + if ((x$1 = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { + new$1 = (x$2 = new $Uint64(old.$high | mutexBit.$high, (old.$low | mutexBit.$low) >>> 0), new $Uint64(x$2.$high + 0, x$2.$low + 8)); + if ((x$3 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388600) >>> 0), (x$3.$high === 0 && x$3.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + } else { + new$1 = new $Uint64(old.$high + mutexWait.$high, old.$low + mutexWait.$low); + if ((x$4 = new $Uint64(new$1.$high & mutexMask.$high, (new$1.$low & mutexMask.$low) >>> 0), (x$4.$high === 0 && x$4.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + } + /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: + if ((x$5 = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0))) { + $s = -1; return true; + } + $r = runtime_Semacquire(mutexSema); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.rwlock }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.mu = mu; $f.mutexBit = mutexBit; $f.mutexMask = mutexMask; $f.mutexSema = mutexSema; $f.mutexWait = mutexWait; $f.new$1 = new$1; $f.old = old; $f.read = read; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f; + }; + fdMutex.prototype.rwlock = function(read) { return this.$val.rwlock(read); }; + fdMutex.ptr.prototype.rwunlock = function(read) { + var _tmp, _tmp$1, _tmp$2, mu, mutexBit, mutexMask, mutexSema, mutexWait, new$1, old, read, x, x$1, x$2, x$3, x$4, x$5, x$6, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; mu = $f.mu; mutexBit = $f.mutexBit; mutexMask = $f.mutexMask; mutexSema = $f.mutexSema; mutexWait = $f.mutexWait; new$1 = $f.new$1; old = $f.old; read = $f.read; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + mu = this; + _tmp = new $Uint64(0, 0); + _tmp$1 = new $Uint64(0, 0); + _tmp$2 = new $Uint64(0, 0); + mutexBit = _tmp; + mutexWait = _tmp$1; + mutexMask = _tmp$2; + mutexSema = ptrType.nil; + if (read) { + mutexBit = new $Uint64(0, 2); + mutexWait = new $Uint64(0, 8388608); + mutexMask = new $Uint64(2047, 4286578688); + mutexSema = (mu.$ptr_rsema || (mu.$ptr_rsema = new ptrType(function() { return this.$target.rsema; }, function($v) { this.$target.rsema = $v; }, mu))); + } else { + mutexBit = new $Uint64(0, 4); + mutexWait = new $Uint64(2048, 0); + mutexMask = new $Uint64(2147481600, 0); + mutexSema = (mu.$ptr_wsema || (mu.$ptr_wsema = new ptrType(function() { return this.$target.wsema; }, function($v) { this.$target.wsema = $v; }, mu))); + } + /* while (true) { */ case 1: + old = atomic.LoadUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu)))); + if ((x = new $Uint64(old.$high & mutexBit.$high, (old.$low & mutexBit.$low) >>> 0), (x.$high === 0 && x.$low === 0)) || (x$1 = new $Uint64(old.$high & 0, (old.$low & 8388600) >>> 0), (x$1.$high === 0 && x$1.$low === 0))) { + $panic(new $String("inconsistent poll.fdMutex")); + } + new$1 = (x$2 = new $Uint64(old.$high & ~mutexBit.$high, (old.$low & ~mutexBit.$low) >>> 0), new $Uint64(x$2.$high - 0, x$2.$low - 8)); + if (!((x$3 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$3.$high === 0 && x$3.$low === 0)))) { + new$1 = (x$4 = mutexWait, new $Uint64(new$1.$high - x$4.$high, new$1.$low - x$4.$low)); + } + /* */ if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapUint64((mu.$ptr_state || (mu.$ptr_state = new ptrType$1(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, mu))), old, new$1)) { */ case 3: + /* */ if (!((x$5 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (!((x$5 = new $Uint64(old.$high & mutexMask.$high, (old.$low & mutexMask.$low) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) { */ case 5: + $r = runtime_Semrelease(mutexSema); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + $s = -1; return (x$6 = new $Uint64(new$1.$high & 0, (new$1.$low & 8388601) >>> 0), (x$6.$high === 0 && x$6.$low === 1)); + /* } */ case 4: + /* } */ $s = 1; continue; case 2: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: fdMutex.ptr.prototype.rwunlock }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f.mu = mu; $f.mutexBit = mutexBit; $f.mutexMask = mutexMask; $f.mutexSema = mutexSema; $f.mutexWait = mutexWait; $f.new$1 = new$1; $f.old = old; $f.read = read; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.$s = $s; $f.$r = $r; return $f; + }; + fdMutex.prototype.rwunlock = function(read) { return this.$val.rwunlock(read); }; + FD.ptr.prototype.incref = function() { + var fd; + fd = this; + if (!fd.fdmu.incref()) { + return errClosing(fd.isFile); + } + return $ifaceNil; + }; + FD.prototype.incref = function() { return this.$val.incref(); }; + FD.ptr.prototype.decref = function() { + var _r, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + /* */ if (fd.fdmu.decref()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (fd.fdmu.decref()) { */ case 1: + _r = fd.destroy(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.decref }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.decref = function() { return this.$val.decref(); }; + FD.ptr.prototype.readLock = function() { + var _r, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwlock(true); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!_r) { */ case 1: + $s = -1; return errClosing(fd.isFile); + /* } */ case 2: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.readLock }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.readLock = function() { return this.$val.readLock(); }; + FD.ptr.prototype.readUnlock = function() { + var _r, _r$1, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwunlock(true); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r) { */ case 1: + _r$1 = fd.destroy(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.readUnlock }; } $f._r = _r; $f._r$1 = _r$1; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.readUnlock = function() { return this.$val.readUnlock(); }; + FD.ptr.prototype.writeLock = function() { + var _r, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwlock(false); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!_r) { */ case 1: + $s = -1; return errClosing(fd.isFile); + /* } */ case 2: + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.writeLock }; } $f._r = _r; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.writeLock = function() { return this.$val.writeLock(); }; + FD.ptr.prototype.writeUnlock = function() { + var _r, _r$1, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.rwunlock(false); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r) { */ case 1: + _r$1 = fd.destroy(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.writeUnlock }; } $f._r = _r; $f._r$1 = _r$1; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.writeUnlock = function() { return this.$val.writeUnlock(); }; + FD.ptr.prototype.eofError = function(n, err) { + var err, fd, n; + fd = this; + if ((n === 0) && $interfaceIsEqual(err, $ifaceNil) && fd.ZeroReadIsEOF) { + return io.EOF; + } + return err; + }; + FD.prototype.eofError = function(n, err) { return this.$val.eofError(n, err); }; + FD.ptr.prototype.Fchmod = function(mode) { + var err, fd, mode, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; mode = $f.mode; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fchmod(fd.Sysfd, mode); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchmod }; } $f.err = err; $f.fd = fd; $f.mode = mode; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fchmod = function(mode) { return this.$val.Fchmod(mode); }; + FD.ptr.prototype.Fchown = function(uid, gid) { + var err, fd, gid, uid, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; gid = $f.gid; uid = $f.uid; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fchown(fd.Sysfd, uid, gid); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchown }; } $f.err = err; $f.fd = fd; $f.gid = gid; $f.uid = uid; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fchown = function(uid, gid) { return this.$val.Fchown(uid, gid); }; + FD.ptr.prototype.Ftruncate = function(size) { + var err, fd, size, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; size = $f.size; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Ftruncate(fd.Sysfd, size); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Ftruncate }; } $f.err = err; $f.fd = fd; $f.size = size; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Ftruncate = function(size) { return this.$val.Ftruncate(size); }; + FD.ptr.prototype.Fsync = function() { + var err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fsync(fd.Sysfd); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fsync }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fsync = function() { return this.$val.Fsync(); }; + FD.ptr.prototype.Init = function(net, pollable) { + var fd, net, pollable; + fd = this; + if (net === "file") { + fd.isFile = true; + } + if (!pollable) { + fd.isBlocking = true; + return $ifaceNil; + } + return fd.pd.init(fd); + }; + FD.prototype.Init = function(net, pollable) { return this.$val.Init(net, pollable); }; + FD.ptr.prototype.destroy = function() { + var _r, err, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + fd.pd.close(); + _r = $pkg.CloseFunc(fd.Sysfd); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + fd.Sysfd = -1; + $r = runtime_Semrelease((fd.$ptr_csema || (fd.$ptr_csema = new ptrType(function() { return this.$target.csema; }, function($v) { this.$target.csema = $v; }, fd)))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.destroy }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.destroy = function() { return this.$val.destroy(); }; + FD.ptr.prototype.Close = function() { + var _r, _r$1, err, fd, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; fd = $f.fd; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + _r = fd.fdmu.increfAndClose(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!_r) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!_r) { */ case 1: + $s = -1; return errClosing(fd.isFile); + /* } */ case 2: + fd.pd.evict(); + _r$1 = fd.decref(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + err = _r$1; + /* */ if (!fd.isBlocking) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (!fd.isBlocking) { */ case 5: + $r = runtime_Semacquire((fd.$ptr_csema || (fd.$ptr_csema = new ptrType(function() { return this.$target.csema; }, function($v) { this.$target.csema = $v; }, fd)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Close }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.fd = fd; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.Close = function() { return this.$val.Close(); }; + FD.ptr.prototype.Shutdown = function(how) { + var err, fd, how, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; how = $f.how; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Shutdown(fd.Sysfd, how); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Shutdown }; } $f.err = err; $f.fd = fd; $f.how = how; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Shutdown = function(how) { return this.$val.Shutdown(how); }; + FD.ptr.prototype.SetBlocking = function() { + var err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + fd.isBlocking = true; + $s = -1; return syscall.SetNonblock(fd.Sysfd, false); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetBlocking }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetBlocking = function() { return this.$val.SetBlocking(); }; + FD.ptr.prototype.Read = function(p) { + var _r, _tuple, err, err$1, err$2, fd, n, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + if (p.$length === 0) { + $s = -1; return [0, $ifaceNil]; + } + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, err$1]; + } + if (fd.IsStream && p.$length > 1073741824) { + p = $subslice(p, 0, 1073741824); + } + while (true) { + _tuple = syscall.Read(fd.Sysfd, p); + n = _tuple[0]; + err$2 = _tuple[1]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + n = 0; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + if (false && $interfaceIsEqual(err$2, new syscall.Errno(4))) { + continue; + } + } + err$2 = fd.eofError(n, err$2); + $s = -1; return [n, err$2]; + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Read }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Read = function(p) { return this.$val.Read(p); }; + FD.ptr.prototype.Pread = function(p, off) { + var _r, _tuple, err, err$1, fd, n, off, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; fd = $f.fd; n = $f.n; off = $f.off; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + if (fd.IsStream && p.$length > 1073741824) { + p = $subslice(p, 0, 1073741824); + } + _tuple = syscall.Pread(fd.Sysfd, p, off); + n = _tuple[0]; + err$1 = _tuple[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + n = 0; + } + _r = fd.decref(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + err$1 = fd.eofError(n, err$1); + $s = -1; return [n, err$1]; + /* */ } return; } if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Pread }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.n = n; $f.off = off; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.prototype.Pread = function(p, off) { return this.$val.Pread(p, off); }; + FD.ptr.prototype.ReadFrom = function(p) { + var _r, _tuple, err, err$1, err$2, fd, n, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, $ifaceNil, err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, $ifaceNil, err$1]; + } + while (true) { + _tuple = syscall.Recvfrom(fd.Sysfd, p, 0); + n = _tuple[0]; + sa = _tuple[1]; + err$2 = _tuple[2]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + n = 0; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + } + err$2 = fd.eofError(n, err$2); + $s = -1; return [n, sa, err$2]; + } + $s = -1; return [0, $ifaceNil, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadFrom }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.ReadFrom = function(p) { return this.$val.ReadFrom(p); }; + FD.ptr.prototype.ReadMsg = function(p, oob) { + var _r, _tuple, err, err$1, err$2, fd, flags, n, oob, oobn, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; flags = $f.flags; n = $f.n; oob = $f.oob; oobn = $f.oobn; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, 0, 0, $ifaceNil, err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, 0, 0, $ifaceNil, err$1]; + } + while (true) { + _tuple = syscall.Recvmsg(fd.Sysfd, p, oob, 0); + n = _tuple[0]; + oobn = _tuple[1]; + flags = _tuple[2]; + sa = _tuple[3]; + err$2 = _tuple[4]; + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + } + err$2 = fd.eofError(n, err$2); + $s = -1; return [n, oobn, flags, sa, err$2]; + } + $s = -1; return [0, 0, 0, $ifaceNil, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, 0, 0, $ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadMsg }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.flags = flags; $f.n = n; $f.oob = oob; $f.oobn = oobn; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.ReadMsg = function(p, oob) { return this.$val.ReadMsg(p, oob); }; + FD.ptr.prototype.Write = function(p) { + var _r, _tuple, err, err$1, err$2, fd, max, n, nn, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; max = $f.max; n = $f.n; nn = $f.nn; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, err$1]; + } + nn = 0; + while (true) { + max = p.$length; + if (fd.IsStream && (max - nn >> 0) > 1073741824) { + max = nn + 1073741824 >> 0; + } + _tuple = syscall.Write(fd.Sysfd, $subslice(p, nn, max)); + n = _tuple[0]; + err$2 = _tuple[1]; + if (n > 0) { + nn = nn + (n) >> 0; + } + if (nn === p.$length) { + $s = -1; return [nn, err$2]; + } + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + continue; + } + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [nn, err$2]; + } + if (n === 0) { + $s = -1; return [nn, io.ErrUnexpectedEOF]; + } + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Write }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.max = max; $f.n = n; $f.nn = nn; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Write = function(p) { return this.$val.Write(p); }; + FD.ptr.prototype.Pwrite = function(p, off) { + var _tuple, err, err$1, fd, max, n, nn, off, p, x, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; fd = $f.fd; max = $f.max; n = $f.n; nn = $f.nn; off = $f.off; p = $f.p; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + nn = 0; + while (true) { + max = p.$length; + if (fd.IsStream && (max - nn >> 0) > 1073741824) { + max = nn + 1073741824 >> 0; + } + _tuple = syscall.Pwrite(fd.Sysfd, $subslice(p, nn, max), (x = (new $Int64(0, nn)), new $Int64(off.$high + x.$high, off.$low + x.$low))); + n = _tuple[0]; + err$1 = _tuple[1]; + if (n > 0) { + nn = nn + (n) >> 0; + } + if (nn === p.$length) { + $s = -1; return [nn, err$1]; + } + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [nn, err$1]; + } + if (n === 0) { + $s = -1; return [nn, io.ErrUnexpectedEOF]; + } + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Pwrite }; } $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.max = max; $f.n = n; $f.nn = nn; $f.off = off; $f.p = p; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Pwrite = function(p, off) { return this.$val.Pwrite(p, off); }; + FD.ptr.prototype.WriteTo = function(p, sa) { + var _r, _r$1, err, err$1, err$2, fd, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, err$1]; + } + /* while (true) { */ case 2: + _r$1 = syscall.Sendto(fd.Sysfd, p, 0, sa); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + err$2 = _r$1; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [0, err$2]; + } + $s = -1; return [p.$length, $ifaceNil]; + /* } */ $s = 2; continue; case 3: + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteTo }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.WriteTo = function(p, sa) { return this.$val.WriteTo(p, sa); }; + FD.ptr.prototype.WriteMsg = function(p, oob, sa) { + var _r, _r$1, _tuple, err, err$1, err$2, fd, n, oob, p, sa, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; n = $f.n; oob = $f.oob; p = $f.p; sa = $f.sa; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, 0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [0, 0, err$1]; + } + /* while (true) { */ case 2: + _r$1 = syscall.SendmsgN(fd.Sysfd, p, oob, sa, 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + n = _tuple[0]; + err$2 = _tuple[1]; + if ($interfaceIsEqual(err$2, new syscall.Errno(11)) && fd.pd.pollable()) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return [n, 0, err$2]; + } + $s = -1; return [n, oob.$length, err$2]; + /* } */ $s = 2; continue; case 3: + $s = -1; return [0, 0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, 0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteMsg }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.n = n; $f.oob = oob; $f.p = p; $f.sa = sa; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.WriteMsg = function(p, oob, sa) { return this.$val.WriteMsg(p, oob, sa); }; + FD.ptr.prototype.Accept = function() { + var _1, _r, _r$1, _tuple, err, err$1, err$2, errcall, fd, rsa, s, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; errcall = $f.errcall; fd = $f.fd; rsa = $f.rsa; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [-1, $ifaceNil, "", err]; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [-1, $ifaceNil, "", err$1]; + } + /* while (true) { */ case 2: + _r$1 = accept(fd.Sysfd); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + s = _tuple[0]; + rsa = _tuple[1]; + errcall = _tuple[2]; + err$2 = _tuple[3]; + if ($interfaceIsEqual(err$2, $ifaceNil)) { + $s = -1; return [s, rsa, "", err$2]; + } + _1 = err$2; + if ($interfaceIsEqual(_1, new syscall.Errno((11)))) { + if (fd.pd.pollable()) { + err$2 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } + } else if ($interfaceIsEqual(_1, new syscall.Errno((103)))) { + /* continue; */ $s = 2; continue; + } + $s = -1; return [-1, $ifaceNil, errcall, err$2]; + /* } */ $s = 2; continue; case 3: + $s = -1; return [0, $ifaceNil, "", $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil, "", $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Accept }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.errcall = errcall; $f.fd = fd; $f.rsa = rsa; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Accept = function() { return this.$val.Accept(); }; + FD.ptr.prototype.Seek = function(offset, whence) { + var err, fd, offset, whence, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; offset = $f.offset; whence = $f.whence; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new $Int64(0, 0), err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Seek(fd.Sysfd, offset, whence); + /* */ } return; } } catch(err) { $err = err; $s = -1; return [new $Int64(0, 0), $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Seek }; } $f.err = err; $f.fd = fd; $f.offset = offset; $f.whence = whence; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + FD.ptr.prototype.ReadDirent = function(buf) { + var _tuple, buf, err, err$1, fd, n, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; buf = $f.buf; err = $f.err; err$1 = $f.err$1; fd = $f.fd; n = $f.n; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "decref"), []]); + while (true) { + _tuple = syscall.ReadDirent(fd.Sysfd, buf); + n = _tuple[0]; + err$1 = _tuple[1]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + n = 0; + if ($interfaceIsEqual(err$1, new syscall.Errno(11)) && fd.pd.pollable()) { + err$1 = fd.pd.waitRead(fd.isFile); + if ($interfaceIsEqual(err$1, $ifaceNil)) { + continue; + } + } + } + $s = -1; return [n, err$1]; + } + $s = -1; return [0, $ifaceNil]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.ReadDirent }; } $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.err$1 = err$1; $f.fd = fd; $f.n = n; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.ReadDirent = function(buf) { return this.$val.ReadDirent(buf); }; + FD.ptr.prototype.Fchdir = function() { + var err, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fchdir(fd.Sysfd); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fchdir }; } $f.err = err; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fchdir = function() { return this.$val.Fchdir(); }; + FD.ptr.prototype.Fstat = function(s) { + var err, fd, s, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.Fstat(fd.Sysfd, s); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Fstat }; } $f.err = err; $f.fd = fd; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Fstat = function(s) { return this.$val.Fstat(s); }; + FD.ptr.prototype.WaitWrite = function() { + var fd; + fd = this; + return fd.pd.waitWrite(fd.isFile); + }; + FD.prototype.WaitWrite = function() { return this.$val.WaitWrite(); }; + FD.ptr.prototype.WriteOnce = function(p) { + var _r, err, fd, p, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; fd = $f.fd; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [0, err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + $s = -1; return syscall.Write(fd.Sysfd, p); + /* */ } return; } } catch(err) { $err = err; $s = -1; return [0, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.WriteOnce }; } $f._r = _r; $f.err = err; $f.fd = fd; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.WriteOnce = function(p) { return this.$val.WriteOnce(p); }; + FD.ptr.prototype.RawControl = function(f) { + var err, f, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $r = f(((fd.Sysfd >>> 0))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return $ifaceNil; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawControl }; } $f.err = err; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.RawControl = function(f) { return this.$val.RawControl(f); }; + FD.ptr.prototype.RawRead = function(f) { + var _r, _r$1, err, err$1, err$2, f, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.readLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "readUnlock"), []]); + err$1 = fd.pd.prepareRead(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return err$1; + } + /* while (true) { */ case 2: + _r$1 = f(((fd.Sysfd >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 5: + err$2 = fd.pd.waitRead(fd.isFile); + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return err$2; + } + /* } */ $s = 2; continue; case 3: + $s = -1; return $ifaceNil; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawRead }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.RawRead = function(f) { return this.$val.RawRead(f); }; + FD.ptr.prototype.RawWrite = function(f) { + var _r, _r$1, err, err$1, err$2, f, fd, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; fd = $f.fd; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return err$1; + } + /* while (true) { */ case 2: + _r$1 = f(((fd.Sysfd >>> 0))); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return $ifaceNil; + /* } */ case 5: + err$2 = fd.pd.waitWrite(fd.isFile); + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + $s = -1; return err$2; + } + /* } */ $s = 2; continue; case 3: + $s = -1; return $ifaceNil; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.RawWrite }; } $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.fd = fd; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.RawWrite = function(f) { return this.$val.RawWrite(f); }; + accept = function(s) { + var _1, _r, _r$1, _r$2, _tuple, _tuple$1, err, ns, s, sa, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; err = $f.err; ns = $f.ns; s = $f.s; sa = $f.sa; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.Accept4Func(s, 526336); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ns = _tuple[0]; + sa = _tuple[1]; + err = _tuple[2]; + _1 = err; + if ($interfaceIsEqual(_1, $ifaceNil)) { + $s = -1; return [ns, sa, "", $ifaceNil]; + } else if ($interfaceIsEqual(_1, new syscall.Errno((38)))) { + } else if ($interfaceIsEqual(_1, new syscall.Errno((22)))) { + } else if ($interfaceIsEqual(_1, new syscall.Errno((13)))) { + } else if ($interfaceIsEqual(_1, new syscall.Errno((14)))) { + } else { + $s = -1; return [-1, sa, "accept4", err]; + } + _r$1 = $pkg.AcceptFunc(s); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + ns = _tuple$1[0]; + sa = _tuple$1[1]; + err = _tuple$1[2]; + if ($interfaceIsEqual(err, $ifaceNil)) { + syscall.CloseOnExec(ns); + } + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [-1, $ifaceNil, "accept", err]; + } + err = syscall.SetNonblock(ns, true); + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 3: + _r$2 = $pkg.CloseFunc(ns); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + $s = -1; return [-1, $ifaceNil, "setnonblock", err]; + /* } */ case 4: + $s = -1; return [ns, sa, "", $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: accept }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.err = err; $f.ns = ns; $f.s = s; $f.sa = sa; $f.$s = $s; $f.$r = $r; return $f; + }; + FD.ptr.prototype.SetsockoptInt = function(level, name, arg) { + var arg, err, fd, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptInt(fd.Sysfd, level, name, arg); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptInt }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptInt = function(level, name, arg) { return this.$val.SetsockoptInt(level, name, arg); }; + FD.ptr.prototype.SetsockoptInet4Addr = function(level, name, arg) { + var arg, err, fd, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptInet4Addr(fd.Sysfd, level, name, $clone(arg, arrayType)); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptInet4Addr }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptInet4Addr = function(level, name, arg) { return this.$val.SetsockoptInet4Addr(level, name, arg); }; + FD.ptr.prototype.SetsockoptLinger = function(level, name, l) { + var err, fd, l, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; l = $f.l; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptLinger(fd.Sysfd, level, name, l); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptLinger }; } $f.err = err; $f.fd = fd; $f.l = l; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptLinger = function(level, name, l) { return this.$val.SetsockoptLinger(level, name, l); }; + FD.ptr.prototype.SetsockoptIPMreqn = function(level, name, mreq) { + var err, fd, level, mreq, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptIPMreqn(fd.Sysfd, level, name, mreq); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPMreqn }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptIPMreqn = function(level, name, mreq) { return this.$val.SetsockoptIPMreqn(level, name, mreq); }; + FD.ptr.prototype.SetsockoptByte = function(level, name, arg) { + var arg, err, fd, level, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; arg = $f.arg; err = $f.err; fd = $f.fd; level = $f.level; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptByte(fd.Sysfd, level, name, arg); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptByte }; } $f.arg = arg; $f.err = err; $f.fd = fd; $f.level = level; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptByte = function(level, name, arg) { return this.$val.SetsockoptByte(level, name, arg); }; + FD.ptr.prototype.SetsockoptIPMreq = function(level, name, mreq) { + var err, fd, level, mreq, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptIPMreq(fd.Sysfd, level, name, mreq); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPMreq }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptIPMreq = function(level, name, mreq) { return this.$val.SetsockoptIPMreq(level, name, mreq); }; + FD.ptr.prototype.SetsockoptIPv6Mreq = function(level, name, mreq) { + var err, fd, level, mreq, name, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; err = $f.err; fd = $f.fd; level = $f.level; mreq = $f.mreq; name = $f.name; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + fd = this; + err = fd.incref(); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + $deferred.push([$methodVal(fd, "decref"), []]); + $s = -1; return syscall.SetsockoptIPv6Mreq(fd.Sysfd, level, name, mreq); + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.SetsockoptIPv6Mreq }; } $f.err = err; $f.fd = fd; $f.level = level; $f.mreq = mreq; $f.name = name; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.SetsockoptIPv6Mreq = function(level, name, mreq) { return this.$val.SetsockoptIPv6Mreq(level, name, mreq); }; + FD.ptr.prototype.Writev = function(v) { + var _i, _r, _ref, _tuple, chunk, e0, err, err$1, err$2, fd, iovecs, maxVec, n, v, wrote, x, x$1, x$2, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; chunk = $f.chunk; e0 = $f.e0; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; fd = $f.fd; iovecs = $f.iovecs; maxVec = $f.maxVec; n = $f.n; v = $f.v; wrote = $f.wrote; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + iovecs = [iovecs]; + fd = this; + _r = fd.writeLock(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [new $Int64(0, 0), err]; + } + $deferred.push([$methodVal(fd, "writeUnlock"), []]); + err$1 = fd.pd.prepareWrite(fd.isFile); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + $s = -1; return [new $Int64(0, 0), err$1]; + } + iovecs[0] = sliceType$1.nil; + if (!(fd.iovecs === ptrType$3.nil)) { + iovecs[0] = fd.iovecs.$get(); + } + maxVec = 1024; + n = new $Int64(0, 0); + err$2 = $ifaceNil; + /* while (true) { */ case 2: + /* if (!(v.$get().$length > 0)) { break; } */ if(!(v.$get().$length > 0)) { $s = 3; continue; } + iovecs[0] = $subslice(iovecs[0], 0, 0); + _ref = v.$get(); + _i = 0; + /* while (true) { */ case 4: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; } + chunk = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (chunk.$length === 0) { + _i++; + /* continue; */ $s = 4; continue; + } + iovecs[0] = $append(iovecs[0], new syscall.Iovec.ptr($indexPtr(chunk.$array, chunk.$offset + 0, ptrType$4), new $Uint64(0, 0))); + if (fd.IsStream && chunk.$length > 1073741824) { + (x = iovecs[0].$length - 1 >> 0, ((x < 0 || x >= iovecs[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : iovecs[0].$array[iovecs[0].$offset + x])).SetLen(1073741824); + /* break; */ $s = 5; continue; + } + (x$1 = iovecs[0].$length - 1 >> 0, ((x$1 < 0 || x$1 >= iovecs[0].$length) ? ($throwRuntimeError("index out of range"), undefined) : iovecs[0].$array[iovecs[0].$offset + x$1])).SetLen(chunk.$length); + if (iovecs[0].$length === maxVec) { + /* break; */ $s = 5; continue; + } + _i++; + /* } */ $s = 4; continue; case 5: + if (iovecs[0].$length === 0) { + /* break; */ $s = 3; continue; + } + fd.iovecs = (iovecs.$ptr || (iovecs.$ptr = new ptrType$3(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, iovecs))); + _tuple = syscall.Syscall(20, ((fd.Sysfd >>> 0)), (($sliceToArray(iovecs[0]))), ((iovecs[0].$length >>> 0))); + wrote = _tuple[0]; + e0 = _tuple[2]; + if (wrote === 4294967295) { + wrote = 0; + } + $r = $pkg.TestHookDidWritev(((wrote >> 0))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + n = (x$2 = (new $Int64(0, wrote.constructor === Number ? wrote : 1)), new $Int64(n.$high + x$2.$high, n.$low + x$2.$low)); + consume(v, (new $Int64(0, wrote.constructor === Number ? wrote : 1))); + if (e0 === 11) { + err$2 = fd.pd.waitWrite(fd.isFile); + if ($interfaceIsEqual(err$2, $ifaceNil)) { + /* continue; */ $s = 2; continue; + } + } else if (!((e0 === 0))) { + err$2 = new syscall.Errno((e0)); + } + if (!($interfaceIsEqual(err$2, $ifaceNil))) { + /* break; */ $s = 3; continue; + } + if ((n.$high === 0 && n.$low === 0)) { + err$2 = io.ErrUnexpectedEOF; + /* break; */ $s = 3; continue; + } + /* } */ $s = 2; continue; case 3: + $s = -1; return [n, err$2]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [new $Int64(0, 0), $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: FD.ptr.prototype.Writev }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.chunk = chunk; $f.e0 = e0; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.fd = fd; $f.iovecs = iovecs; $f.maxVec = maxVec; $f.n = n; $f.v = v; $f.wrote = wrote; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + FD.prototype.Writev = function(v) { return this.$val.Writev(v); }; + ptrType$6.methods = [{prop: "init", name: "init", pkg: "internal/poll", typ: $funcType([ptrType$5], [$error], false)}, {prop: "close", name: "close", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "evict", name: "evict", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "prepare", name: "prepare", pkg: "internal/poll", typ: $funcType([$Int, $Bool], [$error], false)}, {prop: "prepareRead", name: "prepareRead", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "prepareWrite", name: "prepareWrite", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "wait", name: "wait", pkg: "internal/poll", typ: $funcType([$Int, $Bool], [$error], false)}, {prop: "waitRead", name: "waitRead", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "waitWrite", name: "waitWrite", pkg: "internal/poll", typ: $funcType([$Bool], [$error], false)}, {prop: "waitCanceled", name: "waitCanceled", pkg: "internal/poll", typ: $funcType([$Int], [], false)}, {prop: "pollable", name: "pollable", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}]; + ptrType$7.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$8.methods = [{prop: "incref", name: "incref", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "increfAndClose", name: "increfAndClose", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "decref", name: "decref", pkg: "internal/poll", typ: $funcType([], [$Bool], false)}, {prop: "rwlock", name: "rwlock", pkg: "internal/poll", typ: $funcType([$Bool], [$Bool], false)}, {prop: "rwunlock", name: "rwunlock", pkg: "internal/poll", typ: $funcType([$Bool], [$Bool], false)}]; + ptrType$5.methods = [{prop: "SetDeadline", name: "SetDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetReadDeadline", name: "SetReadDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetWriteDeadline", name: "SetWriteDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "incref", name: "incref", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "decref", name: "decref", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "readLock", name: "readLock", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "readUnlock", name: "readUnlock", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "writeLock", name: "writeLock", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "writeUnlock", name: "writeUnlock", pkg: "internal/poll", typ: $funcType([], [], false)}, {prop: "eofError", name: "eofError", pkg: "internal/poll", typ: $funcType([$Int, $error], [$error], false)}, {prop: "Fchmod", name: "Fchmod", pkg: "", typ: $funcType([$Uint32], [$error], false)}, {prop: "Fchown", name: "Fchown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Ftruncate", name: "Ftruncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Fsync", name: "Fsync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([$String, $Bool], [$error], false)}, {prop: "destroy", name: "destroy", pkg: "internal/poll", typ: $funcType([], [$error], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Shutdown", name: "Shutdown", pkg: "", typ: $funcType([$Int], [$error], false)}, {prop: "SetBlocking", name: "SetBlocking", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "Pread", name: "Pread", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([sliceType$2], [$Int, syscall.Sockaddr, $error], false)}, {prop: "ReadMsg", name: "ReadMsg", pkg: "", typ: $funcType([sliceType$2, sliceType$2], [$Int, $Int, $Int, syscall.Sockaddr, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "Pwrite", name: "Pwrite", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([sliceType$2, syscall.Sockaddr], [$Int, $error], false)}, {prop: "WriteMsg", name: "WriteMsg", pkg: "", typ: $funcType([sliceType$2, sliceType$2, syscall.Sockaddr], [$Int, $Int, $error], false)}, {prop: "Accept", name: "Accept", pkg: "", typ: $funcType([], [$Int, syscall.Sockaddr, $String, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "ReadDirent", name: "ReadDirent", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "Fchdir", name: "Fchdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Fstat", name: "Fstat", pkg: "", typ: $funcType([ptrType$9], [$error], false)}, {prop: "WaitWrite", name: "WaitWrite", pkg: "", typ: $funcType([], [$error], false)}, {prop: "WriteOnce", name: "WriteOnce", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "RawControl", name: "RawControl", pkg: "", typ: $funcType([funcType], [$error], false)}, {prop: "RawRead", name: "RawRead", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "RawWrite", name: "RawWrite", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "SetsockoptInt", name: "SetsockoptInt", pkg: "", typ: $funcType([$Int, $Int, $Int], [$error], false)}, {prop: "SetsockoptInet4Addr", name: "SetsockoptInet4Addr", pkg: "", typ: $funcType([$Int, $Int, arrayType], [$error], false)}, {prop: "SetsockoptLinger", name: "SetsockoptLinger", pkg: "", typ: $funcType([$Int, $Int, ptrType$10], [$error], false)}, {prop: "SetsockoptIPMreqn", name: "SetsockoptIPMreqn", pkg: "", typ: $funcType([$Int, $Int, ptrType$11], [$error], false)}, {prop: "SetsockoptByte", name: "SetsockoptByte", pkg: "", typ: $funcType([$Int, $Int, $Uint8], [$error], false)}, {prop: "SetsockoptIPMreq", name: "SetsockoptIPMreq", pkg: "", typ: $funcType([$Int, $Int, ptrType$12], [$error], false)}, {prop: "SetsockoptIPv6Mreq", name: "SetsockoptIPv6Mreq", pkg: "", typ: $funcType([$Int, $Int, ptrType$13], [$error], false)}, {prop: "Writev", name: "Writev", pkg: "", typ: $funcType([ptrType$14], [$Int64, $error], false)}]; + pollDesc.init("internal/poll", [{prop: "closing", name: "closing", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + TimeoutError.init("", []); + fdMutex.init("internal/poll", [{prop: "state", name: "state", anonymous: false, exported: false, typ: $Uint64, tag: ""}, {prop: "rsema", name: "rsema", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "wsema", name: "wsema", anonymous: false, exported: false, typ: $Uint32, tag: ""}]); + FD.init("internal/poll", [{prop: "fdmu", name: "fdmu", anonymous: false, exported: false, typ: fdMutex, tag: ""}, {prop: "Sysfd", name: "Sysfd", anonymous: false, exported: true, typ: $Int, tag: ""}, {prop: "pd", name: "pd", anonymous: false, exported: false, typ: pollDesc, tag: ""}, {prop: "iovecs", name: "iovecs", anonymous: false, exported: false, typ: ptrType$3, tag: ""}, {prop: "csema", name: "csema", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "IsStream", name: "IsStream", anonymous: false, exported: true, typ: $Bool, tag: ""}, {prop: "ZeroReadIsEOF", name: "ZeroReadIsEOF", anonymous: false, exported: true, typ: $Bool, tag: ""}, {prop: "isFile", name: "isFile", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "isBlocking", name: "isBlocking", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + semWaiters = {}; + $pkg.ErrNetClosing = errors.New("use of closed network connection"); + $pkg.ErrFileClosing = errors.New("use of closed file"); + $pkg.ErrNoDeadline = errors.New("file type does not support deadline"); + $pkg.ErrTimeout = new TimeoutError.ptr(); + $pkg.TestHookDidWritev = (function(wrote) { + var wrote; + }); + $pkg.Accept4Func = syscall.Accept4; + $pkg.CloseFunc = syscall.Close; + $pkg.AcceptFunc = syscall.Accept; + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["internal/testlog"] = (function() { + var $pkg = {}, $init, atomic, Interface, ptrType, logger, Logger, Stat; + atomic = $packages["sync/atomic"]; + Interface = $pkg.Interface = $newType(8, $kindInterface, "testlog.Interface", true, "internal/testlog", true, null); + ptrType = $ptrType(Interface); + Logger = function() { + var impl; + impl = logger.Load(); + if ($interfaceIsEqual(impl, $ifaceNil)) { + return $ifaceNil; + } + return $assertType(impl, ptrType).$get(); + }; + $pkg.Logger = Logger; + Stat = function(name) { + var log, name, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; log = $f.log; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + log = Logger(); + /* */ if (!($interfaceIsEqual(log, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(log, $ifaceNil))) { */ case 1: + $r = log.Stat(name); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Stat }; } $f.log = log; $f.name = name; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Stat = Stat; + Interface.init([{prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Getenv", name: "Getenv", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Open", name: "Open", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([$String], [], false)}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = atomic.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + logger = new atomic.Value.ptr($ifaceNil); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["os"] = (function() { + var $pkg = {}, $init, errors, js, poll, testlog, io, runtime, sync, atomic, syscall, time, timeout, PathError, SyscallError, LinkError, file, dirInfo, File, FileInfo, FileMode, fileStat, sliceType, ptrType, sliceType$1, ptrType$1, sliceType$2, ptrType$2, ptrType$3, ptrType$4, sliceType$5, ptrType$12, ptrType$13, funcType$1, ptrType$15, arrayType$2, arrayType$5, ptrType$16, errFinished, lstat, runtime_args, init, NewSyscallError, IsNotExist, underlyingError, wrapSyscallError, isNotExist, sigpipe, syscallMode, NewFile, newFile, epipecheck, basename, init$1, Lstat, fillFileStatFromSys, timespecToTime, lstatNolog; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + poll = $packages["internal/poll"]; + testlog = $packages["internal/testlog"]; + io = $packages["io"]; + runtime = $packages["runtime"]; + sync = $packages["sync"]; + atomic = $packages["sync/atomic"]; + syscall = $packages["syscall"]; + time = $packages["time"]; + timeout = $pkg.timeout = $newType(8, $kindInterface, "os.timeout", true, "os", false, null); + PathError = $pkg.PathError = $newType(0, $kindStruct, "os.PathError", true, "os", true, function(Op_, Path_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Op = ""; + this.Path = ""; + this.Err = $ifaceNil; + return; + } + this.Op = Op_; + this.Path = Path_; + this.Err = Err_; + }); + SyscallError = $pkg.SyscallError = $newType(0, $kindStruct, "os.SyscallError", true, "os", true, function(Syscall_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Syscall = ""; + this.Err = $ifaceNil; + return; + } + this.Syscall = Syscall_; + this.Err = Err_; + }); + LinkError = $pkg.LinkError = $newType(0, $kindStruct, "os.LinkError", true, "os", true, function(Op_, Old_, New_, Err_) { + this.$val = this; + if (arguments.length === 0) { + this.Op = ""; + this.Old = ""; + this.New = ""; + this.Err = $ifaceNil; + return; + } + this.Op = Op_; + this.Old = Old_; + this.New = New_; + this.Err = Err_; + }); + file = $pkg.file = $newType(0, $kindStruct, "os.file", true, "os", false, function(pfd_, name_, dirinfo_, nonblock_, stdoutOrErr_) { + this.$val = this; + if (arguments.length === 0) { + this.pfd = new poll.FD.ptr(new poll.fdMutex.ptr(new $Uint64(0, 0), 0, 0), 0, new poll.pollDesc.ptr(false), ptrType$12.nil, 0, false, false, false, false); + this.name = ""; + this.dirinfo = ptrType$1.nil; + this.nonblock = false; + this.stdoutOrErr = false; + return; + } + this.pfd = pfd_; + this.name = name_; + this.dirinfo = dirinfo_; + this.nonblock = nonblock_; + this.stdoutOrErr = stdoutOrErr_; + }); + dirInfo = $pkg.dirInfo = $newType(0, $kindStruct, "os.dirInfo", true, "os", false, function(buf_, nbuf_, bufp_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = sliceType$2.nil; + this.nbuf = 0; + this.bufp = 0; + return; + } + this.buf = buf_; + this.nbuf = nbuf_; + this.bufp = bufp_; + }); + File = $pkg.File = $newType(0, $kindStruct, "os.File", true, "os", true, function(file_) { + this.$val = this; + if (arguments.length === 0) { + this.file = ptrType$13.nil; + return; + } + this.file = file_; + }); + FileInfo = $pkg.FileInfo = $newType(8, $kindInterface, "os.FileInfo", true, "os", true, null); + FileMode = $pkg.FileMode = $newType(4, $kindUint32, "os.FileMode", true, "os", true, null); + fileStat = $pkg.fileStat = $newType(0, $kindStruct, "os.fileStat", true, "os", false, function(name_, size_, mode_, modTime_, sys_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.size = new $Int64(0, 0); + this.mode = 0; + this.modTime = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil); + this.sys = new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$2.zero()); + return; + } + this.name = name_; + this.size = size_; + this.mode = mode_; + this.modTime = modTime_; + this.sys = sys_; + }); + sliceType = $sliceType($String); + ptrType = $ptrType(File); + sliceType$1 = $sliceType(FileInfo); + ptrType$1 = $ptrType(dirInfo); + sliceType$2 = $sliceType($Uint8); + ptrType$2 = $ptrType(PathError); + ptrType$3 = $ptrType(LinkError); + ptrType$4 = $ptrType(SyscallError); + sliceType$5 = $sliceType(syscall.Iovec); + ptrType$12 = $ptrType(sliceType$5); + ptrType$13 = $ptrType(file); + funcType$1 = $funcType([ptrType$13], [$error], false); + ptrType$15 = $ptrType(time.Location); + arrayType$2 = $arrayType($Int64, 3); + arrayType$5 = $arrayType($Uint8, 32); + ptrType$16 = $ptrType(fileStat); + runtime_args = function() { + return $pkg.Args; + }; + init = function() { + var argv, i, process; + process = $global.process; + if (!(process === undefined)) { + argv = process.argv; + $pkg.Args = $makeSlice(sliceType, ($parseInt(argv.length) - 1 >> 0)); + i = 0; + while (true) { + if (!(i < ($parseInt(argv.length) - 1 >> 0))) { break; } + ((i < 0 || i >= $pkg.Args.$length) ? ($throwRuntimeError("index out of range"), undefined) : $pkg.Args.$array[$pkg.Args.$offset + i] = $internalize(argv[(i + 1 >> 0)], $String)); + i = i + (1) >> 0; + } + } + if ($pkg.Args.$length === 0) { + $pkg.Args = new sliceType(["?"]); + } + }; + File.ptr.prototype.Readdir = function(n) { + var _r, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f === ptrType.nil) { + $s = -1; return [sliceType$1.nil, $pkg.ErrInvalid]; + } + _r = f.readdir(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdir }; } $f._r = _r; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Readdir = function(n) { return this.$val.Readdir(n); }; + File.ptr.prototype.Readdirnames = function(n) { + var _r, _tmp, _tmp$1, _tuple, err, f, n, names, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + names = sliceType.nil; + err = $ifaceNil; + f = this; + if (f === ptrType.nil) { + _tmp = sliceType.nil; + _tmp$1 = $pkg.ErrInvalid; + names = _tmp; + err = _tmp$1; + $s = -1; return [names, err]; + } + _r = f.readdirnames(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + names = _tuple[0]; + err = _tuple[1]; + $s = -1; return [names, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdirnames }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Readdirnames = function(n) { return this.$val.Readdirnames(n); }; + File.ptr.prototype.readdir = function(n) { + var _i, _r, _r$1, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, dirname, err, f, fi, filename, fip, lerr, n, names, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; dirname = $f.dirname; err = $f.err; f = $f.f; fi = $f.fi; filename = $f.filename; fip = $f.fip; lerr = $f.lerr; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fi = sliceType$1.nil; + err = $ifaceNil; + f = this; + dirname = f.file.name; + if (dirname === "") { + dirname = "."; + } + _r = f.Readdirnames(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + names = _tuple[0]; + err = _tuple[1]; + fi = $makeSlice(sliceType$1, 0, names.$length); + _ref = names; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + filename = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + _r$1 = lstat(dirname + "/" + filename); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + fip = _tuple$1[0]; + lerr = _tuple$1[1]; + if (IsNotExist(lerr)) { + _i++; + /* continue; */ $s = 2; continue; + } + if (!($interfaceIsEqual(lerr, $ifaceNil))) { + _tmp = fi; + _tmp$1 = lerr; + fi = _tmp; + err = _tmp$1; + $s = -1; return [fi, err]; + } + fi = $append(fi, fip); + _i++; + /* } */ $s = 2; continue; case 3: + if ((fi.$length === 0) && $interfaceIsEqual(err, $ifaceNil) && n > 0) { + err = io.EOF; + } + _tmp$2 = fi; + _tmp$3 = err; + fi = _tmp$2; + err = _tmp$3; + $s = -1; return [fi, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdir }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.dirname = dirname; $f.err = err; $f.f = f; $f.fi = fi; $f.filename = filename; $f.fip = fip; $f.lerr = lerr; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.readdir = function(n) { return this.$val.readdir(n); }; + File.ptr.prototype.readdirnames = function(n) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, d, err, errno, f, n, names, nb, nc, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; d = $f.d; err = $f.err; errno = $f.errno; f = $f.f; n = $f.n; names = $f.names; nb = $f.nb; nc = $f.nc; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + names = sliceType.nil; + err = $ifaceNil; + f = this; + if (f.file.dirinfo === ptrType$1.nil) { + f.file.dirinfo = new dirInfo.ptr(sliceType$2.nil, 0, 0); + f.file.dirinfo.buf = $makeSlice(sliceType$2, 4096); + } + d = f.file.dirinfo; + size = n; + if (size <= 0) { + size = 100; + n = -1; + } + names = $makeSlice(sliceType, 0, size); + /* while (true) { */ case 1: + /* if (!(!((n === 0)))) { break; } */ if(!(!((n === 0)))) { $s = 2; continue; } + /* */ if (d.bufp >= d.nbuf) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (d.bufp >= d.nbuf) { */ case 3: + d.bufp = 0; + errno = $ifaceNil; + _r = f.file.pfd.ReadDirent(d.buf); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + d.nbuf = _tuple[0]; + errno = _tuple[1]; + runtime.KeepAlive(f); + if (!($interfaceIsEqual(errno, $ifaceNil))) { + _tmp = names; + _tmp$1 = wrapSyscallError("readdirent", errno); + names = _tmp; + err = _tmp$1; + $s = -1; return [names, err]; + } + if (d.nbuf <= 0) { + /* break; */ $s = 2; continue; + } + /* } */ case 4: + _tmp$2 = 0; + _tmp$3 = 0; + nb = _tmp$2; + nc = _tmp$3; + _tuple$1 = syscall.ParseDirent($subslice(d.buf, d.bufp, d.nbuf), n, names); + nb = _tuple$1[0]; + nc = _tuple$1[1]; + names = _tuple$1[2]; + d.bufp = d.bufp + (nb) >> 0; + n = n - (nc) >> 0; + /* } */ $s = 1; continue; case 2: + if (n >= 0 && (names.$length === 0)) { + _tmp$4 = names; + _tmp$5 = io.EOF; + names = _tmp$4; + err = _tmp$5; + $s = -1; return [names, err]; + } + _tmp$6 = names; + _tmp$7 = $ifaceNil; + names = _tmp$6; + err = _tmp$7; + $s = -1; return [names, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdirnames }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.d = d; $f.err = err; $f.errno = errno; $f.f = f; $f.n = n; $f.names = names; $f.nb = nb; $f.nc = nc; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.readdirnames = function(n) { return this.$val.readdirnames(n); }; + PathError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return e.Op + " " + e.Path + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + PathError.prototype.Error = function() { return this.$val.Error(); }; + PathError.ptr.prototype.Timeout = function() { + var _r, _tuple, _v, e, ok, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _v = $f._v; e = $f.e; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _tuple = $assertType(e.Err, timeout, true); + t = _tuple[0]; + ok = _tuple[1]; + if (!(ok)) { _v = false; $s = 1; continue s; } + _r = t.Timeout(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 1: + $s = -1; return _v; + /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Timeout }; } $f._r = _r; $f._tuple = _tuple; $f._v = _v; $f.e = e; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + PathError.prototype.Timeout = function() { return this.$val.Timeout(); }; + SyscallError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return e.Syscall + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + SyscallError.prototype.Error = function() { return this.$val.Error(); }; + SyscallError.ptr.prototype.Timeout = function() { + var _r, _tuple, _v, e, ok, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; _v = $f._v; e = $f.e; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _tuple = $assertType(e.Err, timeout, true); + t = _tuple[0]; + ok = _tuple[1]; + if (!(ok)) { _v = false; $s = 1; continue s; } + _r = t.Timeout(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 1: + $s = -1; return _v; + /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Timeout }; } $f._r = _r; $f._tuple = _tuple; $f._v = _v; $f.e = e; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + SyscallError.prototype.Timeout = function() { return this.$val.Timeout(); }; + NewSyscallError = function(syscall$1, err) { + var err, syscall$1; + if ($interfaceIsEqual(err, $ifaceNil)) { + return $ifaceNil; + } + return new SyscallError.ptr(syscall$1, err); + }; + $pkg.NewSyscallError = NewSyscallError; + IsNotExist = function(err) { + var err; + return isNotExist(err); + }; + $pkg.IsNotExist = IsNotExist; + underlyingError = function(err) { + var _ref, err, err$1, err$2, err$3; + _ref = err; + if ($assertType(_ref, ptrType$2, true)[1]) { + err$1 = _ref.$val; + return err$1.Err; + } else if ($assertType(_ref, ptrType$3, true)[1]) { + err$2 = _ref.$val; + return err$2.Err; + } else if ($assertType(_ref, ptrType$4, true)[1]) { + err$3 = _ref.$val; + return err$3.Err; + } + return err; + }; + wrapSyscallError = function(name, err) { + var _tuple, err, name, ok; + _tuple = $assertType(err, syscall.Errno, true); + ok = _tuple[1]; + if (ok) { + err = NewSyscallError(name, err); + } + return err; + }; + isNotExist = function(err) { + var err; + err = underlyingError(err); + return $interfaceIsEqual(err, new syscall.Errno(2)) || $interfaceIsEqual(err, $pkg.ErrNotExist); + }; + File.ptr.prototype.Name = function() { + var f; + f = this; + return f.file.name; + }; + File.prototype.Name = function() { return this.$val.Name(); }; + LinkError.ptr.prototype.Error = function() { + var _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return e.Op + " " + e.Old + " " + e.New + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: LinkError.ptr.prototype.Error }; } $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + LinkError.prototype.Error = function() { return this.$val.Error(); }; + File.ptr.prototype.Read = function(b) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("read"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + _r = f.read(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + e = _tuple[1]; + _tmp$2 = n; + _tmp$3 = f.wrapErr("read", e); + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Read }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Read = function(b) { return this.$val.Read(b); }; + File.ptr.prototype.ReadAt = function(b, off) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, m, n, off, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; m = $f.m; n = $f.n; off = $f.off; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("read"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { + _tmp$2 = 0; + _tmp$3 = new PathError.ptr("readat", f.file.name, errors.New("negative offset")); + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + /* while (true) { */ case 1: + /* if (!(b.$length > 0)) { break; } */ if(!(b.$length > 0)) { $s = 2; continue; } + _r = f.pread(b, off); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + e = _tuple[1]; + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = f.wrapErr("read", e); + /* break; */ $s = 2; continue; + } + n = n + (m) >> 0; + b = $subslice(b, m); + off = (x = (new $Int64(0, m)), new $Int64(off.$high + x.$high, off.$low + x.$low)); + /* } */ $s = 1; continue; case 2: + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.ReadAt }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.m = m; $f.n = n; $f.off = off; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; + File.ptr.prototype.Write = function(b) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("write"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + _r = f.write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + e = _tuple[1]; + if (n < 0) { + n = 0; + } + if (!((n === b.$length))) { + err = io.ErrShortWrite; + } + epipecheck(f, e); + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = f.wrapErr("write", e); + } + _tmp$2 = n; + _tmp$3 = err; + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Write }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Write = function(b) { return this.$val.Write(b); }; + File.ptr.prototype.WriteAt = function(b, off) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, err$1, f, m, n, off, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; m = $f.m; n = $f.n; off = $f.off; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + err$1 = f.checkValid("write"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = 0; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + } + if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) { + _tmp$2 = 0; + _tmp$3 = new PathError.ptr("writeat", f.file.name, errors.New("negative offset")); + n = _tmp$2; + err = _tmp$3; + $s = -1; return [n, err]; + } + /* while (true) { */ case 1: + /* if (!(b.$length > 0)) { break; } */ if(!(b.$length > 0)) { $s = 2; continue; } + _r = f.pwrite(b, off); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = _tuple[0]; + e = _tuple[1]; + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = f.wrapErr("write", e); + /* break; */ $s = 2; continue; + } + n = n + (m) >> 0; + b = $subslice(b, m); + off = (x = (new $Int64(0, m)), new $Int64(off.$high + x.$high, off.$low + x.$low)); + /* } */ $s = 1; continue; case 2: + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.WriteAt }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.m = m; $f.n = n; $f.off = off; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.WriteAt = function(b, off) { return this.$val.WriteAt(b, off); }; + File.ptr.prototype.Seek = function(offset, whence) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, e, err, err$1, f, offset, r, ret, whence, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; e = $f.e; err = $f.err; err$1 = $f.err$1; f = $f.f; offset = $f.offset; r = $f.r; ret = $f.ret; whence = $f.whence; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ret = new $Int64(0, 0); + err = $ifaceNil; + f = this; + err$1 = f.checkValid("seek"); + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp = new $Int64(0, 0); + _tmp$1 = err$1; + ret = _tmp; + err = _tmp$1; + $s = -1; return [ret, err]; + } + _r = f.seek(offset, whence); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + e = _tuple[1]; + if ($interfaceIsEqual(e, $ifaceNil) && !(f.file.dirinfo === ptrType$1.nil) && !((r.$high === 0 && r.$low === 0))) { + e = new syscall.Errno(21); + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tmp$2 = new $Int64(0, 0); + _tmp$3 = f.wrapErr("seek", e); + ret = _tmp$2; + err = _tmp$3; + $s = -1; return [ret, err]; + } + _tmp$4 = r; + _tmp$5 = $ifaceNil; + ret = _tmp$4; + err = _tmp$5; + $s = -1; return [ret, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Seek }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.offset = offset; $f.r = r; $f.ret = ret; $f.whence = whence; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + File.ptr.prototype.WriteString = function(s) { + var _r, _tuple, err, f, n, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; f = $f.f; n = $f.n; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.Write((new sliceType$2($stringToBytes(s)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.WriteString }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.n = n; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + File.ptr.prototype.wrapErr = function(op, err) { + var err, f, op; + f = this; + if ($interfaceIsEqual(err, $ifaceNil) || $interfaceIsEqual(err, io.EOF)) { + return err; + } + if ($interfaceIsEqual(err, poll.ErrFileClosing)) { + err = $pkg.ErrClosed; + } + return new PathError.ptr(op, f.file.name, err); + }; + File.prototype.wrapErr = function(op, err) { return this.$val.wrapErr(op, err); }; + File.ptr.prototype.Chmod = function(mode) { + var _r, f, mode, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; mode = $f.mode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = f.chmod(mode); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chmod }; } $f._r = _r; $f.f = f; $f.mode = mode; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Chmod = function(mode) { return this.$val.Chmod(mode); }; + File.ptr.prototype.SetDeadline = function(t) { + var f, t; + f = this; + return f.setDeadline($clone(t, time.Time)); + }; + File.prototype.SetDeadline = function(t) { return this.$val.SetDeadline(t); }; + File.ptr.prototype.SetReadDeadline = function(t) { + var f, t; + f = this; + return f.setReadDeadline($clone(t, time.Time)); + }; + File.prototype.SetReadDeadline = function(t) { return this.$val.SetReadDeadline(t); }; + File.ptr.prototype.SetWriteDeadline = function(t) { + var f, t; + f = this; + return f.setWriteDeadline($clone(t, time.Time)); + }; + File.prototype.SetWriteDeadline = function(t) { return this.$val.SetWriteDeadline(t); }; + sigpipe = function() { + $throwRuntimeError("native function not implemented: os.sigpipe"); + }; + syscallMode = function(i) { + var i, o; + o = 0; + o = (o | (((new FileMode(i).Perm() >>> 0)))) >>> 0; + if (!((((i & 8388608) >>> 0) === 0))) { + o = (o | (2048)) >>> 0; + } + if (!((((i & 4194304) >>> 0) === 0))) { + o = (o | (1024)) >>> 0; + } + if (!((((i & 1048576) >>> 0) === 0))) { + o = (o | (512)) >>> 0; + } + return o; + }; + File.ptr.prototype.chmod = function(mode) { + var _r, e, err, f, mode, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; mode = $f.mode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("chmod"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fchmod(syscallMode(mode)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("chmod", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.chmod }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.mode = mode; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.chmod = function(mode) { return this.$val.chmod(mode); }; + File.ptr.prototype.Chown = function(uid, gid) { + var _r, e, err, f, gid, uid, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; gid = $f.gid; uid = $f.uid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("chown"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fchown(uid, gid); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("chown", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chown }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.gid = gid; $f.uid = uid; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Chown = function(uid, gid) { return this.$val.Chown(uid, gid); }; + File.ptr.prototype.Truncate = function(size) { + var _r, e, err, f, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("truncate"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Ftruncate(size); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("truncate", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Truncate }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Truncate = function(size) { return this.$val.Truncate(size); }; + File.ptr.prototype.Sync = function() { + var _r, e, err, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("sync"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fsync(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("sync", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Sync }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Sync = function() { return this.$val.Sync(); }; + File.ptr.prototype.Chdir = function() { + var _r, e, err, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + err = f.checkValid("chdir"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return err; + } + _r = f.file.pfd.Fchdir(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + $s = -1; return f.wrapErr("chdir", e); + } + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Chdir }; } $f._r = _r; $f.e = e; $f.err = err; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Chdir = function() { return this.$val.Chdir(); }; + File.ptr.prototype.setDeadline = function(t) { + var err, f, t; + f = this; + err = f.checkValid("SetDeadline"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + return f.file.pfd.SetDeadline($clone(t, time.Time)); + }; + File.prototype.setDeadline = function(t) { return this.$val.setDeadline(t); }; + File.ptr.prototype.setReadDeadline = function(t) { + var err, f, t; + f = this; + err = f.checkValid("SetReadDeadline"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + return f.file.pfd.SetReadDeadline($clone(t, time.Time)); + }; + File.prototype.setReadDeadline = function(t) { return this.$val.setReadDeadline(t); }; + File.ptr.prototype.setWriteDeadline = function(t) { + var err, f, t; + f = this; + err = f.checkValid("SetWriteDeadline"); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + return f.file.pfd.SetWriteDeadline($clone(t, time.Time)); + }; + File.prototype.setWriteDeadline = function(t) { return this.$val.setWriteDeadline(t); }; + File.ptr.prototype.checkValid = function(op) { + var f, op; + f = this; + if (f === ptrType.nil) { + return $pkg.ErrInvalid; + } + return $ifaceNil; + }; + File.prototype.checkValid = function(op) { return this.$val.checkValid(op); }; + File.ptr.prototype.Fd = function() { + var _r, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f === ptrType.nil) { + $s = -1; return 4294967295; + } + /* */ if (f.file.nonblock) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (f.file.nonblock) { */ case 1: + _r = f.file.pfd.SetBlocking(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + /* } */ case 2: + $s = -1; return ((f.file.pfd.Sysfd >>> 0)); + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Fd }; } $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Fd = function() { return this.$val.Fd(); }; + NewFile = function(fd, name) { + var fd, name; + return newFile(fd, name, 0); + }; + $pkg.NewFile = NewFile; + newFile = function(fd, name, kind) { + var err, err$1, f, fd, fdi, kind, name, pollable; + fdi = ((fd >> 0)); + if (fdi < 0) { + return ptrType.nil; + } + f = new File.ptr(new file.ptr(new poll.FD.ptr(new poll.fdMutex.ptr(new $Uint64(0, 0), 0, 0), fdi, new poll.pollDesc.ptr(false), ptrType$12.nil, 0, true, true, false, false), name, ptrType$1.nil, false, (fdi === 1) || (fdi === 2))); + if (false && (kind === 1)) { + kind = 0; + } + pollable = (kind === 1) || (kind === 2); + err = f.file.pfd.Init("file", pollable); + if (!($interfaceIsEqual(err, $ifaceNil))) { + } else if (pollable) { + err$1 = syscall.SetNonblock(fdi, true); + if ($interfaceIsEqual(err$1, $ifaceNil)) { + f.file.nonblock = true; + } + } + runtime.SetFinalizer(f.file, new funcType$1($methodExpr(ptrType$13, "close"))); + return f; + }; + epipecheck = function(file$1, e) { + var e, file$1; + if ($interfaceIsEqual(e, new syscall.Errno(32)) && file$1.file.stdoutOrErr) { + sigpipe(); + } + }; + File.ptr.prototype.Close = function() { + var _r, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f === ptrType.nil) { + $s = -1; return $pkg.ErrInvalid; + } + _r = f.file.close(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Close }; } $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Close = function() { return this.$val.Close(); }; + file.ptr.prototype.close = function() { + var _r, e, err, file$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; e = $f.e; err = $f.err; file$1 = $f.file$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + file$1 = this; + if (file$1 === ptrType$13.nil) { + $s = -1; return new syscall.Errno(22); + } + err = $ifaceNil; + _r = file$1.pfd.Close(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + e = _r; + if (!($interfaceIsEqual(e, $ifaceNil))) { + if ($interfaceIsEqual(e, poll.ErrFileClosing)) { + e = $pkg.ErrClosed; + } + err = new PathError.ptr("close", file$1.name, e); + } + runtime.SetFinalizer(file$1, $ifaceNil); + $s = -1; return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: file.ptr.prototype.close }; } $f._r = _r; $f.e = e; $f.err = err; $f.file$1 = file$1; $f.$s = $s; $f.$r = $r; return $f; + }; + file.prototype.close = function() { return this.$val.close(); }; + File.ptr.prototype.read = function(b) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Read(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.read }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.read = function(b) { return this.$val.read(b); }; + File.ptr.prototype.pread = function(b, off) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, off, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; off = $f.off; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Pread(b, off); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.pread }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.off = off; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.pread = function(b, off) { return this.$val.pread(b, off); }; + File.ptr.prototype.write = function(b) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.write }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.write = function(b) { return this.$val.write(b); }; + File.ptr.prototype.pwrite = function(b, off) { + var _r, _tmp, _tmp$1, _tuple, b, err, f, n, off, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; f = $f.f; n = $f.n; off = $f.off; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + f = this; + _r = f.file.pfd.Pwrite(b, off); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = n; + _tmp$1 = err; + n = _tmp; + err = _tmp$1; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.pwrite }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.f = f; $f.n = n; $f.off = off; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.pwrite = function(b, off) { return this.$val.pwrite(b, off); }; + File.ptr.prototype.seek = function(offset, whence) { + var _r, _tmp, _tmp$1, _tuple, err, f, offset, ret, whence, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; offset = $f.offset; ret = $f.ret; whence = $f.whence; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + ret = new $Int64(0, 0); + err = $ifaceNil; + f = this; + _r = f.file.pfd.Seek(offset, whence); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + ret = _tuple[0]; + err = _tuple[1]; + runtime.KeepAlive(f); + _tmp = ret; + _tmp$1 = err; + ret = _tmp; + err = _tmp$1; + $s = -1; return [ret, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.seek }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.offset = offset; $f.ret = ret; $f.whence = whence; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.seek = function(offset, whence) { return this.$val.seek(offset, whence); }; + basename = function(name) { + var i, name; + i = name.length - 1 >> 0; + while (true) { + if (!(i > 0 && (name.charCodeAt(i) === 47))) { break; } + name = $substring(name, 0, i); + i = i - (1) >> 0; + } + i = i - (1) >> 0; + while (true) { + if (!(i >= 0)) { break; } + if (name.charCodeAt(i) === 47) { + name = $substring(name, (i + 1 >> 0)); + break; + } + i = i - (1) >> 0; + } + return name; + }; + init$1 = function() { + if (false) { + return; + } + $pkg.Args = runtime_args(); + }; + Lstat = function(name) { + var name, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = testlog.Stat(name); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return lstatNolog(name); + /* */ } return; } if ($f === undefined) { $f = { $blk: Lstat }; } $f.name = name; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Lstat = Lstat; + fillFileStatFromSys = function(fs, name) { + var _1, fs, name; + fs.name = basename(name); + fs.size = fs.sys.Size; + time.Time.copy(fs.modTime, timespecToTime($clone(fs.sys.Mtim, syscall.Timespec))); + fs.mode = ((((fs.sys.Mode & 511) >>> 0) >>> 0)); + _1 = (fs.sys.Mode & 61440) >>> 0; + if (_1 === (24576)) { + fs.mode = (fs.mode | (67108864)) >>> 0; + } else if (_1 === (8192)) { + fs.mode = (fs.mode | (69206016)) >>> 0; + } else if (_1 === (16384)) { + fs.mode = (fs.mode | (2147483648)) >>> 0; + } else if (_1 === (4096)) { + fs.mode = (fs.mode | (33554432)) >>> 0; + } else if (_1 === (40960)) { + fs.mode = (fs.mode | (134217728)) >>> 0; + } else if (_1 === (32768)) { + } else if (_1 === (49152)) { + fs.mode = (fs.mode | (16777216)) >>> 0; + } + if (!((((fs.sys.Mode & 1024) >>> 0) === 0))) { + fs.mode = (fs.mode | (4194304)) >>> 0; + } + if (!((((fs.sys.Mode & 2048) >>> 0) === 0))) { + fs.mode = (fs.mode | (8388608)) >>> 0; + } + if (!((((fs.sys.Mode & 512) >>> 0) === 0))) { + fs.mode = (fs.mode | (1048576)) >>> 0; + } + }; + timespecToTime = function(ts) { + var ts; + return time.Unix((ts.Sec), (ts.Nsec)); + }; + File.ptr.prototype.Stat = function() { + var _r, err, f, fs, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; f = $f.f; fs = $f.fs; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fs = [fs]; + f = this; + if (f === ptrType.nil) { + $s = -1; return [$ifaceNil, $pkg.ErrInvalid]; + } + fs[0] = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil), new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$2.zero())); + _r = f.file.pfd.Fstat(fs[0].sys); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + if (!($interfaceIsEqual(err, $ifaceNil))) { + $s = -1; return [$ifaceNil, new PathError.ptr("stat", f.file.name, err)]; + } + fillFileStatFromSys(fs[0], f.file.name); + $s = -1; return [fs[0], $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Stat }; } $f._r = _r; $f.err = err; $f.f = f; $f.fs = fs; $f.$s = $s; $f.$r = $r; return $f; + }; + File.prototype.Stat = function() { return this.$val.Stat(); }; + lstatNolog = function(name) { + var err, fs, name; + fs = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$15.nil), new syscall.Stat_t.ptr(new $Uint64(0, 0), new $Uint64(0, 0), new $Uint64(0, 0), 0, 0, 0, 0, new $Uint64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new $Int64(0, 0), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), new syscall.Timespec.ptr(new $Int64(0, 0), new $Int64(0, 0)), arrayType$2.zero())); + err = syscall.Lstat(name, fs.sys); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [$ifaceNil, new PathError.ptr("lstat", name, err)]; + } + fillFileStatFromSys(fs, name); + return [fs, $ifaceNil]; + }; + FileMode.prototype.String = function() { + var _i, _i$1, _ref, _ref$1, _rune, _rune$1, buf, c, c$1, i, i$1, m, w, y, y$1; + m = this.$val; + buf = arrayType$5.zero(); + w = 0; + _ref = "dalTLDpSugct"; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + c = _rune[0]; + if (!((((m & (((y = (((31 - i >> 0) >>> 0)), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0) === 0))) { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = ((c << 24 >>> 24))); + w = w + (1) >> 0; + } + _i += _rune[1]; + } + if (w === 0) { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); + w = w + (1) >> 0; + } + _ref$1 = "rwxrwxrwx"; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.length)) { break; } + _rune$1 = $decodeRune(_ref$1, _i$1); + i$1 = _i$1; + c$1 = _rune$1[0]; + if (!((((m & (((y$1 = (((8 - i$1 >> 0) >>> 0)), y$1 < 32 ? (1 << y$1) : 0) >>> 0))) >>> 0) === 0))) { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = ((c$1 << 24 >>> 24))); + } else { + ((w < 0 || w >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[w] = 45); + } + w = w + (1) >> 0; + _i$1 += _rune$1[1]; + } + return ($bytesToString($subslice(new sliceType$2(buf), 0, w))); + }; + $ptrType(FileMode).prototype.String = function() { return new FileMode(this.$get()).String(); }; + FileMode.prototype.IsDir = function() { + var m; + m = this.$val; + return !((((m & 2147483648) >>> 0) === 0)); + }; + $ptrType(FileMode).prototype.IsDir = function() { return new FileMode(this.$get()).IsDir(); }; + FileMode.prototype.IsRegular = function() { + var m; + m = this.$val; + return ((m & 2399141888) >>> 0) === 0; + }; + $ptrType(FileMode).prototype.IsRegular = function() { return new FileMode(this.$get()).IsRegular(); }; + FileMode.prototype.Perm = function() { + var m; + m = this.$val; + return (m & 511) >>> 0; + }; + $ptrType(FileMode).prototype.Perm = function() { return new FileMode(this.$get()).Perm(); }; + fileStat.ptr.prototype.Name = function() { + var fs; + fs = this; + return fs.name; + }; + fileStat.prototype.Name = function() { return this.$val.Name(); }; + fileStat.ptr.prototype.IsDir = function() { + var fs; + fs = this; + return new FileMode(fs.Mode()).IsDir(); + }; + fileStat.prototype.IsDir = function() { return this.$val.IsDir(); }; + fileStat.ptr.prototype.Size = function() { + var fs; + fs = this; + return fs.size; + }; + fileStat.prototype.Size = function() { return this.$val.Size(); }; + fileStat.ptr.prototype.Mode = function() { + var fs; + fs = this; + return fs.mode; + }; + fileStat.prototype.Mode = function() { return this.$val.Mode(); }; + fileStat.ptr.prototype.ModTime = function() { + var fs; + fs = this; + return fs.modTime; + }; + fileStat.prototype.ModTime = function() { return this.$val.ModTime(); }; + fileStat.ptr.prototype.Sys = function() { + var fs; + fs = this; + return fs.sys; + }; + fileStat.prototype.Sys = function() { return this.$val.Sys(); }; + ptrType$2.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$3.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$13.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [$error], false)}]; + ptrType.methods = [{prop: "Readdir", name: "Readdir", pkg: "", typ: $funcType([$Int], [sliceType$1, $error], false)}, {prop: "Readdirnames", name: "Readdirnames", pkg: "", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "readdir", name: "readdir", pkg: "os", typ: $funcType([$Int], [sliceType$1, $error], false)}, {prop: "readdirnames", name: "readdirnames", pkg: "os", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "WriteAt", name: "WriteAt", pkg: "", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "wrapErr", name: "wrapErr", pkg: "os", typ: $funcType([$String, $error], [$error], false)}, {prop: "Chmod", name: "Chmod", pkg: "", typ: $funcType([FileMode], [$error], false)}, {prop: "SetDeadline", name: "SetDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetReadDeadline", name: "SetReadDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "SetWriteDeadline", name: "SetWriteDeadline", pkg: "", typ: $funcType([time.Time], [$error], false)}, {prop: "chmod", name: "chmod", pkg: "os", typ: $funcType([FileMode], [$error], false)}, {prop: "Chown", name: "Chown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Sync", name: "Sync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "setDeadline", name: "setDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "setReadDeadline", name: "setReadDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "setWriteDeadline", name: "setWriteDeadline", pkg: "os", typ: $funcType([time.Time], [$error], false)}, {prop: "checkValid", name: "checkValid", pkg: "os", typ: $funcType([$String], [$error], false)}, {prop: "Fd", name: "Fd", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "read", name: "read", pkg: "os", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "pread", name: "pread", pkg: "os", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "write", name: "write", pkg: "os", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "pwrite", name: "pwrite", pkg: "os", typ: $funcType([sliceType$2, $Int64], [$Int, $error], false)}, {prop: "seek", name: "seek", pkg: "os", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([], [FileInfo, $error], false)}]; + FileMode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsRegular", name: "IsRegular", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([], [FileMode], false)}]; + ptrType$16.methods = [{prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]; + timeout.init([{prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}]); + PathError.init("", [{prop: "Op", name: "Op", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Path", name: "Path", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", anonymous: false, exported: true, typ: $error, tag: ""}]); + SyscallError.init("", [{prop: "Syscall", name: "Syscall", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", anonymous: false, exported: true, typ: $error, tag: ""}]); + LinkError.init("", [{prop: "Op", name: "Op", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Old", name: "Old", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "New", name: "New", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Err", name: "Err", anonymous: false, exported: true, typ: $error, tag: ""}]); + file.init("os", [{prop: "pfd", name: "pfd", anonymous: false, exported: false, typ: poll.FD, tag: ""}, {prop: "name", name: "name", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "dirinfo", name: "dirinfo", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "nonblock", name: "nonblock", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "stdoutOrErr", name: "stdoutOrErr", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + dirInfo.init("os", [{prop: "buf", name: "buf", anonymous: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "nbuf", name: "nbuf", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "bufp", name: "bufp", anonymous: false, exported: false, typ: $Int, tag: ""}]); + File.init("os", [{prop: "file", name: "file", anonymous: true, exported: false, typ: ptrType$13, tag: ""}]); + FileInfo.init([{prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]); + fileStat.init("os", [{prop: "name", name: "name", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "size", name: "size", anonymous: false, exported: false, typ: $Int64, tag: ""}, {prop: "mode", name: "mode", anonymous: false, exported: false, typ: FileMode, tag: ""}, {prop: "modTime", name: "modTime", anonymous: false, exported: false, typ: time.Time, tag: ""}, {prop: "sys", name: "sys", anonymous: false, exported: false, typ: syscall.Stat_t, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = poll.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = testlog.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.Args = sliceType.nil; + $pkg.ErrInvalid = errors.New("invalid argument"); + $pkg.ErrPermission = errors.New("permission denied"); + $pkg.ErrExist = errors.New("file already exists"); + $pkg.ErrNotExist = errors.New("file does not exist"); + $pkg.ErrClosed = errors.New("file already closed"); + errFinished = errors.New("os: process already finished"); + $pkg.Stdin = NewFile(((syscall.Stdin >>> 0)), "/dev/stdin"); + $pkg.Stdout = NewFile(((syscall.Stdout >>> 0)), "/dev/stdout"); + $pkg.Stderr = NewFile(((syscall.Stderr >>> 0)), "/dev/stderr"); + lstat = Lstat; + init(); + init$1(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["unicode/utf8"] = (function() { + var $pkg = {}, $init, acceptRange, first, acceptRanges, DecodeRuneInString, RuneLen, EncodeRune, RuneCount, RuneCountInString, ValidRune; + acceptRange = $pkg.acceptRange = $newType(0, $kindStruct, "utf8.acceptRange", true, "unicode/utf8", false, function(lo_, hi_) { + this.$val = this; + if (arguments.length === 0) { + this.lo = 0; + this.hi = 0; + return; + } + this.lo = lo_; + this.hi = hi_; + }); + DecodeRuneInString = function(s) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, accept, mask, n, r, s, s0, s1, s2, s3, size, sz, x, x$1; + r = 0; + size = 0; + n = s.length; + if (n < 1) { + _tmp = 65533; + _tmp$1 = 0; + r = _tmp; + size = _tmp$1; + return [r, size]; + } + s0 = s.charCodeAt(0); + x = ((s0 < 0 || s0 >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[s0]); + if (x >= 240) { + mask = (((x >> 0)) << 31 >> 0) >> 31 >> 0; + _tmp$2 = ((((s.charCodeAt(0) >> 0)) & ~mask) >> 0) | (65533 & mask); + _tmp$3 = 1; + r = _tmp$2; + size = _tmp$3; + return [r, size]; + } + sz = (x & 7) >>> 0; + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + if (n < ((sz >> 0))) { + _tmp$4 = 65533; + _tmp$5 = 1; + r = _tmp$4; + size = _tmp$5; + return [r, size]; + } + s1 = s.charCodeAt(1); + if (s1 < accept.lo || accept.hi < s1) { + _tmp$6 = 65533; + _tmp$7 = 1; + r = _tmp$6; + size = _tmp$7; + return [r, size]; + } + if (sz === 2) { + _tmp$8 = (((((s0 & 31) >>> 0) >> 0)) << 6 >> 0) | ((((s1 & 63) >>> 0) >> 0)); + _tmp$9 = 2; + r = _tmp$8; + size = _tmp$9; + return [r, size]; + } + s2 = s.charCodeAt(2); + if (s2 < 128 || 191 < s2) { + _tmp$10 = 65533; + _tmp$11 = 1; + r = _tmp$10; + size = _tmp$11; + return [r, size]; + } + if (sz === 3) { + _tmp$12 = ((((((s0 & 15) >>> 0) >> 0)) << 12 >> 0) | (((((s1 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((s2 & 63) >>> 0) >> 0)); + _tmp$13 = 3; + r = _tmp$12; + size = _tmp$13; + return [r, size]; + } + s3 = s.charCodeAt(3); + if (s3 < 128 || 191 < s3) { + _tmp$14 = 65533; + _tmp$15 = 1; + r = _tmp$14; + size = _tmp$15; + return [r, size]; + } + _tmp$16 = (((((((s0 & 7) >>> 0) >> 0)) << 18 >> 0) | (((((s1 & 63) >>> 0) >> 0)) << 12 >> 0)) | (((((s2 & 63) >>> 0) >> 0)) << 6 >> 0)) | ((((s3 & 63) >>> 0) >> 0)); + _tmp$17 = 4; + r = _tmp$16; + size = _tmp$17; + return [r, size]; + }; + $pkg.DecodeRuneInString = DecodeRuneInString; + RuneLen = function(r) { + var r; + if (r < 0) { + return -1; + } else if (r <= 127) { + return 1; + } else if (r <= 2047) { + return 2; + } else if (55296 <= r && r <= 57343) { + return -1; + } else if (r <= 65535) { + return 3; + } else if (r <= 1114111) { + return 4; + } + return -1; + }; + $pkg.RuneLen = RuneLen; + EncodeRune = function(p, r) { + var i, p, r; + i = ((r >>> 0)); + if (i <= 127) { + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((r << 24 >>> 24))); + return 1; + } else if (i <= 2047) { + $unused((1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((192 | (((r >> 6 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 2; + } else if ((i > 1114111) || (55296 <= i && i <= 57343)) { + r = 65533; + $unused((2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((224 | (((r >> 12 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 3; + } else if (i <= 65535) { + $unused((2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((224 | (((r >> 12 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 3; + } else { + $unused((3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3])); + (0 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 0] = ((240 | (((r >> 18 >> 0) << 24 >>> 24))) >>> 0)); + (1 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 1] = ((128 | (((((r >> 12 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 2] = ((128 | (((((r >> 6 >> 0) << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + (3 >= p.$length ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + 3] = ((128 | ((((r << 24 >>> 24)) & 63) >>> 0)) >>> 0)); + return 4; + } + }; + $pkg.EncodeRune = EncodeRune; + RuneCount = function(p) { + var accept, c, c$1, c$2, c$3, i, n, np, p, size, x, x$1, x$2, x$3, x$4; + np = p.$length; + n = 0; + i = 0; + while (true) { + if (!(i < np)) { break; } + n = n + (1) >> 0; + c = ((i < 0 || i >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + i]); + if (c < 128) { + i = i + (1) >> 0; + continue; + } + x = ((c < 0 || c >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[c]); + if (x === 241) { + i = i + (1) >> 0; + continue; + } + size = ((((x & 7) >>> 0) >> 0)); + if ((i + size >> 0) > np) { + i = i + (1) >> 0; + continue; + } + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + c$1 = (x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$2])); + if (c$1 < accept.lo || accept.hi < c$1) { + size = 1; + } else if (size === 2) { + } else { + c$2 = (x$3 = i + 2 >> 0, ((x$3 < 0 || x$3 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$3])); + if (c$2 < 128 || 191 < c$2) { + size = 1; + } else if (size === 3) { + } else { + c$3 = (x$4 = i + 3 >> 0, ((x$4 < 0 || x$4 >= p.$length) ? ($throwRuntimeError("index out of range"), undefined) : p.$array[p.$offset + x$4])); + if (c$3 < 128 || 191 < c$3) { + size = 1; + } + } + } + i = i + (size) >> 0; + } + return n; + }; + $pkg.RuneCount = RuneCount; + RuneCountInString = function(s) { + var accept, c, c$1, c$2, c$3, i, n, ns, s, size, x, x$1; + n = 0; + ns = s.length; + i = 0; + while (true) { + if (!(i < ns)) { break; } + c = s.charCodeAt(i); + if (c < 128) { + i = i + (1) >> 0; + n = n + (1) >> 0; + continue; + } + x = ((c < 0 || c >= first.length) ? ($throwRuntimeError("index out of range"), undefined) : first[c]); + if (x === 241) { + i = i + (1) >> 0; + n = n + (1) >> 0; + continue; + } + size = ((((x & 7) >>> 0) >> 0)); + if ((i + size >> 0) > ns) { + i = i + (1) >> 0; + n = n + (1) >> 0; + continue; + } + accept = $clone((x$1 = x >>> 4 << 24 >>> 24, ((x$1 < 0 || x$1 >= acceptRanges.length) ? ($throwRuntimeError("index out of range"), undefined) : acceptRanges[x$1])), acceptRange); + c$1 = s.charCodeAt((i + 1 >> 0)); + if (c$1 < accept.lo || accept.hi < c$1) { + size = 1; + } else if (size === 2) { + } else { + c$2 = s.charCodeAt((i + 2 >> 0)); + if (c$2 < 128 || 191 < c$2) { + size = 1; + } else if (size === 3) { + } else { + c$3 = s.charCodeAt((i + 3 >> 0)); + if (c$3 < 128 || 191 < c$3) { + size = 1; + } + } + } + i = i + (size) >> 0; + n = n + (1) >> 0; + } + n = n; + return n; + }; + $pkg.RuneCountInString = RuneCountInString; + ValidRune = function(r) { + var r; + if (0 <= r && r < 55296) { + return true; + } else if (57343 < r && r <= 1114111) { + return true; + } + return false; + }; + $pkg.ValidRune = ValidRune; + acceptRange.init("unicode/utf8", [{prop: "lo", name: "lo", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "hi", name: "hi", anonymous: false, exported: false, typ: $Uint8, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + first = $toNativeArray($kindUint8, [240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 19, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 35, 3, 3, 52, 4, 4, 4, 68, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241]); + acceptRanges = $toNativeArray($kindStruct, [new acceptRange.ptr(128, 191), new acceptRange.ptr(160, 191), new acceptRange.ptr(128, 159), new acceptRange.ptr(144, 191), new acceptRange.ptr(128, 143)]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["strconv"] = (function() { + var $pkg = {}, $init, errors, math, utf8, decimal, leftCheat, extFloat, floatInfo, decimalSlice, sliceType$3, sliceType$4, sliceType$5, arrayType, sliceType$6, arrayType$1, arrayType$2, ptrType$1, arrayType$3, arrayType$4, ptrType$2, ptrType$3, ptrType$4, optimize, leftcheats, smallPowersOfTen, powersOfTen, uint64pow10, float32info, float32info$24ptr, float64info, float64info$24ptr, isPrint16, isNotPrint16, isPrint32, isNotPrint32, isGraphic, shifts, digitZero, trim, rightShift, prefixIsLessThan, leftShift, shouldRoundUp, frexp10Many, adjustLastDigitFixed, adjustLastDigit, AppendFloat, genericFtoa, bigFtoa, formatDigits, roundShortest, fmtE, fmtF, fmtB, min, max, FormatInt, Itoa, small, formatBits, appendQuotedWith, appendQuotedRuneWith, appendEscapedRune, AppendQuote, AppendQuoteToASCII, AppendQuoteRune, AppendQuoteRuneToASCII, CanBackquote, unhex, UnquoteChar, Unquote, contains, bsearch16, bsearch32, IsPrint, isInGraphicList; + errors = $packages["errors"]; + math = $packages["math"]; + utf8 = $packages["unicode/utf8"]; + decimal = $pkg.decimal = $newType(0, $kindStruct, "strconv.decimal", true, "strconv", false, function(d_, nd_, dp_, neg_, trunc_) { + this.$val = this; + if (arguments.length === 0) { + this.d = arrayType.zero(); + this.nd = 0; + this.dp = 0; + this.neg = false; + this.trunc = false; + return; + } + this.d = d_; + this.nd = nd_; + this.dp = dp_; + this.neg = neg_; + this.trunc = trunc_; + }); + leftCheat = $pkg.leftCheat = $newType(0, $kindStruct, "strconv.leftCheat", true, "strconv", false, function(delta_, cutoff_) { + this.$val = this; + if (arguments.length === 0) { + this.delta = 0; + this.cutoff = ""; + return; + } + this.delta = delta_; + this.cutoff = cutoff_; + }); + extFloat = $pkg.extFloat = $newType(0, $kindStruct, "strconv.extFloat", true, "strconv", false, function(mant_, exp_, neg_) { + this.$val = this; + if (arguments.length === 0) { + this.mant = new $Uint64(0, 0); + this.exp = 0; + this.neg = false; + return; + } + this.mant = mant_; + this.exp = exp_; + this.neg = neg_; + }); + floatInfo = $pkg.floatInfo = $newType(0, $kindStruct, "strconv.floatInfo", true, "strconv", false, function(mantbits_, expbits_, bias_) { + this.$val = this; + if (arguments.length === 0) { + this.mantbits = 0; + this.expbits = 0; + this.bias = 0; + return; + } + this.mantbits = mantbits_; + this.expbits = expbits_; + this.bias = bias_; + }); + decimalSlice = $pkg.decimalSlice = $newType(0, $kindStruct, "strconv.decimalSlice", true, "strconv", false, function(d_, nd_, dp_, neg_) { + this.$val = this; + if (arguments.length === 0) { + this.d = sliceType$6.nil; + this.nd = 0; + this.dp = 0; + this.neg = false; + return; + } + this.d = d_; + this.nd = nd_; + this.dp = dp_; + this.neg = neg_; + }); + sliceType$3 = $sliceType(leftCheat); + sliceType$4 = $sliceType($Uint16); + sliceType$5 = $sliceType($Uint32); + arrayType = $arrayType($Uint8, 800); + sliceType$6 = $sliceType($Uint8); + arrayType$1 = $arrayType($Uint8, 24); + arrayType$2 = $arrayType($Uint8, 32); + ptrType$1 = $ptrType(floatInfo); + arrayType$3 = $arrayType($Uint8, 65); + arrayType$4 = $arrayType($Uint8, 4); + ptrType$2 = $ptrType(decimal); + ptrType$3 = $ptrType(decimalSlice); + ptrType$4 = $ptrType(extFloat); + decimal.ptr.prototype.String = function() { + var a, buf, n, w; + a = this; + n = 10 + a.nd >> 0; + if (a.dp > 0) { + n = n + (a.dp) >> 0; + } + if (a.dp < 0) { + n = n + (-a.dp) >> 0; + } + buf = $makeSlice(sliceType$6, n); + w = 0; + if ((a.nd === 0)) { + return "0"; + } else if (a.dp <= 0) { + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 48); + w = w + (1) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); + w = w + (1) >> 0; + w = w + (digitZero($subslice(buf, w, (w + -a.dp >> 0)))) >> 0; + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0; + } else if (a.dp < a.nd) { + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.dp))) >> 0; + ((w < 0 || w >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + w] = 46); + w = w + (1) >> 0; + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), a.dp, a.nd))) >> 0; + } else { + w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0; + w = w + (digitZero($subslice(buf, w, ((w + a.dp >> 0) - a.nd >> 0)))) >> 0; + } + return ($bytesToString($subslice(buf, 0, w))); + }; + decimal.prototype.String = function() { return this.$val.String(); }; + digitZero = function(dst) { + var _i, _ref, dst, i; + _ref = dst; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= dst.$length) ? ($throwRuntimeError("index out of range"), undefined) : dst.$array[dst.$offset + i] = 48); + _i++; + } + return dst.$length; + }; + trim = function(a) { + var a, x, x$1; + while (true) { + if (!(a.nd > 0 && ((x = a.d, x$1 = a.nd - 1 >> 0, ((x$1 < 0 || x$1 >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[x$1])) === 48))) { break; } + a.nd = a.nd - (1) >> 0; + } + if (a.nd === 0) { + a.dp = 0; + } + }; + decimal.ptr.prototype.Assign = function(v) { + var a, buf, n, v, v1, x, x$1, x$2; + a = this; + buf = arrayType$1.zero(); + n = 0; + while (true) { + if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } + v1 = $div64(v, new $Uint64(0, 10), false); + v = (x = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x.$high, v.$low - x.$low)); + ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n] = ((new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24))); + n = n + (1) >> 0; + v = v1; + } + a.nd = 0; + n = n - (1) >> 0; + while (true) { + if (!(n >= 0)) { break; } + (x$1 = a.d, x$2 = a.nd, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2] = ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n]))); + a.nd = a.nd + (1) >> 0; + n = n - (1) >> 0; + } + a.dp = a.nd; + trim(a); + }; + decimal.prototype.Assign = function(v) { return this.$val.Assign(v); }; + rightShift = function(a, k) { + var a, c, c$1, dig, dig$1, k, mask, n, r, w, x, x$1, x$2, x$3, y, y$1, y$2, y$3, y$4; + r = 0; + w = 0; + n = 0; + while (true) { + if (!(((y = k, y < 32 ? (n >>> y) : 0) >>> 0) === 0)) { break; } + if (r >= a.nd) { + if (n === 0) { + a.nd = 0; + return; + } + while (true) { + if (!(((y$1 = k, y$1 < 32 ? (n >>> y$1) : 0) >>> 0) === 0)) { break; } + n = n * 10 >>> 0; + r = r + (1) >> 0; + } + break; + } + c = (((x = a.d, ((r < 0 || r >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[r])) >>> 0)); + n = ((n * 10 >>> 0) + c >>> 0) - 48 >>> 0; + r = r + (1) >> 0; + } + a.dp = a.dp - ((r - 1 >> 0)) >> 0; + mask = (((y$2 = k, y$2 < 32 ? (1 << y$2) : 0) >>> 0)) - 1 >>> 0; + while (true) { + if (!(r < a.nd)) { break; } + c$1 = (((x$1 = a.d, ((r < 0 || r >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[r])) >>> 0)); + dig = (y$3 = k, y$3 < 32 ? (n >>> y$3) : 0) >>> 0; + n = (n & (mask)) >>> 0; + (x$2 = a.d, ((w < 0 || w >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[w] = (((dig + 48 >>> 0) << 24 >>> 24)))); + w = w + (1) >> 0; + n = ((n * 10 >>> 0) + c$1 >>> 0) - 48 >>> 0; + r = r + (1) >> 0; + } + while (true) { + if (!(n > 0)) { break; } + dig$1 = (y$4 = k, y$4 < 32 ? (n >>> y$4) : 0) >>> 0; + n = (n & (mask)) >>> 0; + if (w < 800) { + (x$3 = a.d, ((w < 0 || w >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[w] = (((dig$1 + 48 >>> 0) << 24 >>> 24)))); + w = w + (1) >> 0; + } else if (dig$1 > 0) { + a.trunc = true; + } + n = n * 10 >>> 0; + } + a.nd = w; + trim(a); + }; + prefixIsLessThan = function(b, s) { + var b, i, s; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (i >= b.$length) { + return true; + } + if (!((((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) === s.charCodeAt(i)))) { + return ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]) < s.charCodeAt(i); + } + i = i + (1) >> 0; + } + return false; + }; + leftShift = function(a, k) { + var _q, _q$1, a, delta, k, n, quo, quo$1, r, rem, rem$1, w, x, x$1, x$2, y; + delta = ((k < 0 || k >= leftcheats.$length) ? ($throwRuntimeError("index out of range"), undefined) : leftcheats.$array[leftcheats.$offset + k]).delta; + if (prefixIsLessThan($subslice(new sliceType$6(a.d), 0, a.nd), ((k < 0 || k >= leftcheats.$length) ? ($throwRuntimeError("index out of range"), undefined) : leftcheats.$array[leftcheats.$offset + k]).cutoff)) { + delta = delta - (1) >> 0; + } + r = a.nd; + w = a.nd + delta >> 0; + n = 0; + r = r - (1) >> 0; + while (true) { + if (!(r >= 0)) { break; } + n = n + (((y = k, y < 32 ? ((((((x = a.d, ((r < 0 || r >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[r])) >>> 0)) - 48 >>> 0)) << y) : 0) >>> 0)) >>> 0; + quo = (_q = n / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + rem = n - (10 * quo >>> 0) >>> 0; + w = w - (1) >> 0; + if (w < 800) { + (x$1 = a.d, ((w < 0 || w >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[w] = (((rem + 48 >>> 0) << 24 >>> 24)))); + } else if (!((rem === 0))) { + a.trunc = true; + } + n = quo; + r = r - (1) >> 0; + } + while (true) { + if (!(n > 0)) { break; } + quo$1 = (_q$1 = n / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + rem$1 = n - (10 * quo$1 >>> 0) >>> 0; + w = w - (1) >> 0; + if (w < 800) { + (x$2 = a.d, ((w < 0 || w >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[w] = (((rem$1 + 48 >>> 0) << 24 >>> 24)))); + } else if (!((rem$1 === 0))) { + a.trunc = true; + } + n = quo$1; + } + a.nd = a.nd + (delta) >> 0; + if (a.nd >= 800) { + a.nd = 800; + } + a.dp = a.dp + (delta) >> 0; + trim(a); + }; + decimal.ptr.prototype.Shift = function(k) { + var a, k; + a = this; + if ((a.nd === 0)) { + } else if (k > 0) { + while (true) { + if (!(k > 28)) { break; } + leftShift(a, 28); + k = k - (28) >> 0; + } + leftShift(a, ((k >>> 0))); + } else if (k < 0) { + while (true) { + if (!(k < -28)) { break; } + rightShift(a, 28); + k = k + (28) >> 0; + } + rightShift(a, ((-k >>> 0))); + } + }; + decimal.prototype.Shift = function(k) { return this.$val.Shift(k); }; + shouldRoundUp = function(a, nd) { + var _r, a, nd, x, x$1, x$2, x$3; + if (nd < 0 || nd >= a.nd) { + return false; + } + if (((x = a.d, ((nd < 0 || nd >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[nd])) === 53) && ((nd + 1 >> 0) === a.nd)) { + if (a.trunc) { + return true; + } + return nd > 0 && !(((_r = (((x$1 = a.d, x$2 = nd - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[x$2])) - 48 << 24 >>> 24)) % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0)); + } + return (x$3 = a.d, ((nd < 0 || nd >= x$3.length) ? ($throwRuntimeError("index out of range"), undefined) : x$3[nd])) >= 53; + }; + decimal.ptr.prototype.Round = function(nd) { + var a, nd; + a = this; + if (nd < 0 || nd >= a.nd) { + return; + } + if (shouldRoundUp(a, nd)) { + a.RoundUp(nd); + } else { + a.RoundDown(nd); + } + }; + decimal.prototype.Round = function(nd) { return this.$val.Round(nd); }; + decimal.ptr.prototype.RoundDown = function(nd) { + var a, nd; + a = this; + if (nd < 0 || nd >= a.nd) { + return; + } + a.nd = nd; + trim(a); + }; + decimal.prototype.RoundDown = function(nd) { return this.$val.RoundDown(nd); }; + decimal.ptr.prototype.RoundUp = function(nd) { + var a, c, i, nd, x, x$1, x$2; + a = this; + if (nd < 0 || nd >= a.nd) { + return; + } + i = nd - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + c = (x = a.d, ((i < 0 || i >= x.length) ? ($throwRuntimeError("index out of range"), undefined) : x[i])); + if (c < 57) { + (x$2 = a.d, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i] = ((x$1 = a.d, ((i < 0 || i >= x$1.length) ? ($throwRuntimeError("index out of range"), undefined) : x$1[i])) + (1) << 24 >>> 24))); + a.nd = i + 1 >> 0; + return; + } + i = i - (1) >> 0; + } + a.d[0] = 49; + a.nd = 1; + a.dp = a.dp + (1) >> 0; + }; + decimal.prototype.RoundUp = function(nd) { return this.$val.RoundUp(nd); }; + decimal.ptr.prototype.RoundedInteger = function() { + var a, i, n, x, x$1, x$2, x$3; + a = this; + if (a.dp > 20) { + return new $Uint64(4294967295, 4294967295); + } + i = 0; + n = new $Uint64(0, 0); + i = 0; + while (true) { + if (!(i < a.dp && i < a.nd)) { break; } + n = (x = $mul64(n, new $Uint64(0, 10)), x$1 = (new $Uint64(0, ((x$2 = a.d, ((i < 0 || i >= x$2.length) ? ($throwRuntimeError("index out of range"), undefined) : x$2[i])) - 48 << 24 >>> 24))), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low)); + i = i + (1) >> 0; + } + while (true) { + if (!(i < a.dp)) { break; } + n = $mul64(n, (new $Uint64(0, 10))); + i = i + (1) >> 0; + } + if (shouldRoundUp(a, a.dp)) { + n = (x$3 = new $Uint64(0, 1), new $Uint64(n.$high + x$3.$high, n.$low + x$3.$low)); + } + return n; + }; + decimal.prototype.RoundedInteger = function() { return this.$val.RoundedInteger(); }; + extFloat.ptr.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { + var _tmp, _tmp$1, exp, expBiased, f, flt, lower, mant, neg, upper, x, x$1, x$2, x$3, x$4; + lower = new extFloat.ptr(new $Uint64(0, 0), 0, false); + upper = new extFloat.ptr(new $Uint64(0, 0), 0, false); + f = this; + f.mant = mant; + f.exp = exp - ((flt.mantbits >> 0)) >> 0; + f.neg = neg; + if (f.exp <= 0 && (x = $shiftLeft64(($shiftRightUint64(mant, ((-f.exp >>> 0)))), ((-f.exp >>> 0))), (mant.$high === x.$high && mant.$low === x.$low))) { + f.mant = $shiftRightUint64(f.mant, (((-f.exp >>> 0)))); + f.exp = 0; + _tmp = $clone(f, extFloat); + _tmp$1 = $clone(f, extFloat); + extFloat.copy(lower, _tmp); + extFloat.copy(upper, _tmp$1); + return [lower, upper]; + } + expBiased = exp - flt.bias >> 0; + extFloat.copy(upper, new extFloat.ptr((x$1 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$1.$high + 0, x$1.$low + 1)), f.exp - 1 >> 0, f.neg)); + if (!((x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) || (expBiased === 1)) { + extFloat.copy(lower, new extFloat.ptr((x$3 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$3.$high - 0, x$3.$low - 1)), f.exp - 1 >> 0, f.neg)); + } else { + extFloat.copy(lower, new extFloat.ptr((x$4 = $mul64(new $Uint64(0, 4), f.mant), new $Uint64(x$4.$high - 0, x$4.$low - 1)), f.exp - 2 >> 0, f.neg)); + } + return [lower, upper]; + }; + extFloat.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { return this.$val.AssignComputeBounds(mant, exp, neg, flt); }; + extFloat.ptr.prototype.Normalize = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, exp, f, mant, shift, x, x$1, x$2, x$3, x$4, x$5; + shift = 0; + f = this; + _tmp = f.mant; + _tmp$1 = f.exp; + mant = _tmp; + exp = _tmp$1; + if ((mant.$high === 0 && mant.$low === 0)) { + shift = 0; + return shift; + } + if ((x = $shiftRightUint64(mant, 32), (x.$high === 0 && x.$low === 0))) { + mant = $shiftLeft64(mant, (32)); + exp = exp - (32) >> 0; + } + if ((x$1 = $shiftRightUint64(mant, 48), (x$1.$high === 0 && x$1.$low === 0))) { + mant = $shiftLeft64(mant, (16)); + exp = exp - (16) >> 0; + } + if ((x$2 = $shiftRightUint64(mant, 56), (x$2.$high === 0 && x$2.$low === 0))) { + mant = $shiftLeft64(mant, (8)); + exp = exp - (8) >> 0; + } + if ((x$3 = $shiftRightUint64(mant, 60), (x$3.$high === 0 && x$3.$low === 0))) { + mant = $shiftLeft64(mant, (4)); + exp = exp - (4) >> 0; + } + if ((x$4 = $shiftRightUint64(mant, 62), (x$4.$high === 0 && x$4.$low === 0))) { + mant = $shiftLeft64(mant, (2)); + exp = exp - (2) >> 0; + } + if ((x$5 = $shiftRightUint64(mant, 63), (x$5.$high === 0 && x$5.$low === 0))) { + mant = $shiftLeft64(mant, (1)); + exp = exp - (1) >> 0; + } + shift = (((f.exp - exp >> 0) >>> 0)); + _tmp$2 = mant; + _tmp$3 = exp; + f.mant = _tmp$2; + f.exp = _tmp$3; + return shift; + }; + extFloat.prototype.Normalize = function() { return this.$val.Normalize(); }; + extFloat.ptr.prototype.Multiply = function(g) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, cross1, cross2, f, fhi, flo, g, ghi, glo, rem, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + _tmp = $shiftRightUint64(f.mant, 32); + _tmp$1 = (new $Uint64(0, ((f.mant.$low >>> 0)))); + fhi = _tmp; + flo = _tmp$1; + _tmp$2 = $shiftRightUint64(g.mant, 32); + _tmp$3 = (new $Uint64(0, ((g.mant.$low >>> 0)))); + ghi = _tmp$2; + glo = _tmp$3; + cross1 = $mul64(fhi, glo); + cross2 = $mul64(flo, ghi); + f.mant = (x = (x$1 = $mul64(fhi, ghi), x$2 = $shiftRightUint64(cross1, 32), new $Uint64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)), x$3 = $shiftRightUint64(cross2, 32), new $Uint64(x.$high + x$3.$high, x.$low + x$3.$low)); + rem = (x$4 = (x$5 = (new $Uint64(0, ((cross1.$low >>> 0)))), x$6 = (new $Uint64(0, ((cross2.$low >>> 0)))), new $Uint64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)), x$7 = $shiftRightUint64(($mul64(flo, glo)), 32), new $Uint64(x$4.$high + x$7.$high, x$4.$low + x$7.$low)); + rem = (x$8 = new $Uint64(0, 2147483648), new $Uint64(rem.$high + x$8.$high, rem.$low + x$8.$low)); + f.mant = (x$9 = f.mant, x$10 = ($shiftRightUint64(rem, 32)), new $Uint64(x$9.$high + x$10.$high, x$9.$low + x$10.$low)); + f.exp = (f.exp + g.exp >> 0) + 64 >> 0; + }; + extFloat.prototype.Multiply = function(g) { return this.$val.Multiply(g); }; + extFloat.ptr.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { + var _q, _r, adjExp, denormalExp, errors$1, exp10, extrabits, f, flt, halfway, i, mant_extra, mantissa, neg, ok, shift, trunc, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y; + ok = false; + f = this; + errors$1 = 0; + if (trunc) { + errors$1 = errors$1 + (4) >> 0; + } + f.mant = mantissa; + f.exp = 0; + f.neg = neg; + i = (_q = ((exp10 - -348 >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + if (exp10 < -348 || i >= 87) { + ok = false; + return ok; + } + adjExp = (_r = ((exp10 - -348 >> 0)) % 8, _r === _r ? _r : $throwRuntimeError("integer divide by zero")); + if (adjExp < 19 && (x = (x$1 = 19 - adjExp >> 0, ((x$1 < 0 || x$1 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$1])), (mantissa.$high < x.$high || (mantissa.$high === x.$high && mantissa.$low < x.$low)))) { + f.mant = $mul64(f.mant, (((adjExp < 0 || adjExp >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[adjExp]))); + f.Normalize(); + } else { + f.Normalize(); + f.Multiply($clone(((adjExp < 0 || adjExp >= smallPowersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : smallPowersOfTen[adjExp]), extFloat)); + errors$1 = errors$1 + (4) >> 0; + } + f.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + if (errors$1 > 0) { + errors$1 = errors$1 + (1) >> 0; + } + errors$1 = errors$1 + (4) >> 0; + shift = f.Normalize(); + errors$1 = (y = (shift), y < 32 ? (errors$1 << y) : 0) >> 0; + denormalExp = flt.bias - 63 >> 0; + extrabits = 0; + if (f.exp <= denormalExp) { + extrabits = ((63 - flt.mantbits >>> 0) + 1 >>> 0) + (((denormalExp - f.exp >> 0) >>> 0)) >>> 0; + } else { + extrabits = 63 - flt.mantbits >>> 0; + } + halfway = $shiftLeft64(new $Uint64(0, 1), ((extrabits - 1 >>> 0))); + mant_extra = (x$2 = f.mant, x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), extrabits), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0)); + if ((x$5 = (x$6 = (new $Int64(halfway.$high, halfway.$low)), x$7 = (new $Int64(0, errors$1)), new $Int64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)), x$8 = (new $Int64(mant_extra.$high, mant_extra.$low)), (x$5.$high < x$8.$high || (x$5.$high === x$8.$high && x$5.$low < x$8.$low))) && (x$9 = (new $Int64(mant_extra.$high, mant_extra.$low)), x$10 = (x$11 = (new $Int64(halfway.$high, halfway.$low)), x$12 = (new $Int64(0, errors$1)), new $Int64(x$11.$high + x$12.$high, x$11.$low + x$12.$low)), (x$9.$high < x$10.$high || (x$9.$high === x$10.$high && x$9.$low < x$10.$low)))) { + ok = false; + return ok; + } + ok = true; + return ok; + }; + extFloat.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { return this.$val.AssignDecimal(mantissa, exp10, neg, trunc, flt); }; + extFloat.ptr.prototype.frexp10 = function() { + var _q, _q$1, _tmp, _tmp$1, approxExp10, exp, exp10, f, i, index; + exp10 = 0; + index = 0; + f = this; + approxExp10 = (_q = ($imul(((-46 - f.exp >> 0)), 28)) / 93, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + i = (_q$1 = ((approxExp10 - -348 >> 0)) / 8, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")); + Loop: + while (true) { + exp = (f.exp + ((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]).exp >> 0) + 64 >> 0; + if (exp < -60) { + i = i + (1) >> 0; + } else if (exp > -32) { + i = i - (1) >> 0; + } else { + break Loop; + } + } + f.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + _tmp = -((-348 + ($imul(i, 8)) >> 0)); + _tmp$1 = i; + exp10 = _tmp; + index = _tmp$1; + return [exp10, index]; + }; + extFloat.prototype.frexp10 = function() { return this.$val.frexp10(); }; + frexp10Many = function(a, b, c) { + var _tuple, a, b, c, exp10, i; + exp10 = 0; + _tuple = c.frexp10(); + exp10 = _tuple[0]; + i = _tuple[1]; + a.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + b.Multiply($clone(((i < 0 || i >= powersOfTen.length) ? ($throwRuntimeError("index out of range"), undefined) : powersOfTen[i]), extFloat)); + return exp10; + }; + extFloat.ptr.prototype.FixedDecimal = function(d, n) { + var $CE$B5, _q, _q$1, _tmp, _tmp$1, _tuple, buf, d, digit, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, n, nd, needed, ok, pos, pow, pow10, rest, shift, v, v1, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { + d.nd = 0; + d.dp = 0; + d.neg = f.neg; + return true; + } + if (n === 0) { + $panic(new $String("strconv: internal error: extFloat.FixedDecimal called with n == 0")); + } + f.Normalize(); + _tuple = f.frexp10(); + exp10 = _tuple[0]; + shift = ((-f.exp >>> 0)); + integer = (($shiftRightUint64(f.mant, shift).$low >>> 0)); + fraction = (x$1 = f.mant, x$2 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)); + $CE$B5 = new $Uint64(0, 1); + needed = n; + integerDigits = 0; + pow10 = new $Uint64(0, 1); + _tmp = 0; + _tmp$1 = new $Uint64(0, 1); + i = _tmp; + pow = _tmp$1; + while (true) { + if (!(i < 20)) { break; } + if ((x$3 = (new $Uint64(0, integer)), (pow.$high > x$3.$high || (pow.$high === x$3.$high && pow.$low > x$3.$low)))) { + integerDigits = i; + break; + } + pow = $mul64(pow, (new $Uint64(0, 10))); + i = i + (1) >> 0; + } + rest = integer; + if (integerDigits > needed) { + pow10 = (x$4 = integerDigits - needed >> 0, ((x$4 < 0 || x$4 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$4])); + integer = (_q = integer / (((pow10.$low >>> 0))), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + rest = rest - (($imul(integer, ((pow10.$low >>> 0))) >>> 0)) >>> 0; + } else { + rest = 0; + } + buf = arrayType$2.zero(); + pos = 32; + v = integer; + while (true) { + if (!(v > 0)) { break; } + v1 = (_q$1 = v / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + v = v - (($imul(10, v1) >>> 0)) >>> 0; + pos = pos - (1) >> 0; + ((pos < 0 || pos >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[pos] = (((v + 48 >>> 0) << 24 >>> 24))); + v = v1; + } + i$1 = pos; + while (true) { + if (!(i$1 < 32)) { break; } + (x$5 = d.d, x$6 = i$1 - pos >> 0, ((x$6 < 0 || x$6 >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + x$6] = ((i$1 < 0 || i$1 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[i$1]))); + i$1 = i$1 + (1) >> 0; + } + nd = 32 - pos >> 0; + d.nd = nd; + d.dp = integerDigits + exp10 >> 0; + needed = needed - (nd) >> 0; + if (needed > 0) { + if (!((rest === 0)) || !((pow10.$high === 0 && pow10.$low === 1))) { + $panic(new $String("strconv: internal error, rest != 0 but needed > 0")); + } + while (true) { + if (!(needed > 0)) { break; } + fraction = $mul64(fraction, (new $Uint64(0, 10))); + $CE$B5 = $mul64($CE$B5, (new $Uint64(0, 10))); + if ((x$7 = $mul64(new $Uint64(0, 2), $CE$B5), x$8 = $shiftLeft64(new $Uint64(0, 1), shift), (x$7.$high > x$8.$high || (x$7.$high === x$8.$high && x$7.$low > x$8.$low)))) { + return false; + } + digit = $shiftRightUint64(fraction, shift); + (x$9 = d.d, ((nd < 0 || nd >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + nd] = ((new $Uint64(digit.$high + 0, digit.$low + 48).$low << 24 >>> 24)))); + fraction = (x$10 = $shiftLeft64(digit, shift), new $Uint64(fraction.$high - x$10.$high, fraction.$low - x$10.$low)); + nd = nd + (1) >> 0; + needed = needed - (1) >> 0; + } + d.nd = nd; + } + ok = adjustLastDigitFixed(d, (x$11 = $shiftLeft64((new $Uint64(0, rest)), shift), new $Uint64(x$11.$high | fraction.$high, (x$11.$low | fraction.$low) >>> 0)), pow10, shift, $CE$B5); + if (!ok) { + return false; + } + i$2 = d.nd - 1 >> 0; + while (true) { + if (!(i$2 >= 0)) { break; } + if (!(((x$12 = d.d, ((i$2 < 0 || i$2 >= x$12.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + i$2])) === 48))) { + d.nd = i$2 + 1 >> 0; + break; + } + i$2 = i$2 - (1) >> 0; + } + return true; + }; + extFloat.prototype.FixedDecimal = function(d, n) { return this.$val.FixedDecimal(d, n); }; + adjustLastDigitFixed = function(d, num, den, shift, $CE$B5) { + var $CE$B5, d, den, i, num, shift, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + if ((x = $shiftLeft64(den, shift), (num.$high > x.$high || (num.$high === x.$high && num.$low > x.$low)))) { + $panic(new $String("strconv: num > den< x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) { + $panic(new $String("strconv: \xCE\xB5 > (den< x$6.$high || (x$5.$high === x$6.$high && x$5.$low > x$6.$low)))) { + i = d.nd - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + if ((x$7 = d.d, ((i < 0 || i >= x$7.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$7.$array[x$7.$offset + i])) === 57) { + d.nd = d.nd - (1) >> 0; + } else { + break; + } + i = i - (1) >> 0; + } + if (i < 0) { + (x$8 = d.d, (0 >= x$8.$length ? ($throwRuntimeError("index out of range"), undefined) : x$8.$array[x$8.$offset + 0] = 49)); + d.nd = 1; + d.dp = d.dp + (1) >> 0; + } else { + (x$10 = d.d, ((i < 0 || i >= x$10.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$10.$array[x$10.$offset + i] = ((x$9 = d.d, ((i < 0 || i >= x$9.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$9.$array[x$9.$offset + i])) + (1) << 24 >>> 24))); + } + return true; + } + return false; + }; + extFloat.ptr.prototype.ShortestDecimal = function(d, lower, upper) { + var _q, _tmp, _tmp$1, _tmp$2, _tmp$3, allowance, buf, currentDiff, d, digit, digit$1, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, lower, multiplier, n, nd, pow, pow$1, shift, targetDiff, upper, v, v1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + if ((x = f.mant, (x.$high === 0 && x.$low === 0))) { + d.nd = 0; + d.dp = 0; + d.neg = f.neg; + return true; + } + if ((f.exp === 0) && $equal(lower, f, extFloat) && $equal(lower, upper, extFloat)) { + buf = arrayType$1.zero(); + n = 23; + v = f.mant; + while (true) { + if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; } + v1 = $div64(v, new $Uint64(0, 10), false); + v = (x$1 = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x$1.$high, v.$low - x$1.$low)); + ((n < 0 || n >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[n] = ((new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24))); + n = n - (1) >> 0; + v = v1; + } + nd = (24 - n >> 0) - 1 >> 0; + i = 0; + while (true) { + if (!(i < nd)) { break; } + (x$3 = d.d, ((i < 0 || i >= x$3.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$3.$array[x$3.$offset + i] = (x$2 = (n + 1 >> 0) + i >> 0, ((x$2 < 0 || x$2 >= buf.length) ? ($throwRuntimeError("index out of range"), undefined) : buf[x$2])))); + i = i + (1) >> 0; + } + _tmp = nd; + _tmp$1 = nd; + d.nd = _tmp; + d.dp = _tmp$1; + while (true) { + if (!(d.nd > 0 && ((x$4 = d.d, x$5 = d.nd - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + x$5])) === 48))) { break; } + d.nd = d.nd - (1) >> 0; + } + if (d.nd === 0) { + d.dp = 0; + } + d.neg = f.neg; + return true; + } + upper.Normalize(); + if (f.exp > upper.exp) { + f.mant = $shiftLeft64(f.mant, ((((f.exp - upper.exp >> 0) >>> 0)))); + f.exp = upper.exp; + } + if (lower.exp > upper.exp) { + lower.mant = $shiftLeft64(lower.mant, ((((lower.exp - upper.exp >> 0) >>> 0)))); + lower.exp = upper.exp; + } + exp10 = frexp10Many(lower, f, upper); + upper.mant = (x$6 = upper.mant, x$7 = new $Uint64(0, 1), new $Uint64(x$6.$high + x$7.$high, x$6.$low + x$7.$low)); + lower.mant = (x$8 = lower.mant, x$9 = new $Uint64(0, 1), new $Uint64(x$8.$high - x$9.$high, x$8.$low - x$9.$low)); + shift = ((-upper.exp >>> 0)); + integer = (($shiftRightUint64(upper.mant, shift).$low >>> 0)); + fraction = (x$10 = upper.mant, x$11 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$10.$high - x$11.$high, x$10.$low - x$11.$low)); + allowance = (x$12 = upper.mant, x$13 = lower.mant, new $Uint64(x$12.$high - x$13.$high, x$12.$low - x$13.$low)); + targetDiff = (x$14 = upper.mant, x$15 = f.mant, new $Uint64(x$14.$high - x$15.$high, x$14.$low - x$15.$low)); + integerDigits = 0; + _tmp$2 = 0; + _tmp$3 = new $Uint64(0, 1); + i$1 = _tmp$2; + pow = _tmp$3; + while (true) { + if (!(i$1 < 20)) { break; } + if ((x$16 = (new $Uint64(0, integer)), (pow.$high > x$16.$high || (pow.$high === x$16.$high && pow.$low > x$16.$low)))) { + integerDigits = i$1; + break; + } + pow = $mul64(pow, (new $Uint64(0, 10))); + i$1 = i$1 + (1) >> 0; + } + i$2 = 0; + while (true) { + if (!(i$2 < integerDigits)) { break; } + pow$1 = (x$17 = (integerDigits - i$2 >> 0) - 1 >> 0, ((x$17 < 0 || x$17 >= uint64pow10.length) ? ($throwRuntimeError("index out of range"), undefined) : uint64pow10[x$17])); + digit = (_q = integer / ((pow$1.$low >>> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + (x$18 = d.d, ((i$2 < 0 || i$2 >= x$18.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$18.$array[x$18.$offset + i$2] = (((digit + 48 >>> 0) << 24 >>> 24)))); + integer = integer - (($imul(digit, ((pow$1.$low >>> 0))) >>> 0)) >>> 0; + currentDiff = (x$19 = $shiftLeft64((new $Uint64(0, integer)), shift), new $Uint64(x$19.$high + fraction.$high, x$19.$low + fraction.$low)); + if ((currentDiff.$high < allowance.$high || (currentDiff.$high === allowance.$high && currentDiff.$low < allowance.$low))) { + d.nd = i$2 + 1 >> 0; + d.dp = integerDigits + exp10 >> 0; + d.neg = f.neg; + return adjustLastDigit(d, currentDiff, targetDiff, allowance, $shiftLeft64(pow$1, shift), new $Uint64(0, 2)); + } + i$2 = i$2 + (1) >> 0; + } + d.nd = integerDigits; + d.dp = d.nd + exp10 >> 0; + d.neg = f.neg; + digit$1 = 0; + multiplier = new $Uint64(0, 1); + while (true) { + fraction = $mul64(fraction, (new $Uint64(0, 10))); + multiplier = $mul64(multiplier, (new $Uint64(0, 10))); + digit$1 = (($shiftRightUint64(fraction, shift).$low >> 0)); + (x$20 = d.d, x$21 = d.nd, ((x$21 < 0 || x$21 >= x$20.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$20.$array[x$20.$offset + x$21] = (((digit$1 + 48 >> 0) << 24 >>> 24)))); + d.nd = d.nd + (1) >> 0; + fraction = (x$22 = $shiftLeft64((new $Uint64(0, digit$1)), shift), new $Uint64(fraction.$high - x$22.$high, fraction.$low - x$22.$low)); + if ((x$23 = $mul64(allowance, multiplier), (fraction.$high < x$23.$high || (fraction.$high === x$23.$high && fraction.$low < x$23.$low)))) { + return adjustLastDigit(d, fraction, $mul64(targetDiff, multiplier), $mul64(allowance, multiplier), $shiftLeft64(new $Uint64(0, 1), shift), $mul64(multiplier, new $Uint64(0, 2))); + } + } + }; + extFloat.prototype.ShortestDecimal = function(d, lower, upper) { return this.$val.ShortestDecimal(d, lower, upper); }; + adjustLastDigit = function(d, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary) { + var _index, currentDiff, d, maxDiff, targetDiff, ulpBinary, ulpDecimal, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + if ((x = $mul64(new $Uint64(0, 2), ulpBinary), (ulpDecimal.$high < x.$high || (ulpDecimal.$high === x.$high && ulpDecimal.$low < x.$low)))) { + return false; + } + while (true) { + if (!((x$1 = (x$2 = (x$3 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(currentDiff.$high + x$3.$high, currentDiff.$low + x$3.$low)), new $Uint64(x$2.$high + ulpBinary.$high, x$2.$low + ulpBinary.$low)), (x$1.$high < targetDiff.$high || (x$1.$high === targetDiff.$high && x$1.$low < targetDiff.$low))))) { break; } + _index = d.nd - 1 >> 0; + (x$5 = d.d, ((_index < 0 || _index >= x$5.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$5.$array[x$5.$offset + _index] = ((x$4 = d.d, ((_index < 0 || _index >= x$4.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$4.$array[x$4.$offset + _index])) - (1) << 24 >>> 24))); + currentDiff = (x$6 = ulpDecimal, new $Uint64(currentDiff.$high + x$6.$high, currentDiff.$low + x$6.$low)); + } + if ((x$7 = new $Uint64(currentDiff.$high + ulpDecimal.$high, currentDiff.$low + ulpDecimal.$low), x$8 = (x$9 = (x$10 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(targetDiff.$high + x$10.$high, targetDiff.$low + x$10.$low)), new $Uint64(x$9.$high + ulpBinary.$high, x$9.$low + ulpBinary.$low)), (x$7.$high < x$8.$high || (x$7.$high === x$8.$high && x$7.$low <= x$8.$low)))) { + return false; + } + if ((currentDiff.$high < ulpBinary.$high || (currentDiff.$high === ulpBinary.$high && currentDiff.$low < ulpBinary.$low)) || (x$11 = new $Uint64(maxDiff.$high - ulpBinary.$high, maxDiff.$low - ulpBinary.$low), (currentDiff.$high > x$11.$high || (currentDiff.$high === x$11.$high && currentDiff.$low > x$11.$low)))) { + return false; + } + if ((d.nd === 1) && ((x$12 = d.d, (0 >= x$12.$length ? ($throwRuntimeError("index out of range"), undefined) : x$12.$array[x$12.$offset + 0])) === 48)) { + d.nd = 0; + d.dp = 0; + } + return true; + }; + AppendFloat = function(dst, f, fmt, prec, bitSize) { + var bitSize, dst, f, fmt, prec; + return genericFtoa(dst, f, fmt, prec, bitSize); + }; + $pkg.AppendFloat = AppendFloat; + genericFtoa = function(dst, val, fmt, prec, bitSize) { + var _1, _2, _3, _4, _tuple, bitSize, bits, buf, buf$1, digits, digs, dst, exp, f, f$1, flt, fmt, lower, mant, neg, ok, prec, s, shortest, upper, val, x, x$1, x$2, x$3, y, y$1; + bits = new $Uint64(0, 0); + flt = ptrType$1.nil; + _1 = bitSize; + if (_1 === (32)) { + bits = (new $Uint64(0, math.Float32bits(($fround(val))))); + flt = float32info; + } else if (_1 === (64)) { + bits = math.Float64bits(val); + flt = float64info; + } else { + $panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize")); + } + neg = !((x = $shiftRightUint64(bits, ((flt.expbits + flt.mantbits >>> 0))), (x.$high === 0 && x.$low === 0))); + exp = (($shiftRightUint64(bits, flt.mantbits).$low >> 0)) & ((((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)); + mant = (x$1 = (x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$2.$high - 0, x$2.$low - 1)), new $Uint64(bits.$high & x$1.$high, (bits.$low & x$1.$low) >>> 0)); + _2 = exp; + if (_2 === ((((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0))) { + s = ""; + if (!((mant.$high === 0 && mant.$low === 0))) { + s = "NaN"; + } else if (neg) { + s = "-Inf"; + } else { + s = "+Inf"; + } + return $appendSlice(dst, s); + } else if (_2 === (0)) { + exp = exp + (1) >> 0; + } else { + mant = (x$3 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high | x$3.$high, (mant.$low | x$3.$low) >>> 0)); + } + exp = exp + (flt.bias) >> 0; + if (fmt === 98) { + return fmtB(dst, neg, mant, exp, flt); + } + if (!optimize) { + return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); + } + digs = new decimalSlice.ptr(sliceType$6.nil, 0, 0, false); + ok = false; + shortest = prec < 0; + if (shortest) { + f = new extFloat.ptr(new $Uint64(0, 0), 0, false); + _tuple = f.AssignComputeBounds(mant, exp, neg, flt); + lower = $clone(_tuple[0], extFloat); + upper = $clone(_tuple[1], extFloat); + buf = arrayType$2.zero(); + digs.d = new sliceType$6(buf); + ok = f.ShortestDecimal(digs, lower, upper); + if (!ok) { + return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); + } + _3 = fmt; + if ((_3 === (101)) || (_3 === (69))) { + prec = max(digs.nd - 1 >> 0, 0); + } else if (_3 === (102)) { + prec = max(digs.nd - digs.dp >> 0, 0); + } else if ((_3 === (103)) || (_3 === (71))) { + prec = digs.nd; + } + } else if (!((fmt === 102))) { + digits = prec; + _4 = fmt; + if ((_4 === (101)) || (_4 === (69))) { + digits = digits + (1) >> 0; + } else if ((_4 === (103)) || (_4 === (71))) { + if (prec === 0) { + prec = 1; + } + digits = prec; + } + if (digits <= 15) { + buf$1 = arrayType$1.zero(); + digs.d = new sliceType$6(buf$1); + f$1 = new extFloat.ptr(mant, exp - ((flt.mantbits >> 0)) >> 0, neg); + ok = f$1.FixedDecimal(digs, digits); + } + } + if (!ok) { + return bigFtoa(dst, prec, fmt, neg, mant, exp, flt); + } + return formatDigits(dst, shortest, neg, $clone(digs, decimalSlice), prec, fmt); + }; + bigFtoa = function(dst, prec, fmt, neg, mant, exp, flt) { + var _1, _2, d, digs, dst, exp, flt, fmt, mant, neg, prec, shortest; + d = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + d.Assign(mant); + d.Shift(exp - ((flt.mantbits >> 0)) >> 0); + digs = new decimalSlice.ptr(sliceType$6.nil, 0, 0, false); + shortest = prec < 0; + if (shortest) { + roundShortest(d, mant, exp, flt); + decimalSlice.copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false)); + _1 = fmt; + if ((_1 === (101)) || (_1 === (69))) { + prec = digs.nd - 1 >> 0; + } else if (_1 === (102)) { + prec = max(digs.nd - digs.dp >> 0, 0); + } else if ((_1 === (103)) || (_1 === (71))) { + prec = digs.nd; + } + } else { + _2 = fmt; + if ((_2 === (101)) || (_2 === (69))) { + d.Round(prec + 1 >> 0); + } else if (_2 === (102)) { + d.Round(d.dp + prec >> 0); + } else if ((_2 === (103)) || (_2 === (71))) { + if (prec === 0) { + prec = 1; + } + d.Round(prec); + } + decimalSlice.copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false)); + } + return formatDigits(dst, shortest, neg, $clone(digs, decimalSlice), prec, fmt); + }; + formatDigits = function(dst, shortest, neg, digs, prec, fmt) { + var _1, digs, dst, eprec, exp, fmt, neg, prec, shortest; + _1 = fmt; + if ((_1 === (101)) || (_1 === (69))) { + return fmtE(dst, neg, $clone(digs, decimalSlice), prec, fmt); + } else if (_1 === (102)) { + return fmtF(dst, neg, $clone(digs, decimalSlice), prec); + } else if ((_1 === (103)) || (_1 === (71))) { + eprec = prec; + if (eprec > digs.nd && digs.nd >= digs.dp) { + eprec = digs.nd; + } + if (shortest) { + eprec = 6; + } + exp = digs.dp - 1 >> 0; + if (exp < -4 || exp >= eprec) { + if (prec > digs.nd) { + prec = digs.nd; + } + return fmtE(dst, neg, $clone(digs, decimalSlice), prec - 1 >> 0, (fmt + 101 << 24 >>> 24) - 103 << 24 >>> 24); + } + if (prec > digs.dp) { + prec = digs.nd; + } + return fmtF(dst, neg, $clone(digs, decimalSlice), max(prec - digs.dp >> 0, 0)); + } + return $append(dst, 37, fmt); + }; + roundShortest = function(d, mant, exp, flt) { + var d, exp, explo, flt, i, inclusive, l, lower, m, mant, mantlo, minexp, okdown, okup, u, upper, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; + if ((mant.$high === 0 && mant.$low === 0)) { + d.nd = 0; + return; + } + minexp = flt.bias + 1 >> 0; + if (exp > minexp && ($imul(332, ((d.dp - d.nd >> 0)))) >= ($imul(100, ((exp - ((flt.mantbits >> 0)) >> 0))))) { + return; + } + upper = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + upper.Assign((x = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x.$high + 0, x.$low + 1))); + upper.Shift((exp - ((flt.mantbits >> 0)) >> 0) - 1 >> 0); + mantlo = new $Uint64(0, 0); + explo = 0; + if ((x$1 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high > x$1.$high || (mant.$high === x$1.$high && mant.$low > x$1.$low))) || (exp === minexp)) { + mantlo = new $Uint64(mant.$high - 0, mant.$low - 1); + explo = exp; + } else { + mantlo = (x$2 = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x$2.$high - 0, x$2.$low - 1)); + explo = exp - 1 >> 0; + } + lower = new decimal.ptr(arrayType.zero(), 0, 0, false, false); + lower.Assign((x$3 = $mul64(mantlo, new $Uint64(0, 2)), new $Uint64(x$3.$high + 0, x$3.$low + 1))); + lower.Shift((explo - ((flt.mantbits >> 0)) >> 0) - 1 >> 0); + inclusive = (x$4 = $div64(mant, new $Uint64(0, 2), true), (x$4.$high === 0 && x$4.$low === 0)); + i = 0; + while (true) { + if (!(i < d.nd)) { break; } + l = 48; + if (i < lower.nd) { + l = (x$5 = lower.d, ((i < 0 || i >= x$5.length) ? ($throwRuntimeError("index out of range"), undefined) : x$5[i])); + } + m = (x$6 = d.d, ((i < 0 || i >= x$6.length) ? ($throwRuntimeError("index out of range"), undefined) : x$6[i])); + u = 48; + if (i < upper.nd) { + u = (x$7 = upper.d, ((i < 0 || i >= x$7.length) ? ($throwRuntimeError("index out of range"), undefined) : x$7[i])); + } + okdown = !((l === m)) || inclusive && ((i + 1 >> 0) === lower.nd); + okup = !((m === u)) && (inclusive || (m + 1 << 24 >>> 24) < u || (i + 1 >> 0) < upper.nd); + if (okdown && okup) { + d.Round(i + 1 >> 0); + return; + } else if (okdown) { + d.RoundDown(i + 1 >> 0); + return; + } else if (okup) { + d.RoundUp(i + 1 >> 0); + return; + } + i = i + (1) >> 0; + } + }; + fmtE = function(dst, neg, d, prec, fmt) { + var _q, _q$1, _q$2, _r, _r$1, _r$2, ch, d, dst, exp, fmt, i, m, neg, prec, x; + if (neg) { + dst = $append(dst, 45); + } + ch = 48; + if (!((d.nd === 0))) { + ch = (x = d.d, (0 >= x.$length ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + 0])); + } + dst = $append(dst, ch); + if (prec > 0) { + dst = $append(dst, 46); + i = 1; + m = min(d.nd, prec + 1 >> 0); + if (i < m) { + dst = $appendSlice(dst, $subslice(d.d, i, m)); + i = m; + } + while (true) { + if (!(i <= prec)) { break; } + dst = $append(dst, 48); + i = i + (1) >> 0; + } + } + dst = $append(dst, fmt); + exp = d.dp - 1 >> 0; + if (d.nd === 0) { + exp = 0; + } + if (exp < 0) { + ch = 45; + exp = -exp; + } else { + ch = 43; + } + dst = $append(dst, ch); + if (exp < 10) { + dst = $append(dst, 48, ((exp << 24 >>> 24)) + 48 << 24 >>> 24); + } else if (exp < 100) { + dst = $append(dst, (((_q = exp / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24, (((_r = exp % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24); + } else { + dst = $append(dst, (((_q$1 = exp / 100, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24, (_r$1 = (((_q$2 = exp / 10, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) % 10, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) + 48 << 24 >>> 24, (((_r$2 = exp % 10, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) << 24 >>> 24)) + 48 << 24 >>> 24); + } + return dst; + }; + fmtF = function(dst, neg, d, prec) { + var ch, d, dst, i, j, m, neg, prec, x; + if (neg) { + dst = $append(dst, 45); + } + if (d.dp > 0) { + m = min(d.nd, d.dp); + dst = $appendSlice(dst, $subslice(d.d, 0, m)); + while (true) { + if (!(m < d.dp)) { break; } + dst = $append(dst, 48); + m = m + (1) >> 0; + } + } else { + dst = $append(dst, 48); + } + if (prec > 0) { + dst = $append(dst, 46); + i = 0; + while (true) { + if (!(i < prec)) { break; } + ch = 48; + j = d.dp + i >> 0; + if (0 <= j && j < d.nd) { + ch = (x = d.d, ((j < 0 || j >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + j])); + } + dst = $append(dst, ch); + i = i + (1) >> 0; + } + } + return dst; + }; + fmtB = function(dst, neg, mant, exp, flt) { + var _tuple, _tuple$1, dst, exp, flt, mant, neg; + if (neg) { + dst = $append(dst, 45); + } + _tuple = formatBits(dst, mant, 10, false, true); + dst = _tuple[0]; + dst = $append(dst, 112); + exp = exp - (((flt.mantbits >> 0))) >> 0; + if (exp >= 0) { + dst = $append(dst, 43); + } + _tuple$1 = formatBits(dst, (new $Uint64(0, exp)), 10, exp < 0, true); + dst = _tuple$1[0]; + return dst; + }; + min = function(a, b) { + var a, b; + if (a < b) { + return a; + } + return b; + }; + max = function(a, b) { + var a, b; + if (a > b) { + return a; + } + return b; + }; + FormatInt = function(i, base) { + var _tuple, base, i, s; + if (true && (0 < i.$high || (0 === i.$high && 0 <= i.$low)) && (i.$high < 0 || (i.$high === 0 && i.$low < 100)) && (base === 10)) { + return small((((i.$low + ((i.$high >> 31) * 4294967296)) >> 0))); + } + _tuple = formatBits(sliceType$6.nil, (new $Uint64(i.$high, i.$low)), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), false); + s = _tuple[1]; + return s; + }; + $pkg.FormatInt = FormatInt; + Itoa = function(i) { + var i; + return FormatInt((new $Int64(0, i)), 10); + }; + $pkg.Itoa = Itoa; + small = function(i) { + var i, off; + off = 0; + if (i < 10) { + off = 1; + } + return $substring("00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899", (($imul(i, 2)) + off >> 0), (($imul(i, 2)) + 2 >> 0)); + }; + formatBits = function(dst, u, base, neg, append_) { + var _q, _q$1, _r, _r$1, a, append_, b, b$1, base, d, dst, i, is, is$1, is$2, j, m, neg, q, q$1, s, s$1, u, us, us$1, x, x$1, x$2, x$3, x$4, x$5; + d = sliceType$6.nil; + s = ""; + if (base < 2 || base > 36) { + $panic(new $String("strconv: illegal AppendInt/FormatInt base")); + } + a = arrayType$3.zero(); + i = 65; + if (neg) { + u = new $Uint64(-u.$high, -u.$low); + } + if (base === 10) { + if (true) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 1000000000)))) { break; } + q = $div64(u, new $Uint64(0, 1000000000), false); + us = (((x = $mul64(q, new $Uint64(0, 1000000000)), new $Uint64(u.$high - x.$high, u.$low - x.$low)).$low >>> 0)); + j = 4; + while (true) { + if (!(j > 0)) { break; } + is = (_r = us % 100, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) * 2 >>> 0; + us = (_q = us / (100), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + i = i - (2) >> 0; + (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$1] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is + 1 >>> 0)))); + (x$2 = i + 0 >> 0, ((x$2 < 0 || x$2 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$2] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is + 0 >>> 0)))); + j = j - (1) >> 0; + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(((us * 2 >>> 0) + 1 >>> 0))); + u = q; + } + } + us$1 = ((u.$low >>> 0)); + while (true) { + if (!(us$1 >= 100)) { break; } + is$1 = (_r$1 = us$1 % 100, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) * 2 >>> 0; + us$1 = (_q$1 = us$1 / (100), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + i = i - (2) >> 0; + (x$3 = i + 1 >> 0, ((x$3 < 0 || x$3 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$3] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$1 + 1 >>> 0)))); + (x$4 = i + 0 >> 0, ((x$4 < 0 || x$4 >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[x$4] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$1 + 0 >>> 0)))); + } + is$2 = us$1 * 2 >>> 0; + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((is$2 + 1 >>> 0))); + if (us$1 >= 10) { + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(is$2)); + } + } else { + s$1 = ((base < 0 || base >= shifts.length) ? ($throwRuntimeError("index out of range"), undefined) : shifts[base]); + if (s$1 > 0) { + b = (new $Uint64(0, base)); + m = ((base >>> 0)) - 1 >>> 0; + while (true) { + if (!((u.$high > b.$high || (u.$high === b.$high && u.$low >= b.$low)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((((u.$low >>> 0)) & m) >>> 0))); + u = $shiftRightUint64(u, (s$1)); + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((u.$low >>> 0)))); + } else { + b$1 = (new $Uint64(0, base)); + while (true) { + if (!((u.$high > b$1.$high || (u.$high === b$1.$high && u.$low >= b$1.$low)))) { break; } + i = i - (1) >> 0; + q$1 = $div64(u, b$1, false); + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((x$5 = $mul64(q$1, b$1), new $Uint64(u.$high - x$5.$high, u.$low - x$5.$low)).$low >>> 0)))); + u = q$1; + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((u.$low >>> 0)))); + } + } + if (neg) { + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? ($throwRuntimeError("index out of range"), undefined) : a[i] = 45); + } + if (append_) { + d = $appendSlice(dst, $subslice(new sliceType$6(a), i)); + return [d, s]; + } + s = ($bytesToString($subslice(new sliceType$6(a), i))); + return [d, s]; + }; + appendQuotedWith = function(buf, s, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, _tuple, buf, graphicOnly, quote, r, s, width; + buf = $append(buf, quote); + width = 0; + while (true) { + if (!(s.length > 0)) { break; } + r = ((s.charCodeAt(0) >> 0)); + width = 1; + if (r >= 128) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + width = _tuple[1]; + } + if ((width === 1) && (r === 65533)) { + buf = $appendSlice(buf, "\\x"); + buf = $append(buf, "0123456789abcdef".charCodeAt((s.charCodeAt(0) >>> 4 << 24 >>> 24))); + buf = $append(buf, "0123456789abcdef".charCodeAt(((s.charCodeAt(0) & 15) >>> 0))); + s = $substring(s, width); + continue; + } + buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly); + s = $substring(s, width); + } + buf = $append(buf, quote); + return buf; + }; + appendQuotedRuneWith = function(buf, r, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, buf, graphicOnly, quote, r; + buf = $append(buf, quote); + if (!utf8.ValidRune(r)) { + r = 65533; + } + buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly); + buf = $append(buf, quote); + return buf; + }; + appendEscapedRune = function(buf, r, quote, ASCIIonly, graphicOnly) { + var ASCIIonly, _1, buf, graphicOnly, n, quote, r, runeTmp, s, s$1; + runeTmp = arrayType$4.zero(); + if ((r === ((quote >> 0))) || (r === 92)) { + buf = $append(buf, 92); + buf = $append(buf, ((r << 24 >>> 24))); + return buf; + } + if (ASCIIonly) { + if (r < 128 && IsPrint(r)) { + buf = $append(buf, ((r << 24 >>> 24))); + return buf; + } + } else if (IsPrint(r) || graphicOnly && isInGraphicList(r)) { + n = utf8.EncodeRune(new sliceType$6(runeTmp), r); + buf = $appendSlice(buf, $subslice(new sliceType$6(runeTmp), 0, n)); + return buf; + } + _1 = r; + if (_1 === (7)) { + buf = $appendSlice(buf, "\\a"); + } else if (_1 === (8)) { + buf = $appendSlice(buf, "\\b"); + } else if (_1 === (12)) { + buf = $appendSlice(buf, "\\f"); + } else if (_1 === (10)) { + buf = $appendSlice(buf, "\\n"); + } else if (_1 === (13)) { + buf = $appendSlice(buf, "\\r"); + } else if (_1 === (9)) { + buf = $appendSlice(buf, "\\t"); + } else if (_1 === (11)) { + buf = $appendSlice(buf, "\\v"); + } else { + if (r < 32) { + buf = $appendSlice(buf, "\\x"); + buf = $append(buf, "0123456789abcdef".charCodeAt((((r << 24 >>> 24)) >>> 4 << 24 >>> 24))); + buf = $append(buf, "0123456789abcdef".charCodeAt(((((r << 24 >>> 24)) & 15) >>> 0))); + } else if (r > 1114111) { + r = 65533; + buf = $appendSlice(buf, "\\u"); + s = 12; + while (true) { + if (!(s >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s >>> 0)), 31)) >> 0) & 15))); + s = s - (4) >> 0; + } + } else if (r < 65536) { + buf = $appendSlice(buf, "\\u"); + s = 12; + while (true) { + if (!(s >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s >>> 0)), 31)) >> 0) & 15))); + s = s - (4) >> 0; + } + } else { + buf = $appendSlice(buf, "\\U"); + s$1 = 28; + while (true) { + if (!(s$1 >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min(((s$1 >>> 0)), 31)) >> 0) & 15))); + s$1 = s$1 - (4) >> 0; + } + } + } + return buf; + }; + AppendQuote = function(dst, s) { + var dst, s; + return appendQuotedWith(dst, s, 34, false, false); + }; + $pkg.AppendQuote = AppendQuote; + AppendQuoteToASCII = function(dst, s) { + var dst, s; + return appendQuotedWith(dst, s, 34, true, false); + }; + $pkg.AppendQuoteToASCII = AppendQuoteToASCII; + AppendQuoteRune = function(dst, r) { + var dst, r; + return appendQuotedRuneWith(dst, r, 39, false, false); + }; + $pkg.AppendQuoteRune = AppendQuoteRune; + AppendQuoteRuneToASCII = function(dst, r) { + var dst, r; + return appendQuotedRuneWith(dst, r, 39, true, false); + }; + $pkg.AppendQuoteRuneToASCII = AppendQuoteRuneToASCII; + CanBackquote = function(s) { + var _tuple, r, s, wid; + while (true) { + if (!(s.length > 0)) { break; } + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + wid = _tuple[1]; + s = $substring(s, wid); + if (wid > 1) { + if (r === 65279) { + return false; + } + continue; + } + if (r === 65533) { + return false; + } + if ((r < 32 && !((r === 9))) || (r === 96) || (r === 127)) { + return false; + } + } + return true; + }; + $pkg.CanBackquote = CanBackquote; + unhex = function(b) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, c, ok, v; + v = 0; + ok = false; + c = ((b >> 0)); + if (48 <= c && c <= 57) { + _tmp = c - 48 >> 0; + _tmp$1 = true; + v = _tmp; + ok = _tmp$1; + return [v, ok]; + } else if (97 <= c && c <= 102) { + _tmp$2 = (c - 97 >> 0) + 10 >> 0; + _tmp$3 = true; + v = _tmp$2; + ok = _tmp$3; + return [v, ok]; + } else if (65 <= c && c <= 70) { + _tmp$4 = (c - 65 >> 0) + 10 >> 0; + _tmp$5 = true; + v = _tmp$4; + ok = _tmp$5; + return [v, ok]; + } + return [v, ok]; + }; + UnquoteChar = function(s, quote) { + var _1, _2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, c, c$1, err, j, j$1, multibyte, n, ok, quote, r, s, size, tail, v, v$1, value, x, x$1; + value = 0; + multibyte = false; + tail = ""; + err = $ifaceNil; + c = s.charCodeAt(0); + if ((c === quote) && ((quote === 39) || (quote === 34))) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } else if (c >= 128) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + size = _tuple[1]; + _tmp = r; + _tmp$1 = true; + _tmp$2 = $substring(s, size); + _tmp$3 = $ifaceNil; + value = _tmp; + multibyte = _tmp$1; + tail = _tmp$2; + err = _tmp$3; + return [value, multibyte, tail, err]; + } else if (!((c === 92))) { + _tmp$4 = ((s.charCodeAt(0) >> 0)); + _tmp$5 = false; + _tmp$6 = $substring(s, 1); + _tmp$7 = $ifaceNil; + value = _tmp$4; + multibyte = _tmp$5; + tail = _tmp$6; + err = _tmp$7; + return [value, multibyte, tail, err]; + } + if (s.length <= 1) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + c$1 = s.charCodeAt(1); + s = $substring(s, 2); + switch (0) { default: + _1 = c$1; + if (_1 === (97)) { + value = 7; + } else if (_1 === (98)) { + value = 8; + } else if (_1 === (102)) { + value = 12; + } else if (_1 === (110)) { + value = 10; + } else if (_1 === (114)) { + value = 13; + } else if (_1 === (116)) { + value = 9; + } else if (_1 === (118)) { + value = 11; + } else if ((_1 === (120)) || (_1 === (117)) || (_1 === (85))) { + n = 0; + _2 = c$1; + if (_2 === (120)) { + n = 2; + } else if (_2 === (117)) { + n = 4; + } else if (_2 === (85)) { + n = 8; + } + v = 0; + if (s.length < n) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + j = 0; + while (true) { + if (!(j < n)) { break; } + _tuple$1 = unhex(s.charCodeAt(j)); + x = _tuple$1[0]; + ok = _tuple$1[1]; + if (!ok) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + v = (v << 4 >> 0) | x; + j = j + (1) >> 0; + } + s = $substring(s, n); + if (c$1 === 120) { + value = v; + break; + } + if (v > 1114111) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = v; + multibyte = true; + } else if ((_1 === (48)) || (_1 === (49)) || (_1 === (50)) || (_1 === (51)) || (_1 === (52)) || (_1 === (53)) || (_1 === (54)) || (_1 === (55))) { + v$1 = ((c$1 >> 0)) - 48 >> 0; + if (s.length < 2) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + j$1 = 0; + while (true) { + if (!(j$1 < 2)) { break; } + x$1 = ((s.charCodeAt(j$1) >> 0)) - 48 >> 0; + if (x$1 < 0 || x$1 > 7) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + v$1 = ((v$1 << 3 >> 0)) | x$1; + j$1 = j$1 + (1) >> 0; + } + s = $substring(s, 2); + if (v$1 > 255) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = v$1; + } else if (_1 === (92)) { + value = 92; + } else if ((_1 === (39)) || (_1 === (34))) { + if (!((c$1 === quote))) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = ((c$1 >> 0)); + } else { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + } + tail = s; + return [value, multibyte, tail, err]; + }; + $pkg.UnquoteChar = UnquoteChar; + Unquote = function(s) { + var _1, _q, _tuple, _tuple$1, buf, buf$1, c, err, i, multibyte, n, n$1, quote, r, runeTmp, s, size, ss; + n = s.length; + if (n < 2) { + return ["", $pkg.ErrSyntax]; + } + quote = s.charCodeAt(0); + if (!((quote === s.charCodeAt((n - 1 >> 0))))) { + return ["", $pkg.ErrSyntax]; + } + s = $substring(s, 1, (n - 1 >> 0)); + if (quote === 96) { + if (contains(s, 96)) { + return ["", $pkg.ErrSyntax]; + } + if (contains(s, 13)) { + buf = $makeSlice(sliceType$6, 0, (s.length - 1 >> 0)); + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (!((s.charCodeAt(i) === 13))) { + buf = $append(buf, s.charCodeAt(i)); + } + i = i + (1) >> 0; + } + return [($bytesToString(buf)), $ifaceNil]; + } + return [s, $ifaceNil]; + } + if (!((quote === 34)) && !((quote === 39))) { + return ["", $pkg.ErrSyntax]; + } + if (contains(s, 10)) { + return ["", $pkg.ErrSyntax]; + } + if (!contains(s, 92) && !contains(s, quote)) { + _1 = quote; + if (_1 === (34)) { + return [s, $ifaceNil]; + } else if (_1 === (39)) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + size = _tuple[1]; + if ((size === s.length) && (!((r === 65533)) || !((size === 1)))) { + return [s, $ifaceNil]; + } + } + } + runeTmp = arrayType$4.zero(); + buf$1 = $makeSlice(sliceType$6, 0, (_q = ($imul(3, s.length)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))); + while (true) { + if (!(s.length > 0)) { break; } + _tuple$1 = UnquoteChar(s, quote); + c = _tuple$1[0]; + multibyte = _tuple$1[1]; + ss = _tuple$1[2]; + err = _tuple$1[3]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return ["", err]; + } + s = ss; + if (c < 128 || !multibyte) { + buf$1 = $append(buf$1, ((c << 24 >>> 24))); + } else { + n$1 = utf8.EncodeRune(new sliceType$6(runeTmp), c); + buf$1 = $appendSlice(buf$1, $subslice(new sliceType$6(runeTmp), 0, n$1)); + } + if ((quote === 39) && !((s.length === 0))) { + return ["", $pkg.ErrSyntax]; + } + } + return [($bytesToString(buf$1)), $ifaceNil]; + }; + $pkg.Unquote = Unquote; + contains = function(s, c) { + var c, i, s; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (s.charCodeAt(i) === c) { + return true; + } + i = i + (1) >> 0; + } + return false; + }; + bsearch16 = function(a, x) { + var _q, _tmp, _tmp$1, a, h, i, j, x; + _tmp = 0; + _tmp$1 = a.$length; + i = _tmp; + j = _tmp$1; + while (true) { + if (!(i < j)) { break; } + h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + if (((h < 0 || h >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + h]) < x) { + i = h + 1 >> 0; + } else { + j = h; + } + } + return i; + }; + bsearch32 = function(a, x) { + var _q, _tmp, _tmp$1, a, h, i, j, x; + _tmp = 0; + _tmp$1 = a.$length; + i = _tmp; + j = _tmp$1; + while (true) { + if (!(i < j)) { break; } + h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + if (((h < 0 || h >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + h]) < x) { + i = h + 1 >> 0; + } else { + j = h; + } + } + return i; + }; + IsPrint = function(r) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, i, i$1, isNotPrint, isNotPrint$1, isPrint, isPrint$1, j, j$1, r, rr, rr$1, x, x$1, x$2, x$3; + if (r <= 255) { + if (32 <= r && r <= 126) { + return true; + } + if (161 <= r && r <= 255) { + return !((r === 173)); + } + return false; + } + if (0 <= r && r < 65536) { + _tmp = ((r << 16 >>> 16)); + _tmp$1 = isPrint16; + _tmp$2 = isNotPrint16; + rr = _tmp; + isPrint = _tmp$1; + isNotPrint = _tmp$2; + i = bsearch16(isPrint, rr); + if (i >= isPrint.$length || rr < (x = (i & ~1) >> 0, ((x < 0 || x >= isPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint.$array[isPrint.$offset + x])) || (x$1 = i | 1, ((x$1 < 0 || x$1 >= isPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint.$array[isPrint.$offset + x$1])) < rr) { + return false; + } + j = bsearch16(isNotPrint, rr); + return j >= isNotPrint.$length || !((((j < 0 || j >= isNotPrint.$length) ? ($throwRuntimeError("index out of range"), undefined) : isNotPrint.$array[isNotPrint.$offset + j]) === rr)); + } + _tmp$3 = ((r >>> 0)); + _tmp$4 = isPrint32; + _tmp$5 = isNotPrint32; + rr$1 = _tmp$3; + isPrint$1 = _tmp$4; + isNotPrint$1 = _tmp$5; + i$1 = bsearch32(isPrint$1, rr$1); + if (i$1 >= isPrint$1.$length || rr$1 < (x$2 = (i$1 & ~1) >> 0, ((x$2 < 0 || x$2 >= isPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint$1.$array[isPrint$1.$offset + x$2])) || (x$3 = i$1 | 1, ((x$3 < 0 || x$3 >= isPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isPrint$1.$array[isPrint$1.$offset + x$3])) < rr$1) { + return false; + } + if (r >= 131072) { + return true; + } + r = r - (65536) >> 0; + j$1 = bsearch16(isNotPrint$1, ((r << 16 >>> 16))); + return j$1 >= isNotPrint$1.$length || !((((j$1 < 0 || j$1 >= isNotPrint$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : isNotPrint$1.$array[isNotPrint$1.$offset + j$1]) === ((r << 16 >>> 16)))); + }; + $pkg.IsPrint = IsPrint; + isInGraphicList = function(r) { + var i, r, rr; + if (r > 65535) { + return false; + } + rr = ((r << 16 >>> 16)); + i = bsearch16(isGraphic, rr); + return i < isGraphic.$length && (rr === ((i < 0 || i >= isGraphic.$length) ? ($throwRuntimeError("index out of range"), undefined) : isGraphic.$array[isGraphic.$offset + i])); + }; + ptrType$2.methods = [{prop: "set", name: "set", pkg: "strconv", typ: $funcType([$String], [$Bool], false)}, {prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Assign", name: "Assign", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "Shift", name: "Shift", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundDown", name: "RoundDown", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundUp", name: "RoundUp", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundedInteger", name: "RoundedInteger", pkg: "", typ: $funcType([], [$Uint64], false)}]; + ptrType$4.methods = [{prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "AssignComputeBounds", name: "AssignComputeBounds", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, ptrType$1], [extFloat, extFloat], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "Multiply", name: "Multiply", pkg: "", typ: $funcType([extFloat], [], false)}, {prop: "AssignDecimal", name: "AssignDecimal", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, $Bool, ptrType$1], [$Bool], false)}, {prop: "frexp10", name: "frexp10", pkg: "strconv", typ: $funcType([], [$Int, $Int], false)}, {prop: "FixedDecimal", name: "FixedDecimal", pkg: "", typ: $funcType([ptrType$3, $Int], [$Bool], false)}, {prop: "ShortestDecimal", name: "ShortestDecimal", pkg: "", typ: $funcType([ptrType$3, ptrType$4, ptrType$4], [$Bool], false)}]; + decimal.init("strconv", [{prop: "d", name: "d", anonymous: false, exported: false, typ: arrayType, tag: ""}, {prop: "nd", name: "nd", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "dp", name: "dp", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "trunc", name: "trunc", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + leftCheat.init("strconv", [{prop: "delta", name: "delta", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "cutoff", name: "cutoff", anonymous: false, exported: false, typ: $String, tag: ""}]); + extFloat.init("strconv", [{prop: "mant", name: "mant", anonymous: false, exported: false, typ: $Uint64, tag: ""}, {prop: "exp", name: "exp", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + floatInfo.init("strconv", [{prop: "mantbits", name: "mantbits", anonymous: false, exported: false, typ: $Uint, tag: ""}, {prop: "expbits", name: "expbits", anonymous: false, exported: false, typ: $Uint, tag: ""}, {prop: "bias", name: "bias", anonymous: false, exported: false, typ: $Int, tag: ""}]); + decimalSlice.init("strconv", [{prop: "d", name: "d", anonymous: false, exported: false, typ: sliceType$6, tag: ""}, {prop: "nd", name: "nd", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "dp", name: "dp", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "neg", name: "neg", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + optimize = true; + $pkg.ErrRange = errors.New("value out of range"); + $pkg.ErrSyntax = errors.New("invalid syntax"); + leftcheats = new sliceType$3([new leftCheat.ptr(0, ""), new leftCheat.ptr(1, "5"), new leftCheat.ptr(1, "25"), new leftCheat.ptr(1, "125"), new leftCheat.ptr(2, "625"), new leftCheat.ptr(2, "3125"), new leftCheat.ptr(2, "15625"), new leftCheat.ptr(3, "78125"), new leftCheat.ptr(3, "390625"), new leftCheat.ptr(3, "1953125"), new leftCheat.ptr(4, "9765625"), new leftCheat.ptr(4, "48828125"), new leftCheat.ptr(4, "244140625"), new leftCheat.ptr(4, "1220703125"), new leftCheat.ptr(5, "6103515625"), new leftCheat.ptr(5, "30517578125"), new leftCheat.ptr(5, "152587890625"), new leftCheat.ptr(6, "762939453125"), new leftCheat.ptr(6, "3814697265625"), new leftCheat.ptr(6, "19073486328125"), new leftCheat.ptr(7, "95367431640625"), new leftCheat.ptr(7, "476837158203125"), new leftCheat.ptr(7, "2384185791015625"), new leftCheat.ptr(7, "11920928955078125"), new leftCheat.ptr(8, "59604644775390625"), new leftCheat.ptr(8, "298023223876953125"), new leftCheat.ptr(8, "1490116119384765625"), new leftCheat.ptr(9, "7450580596923828125"), new leftCheat.ptr(9, "37252902984619140625"), new leftCheat.ptr(9, "186264514923095703125"), new leftCheat.ptr(10, "931322574615478515625"), new leftCheat.ptr(10, "4656612873077392578125"), new leftCheat.ptr(10, "23283064365386962890625"), new leftCheat.ptr(10, "116415321826934814453125"), new leftCheat.ptr(11, "582076609134674072265625"), new leftCheat.ptr(11, "2910383045673370361328125"), new leftCheat.ptr(11, "14551915228366851806640625"), new leftCheat.ptr(12, "72759576141834259033203125"), new leftCheat.ptr(12, "363797880709171295166015625"), new leftCheat.ptr(12, "1818989403545856475830078125"), new leftCheat.ptr(13, "9094947017729282379150390625"), new leftCheat.ptr(13, "45474735088646411895751953125"), new leftCheat.ptr(13, "227373675443232059478759765625"), new leftCheat.ptr(13, "1136868377216160297393798828125"), new leftCheat.ptr(14, "5684341886080801486968994140625"), new leftCheat.ptr(14, "28421709430404007434844970703125"), new leftCheat.ptr(14, "142108547152020037174224853515625"), new leftCheat.ptr(15, "710542735760100185871124267578125"), new leftCheat.ptr(15, "3552713678800500929355621337890625"), new leftCheat.ptr(15, "17763568394002504646778106689453125"), new leftCheat.ptr(16, "88817841970012523233890533447265625"), new leftCheat.ptr(16, "444089209850062616169452667236328125"), new leftCheat.ptr(16, "2220446049250313080847263336181640625"), new leftCheat.ptr(16, "11102230246251565404236316680908203125"), new leftCheat.ptr(17, "55511151231257827021181583404541015625"), new leftCheat.ptr(17, "277555756156289135105907917022705078125"), new leftCheat.ptr(17, "1387778780781445675529539585113525390625"), new leftCheat.ptr(18, "6938893903907228377647697925567626953125"), new leftCheat.ptr(18, "34694469519536141888238489627838134765625"), new leftCheat.ptr(18, "173472347597680709441192448139190673828125"), new leftCheat.ptr(19, "867361737988403547205962240695953369140625")]); + smallPowersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(2147483648, 0), -63, false), new extFloat.ptr(new $Uint64(2684354560, 0), -60, false), new extFloat.ptr(new $Uint64(3355443200, 0), -57, false), new extFloat.ptr(new $Uint64(4194304000, 0), -54, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3276800000, 0), -47, false), new extFloat.ptr(new $Uint64(4096000000, 0), -44, false), new extFloat.ptr(new $Uint64(2560000000, 0), -40, false)]); + powersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(4203730336, 136053384), -1220, false), new extFloat.ptr(new $Uint64(3132023167, 2722021238), -1193, false), new extFloat.ptr(new $Uint64(2333539104, 810921078), -1166, false), new extFloat.ptr(new $Uint64(3477244234, 1573795306), -1140, false), new extFloat.ptr(new $Uint64(2590748842, 1432697645), -1113, false), new extFloat.ptr(new $Uint64(3860516611, 1025131999), -1087, false), new extFloat.ptr(new $Uint64(2876309015, 3348809418), -1060, false), new extFloat.ptr(new $Uint64(4286034428, 3200048207), -1034, false), new extFloat.ptr(new $Uint64(3193344495, 1097586188), -1007, false), new extFloat.ptr(new $Uint64(2379227053, 2424306748), -980, false), new extFloat.ptr(new $Uint64(3545324584, 827693699), -954, false), new extFloat.ptr(new $Uint64(2641472655, 2913388981), -927, false), new extFloat.ptr(new $Uint64(3936100983, 602835915), -901, false), new extFloat.ptr(new $Uint64(2932623761, 1081627501), -874, false), new extFloat.ptr(new $Uint64(2184974969, 1572261463), -847, false), new extFloat.ptr(new $Uint64(3255866422, 1308317239), -821, false), new extFloat.ptr(new $Uint64(2425809519, 944281679), -794, false), new extFloat.ptr(new $Uint64(3614737867, 629291719), -768, false), new extFloat.ptr(new $Uint64(2693189581, 2545915892), -741, false), new extFloat.ptr(new $Uint64(4013165208, 388672741), -715, false), new extFloat.ptr(new $Uint64(2990041083, 708162190), -688, false), new extFloat.ptr(new $Uint64(2227754207, 3536207675), -661, false), new extFloat.ptr(new $Uint64(3319612455, 450088378), -635, false), new extFloat.ptr(new $Uint64(2473304014, 3139815830), -608, false), new extFloat.ptr(new $Uint64(3685510180, 2103616900), -582, false), new extFloat.ptr(new $Uint64(2745919064, 224385782), -555, false), new extFloat.ptr(new $Uint64(4091738259, 3737383206), -529, false), new extFloat.ptr(new $Uint64(3048582568, 2868871352), -502, false), new extFloat.ptr(new $Uint64(2271371013, 1820084875), -475, false), new extFloat.ptr(new $Uint64(3384606560, 885076051), -449, false), new extFloat.ptr(new $Uint64(2521728396, 2444895829), -422, false), new extFloat.ptr(new $Uint64(3757668132, 1881767613), -396, false), new extFloat.ptr(new $Uint64(2799680927, 3102062735), -369, false), new extFloat.ptr(new $Uint64(4171849679, 2289335700), -343, false), new extFloat.ptr(new $Uint64(3108270227, 2410191823), -316, false), new extFloat.ptr(new $Uint64(2315841784, 3205436779), -289, false), new extFloat.ptr(new $Uint64(3450873173, 1697722806), -263, false), new extFloat.ptr(new $Uint64(2571100870, 3497754540), -236, false), new extFloat.ptr(new $Uint64(3831238852, 707476230), -210, false), new extFloat.ptr(new $Uint64(2854495385, 1769181907), -183, false), new extFloat.ptr(new $Uint64(4253529586, 2197867022), -157, false), new extFloat.ptr(new $Uint64(3169126500, 2450594539), -130, false), new extFloat.ptr(new $Uint64(2361183241, 1867548876), -103, false), new extFloat.ptr(new $Uint64(3518437208, 3793315116), -77, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3906250000, 0), -24, false), new extFloat.ptr(new $Uint64(2910383045, 2892103680), 3, false), new extFloat.ptr(new $Uint64(2168404344, 4170451332), 30, false), new extFloat.ptr(new $Uint64(3231174267, 3372684723), 56, false), new extFloat.ptr(new $Uint64(2407412430, 2078956656), 83, false), new extFloat.ptr(new $Uint64(3587324068, 2884206696), 109, false), new extFloat.ptr(new $Uint64(2672764710, 395977285), 136, false), new extFloat.ptr(new $Uint64(3982729777, 3569679143), 162, false), new extFloat.ptr(new $Uint64(2967364920, 2361961896), 189, false), new extFloat.ptr(new $Uint64(2210859150, 447440347), 216, false), new extFloat.ptr(new $Uint64(3294436857, 1114709402), 242, false), new extFloat.ptr(new $Uint64(2454546732, 2786846552), 269, false), new extFloat.ptr(new $Uint64(3657559652, 443583978), 295, false), new extFloat.ptr(new $Uint64(2725094297, 2599384906), 322, false), new extFloat.ptr(new $Uint64(4060706939, 3028118405), 348, false), new extFloat.ptr(new $Uint64(3025462433, 2044532855), 375, false), new extFloat.ptr(new $Uint64(2254145170, 1536935362), 402, false), new extFloat.ptr(new $Uint64(3358938053, 3365297469), 428, false), new extFloat.ptr(new $Uint64(2502603868, 4204241075), 455, false), new extFloat.ptr(new $Uint64(3729170365, 2577424355), 481, false), new extFloat.ptr(new $Uint64(2778448436, 3677981733), 508, false), new extFloat.ptr(new $Uint64(4140210802, 2744688476), 534, false), new extFloat.ptr(new $Uint64(3084697427, 1424604878), 561, false), new extFloat.ptr(new $Uint64(2298278679, 4062331362), 588, false), new extFloat.ptr(new $Uint64(3424702107, 3546052773), 614, false), new extFloat.ptr(new $Uint64(2551601907, 2065781727), 641, false), new extFloat.ptr(new $Uint64(3802183132, 2535403578), 667, false), new extFloat.ptr(new $Uint64(2832847187, 1558426518), 694, false), new extFloat.ptr(new $Uint64(4221271257, 2762425404), 720, false), new extFloat.ptr(new $Uint64(3145092172, 2812560400), 747, false), new extFloat.ptr(new $Uint64(2343276271, 3057687578), 774, false), new extFloat.ptr(new $Uint64(3491753744, 2790753324), 800, false), new extFloat.ptr(new $Uint64(2601559269, 3918606633), 827, false), new extFloat.ptr(new $Uint64(3876625403, 2711358621), 853, false), new extFloat.ptr(new $Uint64(2888311001, 1648096297), 880, false), new extFloat.ptr(new $Uint64(2151959390, 2057817989), 907, false), new extFloat.ptr(new $Uint64(3206669376, 61660461), 933, false), new extFloat.ptr(new $Uint64(2389154863, 1581580175), 960, false), new extFloat.ptr(new $Uint64(3560118173, 2626467905), 986, false), new extFloat.ptr(new $Uint64(2652494738, 3034782633), 1013, false), new extFloat.ptr(new $Uint64(3952525166, 3135207385), 1039, false), new extFloat.ptr(new $Uint64(2944860731, 2616258155), 1066, false)]); + uint64pow10 = $toNativeArray($kindUint64, [new $Uint64(0, 1), new $Uint64(0, 10), new $Uint64(0, 100), new $Uint64(0, 1000), new $Uint64(0, 10000), new $Uint64(0, 100000), new $Uint64(0, 1000000), new $Uint64(0, 10000000), new $Uint64(0, 100000000), new $Uint64(0, 1000000000), new $Uint64(2, 1410065408), new $Uint64(23, 1215752192), new $Uint64(232, 3567587328), new $Uint64(2328, 1316134912), new $Uint64(23283, 276447232), new $Uint64(232830, 2764472320), new $Uint64(2328306, 1874919424), new $Uint64(23283064, 1569325056), new $Uint64(232830643, 2808348672), new $Uint64(2328306436, 2313682944)]); + float32info = new floatInfo.ptr(23, 8, -127); + float64info = new floatInfo.ptr(52, 11, -1023); + isPrint16 = new sliceType$4([32, 126, 161, 887, 890, 895, 900, 1366, 1369, 1418, 1421, 1479, 1488, 1514, 1520, 1524, 1542, 1563, 1566, 1805, 1808, 1866, 1869, 1969, 1984, 2042, 2048, 2093, 2096, 2139, 2142, 2154, 2208, 2237, 2260, 2444, 2447, 2448, 2451, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2531, 2534, 2557, 2561, 2570, 2575, 2576, 2579, 2617, 2620, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2654, 2662, 2677, 2689, 2745, 2748, 2765, 2768, 2768, 2784, 2787, 2790, 2801, 2809, 2828, 2831, 2832, 2835, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2915, 2918, 2935, 2946, 2954, 2958, 2965, 2969, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3021, 3024, 3024, 3031, 3031, 3046, 3066, 3072, 3129, 3133, 3149, 3157, 3162, 3168, 3171, 3174, 3183, 3192, 3257, 3260, 3277, 3285, 3286, 3294, 3299, 3302, 3314, 3328, 3407, 3412, 3427, 3430, 3455, 3458, 3478, 3482, 3517, 3520, 3526, 3530, 3530, 3535, 3551, 3558, 3567, 3570, 3572, 3585, 3642, 3647, 3675, 3713, 3716, 3719, 3722, 3725, 3725, 3732, 3751, 3754, 3773, 3776, 3789, 3792, 3801, 3804, 3807, 3840, 3948, 3953, 4058, 4096, 4295, 4301, 4301, 4304, 4685, 4688, 4701, 4704, 4749, 4752, 4789, 4792, 4805, 4808, 4885, 4888, 4954, 4957, 4988, 4992, 5017, 5024, 5109, 5112, 5117, 5120, 5788, 5792, 5880, 5888, 5908, 5920, 5942, 5952, 5971, 5984, 6003, 6016, 6109, 6112, 6121, 6128, 6137, 6144, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6443, 6448, 6459, 6464, 6464, 6468, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6622, 6683, 6686, 6780, 6783, 6793, 6800, 6809, 6816, 6829, 6832, 6846, 6912, 6987, 6992, 7036, 7040, 7155, 7164, 7223, 7227, 7241, 7245, 7304, 7360, 7367, 7376, 7417, 7424, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8061, 8064, 8147, 8150, 8175, 8178, 8190, 8208, 8231, 8240, 8286, 8304, 8305, 8308, 8348, 8352, 8383, 8400, 8432, 8448, 8587, 8592, 9254, 9280, 9290, 9312, 11123, 11126, 11157, 11160, 11193, 11197, 11218, 11244, 11247, 11264, 11507, 11513, 11559, 11565, 11565, 11568, 11623, 11631, 11632, 11647, 11670, 11680, 11849, 11904, 12019, 12032, 12245, 12272, 12283, 12289, 12438, 12441, 12543, 12549, 12590, 12593, 12730, 12736, 12771, 12784, 19893, 19904, 40938, 40960, 42124, 42128, 42182, 42192, 42539, 42560, 42743, 42752, 42935, 42999, 43051, 43056, 43065, 43072, 43127, 43136, 43205, 43214, 43225, 43232, 43261, 43264, 43347, 43359, 43388, 43392, 43481, 43486, 43574, 43584, 43597, 43600, 43609, 43612, 43714, 43739, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43877, 43888, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64449, 64467, 64831, 64848, 64911, 64914, 64967, 65008, 65021, 65024, 65049, 65056, 65131, 65136, 65276, 65281, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65504, 65518, 65532, 65533]); + isNotPrint16 = new sliceType$4([173, 907, 909, 930, 1328, 1376, 1416, 1424, 1757, 2111, 2143, 2229, 2274, 2436, 2473, 2481, 2526, 2564, 2601, 2609, 2612, 2615, 2621, 2653, 2692, 2702, 2706, 2729, 2737, 2740, 2758, 2762, 2816, 2820, 2857, 2865, 2868, 2910, 2948, 2961, 2971, 2973, 3017, 3076, 3085, 3089, 3113, 3141, 3145, 3159, 3204, 3213, 3217, 3241, 3252, 3269, 3273, 3295, 3312, 3332, 3341, 3345, 3397, 3401, 3460, 3506, 3516, 3541, 3543, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3770, 3781, 3783, 3912, 3992, 4029, 4045, 4294, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823, 4881, 5760, 5901, 5997, 6001, 6431, 6751, 7674, 8024, 8026, 8028, 8030, 8117, 8133, 8156, 8181, 8335, 11209, 11311, 11359, 11558, 11687, 11695, 11703, 11711, 11719, 11727, 11735, 11743, 11930, 12352, 12687, 12831, 13055, 42927, 43470, 43519, 43815, 43823, 64311, 64317, 64319, 64322, 64325, 65107, 65127, 65141, 65511]); + isPrint32 = new sliceType$5([65536, 65613, 65616, 65629, 65664, 65786, 65792, 65794, 65799, 65843, 65847, 65947, 65952, 65952, 66000, 66045, 66176, 66204, 66208, 66256, 66272, 66299, 66304, 66339, 66349, 66378, 66384, 66426, 66432, 66499, 66504, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66927, 66927, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67640, 67644, 67644, 67647, 67742, 67751, 67759, 67808, 67829, 67835, 67867, 67871, 67897, 67903, 67903, 67968, 68023, 68028, 68047, 68050, 68102, 68108, 68147, 68152, 68154, 68159, 68167, 68176, 68184, 68192, 68255, 68288, 68326, 68331, 68342, 68352, 68405, 68409, 68437, 68440, 68466, 68472, 68497, 68505, 68508, 68521, 68527, 68608, 68680, 68736, 68786, 68800, 68850, 68858, 68863, 69216, 69246, 69632, 69709, 69714, 69743, 69759, 69825, 69840, 69864, 69872, 69881, 69888, 69955, 69968, 70006, 70016, 70093, 70096, 70132, 70144, 70206, 70272, 70313, 70320, 70378, 70384, 70393, 70400, 70412, 70415, 70416, 70419, 70457, 70460, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70749, 70784, 70855, 70864, 70873, 71040, 71093, 71096, 71133, 71168, 71236, 71248, 71257, 71264, 71276, 71296, 71351, 71360, 71369, 71424, 71449, 71453, 71467, 71472, 71487, 71840, 71922, 71935, 71935, 72192, 72263, 72272, 72323, 72326, 72354, 72384, 72440, 72704, 72773, 72784, 72812, 72816, 72847, 72850, 72886, 72960, 73014, 73018, 73031, 73040, 73049, 73728, 74649, 74752, 74868, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92777, 92782, 92783, 92880, 92909, 92912, 92917, 92928, 92997, 93008, 93047, 93053, 93071, 93952, 94020, 94032, 94078, 94095, 94111, 94176, 94177, 94208, 100332, 100352, 101106, 110592, 110878, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113820, 113823, 118784, 119029, 119040, 119078, 119081, 119154, 119163, 119272, 119296, 119365, 119552, 119638, 119648, 119665, 119808, 119967, 119970, 119970, 119973, 119974, 119977, 120074, 120077, 120134, 120138, 120485, 120488, 120779, 120782, 121483, 121499, 121519, 122880, 122904, 122907, 122922, 124928, 125124, 125127, 125142, 125184, 125258, 125264, 125273, 125278, 125279, 126464, 126500, 126503, 126523, 126530, 126530, 126535, 126548, 126551, 126564, 126567, 126619, 126625, 126651, 126704, 126705, 126976, 127019, 127024, 127123, 127136, 127150, 127153, 127221, 127232, 127244, 127248, 127339, 127344, 127404, 127462, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 128724, 128736, 128748, 128752, 128760, 128768, 128883, 128896, 128980, 129024, 129035, 129040, 129095, 129104, 129113, 129120, 129159, 129168, 129197, 129280, 129291, 129296, 129356, 129360, 129387, 129408, 129431, 129472, 129472, 129488, 129510, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999]); + isNotPrint32 = new sliceType$4([12, 39, 59, 62, 399, 926, 2057, 2102, 2134, 2291, 2564, 2580, 2584, 4285, 4405, 4576, 4626, 4743, 4745, 4750, 4766, 4868, 4905, 4913, 4916, 5210, 5212, 6813, 7177, 7223, 7336, 7431, 7434, 7483, 7486, 9327, 27231, 27482, 27490, 54357, 54429, 54445, 54458, 54460, 54468, 54534, 54549, 54557, 54586, 54591, 54597, 54609, 55968, 57351, 57378, 57381, 60932, 60960, 60963, 60968, 60979, 60984, 60986, 61000, 61002, 61004, 61008, 61011, 61016, 61018, 61020, 61022, 61024, 61027, 61035, 61043, 61048, 61053, 61055, 61066, 61092, 61098, 61632, 61648, 61743, 63807]); + isGraphic = new sliceType$4([160, 5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288]); + shifts = $toNativeArray($kindUint, [0, 0, 1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0]); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["unicode"] = (function() { + var $pkg = {}, $init; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["reflect"] = (function() { + var $pkg = {}, $init, errors, js, math, runtime, strconv, sync, unicode, utf8, uncommonType, funcType, name, nameData, mapIter, Type, Kind, tflag, rtype, typeAlg, method, ChanDir, arrayType, chanType, imethod, interfaceType, mapType, ptrType, sliceType, structField, structType, Method, nameOff, typeOff, textOff, StructField, StructTag, fieldScan, Value, flag, ValueError, sliceType$1, ptrType$1, sliceType$2, sliceType$3, ptrType$2, funcType$1, sliceType$4, ptrType$3, ptrType$4, sliceType$5, sliceType$6, sliceType$7, ptrType$5, ptrType$6, structType$3, sliceType$8, sliceType$9, sliceType$10, sliceType$11, ptrType$7, ptrType$8, sliceType$13, sliceType$14, ptrType$9, sliceType$15, ptrType$15, sliceType$17, ptrType$16, funcType$3, funcType$4, funcType$5, ptrType$17, arrayType$12, ptrType$18, initialized, uncommonTypeMap, nameMap, nameOffList, typeOffList, callHelper, jsObjectPtr, selectHelper, kindNames, methodCache, uint8Type, init, jsType, reflectType, setKindType, newName, newNameOff, newTypeOff, internalStr, isWrapped, copyStruct, makeValue, MakeSlice, TypeOf, ValueOf, FuncOf, SliceOf, Zero, unsafe_New, makeInt, typedmemmove, keyFor, mapaccess, mapassign, mapdelete, mapiterinit, mapiterkey, mapiternext, maplen, cvtDirect, methodReceiver, valueInterface, ifaceE2I, methodName, makeMethodValue, wrapJsObject, unwrapJsObject, getJsTag, chanrecv, chansend, PtrTo, implements$1, directlyAssignable, haveIdenticalType, haveIdenticalUnderlyingType, toType, ifaceIndir, overflowFloat32, New, convertOp, makeFloat, makeComplex, makeString, makeBytes, makeRunes, cvtInt, cvtUint, cvtFloatInt, cvtFloatUint, cvtIntFloat, cvtUintFloat, cvtFloat, cvtComplex, cvtIntString, cvtUintString, cvtBytesString, cvtStringBytes, cvtRunesString, cvtStringRunes, cvtT2I, cvtI2I; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + math = $packages["math"]; + runtime = $packages["runtime"]; + strconv = $packages["strconv"]; + sync = $packages["sync"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + uncommonType = $pkg.uncommonType = $newType(0, $kindStruct, "reflect.uncommonType", true, "reflect", false, function(pkgPath_, mcount_, _$2_, moff_, _$4_, _methods_) { + this.$val = this; + if (arguments.length === 0) { + this.pkgPath = 0; + this.mcount = 0; + this._$2 = 0; + this.moff = 0; + this._$4 = 0; + this._methods = sliceType$5.nil; + return; + } + this.pkgPath = pkgPath_; + this.mcount = mcount_; + this._$2 = _$2_; + this.moff = moff_; + this._$4 = _$4_; + this._methods = _methods_; + }); + funcType = $pkg.funcType = $newType(0, $kindStruct, "reflect.funcType", true, "reflect", false, function(rtype_, inCount_, outCount_, _in_, _out_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.inCount = 0; + this.outCount = 0; + this._in = sliceType$2.nil; + this._out = sliceType$2.nil; + return; + } + this.rtype = rtype_; + this.inCount = inCount_; + this.outCount = outCount_; + this._in = _in_; + this._out = _out_; + }); + name = $pkg.name = $newType(0, $kindStruct, "reflect.name", true, "reflect", false, function(bytes_) { + this.$val = this; + if (arguments.length === 0) { + this.bytes = ptrType$4.nil; + return; + } + this.bytes = bytes_; + }); + nameData = $pkg.nameData = $newType(0, $kindStruct, "reflect.nameData", true, "reflect", false, function(name_, tag_, exported_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.tag = ""; + this.exported = false; + return; + } + this.name = name_; + this.tag = tag_; + this.exported = exported_; + }); + mapIter = $pkg.mapIter = $newType(0, $kindStruct, "reflect.mapIter", true, "reflect", false, function(t_, m_, keys_, i_) { + this.$val = this; + if (arguments.length === 0) { + this.t = $ifaceNil; + this.m = null; + this.keys = null; + this.i = 0; + return; + } + this.t = t_; + this.m = m_; + this.keys = keys_; + this.i = i_; + }); + Type = $pkg.Type = $newType(8, $kindInterface, "reflect.Type", true, "reflect", true, null); + Kind = $pkg.Kind = $newType(4, $kindUint, "reflect.Kind", true, "reflect", true, null); + tflag = $pkg.tflag = $newType(1, $kindUint8, "reflect.tflag", true, "reflect", false, null); + rtype = $pkg.rtype = $newType(0, $kindStruct, "reflect.rtype", true, "reflect", false, function(size_, ptrdata_, hash_, tflag_, align_, fieldAlign_, kind_, alg_, gcdata_, str_, ptrToThis_) { + this.$val = this; + if (arguments.length === 0) { + this.size = 0; + this.ptrdata = 0; + this.hash = 0; + this.tflag = 0; + this.align = 0; + this.fieldAlign = 0; + this.kind = 0; + this.alg = ptrType$3.nil; + this.gcdata = ptrType$4.nil; + this.str = 0; + this.ptrToThis = 0; + return; + } + this.size = size_; + this.ptrdata = ptrdata_; + this.hash = hash_; + this.tflag = tflag_; + this.align = align_; + this.fieldAlign = fieldAlign_; + this.kind = kind_; + this.alg = alg_; + this.gcdata = gcdata_; + this.str = str_; + this.ptrToThis = ptrToThis_; + }); + typeAlg = $pkg.typeAlg = $newType(0, $kindStruct, "reflect.typeAlg", true, "reflect", false, function(hash_, equal_) { + this.$val = this; + if (arguments.length === 0) { + this.hash = $throwNilPointerError; + this.equal = $throwNilPointerError; + return; + } + this.hash = hash_; + this.equal = equal_; + }); + method = $pkg.method = $newType(0, $kindStruct, "reflect.method", true, "reflect", false, function(name_, mtyp_, ifn_, tfn_) { + this.$val = this; + if (arguments.length === 0) { + this.name = 0; + this.mtyp = 0; + this.ifn = 0; + this.tfn = 0; + return; + } + this.name = name_; + this.mtyp = mtyp_; + this.ifn = ifn_; + this.tfn = tfn_; + }); + ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "reflect.ChanDir", true, "reflect", true, null); + arrayType = $pkg.arrayType = $newType(0, $kindStruct, "reflect.arrayType", true, "reflect", false, function(rtype_, elem_, slice_, len_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + this.slice = ptrType$1.nil; + this.len = 0; + return; + } + this.rtype = rtype_; + this.elem = elem_; + this.slice = slice_; + this.len = len_; + }); + chanType = $pkg.chanType = $newType(0, $kindStruct, "reflect.chanType", true, "reflect", false, function(rtype_, elem_, dir_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + this.dir = 0; + return; + } + this.rtype = rtype_; + this.elem = elem_; + this.dir = dir_; + }); + imethod = $pkg.imethod = $newType(0, $kindStruct, "reflect.imethod", true, "reflect", false, function(name_, typ_) { + this.$val = this; + if (arguments.length === 0) { + this.name = 0; + this.typ = 0; + return; + } + this.name = name_; + this.typ = typ_; + }); + interfaceType = $pkg.interfaceType = $newType(0, $kindStruct, "reflect.interfaceType", true, "reflect", false, function(rtype_, pkgPath_, methods_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.pkgPath = new name.ptr(ptrType$4.nil); + this.methods = sliceType$6.nil; + return; + } + this.rtype = rtype_; + this.pkgPath = pkgPath_; + this.methods = methods_; + }); + mapType = $pkg.mapType = $newType(0, $kindStruct, "reflect.mapType", true, "reflect", false, function(rtype_, key_, elem_, bucket_, hmap_, keysize_, indirectkey_, valuesize_, indirectvalue_, bucketsize_, reflexivekey_, needkeyupdate_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.key = ptrType$1.nil; + this.elem = ptrType$1.nil; + this.bucket = ptrType$1.nil; + this.hmap = ptrType$1.nil; + this.keysize = 0; + this.indirectkey = 0; + this.valuesize = 0; + this.indirectvalue = 0; + this.bucketsize = 0; + this.reflexivekey = false; + this.needkeyupdate = false; + return; + } + this.rtype = rtype_; + this.key = key_; + this.elem = elem_; + this.bucket = bucket_; + this.hmap = hmap_; + this.keysize = keysize_; + this.indirectkey = indirectkey_; + this.valuesize = valuesize_; + this.indirectvalue = indirectvalue_; + this.bucketsize = bucketsize_; + this.reflexivekey = reflexivekey_; + this.needkeyupdate = needkeyupdate_; + }); + ptrType = $pkg.ptrType = $newType(0, $kindStruct, "reflect.ptrType", true, "reflect", false, function(rtype_, elem_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + return; + } + this.rtype = rtype_; + this.elem = elem_; + }); + sliceType = $pkg.sliceType = $newType(0, $kindStruct, "reflect.sliceType", true, "reflect", false, function(rtype_, elem_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.elem = ptrType$1.nil; + return; + } + this.rtype = rtype_; + this.elem = elem_; + }); + structField = $pkg.structField = $newType(0, $kindStruct, "reflect.structField", true, "reflect", false, function(name_, typ_, offsetAnon_) { + this.$val = this; + if (arguments.length === 0) { + this.name = new name.ptr(ptrType$4.nil); + this.typ = ptrType$1.nil; + this.offsetAnon = 0; + return; + } + this.name = name_; + this.typ = typ_; + this.offsetAnon = offsetAnon_; + }); + structType = $pkg.structType = $newType(0, $kindStruct, "reflect.structType", true, "reflect", false, function(rtype_, pkgPath_, fields_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + this.pkgPath = new name.ptr(ptrType$4.nil); + this.fields = sliceType$7.nil; + return; + } + this.rtype = rtype_; + this.pkgPath = pkgPath_; + this.fields = fields_; + }); + Method = $pkg.Method = $newType(0, $kindStruct, "reflect.Method", true, "reflect", true, function(Name_, PkgPath_, Type_, Func_, Index_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.PkgPath = ""; + this.Type = $ifaceNil; + this.Func = new Value.ptr(ptrType$1.nil, 0, 0); + this.Index = 0; + return; + } + this.Name = Name_; + this.PkgPath = PkgPath_; + this.Type = Type_; + this.Func = Func_; + this.Index = Index_; + }); + nameOff = $pkg.nameOff = $newType(4, $kindInt32, "reflect.nameOff", true, "reflect", false, null); + typeOff = $pkg.typeOff = $newType(4, $kindInt32, "reflect.typeOff", true, "reflect", false, null); + textOff = $pkg.textOff = $newType(4, $kindInt32, "reflect.textOff", true, "reflect", false, null); + StructField = $pkg.StructField = $newType(0, $kindStruct, "reflect.StructField", true, "reflect", true, function(Name_, PkgPath_, Type_, Tag_, Offset_, Index_, Anonymous_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.PkgPath = ""; + this.Type = $ifaceNil; + this.Tag = ""; + this.Offset = 0; + this.Index = sliceType$13.nil; + this.Anonymous = false; + return; + } + this.Name = Name_; + this.PkgPath = PkgPath_; + this.Type = Type_; + this.Tag = Tag_; + this.Offset = Offset_; + this.Index = Index_; + this.Anonymous = Anonymous_; + }); + StructTag = $pkg.StructTag = $newType(8, $kindString, "reflect.StructTag", true, "reflect", true, null); + fieldScan = $pkg.fieldScan = $newType(0, $kindStruct, "reflect.fieldScan", true, "reflect", false, function(typ_, index_) { + this.$val = this; + if (arguments.length === 0) { + this.typ = ptrType$9.nil; + this.index = sliceType$13.nil; + return; + } + this.typ = typ_; + this.index = index_; + }); + Value = $pkg.Value = $newType(0, $kindStruct, "reflect.Value", true, "reflect", true, function(typ_, ptr_, flag_) { + this.$val = this; + if (arguments.length === 0) { + this.typ = ptrType$1.nil; + this.ptr = 0; + this.flag = 0; + return; + } + this.typ = typ_; + this.ptr = ptr_; + this.flag = flag_; + }); + flag = $pkg.flag = $newType(4, $kindUintptr, "reflect.flag", true, "reflect", false, null); + ValueError = $pkg.ValueError = $newType(0, $kindStruct, "reflect.ValueError", true, "reflect", true, function(Method_, Kind_) { + this.$val = this; + if (arguments.length === 0) { + this.Method = ""; + this.Kind = 0; + return; + } + this.Method = Method_; + this.Kind = Kind_; + }); + sliceType$1 = $sliceType(name); + ptrType$1 = $ptrType(rtype); + sliceType$2 = $sliceType(ptrType$1); + sliceType$3 = $sliceType($emptyInterface); + ptrType$2 = $ptrType(js.Object); + funcType$1 = $funcType([sliceType$3], [ptrType$2], true); + sliceType$4 = $sliceType($String); + ptrType$3 = $ptrType(typeAlg); + ptrType$4 = $ptrType($Uint8); + sliceType$5 = $sliceType(method); + sliceType$6 = $sliceType(imethod); + sliceType$7 = $sliceType(structField); + ptrType$5 = $ptrType(uncommonType); + ptrType$6 = $ptrType(nameData); + structType$3 = $structType("reflect", [{prop: "str", name: "str", anonymous: false, exported: false, typ: $String, tag: ""}]); + sliceType$8 = $sliceType(ptrType$2); + sliceType$9 = $sliceType(Value); + sliceType$10 = $sliceType(Type); + sliceType$11 = $sliceType(sliceType$8); + ptrType$7 = $ptrType(interfaceType); + ptrType$8 = $ptrType(imethod); + sliceType$13 = $sliceType($Int); + sliceType$14 = $sliceType(fieldScan); + ptrType$9 = $ptrType(structType); + sliceType$15 = $sliceType($Uint8); + ptrType$15 = $ptrType($UnsafePointer); + sliceType$17 = $sliceType($Int32); + ptrType$16 = $ptrType(funcType); + funcType$3 = $funcType([$String], [$Bool], false); + funcType$4 = $funcType([$UnsafePointer, $Uintptr], [$Uintptr], false); + funcType$5 = $funcType([$UnsafePointer, $UnsafePointer], [$Bool], false); + ptrType$17 = $ptrType(structField); + arrayType$12 = $arrayType($Uintptr, 2); + ptrType$18 = $ptrType(ValueError); + init = function() { + var used, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; used = $f.used; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + used = (function(i) { + var i; + }); + $r = used((x = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$1 = new uncommonType.ptr(0, 0, 0, 0, 0, sliceType$5.nil), new x$1.constructor.elem(x$1))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$2 = new method.ptr(0, 0, 0, 0), new x$2.constructor.elem(x$2))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$3 = new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, ptrType$1.nil, 0), new x$3.constructor.elem(x$3))); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$4 = new chanType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, 0), new x$4.constructor.elem(x$4))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$5 = new funcType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), 0, 0, sliceType$2.nil, sliceType$2.nil), new x$5.constructor.elem(x$5))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$6 = new interfaceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new name.ptr(ptrType$4.nil), sliceType$6.nil), new x$6.constructor.elem(x$6))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$7 = new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0, 0, false, false), new x$7.constructor.elem(x$7))); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$8 = new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil), new x$8.constructor.elem(x$8))); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$9 = new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), ptrType$1.nil), new x$9.constructor.elem(x$9))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$10 = new structType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), new name.ptr(ptrType$4.nil), sliceType$7.nil), new x$10.constructor.elem(x$10))); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$11 = new imethod.ptr(0, 0), new x$11.constructor.elem(x$11))); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = used((x$12 = new structField.ptr(new name.ptr(ptrType$4.nil), ptrType$1.nil, 0), new x$12.constructor.elem(x$12))); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + initialized = true; + uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: init }; } $f.used = used; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f; + }; + jsType = function(typ) { + var typ; + return typ.jsType; + }; + reflectType = function(typ) { + var _1, _i, _i$1, _i$2, _i$3, _i$4, _key, _ref, _ref$1, _ref$2, _ref$3, _ref$4, dir, f, fields, i, i$1, i$2, i$3, i$4, imethods, in$1, m, m$1, methodSet, methods, offsetAnon, out, outCount, params, reflectFields, reflectMethods, results, rt, typ, ut; + if (typ.reflectType === undefined) { + rt = new rtype.ptr(((($parseInt(typ.size) >> 0) >>> 0)), 0, 0, 0, 0, 0, ((($parseInt(typ.kind) >> 0) << 24 >>> 24)), ptrType$3.nil, ptrType$4.nil, newNameOff($clone(newName(internalStr(typ.string), "", !!(typ.exported)), name)), 0); + rt.jsType = typ; + typ.reflectType = rt; + methodSet = $methodSet(typ); + if (!(($parseInt(methodSet.length) === 0)) || !!(typ.named)) { + rt.tflag = (rt.tflag | (1)) >>> 0; + if (!!(typ.named)) { + rt.tflag = (rt.tflag | (4)) >>> 0; + } + reflectMethods = $makeSlice(sliceType$5, $parseInt(methodSet.length)); + _ref = reflectMethods; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + m = methodSet[i]; + method.copy(((i < 0 || i >= reflectMethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : reflectMethods.$array[reflectMethods.$offset + i]), new method.ptr(newNameOff($clone(newName(internalStr(m.name), "", internalStr(m.pkg) === ""), name)), newTypeOff(reflectType(m.typ)), 0, 0)); + _i++; + } + ut = new uncommonType.ptr(newNameOff($clone(newName(internalStr(typ.pkg), "", false), name)), (($parseInt(methodSet.length) << 16 >>> 16)), 0, 0, 0, reflectMethods); + _key = rt; (uncommonTypeMap || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: ut }; + ut.jsType = typ; + } + _1 = rt.Kind(); + if (_1 === (17)) { + setKindType(rt, new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem), ptrType$1.nil, ((($parseInt(typ.len) >> 0) >>> 0)))); + } else if (_1 === (18)) { + dir = 3; + if (!!(typ.sendOnly)) { + dir = 2; + } + if (!!(typ.recvOnly)) { + dir = 1; + } + setKindType(rt, new chanType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem), ((dir >>> 0)))); + } else if (_1 === (19)) { + params = typ.params; + in$1 = $makeSlice(sliceType$2, $parseInt(params.length)); + _ref$1 = in$1; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + ((i$1 < 0 || i$1 >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + i$1] = reflectType(params[i$1])); + _i$1++; + } + results = typ.results; + out = $makeSlice(sliceType$2, $parseInt(results.length)); + _ref$2 = out; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$2 = _i$2; + ((i$2 < 0 || i$2 >= out.$length) ? ($throwRuntimeError("index out of range"), undefined) : out.$array[out.$offset + i$2] = reflectType(results[i$2])); + _i$2++; + } + outCount = (($parseInt(results.length) << 16 >>> 16)); + if (!!(typ.variadic)) { + outCount = (outCount | (32768)) >>> 0; + } + setKindType(rt, new funcType.ptr($clone(rt, rtype), (($parseInt(params.length) << 16 >>> 16)), outCount, in$1, out)); + } else if (_1 === (20)) { + methods = typ.methods; + imethods = $makeSlice(sliceType$6, $parseInt(methods.length)); + _ref$3 = imethods; + _i$3 = 0; + while (true) { + if (!(_i$3 < _ref$3.$length)) { break; } + i$3 = _i$3; + m$1 = methods[i$3]; + imethod.copy(((i$3 < 0 || i$3 >= imethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : imethods.$array[imethods.$offset + i$3]), new imethod.ptr(newNameOff($clone(newName(internalStr(m$1.name), "", internalStr(m$1.pkg) === ""), name)), newTypeOff(reflectType(m$1.typ)))); + _i$3++; + } + setKindType(rt, new interfaceType.ptr($clone(rt, rtype), $clone(newName(internalStr(typ.pkg), "", false), name), imethods)); + } else if (_1 === (21)) { + setKindType(rt, new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.key), reflectType(typ.elem), ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0, 0, false, false)); + } else if (_1 === (22)) { + setKindType(rt, new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem))); + } else if (_1 === (23)) { + setKindType(rt, new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0), reflectType(typ.elem))); + } else if (_1 === (25)) { + fields = typ.fields; + reflectFields = $makeSlice(sliceType$7, $parseInt(fields.length)); + _ref$4 = reflectFields; + _i$4 = 0; + while (true) { + if (!(_i$4 < _ref$4.$length)) { break; } + i$4 = _i$4; + f = fields[i$4]; + offsetAnon = ((i$4 >>> 0)) << 1 >>> 0; + if (!!(f.anonymous)) { + offsetAnon = (offsetAnon | (1)) >>> 0; + } + structField.copy(((i$4 < 0 || i$4 >= reflectFields.$length) ? ($throwRuntimeError("index out of range"), undefined) : reflectFields.$array[reflectFields.$offset + i$4]), new structField.ptr($clone(newName(internalStr(f.name), internalStr(f.tag), !!(f.exported)), name), reflectType(f.typ), offsetAnon)); + _i$4++; + } + setKindType(rt, new structType.ptr($clone(rt, rtype), $clone(newName(internalStr(typ.pkgPath), "", false), name), reflectFields)); + } + } + return ((typ.reflectType)); + }; + setKindType = function(rt, kindType) { + var kindType, rt; + rt.kindType = kindType; + kindType.rtype = rt; + }; + uncommonType.ptr.prototype.methods = function() { + var t; + t = this; + return t._methods; + }; + uncommonType.prototype.methods = function() { return this.$val.methods(); }; + rtype.ptr.prototype.uncommon = function() { + var _entry, t; + t = this; + return (_entry = uncommonTypeMap[ptrType$1.keyFor(t)], _entry !== undefined ? _entry.v : ptrType$5.nil); + }; + rtype.prototype.uncommon = function() { return this.$val.uncommon(); }; + funcType.ptr.prototype.in$ = function() { + var t; + t = this; + return t._in; + }; + funcType.prototype.in$ = function() { return this.$val.in$(); }; + funcType.ptr.prototype.out = function() { + var t; + t = this; + return t._out; + }; + funcType.prototype.out = function() { return this.$val.out(); }; + name.ptr.prototype.name = function() { + var _entry, n, s; + s = ""; + n = this; + s = (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).name; + return s; + }; + name.prototype.name = function() { return this.$val.name(); }; + name.ptr.prototype.tag = function() { + var _entry, n, s; + s = ""; + n = this; + s = (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).tag; + return s; + }; + name.prototype.tag = function() { return this.$val.tag(); }; + name.ptr.prototype.pkgPath = function() { + var n; + n = this; + return ""; + }; + name.prototype.pkgPath = function() { return this.$val.pkgPath(); }; + name.ptr.prototype.isExported = function() { + var _entry, n; + n = this; + return (_entry = nameMap[ptrType$4.keyFor(n.bytes)], _entry !== undefined ? _entry.v : ptrType$6.nil).exported; + }; + name.prototype.isExported = function() { return this.$val.isExported(); }; + newName = function(n, tag, exported) { + var _key, b, exported, n, tag; + b = $newDataPointer(0, ptrType$4); + _key = b; (nameMap || $throwRuntimeError("assignment to entry in nil map"))[ptrType$4.keyFor(_key)] = { k: _key, v: new nameData.ptr(n, tag, exported) }; + return new name.ptr(b); + }; + rtype.ptr.prototype.nameOff = function(off) { + var off, t, x; + t = this; + return (x = ((off >> 0)), ((x < 0 || x >= nameOffList.$length) ? ($throwRuntimeError("index out of range"), undefined) : nameOffList.$array[nameOffList.$offset + x])); + }; + rtype.prototype.nameOff = function(off) { return this.$val.nameOff(off); }; + newNameOff = function(n) { + var i, n; + i = nameOffList.$length; + nameOffList = $append(nameOffList, n); + return ((i >> 0)); + }; + rtype.ptr.prototype.typeOff = function(off) { + var off, t, x; + t = this; + return (x = ((off >> 0)), ((x < 0 || x >= typeOffList.$length) ? ($throwRuntimeError("index out of range"), undefined) : typeOffList.$array[typeOffList.$offset + x])); + }; + rtype.prototype.typeOff = function(off) { return this.$val.typeOff(off); }; + newTypeOff = function(t) { + var i, t; + i = typeOffList.$length; + typeOffList = $append(typeOffList, t); + return ((i >> 0)); + }; + internalStr = function(strObj) { + var c, strObj; + c = new structType$3.ptr(""); + c.str = strObj; + return c.str; + }; + isWrapped = function(typ) { + var typ; + return !!(jsType(typ).wrapped); + }; + copyStruct = function(dst, src, typ) { + var dst, fields, i, prop, src, typ; + fields = jsType(typ).fields; + i = 0; + while (true) { + if (!(i < $parseInt(fields.length))) { break; } + prop = $internalize(fields[i].prop, $String); + dst[$externalize(prop, $String)] = src[$externalize(prop, $String)]; + i = i + (1) >> 0; + } + }; + makeValue = function(t, v, fl) { + var _r, _r$1, _r$2, _r$3, _r$4, _r$5, _v, _v$1, fl, rt, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _v = $f._v; _v$1 = $f._v$1; fl = $f.fl; rt = $f.rt; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + rt = _r; + _r$1 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + if (_r$1 === 17) { _v$1 = true; $s = 5; continue s; } + _r$2 = t.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$1 = _r$2 === 25; case 5: + if (_v$1) { _v = true; $s = 4; continue s; } + _r$3 = t.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _v = _r$3 === 22; case 4: + /* */ if (_v) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (_v) { */ case 2: + _r$4 = t.Kind(); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(rt, (v), (fl | ((_r$4 >>> 0))) >>> 0); + /* } */ case 3: + _r$5 = t.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(rt, ($newDataPointer(v, jsType(rt.ptrTo()))), (((fl | ((_r$5 >>> 0))) >>> 0) | 128) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeValue }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._v = _v; $f._v$1 = _v$1; $f.fl = fl; $f.rt = rt; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + MakeSlice = function(typ, len, cap) { + var _r, _r$1, cap, len, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; len = $f.len; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + typ = [typ]; + _r = typ[0].Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 23))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 23))) { */ case 1: + $panic(new $String("reflect.MakeSlice of non-slice type")); + /* } */ case 2: + if (len < 0) { + $panic(new $String("reflect.MakeSlice: negative len")); + } + if (cap < 0) { + $panic(new $String("reflect.MakeSlice: negative cap")); + } + if (len > cap) { + $panic(new $String("reflect.MakeSlice: len > cap")); + } + _r$1 = makeValue(typ[0], $makeSlice(jsType(typ[0]), len, cap, (function(typ) { return function $b() { + var _r$1, _r$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r$1 = $f._r$1; _r$2 = $f._r$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$1 = typ[0].Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = jsType(_r$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2.zero(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._r$1 = _r$1; $f._r$2 = _r$2; $f.$s = $s; $f.$r = $r; return $f; + }; })(typ)), 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: MakeSlice }; } $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.len = len; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.MakeSlice = MakeSlice; + TypeOf = function(i) { + var i; + if (!initialized) { + return new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$3.nil, ptrType$4.nil, 0, 0); + } + if ($interfaceIsEqual(i, $ifaceNil)) { + return $ifaceNil; + } + return reflectType(i.constructor); + }; + $pkg.TypeOf = TypeOf; + ValueOf = function(i) { + var _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($interfaceIsEqual(i, $ifaceNil)) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + _r = makeValue(reflectType(i.constructor), i.$val, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ValueOf }; } $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.ValueOf = ValueOf; + FuncOf = function(in$1, out, variadic) { + var _i, _i$1, _r, _ref, _ref$1, _v, _v$1, i, i$1, in$1, jsIn, jsOut, out, v, v$1, variadic, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; _v$1 = $f._v$1; i = $f.i; i$1 = $f.i$1; in$1 = $f.in$1; jsIn = $f.jsIn; jsOut = $f.jsOut; out = $f.out; v = $f.v; v$1 = $f.v$1; variadic = $f.variadic; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (!(variadic)) { _v = false; $s = 3; continue s; } + if (in$1.$length === 0) { _v$1 = true; $s = 4; continue s; } + _r = (x = in$1.$length - 1 >> 0, ((x < 0 || x >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + x])).Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v$1 = !((_r === 23)); case 4: + _v = _v$1; case 3: + /* */ if (_v) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_v) { */ case 1: + $panic(new $String("reflect.FuncOf: last arg of variadic func must be slice")); + /* } */ case 2: + jsIn = $makeSlice(sliceType$8, in$1.$length); + _ref = in$1; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + v = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= jsIn.$length) ? ($throwRuntimeError("index out of range"), undefined) : jsIn.$array[jsIn.$offset + i] = jsType(v)); + _i++; + } + jsOut = $makeSlice(sliceType$8, out.$length); + _ref$1 = out; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + v$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + ((i$1 < 0 || i$1 >= jsOut.$length) ? ($throwRuntimeError("index out of range"), undefined) : jsOut.$array[jsOut.$offset + i$1] = jsType(v$1)); + _i$1++; + } + $s = -1; return reflectType($funcType($externalize(jsIn, sliceType$8), $externalize(jsOut, sliceType$8), $externalize(variadic, $Bool))); + /* */ } return; } if ($f === undefined) { $f = { $blk: FuncOf }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f._v$1 = _v$1; $f.i = i; $f.i$1 = i$1; $f.in$1 = in$1; $f.jsIn = jsIn; $f.jsOut = jsOut; $f.out = out; $f.v = v; $f.v$1 = v$1; $f.variadic = variadic; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.FuncOf = FuncOf; + rtype.ptr.prototype.ptrTo = function() { + var t; + t = this; + return reflectType($ptrType(jsType(t))); + }; + rtype.prototype.ptrTo = function() { return this.$val.ptrTo(); }; + SliceOf = function(t) { + var t; + return reflectType($sliceType(jsType(t))); + }; + $pkg.SliceOf = SliceOf; + Zero = function(typ) { + var _r, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeValue(typ, jsType(typ).zero(), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Zero }; } $f._r = _r; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Zero = Zero; + unsafe_New = function(typ) { + var _1, typ; + _1 = typ.Kind(); + if (_1 === (25)) { + return (new (jsType(typ).ptr)()); + } else if (_1 === (17)) { + return (jsType(typ).zero()); + } else { + return ($newDataPointer(jsType(typ).zero(), jsType(typ.ptrTo()))); + } + }; + makeInt = function(f, bits, t) { + var _1, _r, bits, f, ptr, t, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; bits = $f.bits; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + typ = _r; + ptr = unsafe_New(typ); + _1 = typ.Kind(); + if (_1 === (3)) { + (ptr).$set(((bits.$low << 24 >> 24))); + } else if (_1 === (4)) { + (ptr).$set(((bits.$low << 16 >> 16))); + } else if ((_1 === (2)) || (_1 === (5))) { + (ptr).$set(((bits.$low >> 0))); + } else if (_1 === (6)) { + (ptr).$set((new $Int64(bits.$high, bits.$low))); + } else if (_1 === (8)) { + (ptr).$set(((bits.$low << 24 >>> 24))); + } else if (_1 === (9)) { + (ptr).$set(((bits.$low << 16 >>> 16))); + } else if ((_1 === (7)) || (_1 === (10)) || (_1 === (12))) { + (ptr).$set(((bits.$low >>> 0))); + } else if (_1 === (11)) { + (ptr).$set((bits)); + } + $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeInt }; } $f._1 = _1; $f._r = _r; $f.bits = bits; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + typedmemmove = function(t, dst, src) { + var dst, src, t; + dst.$set(src.$get()); + }; + keyFor = function(t, key) { + var k, key, kv, t; + kv = key; + if (!(kv.$get === undefined)) { + kv = kv.$get(); + } + k = $internalize(jsType(t.Key()).keyFor(kv), $String); + return [kv, k]; + }; + mapaccess = function(t, m, key) { + var _tuple, entry, k, key, m, t; + _tuple = keyFor(t, key); + k = _tuple[1]; + entry = m[$externalize(k, $String)]; + if (entry === undefined) { + return 0; + } + return ($newDataPointer(entry.v, jsType(PtrTo(t.Elem())))); + }; + mapassign = function(t, m, key, val) { + var _r, _tuple, entry, et, jsVal, k, key, kv, m, newVal, t, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; entry = $f.entry; et = $f.et; jsVal = $f.jsVal; k = $f.k; key = $f.key; kv = $f.kv; m = $f.m; newVal = $f.newVal; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tuple = keyFor(t, key); + kv = _tuple[0]; + k = _tuple[1]; + jsVal = val.$get(); + et = t.Elem(); + _r = et.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === 25) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r === 25) { */ case 1: + newVal = jsType(et).zero(); + copyStruct(newVal, jsVal, et); + jsVal = newVal; + /* } */ case 2: + entry = new ($global.Object)(); + entry.k = kv; + entry.v = jsVal; + m[$externalize(k, $String)] = entry; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: mapassign }; } $f._r = _r; $f._tuple = _tuple; $f.entry = entry; $f.et = et; $f.jsVal = jsVal; $f.k = k; $f.key = key; $f.kv = kv; $f.m = m; $f.newVal = newVal; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + mapdelete = function(t, m, key) { + var _tuple, k, key, m, t; + _tuple = keyFor(t, key); + k = _tuple[1]; + delete m[$externalize(k, $String)]; + }; + mapiterinit = function(t, m) { + var m, t; + return ((new mapIter.ptr(t, m, $keys(m), 0))); + }; + mapiterkey = function(it) { + var _r, _r$1, _r$2, it, iter, k, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + iter = ((it)); + k = iter.keys[iter.i]; + _r = iter.t.Key(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = PtrTo(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = jsType(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return ($newDataPointer(iter.m[$externalize($internalize(k, $String), $String)].k, _r$2)); + /* */ } return; } if ($f === undefined) { $f = { $blk: mapiterkey }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.$s = $s; $f.$r = $r; return $f; + }; + mapiternext = function(it) { + var it, iter; + iter = ((it)); + iter.i = iter.i + (1) >> 0; + }; + maplen = function(m) { + var m; + return $parseInt($keys(m).length); + }; + cvtDirect = function(v, typ) { + var _1, _arg, _arg$1, _arg$2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, k, slice, srcVal, typ, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; k = $f.k; slice = $f.slice; srcVal = $f.srcVal; typ = $f.typ; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + srcVal = $clone(v, Value).object(); + /* */ if (srcVal === jsType(v.typ).nil) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (srcVal === jsType(v.typ).nil) { */ case 1: + _r = makeValue(typ, jsType(typ).nil, v.flag); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + val = null; + _r$1 = typ.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + k = _r$1; + _1 = k; + /* */ if (_1 === (23)) { $s = 6; continue; } + /* */ if (_1 === (22)) { $s = 7; continue; } + /* */ if (_1 === (25)) { $s = 8; continue; } + /* */ if ((_1 === (17)) || (_1 === (1)) || (_1 === (18)) || (_1 === (19)) || (_1 === (20)) || (_1 === (21)) || (_1 === (24))) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_1 === (23)) { */ case 6: + slice = new (jsType(typ))(srcVal.$array); + slice.$offset = srcVal.$offset; + slice.$length = srcVal.$length; + slice.$capacity = srcVal.$capacity; + val = $newDataPointer(slice, jsType(PtrTo(typ))); + $s = 11; continue; + /* } else if (_1 === (22)) { */ case 7: + _r$2 = typ.Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = _r$2.Kind(); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 25) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_r$3 === 25) { */ case 12: + _r$4 = typ.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if ($interfaceIsEqual(_r$4, v.typ.Elem())) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if ($interfaceIsEqual(_r$4, v.typ.Elem())) { */ case 16: + val = srcVal; + /* break; */ $s = 4; continue; + /* } */ case 17: + val = new (jsType(typ))(); + _arg = val; + _arg$1 = srcVal; + _r$5 = typ.Elem(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$2 = _r$5; + $r = copyStruct(_arg, _arg$1, _arg$2); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* break; */ $s = 4; continue; + /* } */ case 13: + val = new (jsType(typ))(srcVal.$get, srcVal.$set); + $s = 11; continue; + /* } else if (_1 === (25)) { */ case 8: + val = new (jsType(typ).ptr)(); + copyStruct(val, srcVal, typ); + $s = 11; continue; + /* } else if ((_1 === (17)) || (_1 === (1)) || (_1 === (18)) || (_1 === (19)) || (_1 === (20)) || (_1 === (21)) || (_1 === (24))) { */ case 9: + val = v.ptr; + $s = 11; continue; + /* } else { */ case 10: + $panic(new ValueError.ptr("reflect.Convert", k)); + /* } */ case 11: + case 4: + _r$6 = typ.common(); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$7 = typ.Kind(); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r$6, (val), (((new flag(v.flag).ro() | ((v.flag & 128) >>> 0)) >>> 0) | ((_r$7 >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtDirect }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f.k = k; $f.slice = slice; $f.srcVal = srcVal; $f.typ = typ; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + methodReceiver = function(op, v, i) { + var _$38, _r, fn, i, m, m$1, ms, op, prop, rcvr, t, tt, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _$38 = $f._$38; _r = $f._r; fn = $f.fn; i = $f.i; m = $f.m; m$1 = $f.m$1; ms = $f.ms; op = $f.op; prop = $f.prop; rcvr = $f.rcvr; t = $f.t; tt = $f.tt; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _$38 = ptrType$1.nil; + t = ptrType$1.nil; + fn = 0; + prop = ""; + /* */ if (v.typ.Kind() === 20) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (v.typ.Kind() === 20) { */ case 1: + tt = (v.typ.kindType); + if (i < 0 || i >= tt.methods.$length) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m = (x = tt.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + if (!$clone(tt.rtype.nameOff(m.name), name).isExported()) { + $panic(new $String("reflect: " + op + " of unexported method")); + } + t = tt.rtype.typeOff(m.typ); + prop = $clone(tt.rtype.nameOff(m.name), name).name(); + $s = 3; continue; + /* } else { */ case 2: + _r = v.typ.exportedMethods(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ms = _r; + if (((i >>> 0)) >= ((ms.$length >>> 0))) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m$1 = $clone(((i < 0 || i >= ms.$length) ? ($throwRuntimeError("index out of range"), undefined) : ms.$array[ms.$offset + i]), method); + if (!$clone(v.typ.nameOff(m$1.name), name).isExported()) { + $panic(new $String("reflect: " + op + " of unexported method")); + } + t = v.typ.typeOff(m$1.mtyp); + prop = $internalize($methodSet(jsType(v.typ))[i].prop, $String); + /* } */ case 3: + rcvr = $clone(v, Value).object(); + if (isWrapped(v.typ)) { + rcvr = new (jsType(v.typ))(rcvr); + } + fn = (rcvr[$externalize(prop, $String)]); + $s = -1; return [_$38, t, fn]; + /* */ } return; } if ($f === undefined) { $f = { $blk: methodReceiver }; } $f._$38 = _$38; $f._r = _r; $f.fn = fn; $f.i = i; $f.m = m; $f.m$1 = m$1; $f.ms = ms; $f.op = op; $f.prop = prop; $f.rcvr = rcvr; $f.t = t; $f.tt = tt; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + valueInterface = function(v, safe) { + var _r, safe, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; safe = $f.safe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (v.flag === 0) { + $panic(new ValueError.ptr("reflect.Value.Interface", 0)); + } + if (safe && !((((v.flag & 96) >>> 0) === 0))) { + $panic(new $String("reflect.Value.Interface: cannot return value obtained from unexported field or method")); + } + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = makeMethodValue("Interface", $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + if (isWrapped(v.typ)) { + $s = -1; return ((new (jsType(v.typ))($clone(v, Value).object()))); + } + $s = -1; return (($clone(v, Value).object())); + /* */ } return; } if ($f === undefined) { $f = { $blk: valueInterface }; } $f._r = _r; $f.safe = safe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ifaceE2I = function(t, src, dst) { + var dst, src, t; + dst.$set(src); + }; + methodName = function() { + return "?FIXME?"; + }; + makeMethodValue = function(op, v) { + var _r, _r$1, _r$2, _tuple, fn, fv, op, rcvr, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; fn = $f.fn; fv = $f.fv; op = $f.op; rcvr = $f.rcvr; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fn = [fn]; + rcvr = [rcvr]; + if (((v.flag & 512) >>> 0) === 0) { + $panic(new $String("reflect: internal error: invalid use of makePartialFunc")); + } + _r = methodReceiver(op, $clone(v, Value), ((v.flag >> 0)) >> 10 >> 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + fn[0] = _tuple[2]; + rcvr[0] = $clone(v, Value).object(); + if (isWrapped(v.typ)) { + rcvr[0] = new (jsType(v.typ))(rcvr[0]); + } + fv = js.MakeFunc((function(fn, rcvr) { return function(this$1, arguments$1) { + var arguments$1, this$1; + return new $jsObjectPtr(fn[0].apply(rcvr[0], $externalize(arguments$1, sliceType$8))); + }; })(fn, rcvr)); + _r$1 = $clone(v, Value).Type(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = _r$1.common(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r$2, (fv), (new flag(v.flag).ro() | 19) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeMethodValue }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.fn = fn; $f.fv = fv; $f.op = op; $f.rcvr = rcvr; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.ptr.prototype.pointers = function() { + var _1, t; + t = this; + _1 = t.Kind(); + if ((_1 === (22)) || (_1 === (21)) || (_1 === (18)) || (_1 === (19)) || (_1 === (25)) || (_1 === (17))) { + return true; + } else { + return false; + } + }; + rtype.prototype.pointers = function() { return this.$val.pointers(); }; + rtype.ptr.prototype.Comparable = function() { + var _1, _r, _r$1, i, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; i = $f.i; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _1 = t.Kind(); + /* */ if ((_1 === (19)) || (_1 === (23)) || (_1 === (21))) { $s = 2; continue; } + /* */ if (_1 === (17)) { $s = 3; continue; } + /* */ if (_1 === (25)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((_1 === (19)) || (_1 === (23)) || (_1 === (21))) { */ case 2: + $s = -1; return false; + /* } else if (_1 === (17)) { */ case 3: + _r = t.Elem().Comparable(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else if (_1 === (25)) { */ case 4: + i = 0; + /* while (true) { */ case 7: + /* if (!(i < t.NumField())) { break; } */ if(!(i < t.NumField())) { $s = 8; continue; } + _r$1 = t.Field(i).Type.Comparable(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!_r$1) { */ case 9: + $s = -1; return false; + /* } */ case 10: + i = i + (1) >> 0; + /* } */ $s = 7; continue; case 8: + /* } */ case 5: + case 1: + $s = -1; return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Comparable }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Comparable = function() { return this.$val.Comparable(); }; + rtype.ptr.prototype.Method = function(i) { + var _i, _i$1, _r, _r$1, _ref, _ref$1, arg, fl, fn, ft, i, in$1, m, methods, mt, mtyp, out, p, pname, prop, ret, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; arg = $f.arg; fl = $f.fl; fn = $f.fn; ft = $f.ft; i = $f.i; in$1 = $f.in$1; m = $f.m; methods = $f.methods; mt = $f.mt; mtyp = $f.mtyp; out = $f.out; p = $f.p; pname = $f.pname; prop = $f.prop; ret = $f.ret; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + prop = [prop]; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + t = this; + if (t.Kind() === 20) { + tt = (t.kindType); + Method.copy(m, tt.Method(i)); + $s = -1; return m; + } + _r = t.exportedMethods(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + methods = _r; + if (i < 0 || i >= methods.$length) { + $panic(new $String("reflect: Method index out of range")); + } + p = $clone(((i < 0 || i >= methods.$length) ? ($throwRuntimeError("index out of range"), undefined) : methods.$array[methods.$offset + i]), method); + pname = $clone(t.nameOff(p.name), name); + m.Name = $clone(pname, name).name(); + fl = 19; + mtyp = t.typeOff(p.mtyp); + ft = (mtyp.kindType); + in$1 = $makeSlice(sliceType$10, 0, (1 + ft.in$().$length >> 0)); + in$1 = $append(in$1, t); + _ref = ft.in$(); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + in$1 = $append(in$1, arg); + _i++; + } + out = $makeSlice(sliceType$10, 0, ft.out().$length); + _ref$1 = ft.out(); + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + ret = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + out = $append(out, ret); + _i$1++; + } + _r$1 = FuncOf(in$1, out, ft.rtype.IsVariadic()); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + mt = _r$1; + m.Type = mt; + prop[0] = $internalize($methodSet(t.jsType)[i].prop, $String); + fn = js.MakeFunc((function(prop) { return function(this$1, arguments$1) { + var arguments$1, rcvr, this$1; + rcvr = (0 >= arguments$1.$length ? ($throwRuntimeError("index out of range"), undefined) : arguments$1.$array[arguments$1.$offset + 0]); + return new $jsObjectPtr(rcvr[$externalize(prop[0], $String)].apply(rcvr, $externalize($subslice(arguments$1, 1), sliceType$8))); + }; })(prop)); + m.Func = new Value.ptr($assertType(mt, ptrType$1), (fn), fl); + m.Index = i; + Method.copy(m, m); + $s = -1; return m; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Method }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f.arg = arg; $f.fl = fl; $f.fn = fn; $f.ft = ft; $f.i = i; $f.in$1 = in$1; $f.m = m; $f.methods = methods; $f.mt = mt; $f.mtyp = mtyp; $f.out = out; $f.p = p; $f.pname = pname; $f.prop = prop; $f.ret = ret; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Method = function(i) { return this.$val.Method(i); }; + Value.ptr.prototype.object = function() { + var _1, newVal, v, val; + v = this; + if ((v.typ.Kind() === 17) || (v.typ.Kind() === 25)) { + return v.ptr; + } + if (!((((v.flag & 128) >>> 0) === 0))) { + val = v.ptr.$get(); + if (!(val === $ifaceNil) && !(val.constructor === jsType(v.typ))) { + switch (0) { default: + _1 = v.typ.Kind(); + if ((_1 === (11)) || (_1 === (6))) { + val = new (jsType(v.typ))(val.$high, val.$low); + } else if ((_1 === (15)) || (_1 === (16))) { + val = new (jsType(v.typ))(val.$real, val.$imag); + } else if (_1 === (23)) { + if (val === val.constructor.nil) { + val = jsType(v.typ).nil; + break; + } + newVal = new (jsType(v.typ))(val.$array); + newVal.$offset = val.$offset; + newVal.$length = val.$length; + newVal.$capacity = val.$capacity; + val = newVal; + } + } + } + return val; + } + return v.ptr; + }; + Value.prototype.object = function() { return this.$val.object(); }; + Value.ptr.prototype.assignTo = function(context, dst, target) { + var _r, _r$1, _r$2, _r$3, context, dst, fl, target, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; context = $f.context; dst = $f.dst; fl = $f.fl; target = $f.target; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = makeMethodValue(context, $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + _r$1 = directlyAssignable(dst, v.typ); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 5; continue; } + /* */ if (implements$1(dst, v.typ)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (_r$1) { */ case 5: + fl = (((v.flag & 384) >>> 0) | new flag(v.flag).ro()) >>> 0; + fl = (fl | (((dst.Kind() >>> 0)))) >>> 0; + $s = -1; return new Value.ptr(dst, v.ptr, fl); + /* } else if (implements$1(dst, v.typ)) { */ case 6: + if (target === 0) { + target = unsafe_New(dst); + } + _r$2 = valueInterface($clone(v, Value), false); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + _r$3 = dst.NumMethod(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 0) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_r$3 === 0) { */ case 10: + (target).$set(x); + $s = 12; continue; + /* } else { */ case 11: + ifaceE2I(dst, x, target); + /* } */ case 12: + $s = -1; return new Value.ptr(dst, target, 148); + /* } */ case 7: + case 4: + $panic(new $String(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String())); + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.assignTo }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.context = context; $f.dst = dst; $f.fl = fl; $f.target = target; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.assignTo = function(context, dst, target) { return this.$val.assignTo(context, dst, target); }; + Value.ptr.prototype.call = function(op, in$1) { + var _1, _arg, _arg$1, _arg$2, _arg$3, _i, _i$1, _i$2, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tuple, arg, argsArray, elem, fn, i, i$1, i$2, i$3, in$1, isSlice, m, n, nin, nout, op, origIn, rcvr, results, ret, slice, t, targ, v, x, x$1, x$2, xt, xt$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; arg = $f.arg; argsArray = $f.argsArray; elem = $f.elem; fn = $f.fn; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; in$1 = $f.in$1; isSlice = $f.isSlice; m = $f.m; n = $f.n; nin = $f.nin; nout = $f.nout; op = $f.op; origIn = $f.origIn; rcvr = $f.rcvr; results = $f.results; ret = $f.ret; slice = $f.slice; t = $f.t; targ = $f.targ; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; xt = $f.xt; xt$1 = $f.xt$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + t = ptrType$1.nil; + fn = 0; + rcvr = null; + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = methodReceiver(op, $clone(v, Value), ((v.flag >> 0)) >> 10 >> 0); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + t = _tuple[1]; + fn = _tuple[2]; + rcvr = $clone(v, Value).object(); + if (isWrapped(v.typ)) { + rcvr = new (jsType(v.typ))(rcvr); + } + $s = 3; continue; + /* } else { */ case 2: + t = v.typ; + fn = ($clone(v, Value).object()); + rcvr = undefined; + /* } */ case 3: + if (fn === 0) { + $panic(new $String("reflect.Value.Call: call of nil function")); + } + isSlice = op === "CallSlice"; + n = t.NumIn(); + if (isSlice) { + if (!t.IsVariadic()) { + $panic(new $String("reflect: CallSlice of non-variadic function")); + } + if (in$1.$length < n) { + $panic(new $String("reflect: CallSlice with too few input arguments")); + } + if (in$1.$length > n) { + $panic(new $String("reflect: CallSlice with too many input arguments")); + } + } else { + if (t.IsVariadic()) { + n = n - (1) >> 0; + } + if (in$1.$length < n) { + $panic(new $String("reflect: Call with too few input arguments")); + } + if (!t.IsVariadic() && in$1.$length > n) { + $panic(new $String("reflect: Call with too many input arguments")); + } + } + _ref = in$1; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if ($clone(x, Value).Kind() === 0) { + $panic(new $String("reflect: " + op + " using zero Value argument")); + } + _i++; + } + i = 0; + /* while (true) { */ case 5: + /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 6; continue; } + _r$1 = $clone(((i < 0 || i >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + i]), Value).Type(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tmp = _r$1; + _tmp$1 = t.In(i); + xt = _tmp; + targ = _tmp$1; + _r$2 = xt.AssignableTo(targ); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (!_r$2) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!_r$2) { */ case 8: + _r$3 = xt.String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = targ.String(); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $panic(new $String("reflect: " + op + " using " + _r$3 + " as type " + _r$4)); + /* } */ case 9: + i = i + (1) >> 0; + /* } */ $s = 5; continue; case 6: + /* */ if (!isSlice && t.IsVariadic()) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (!isSlice && t.IsVariadic()) { */ case 13: + m = in$1.$length - n >> 0; + _r$5 = MakeSlice(t.In(n), m, m); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + slice = _r$5; + _r$6 = t.In(n).Elem(); /* */ $s = 16; case 16: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + elem = _r$6; + i$1 = 0; + /* while (true) { */ case 17: + /* if (!(i$1 < m)) { break; } */ if(!(i$1 < m)) { $s = 18; continue; } + x$2 = (x$1 = n + i$1 >> 0, ((x$1 < 0 || x$1 >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + x$1])); + _r$7 = $clone(x$2, Value).Type(); /* */ $s = 19; case 19: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + xt$1 = _r$7; + _r$8 = xt$1.AssignableTo(elem); /* */ $s = 22; case 22: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + /* */ if (!_r$8) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (!_r$8) { */ case 20: + _r$9 = xt$1.String(); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$10 = elem.String(); /* */ $s = 24; case 24: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + $panic(new $String("reflect: cannot use " + _r$9 + " as type " + _r$10 + " in " + op)); + /* } */ case 21: + _r$11 = $clone(slice, Value).Index(i$1); /* */ $s = 25; case 25: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + $r = $clone(_r$11, Value).Set($clone(x$2, Value)); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$1 = i$1 + (1) >> 0; + /* } */ $s = 17; continue; case 18: + origIn = in$1; + in$1 = $makeSlice(sliceType$9, (n + 1 >> 0)); + $copySlice($subslice(in$1, 0, n), origIn); + ((n < 0 || n >= in$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : in$1.$array[in$1.$offset + n] = slice); + /* } */ case 14: + nin = in$1.$length; + if (!((nin === t.NumIn()))) { + $panic(new $String("reflect.Value.Call: wrong argument count")); + } + nout = t.NumOut(); + argsArray = new ($global.Array)(t.NumIn()); + _ref$1 = in$1; + _i$1 = 0; + /* while (true) { */ case 27: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 28; continue; } + i$2 = _i$1; + arg = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + _arg = t.In(i$2); + _r$12 = t.In(i$2).common(); /* */ $s = 29; case 29: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _arg$1 = _r$12; + _arg$2 = 0; + _r$13 = $clone(arg, Value).assignTo("reflect.Value.Call", _arg$1, _arg$2); /* */ $s = 30; case 30: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + _r$14 = $clone(_r$13, Value).object(); /* */ $s = 31; case 31: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + _arg$3 = _r$14; + _r$15 = unwrapJsObject(_arg, _arg$3); /* */ $s = 32; case 32: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + argsArray[i$2] = _r$15; + _i$1++; + /* } */ $s = 27; continue; case 28: + _r$16 = callHelper(new sliceType$3([new $jsObjectPtr(fn), new $jsObjectPtr(rcvr), new $jsObjectPtr(argsArray)])); /* */ $s = 33; case 33: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + results = _r$16; + _1 = nout; + /* */ if (_1 === (0)) { $s = 35; continue; } + /* */ if (_1 === (1)) { $s = 36; continue; } + /* */ $s = 37; continue; + /* if (_1 === (0)) { */ case 35: + $s = -1; return sliceType$9.nil; + /* } else if (_1 === (1)) { */ case 36: + _r$17 = makeValue(t.Out(0), wrapJsObject(t.Out(0), results), 0); /* */ $s = 39; case 39: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + $s = -1; return new sliceType$9([$clone(_r$17, Value)]); + /* } else { */ case 37: + ret = $makeSlice(sliceType$9, nout); + _ref$2 = ret; + _i$2 = 0; + /* while (true) { */ case 40: + /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 41; continue; } + i$3 = _i$2; + _r$18 = makeValue(t.Out(i$3), wrapJsObject(t.Out(i$3), results[i$3]), 0); /* */ $s = 42; case 42: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + ((i$3 < 0 || i$3 >= ret.$length) ? ($throwRuntimeError("index out of range"), undefined) : ret.$array[ret.$offset + i$3] = _r$18); + _i$2++; + /* } */ $s = 40; continue; case 41: + $s = -1; return ret; + /* } */ case 38: + case 34: + $s = -1; return sliceType$9.nil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.call }; } $f._1 = _1; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.arg = arg; $f.argsArray = argsArray; $f.elem = elem; $f.fn = fn; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.in$1 = in$1; $f.isSlice = isSlice; $f.m = m; $f.n = n; $f.nin = nin; $f.nout = nout; $f.op = op; $f.origIn = origIn; $f.rcvr = rcvr; $f.results = results; $f.ret = ret; $f.slice = slice; $f.t = t; $f.targ = targ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.xt = xt; $f.xt$1 = xt$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.call = function(op, in$1) { return this.$val.call(op, in$1); }; + Value.ptr.prototype.Cap = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (17)) { + return v.typ.Len(); + } else if ((_1 === (18)) || (_1 === (23))) { + return $parseInt($clone(v, Value).object().$capacity) >> 0; + } + $panic(new ValueError.ptr("reflect.Value.Cap", k)); + }; + Value.prototype.Cap = function() { return this.$val.Cap(); }; + wrapJsObject = function(typ, val) { + var typ, val; + if ($interfaceIsEqual(typ, jsObjectPtr)) { + return new (jsType(jsObjectPtr))(val); + } + return val; + }; + unwrapJsObject = function(typ, val) { + var typ, val; + if ($interfaceIsEqual(typ, jsObjectPtr)) { + return val.object; + } + return val; + }; + Value.ptr.prototype.Elem = function() { + var _1, _r, fl, k, tt, typ, v, val, val$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; fl = $f.fl; k = $f.k; tt = $f.tt; typ = $f.typ; v = $f.v; val = $f.val; val$1 = $f.val$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + k = new flag(v.flag).kind(); + _1 = k; + /* */ if (_1 === (20)) { $s = 2; continue; } + /* */ if (_1 === (22)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_1 === (20)) { */ case 2: + val = $clone(v, Value).object(); + if (val === $ifaceNil) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + typ = reflectType(val.constructor); + _r = makeValue(typ, val.$val, new flag(v.flag).ro()); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else if (_1 === (22)) { */ case 3: + if ($clone(v, Value).IsNil()) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + val$1 = $clone(v, Value).object(); + tt = (v.typ.kindType); + fl = (((((v.flag & 96) >>> 0) | 128) >>> 0) | 256) >>> 0; + fl = (fl | (((tt.elem.Kind() >>> 0)))) >>> 0; + $s = -1; return new Value.ptr(tt.elem, (wrapJsObject(tt.elem, val$1)), fl); + /* } else { */ case 4: + $panic(new ValueError.ptr("reflect.Value.Elem", k)); + /* } */ case 5: + case 1: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Elem }; } $f._1 = _1; $f._r = _r; $f.fl = fl; $f.k = k; $f.tt = tt; $f.typ = typ; $f.v = v; $f.val = val; $f.val$1 = val$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Elem = function() { return this.$val.Elem(); }; + Value.ptr.prototype.Field = function(i) { + var _r, _r$1, _r$2, field, fl, i, jsTag, o, prop, s, tag, tt, typ, v, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; field = $f.field; fl = $f.fl; i = $f.i; jsTag = $f.jsTag; o = $f.o; prop = $f.prop; s = $f.s; tag = $f.tag; tt = $f.tt; typ = $f.typ; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + jsTag = [jsTag]; + prop = [prop]; + s = [s]; + typ = [typ]; + v = this; + if (!((new flag(v.flag).kind() === 25))) { + $panic(new ValueError.ptr("reflect.Value.Field", new flag(v.flag).kind())); + } + tt = (v.typ.kindType); + if (((i >>> 0)) >= ((tt.fields.$length >>> 0))) { + $panic(new $String("reflect: Field index out of range")); + } + prop[0] = $internalize(jsType(v.typ).fields[i].prop, $String); + field = (x = tt.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + typ[0] = field.typ; + fl = (((v.flag & 416) >>> 0) | ((typ[0].Kind() >>> 0))) >>> 0; + if (!$clone(field.name, name).isExported()) { + if (field.anon()) { + fl = (fl | (64)) >>> 0; + } else { + fl = (fl | (32)) >>> 0; + } + } + tag = $clone((x$1 = tt.fields, ((i < 0 || i >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i])).name, name).tag(); + /* */ if (!(tag === "") && !((i === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(tag === "") && !((i === 0))) { */ case 1: + jsTag[0] = getJsTag(tag); + /* */ if (!(jsTag[0] === "")) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(jsTag[0] === "")) { */ case 3: + /* while (true) { */ case 5: + o = [o]; + _r = $clone(v, Value).Field(0); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* */ if (v.typ === jsObjectPtr) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (v.typ === jsObjectPtr) { */ case 8: + o[0] = $clone(v, Value).object().object; + $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(jsTag, o, prop, s, typ) { return function() { + return $internalize(o[0][$externalize(jsTag[0], $String)], jsType(typ[0])); + }; })(jsTag, o, prop, s, typ), (function(jsTag, o, prop, s, typ) { return function(x$2) { + var x$2; + o[0][$externalize(jsTag[0], $String)] = $externalize(x$2, jsType(typ[0])); + }; })(jsTag, o, prop, s, typ))), fl); + /* } */ case 9: + /* */ if (v.typ.Kind() === 22) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (v.typ.Kind() === 22) { */ case 10: + _r$1 = $clone(v, Value).Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + v = _r$1; + /* } */ case 11: + /* } */ $s = 5; continue; case 6: + /* } */ case 4: + /* } */ case 2: + s[0] = v.ptr; + /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 13: + $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(jsTag, prop, s, typ) { return function() { + return wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]); + }; })(jsTag, prop, s, typ), (function(jsTag, prop, s, typ) { return function(x$2) { + var x$2; + s[0][$externalize(prop[0], $String)] = unwrapJsObject(typ[0], x$2); + }; })(jsTag, prop, s, typ))), fl); + /* } */ case 14: + _r$2 = makeValue(typ[0], wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]), fl); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Field }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.field = field; $f.fl = fl; $f.i = i; $f.jsTag = jsTag; $f.o = o; $f.prop = prop; $f.s = s; $f.tag = tag; $f.tt = tt; $f.typ = typ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Field = function(i) { return this.$val.Field(i); }; + getJsTag = function(tag) { + var _tuple, i, name$1, qvalue, tag, value; + while (true) { + if (!(!(tag === ""))) { break; } + i = 0; + while (true) { + if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; } + i = i + (1) >> 0; + } + tag = $substring(tag, i); + if (tag === "") { + break; + } + i = 0; + while (true) { + if (!(i < tag.length && !((tag.charCodeAt(i) === 32)) && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)))) { break; } + i = i + (1) >> 0; + } + if ((i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) { + break; + } + name$1 = ($substring(tag, 0, i)); + tag = $substring(tag, (i + 1 >> 0)); + i = 1; + while (true) { + if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; } + if (tag.charCodeAt(i) === 92) { + i = i + (1) >> 0; + } + i = i + (1) >> 0; + } + if (i >= tag.length) { + break; + } + qvalue = ($substring(tag, 0, (i + 1 >> 0))); + tag = $substring(tag, (i + 1 >> 0)); + if (name$1 === "js") { + _tuple = strconv.Unquote(qvalue); + value = _tuple[0]; + return value; + } + } + return ""; + }; + Value.ptr.prototype.Index = function(i) { + var _1, _r, _r$1, a, a$1, c, fl, fl$1, fl$2, i, k, s, str, tt, tt$1, typ, typ$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; a = $f.a; a$1 = $f.a$1; c = $f.c; fl = $f.fl; fl$1 = $f.fl$1; fl$2 = $f.fl$2; i = $f.i; k = $f.k; s = $f.s; str = $f.str; tt = $f.tt; tt$1 = $f.tt$1; typ = $f.typ; typ$1 = $f.typ$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + a = [a]; + a$1 = [a$1]; + c = [c]; + i = [i]; + typ = [typ]; + typ$1 = [typ$1]; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + /* */ if (_1 === (17)) { $s = 2; continue; } + /* */ if (_1 === (23)) { $s = 3; continue; } + /* */ if (_1 === (24)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_1 === (17)) { */ case 2: + tt = (v.typ.kindType); + if (i[0] < 0 || i[0] > ((tt.len >> 0))) { + $panic(new $String("reflect: array index out of range")); + } + typ[0] = tt.elem; + fl = (((((v.flag & 384) >>> 0) | new flag(v.flag).ro()) >>> 0) | ((typ[0].Kind() >>> 0))) >>> 0; + a[0] = v.ptr; + /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!((((fl & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 7: + $s = -1; return new Value.ptr(typ[0], (new (jsType(PtrTo(typ[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { + return wrapJsObject(typ[0], a[0][i[0]]); + }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) { + var x; + a[0][i[0]] = unwrapJsObject(typ[0], x); + }; })(a, a$1, c, i, typ, typ$1))), fl); + /* } */ case 8: + _r = makeValue(typ[0], wrapJsObject(typ[0], a[0][i[0]]), fl); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else if (_1 === (23)) { */ case 3: + s = $clone(v, Value).object(); + if (i[0] < 0 || i[0] >= ($parseInt(s.$length) >> 0)) { + $panic(new $String("reflect: slice index out of range")); + } + tt$1 = (v.typ.kindType); + typ$1[0] = tt$1.elem; + fl$1 = (((384 | new flag(v.flag).ro()) >>> 0) | ((typ$1[0].Kind() >>> 0))) >>> 0; + i[0] = i[0] + (($parseInt(s.$offset) >> 0)) >> 0; + a$1[0] = s.$array; + /* */ if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { */ case 10: + $s = -1; return new Value.ptr(typ$1[0], (new (jsType(PtrTo(typ$1[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { + return wrapJsObject(typ$1[0], a$1[0][i[0]]); + }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) { + var x; + a$1[0][i[0]] = unwrapJsObject(typ$1[0], x); + }; })(a, a$1, c, i, typ, typ$1))), fl$1); + /* } */ case 11: + _r$1 = makeValue(typ$1[0], wrapJsObject(typ$1[0], a$1[0][i[0]]), fl$1); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } else if (_1 === (24)) { */ case 4: + str = (v.ptr).$get(); + if (i[0] < 0 || i[0] >= str.length) { + $panic(new $String("reflect: string index out of range")); + } + fl$2 = (((new flag(v.flag).ro() | 8) >>> 0) | 128) >>> 0; + c[0] = str.charCodeAt(i[0]); + $s = -1; return new Value.ptr(uint8Type, ((c.$ptr || (c.$ptr = new ptrType$4(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, c)))), fl$2); + /* } else { */ case 5: + $panic(new ValueError.ptr("reflect.Value.Index", k)); + /* } */ case 6: + case 1: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Index }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.a$1 = a$1; $f.c = c; $f.fl = fl; $f.fl$1 = fl$1; $f.fl$2 = fl$2; $f.i = i; $f.k = k; $f.s = s; $f.str = str; $f.tt = tt; $f.tt$1 = tt$1; $f.typ = typ; $f.typ$1 = typ$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Index = function(i) { return this.$val.Index(i); }; + Value.ptr.prototype.InterfaceData = function() { + var v; + v = this; + $panic(errors.New("InterfaceData is not supported by GopherJS")); + }; + Value.prototype.InterfaceData = function() { return this.$val.InterfaceData(); }; + Value.ptr.prototype.IsNil = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (22)) || (_1 === (23))) { + return $clone(v, Value).object() === jsType(v.typ).nil; + } else if (_1 === (18)) { + return $clone(v, Value).object() === $chanNil; + } else if (_1 === (19)) { + return $clone(v, Value).object() === $throwNilPointerError; + } else if (_1 === (21)) { + return $clone(v, Value).object() === false; + } else if (_1 === (20)) { + return $clone(v, Value).object() === $ifaceNil; + } else { + $panic(new ValueError.ptr("reflect.Value.IsNil", k)); + } + }; + Value.prototype.IsNil = function() { return this.$val.IsNil(); }; + Value.ptr.prototype.Len = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (17)) || (_1 === (24))) { + return $parseInt($clone(v, Value).object().length); + } else if (_1 === (23)) { + return $parseInt($clone(v, Value).object().$length) >> 0; + } else if (_1 === (18)) { + return $parseInt($clone(v, Value).object().$buffer.length) >> 0; + } else if (_1 === (21)) { + return $parseInt($keys($clone(v, Value).object()).length); + } else { + $panic(new ValueError.ptr("reflect.Value.Len", k)); + } + }; + Value.prototype.Len = function() { return this.$val.Len(); }; + Value.ptr.prototype.Pointer = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (18)) || (_1 === (21)) || (_1 === (22)) || (_1 === (26))) { + if ($clone(v, Value).IsNil()) { + return 0; + } + return $clone(v, Value).object(); + } else if (_1 === (19)) { + if ($clone(v, Value).IsNil()) { + return 0; + } + return 1; + } else if (_1 === (23)) { + if ($clone(v, Value).IsNil()) { + return 0; + } + return $clone(v, Value).object().$array; + } else { + $panic(new ValueError.ptr("reflect.Value.Pointer", k)); + } + }; + Value.prototype.Pointer = function() { return this.$val.Pointer(); }; + Value.ptr.prototype.Set = function(x) { + var _1, _r, _r$1, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(x.flag).mustBeExported(); + _r = $clone(x, Value).assignTo("reflect.Set", v.typ, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + /* */ if (!((((v.flag & 128) >>> 0) === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((((v.flag & 128) >>> 0) === 0))) { */ case 2: + _1 = v.typ.Kind(); + /* */ if (_1 === (17)) { $s = 5; continue; } + /* */ if (_1 === (20)) { $s = 6; continue; } + /* */ if (_1 === (25)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_1 === (17)) { */ case 5: + jsType(v.typ).copy(v.ptr, x.ptr); + $s = 9; continue; + /* } else if (_1 === (20)) { */ case 6: + _r$1 = valueInterface($clone(x, Value), false); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + v.ptr.$set(_r$1); + $s = 9; continue; + /* } else if (_1 === (25)) { */ case 7: + copyStruct(v.ptr, x.ptr, v.typ); + $s = 9; continue; + /* } else { */ case 8: + v.ptr.$set($clone(x, Value).object()); + /* } */ case 9: + case 4: + $s = -1; return; + /* } */ case 3: + v.ptr = x.ptr; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Set }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Set = function(x) { return this.$val.Set(x); }; + Value.ptr.prototype.SetBytes = function(x) { + var _r, _r$1, _v, slice, typedSlice, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; slice = $f.slice; typedSlice = $f.typedSlice; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 8))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 8))) { */ case 1: + $panic(new $String("reflect.Value.SetBytes of non-byte slice")); + /* } */ case 2: + slice = x; + if (!(v.typ.Name() === "")) { _v = true; $s = 6; continue s; } + _r$1 = v.typ.Elem().Name(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = !(_r$1 === ""); case 6: + /* */ if (_v) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_v) { */ case 4: + typedSlice = new (jsType(v.typ))(slice.$array); + typedSlice.$offset = slice.$offset; + typedSlice.$length = slice.$length; + typedSlice.$capacity = slice.$capacity; + slice = typedSlice; + /* } */ case 5: + v.ptr.$set(slice); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetBytes }; } $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.slice = slice; $f.typedSlice = typedSlice; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.SetBytes = function(x) { return this.$val.SetBytes(x); }; + Value.ptr.prototype.SetCap = function(n) { + var n, newSlice, s, v; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + s = v.ptr.$get(); + if (n < ($parseInt(s.$length) >> 0) || n > ($parseInt(s.$capacity) >> 0)) { + $panic(new $String("reflect: slice capacity out of range in SetCap")); + } + newSlice = new (jsType(v.typ))(s.$array); + newSlice.$offset = s.$offset; + newSlice.$length = s.$length; + newSlice.$capacity = n; + v.ptr.$set(newSlice); + }; + Value.prototype.SetCap = function(n) { return this.$val.SetCap(n); }; + Value.ptr.prototype.SetLen = function(n) { + var n, newSlice, s, v; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + s = v.ptr.$get(); + if (n < 0 || n > ($parseInt(s.$capacity) >> 0)) { + $panic(new $String("reflect: slice length out of range in SetLen")); + } + newSlice = new (jsType(v.typ))(s.$array); + newSlice.$offset = s.$offset; + newSlice.$length = n; + newSlice.$capacity = s.$capacity; + v.ptr.$set(newSlice); + }; + Value.prototype.SetLen = function(n) { return this.$val.SetLen(n); }; + Value.ptr.prototype.Slice = function(i, j) { + var _1, _r, _r$1, cap, i, j, kind, s, str, tt, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; i = $f.i; j = $f.j; kind = $f.kind; s = $f.s; str = $f.str; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + cap = 0; + typ = $ifaceNil; + s = null; + kind = new flag(v.flag).kind(); + _1 = kind; + /* */ if (_1 === (17)) { $s = 2; continue; } + /* */ if (_1 === (23)) { $s = 3; continue; } + /* */ if (_1 === (24)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_1 === (17)) { */ case 2: + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.Slice: slice of unaddressable array")); + } + tt = (v.typ.kindType); + cap = ((tt.len >> 0)); + typ = SliceOf(tt.elem); + s = new (jsType(typ))($clone(v, Value).object()); + $s = 6; continue; + /* } else if (_1 === (23)) { */ case 3: + typ = v.typ; + s = $clone(v, Value).object(); + cap = $parseInt(s.$capacity) >> 0; + $s = 6; continue; + /* } else if (_1 === (24)) { */ case 4: + str = (v.ptr).$get(); + if (i < 0 || j < i || j > str.length) { + $panic(new $String("reflect.Value.Slice: string slice index out of bounds")); + } + _r = ValueOf(new $String($substring(str, i, j))); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } else { */ case 5: + $panic(new ValueError.ptr("reflect.Value.Slice", kind)); + /* } */ case 6: + case 1: + if (i < 0 || j < i || j > cap) { + $panic(new $String("reflect.Value.Slice: slice index out of bounds")); + } + _r$1 = makeValue(typ, $subslice(s, i, j), new flag(v.flag).ro()); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.i = i; $f.j = j; $f.kind = kind; $f.s = s; $f.str = str; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Slice = function(i, j) { return this.$val.Slice(i, j); }; + Value.ptr.prototype.Slice3 = function(i, j, k) { + var _1, _r, cap, i, j, k, kind, s, tt, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; cap = $f.cap; i = $f.i; j = $f.j; k = $f.k; kind = $f.kind; s = $f.s; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + cap = 0; + typ = $ifaceNil; + s = null; + kind = new flag(v.flag).kind(); + _1 = kind; + if (_1 === (17)) { + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.Slice: slice of unaddressable array")); + } + tt = (v.typ.kindType); + cap = ((tt.len >> 0)); + typ = SliceOf(tt.elem); + s = new (jsType(typ))($clone(v, Value).object()); + } else if (_1 === (23)) { + typ = v.typ; + s = $clone(v, Value).object(); + cap = $parseInt(s.$capacity) >> 0; + } else { + $panic(new ValueError.ptr("reflect.Value.Slice3", kind)); + } + if (i < 0 || j < i || k < j || k > cap) { + $panic(new $String("reflect.Value.Slice3: slice index out of bounds")); + } + _r = makeValue(typ, $subslice(s, i, j, k), new flag(v.flag).ro()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice3 }; } $f._1 = _1; $f._r = _r; $f.cap = cap; $f.i = i; $f.j = j; $f.k = k; $f.kind = kind; $f.s = s; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Slice3 = function(i, j, k) { return this.$val.Slice3(i, j, k); }; + Value.ptr.prototype.Close = function() { + var v; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + $close($clone(v, Value).object()); + }; + Value.prototype.Close = function() { return this.$val.Close(); }; + chanrecv = function(ch, nb, val) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, ch, comms, nb, received, recvRes, selectRes, selected, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; ch = $f.ch; comms = $f.comms; nb = $f.nb; received = $f.received; recvRes = $f.recvRes; selectRes = $f.selectRes; selected = $f.selected; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + selected = false; + received = false; + comms = new sliceType$11([new sliceType$8([ch])]); + if (nb) { + comms = $append(comms, new sliceType$8([])); + } + _r = selectHelper(new sliceType$3([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + selectRes = _r; + if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) { + _tmp = false; + _tmp$1 = false; + selected = _tmp; + received = _tmp$1; + $s = -1; return [selected, received]; + } + recvRes = selectRes[1]; + val.$set(recvRes[0]); + _tmp$2 = true; + _tmp$3 = !!(recvRes[1]); + selected = _tmp$2; + received = _tmp$3; + $s = -1; return [selected, received]; + /* */ } return; } if ($f === undefined) { $f = { $blk: chanrecv }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.received = received; $f.recvRes = recvRes; $f.selectRes = selectRes; $f.selected = selected; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + chansend = function(ch, val, nb) { + var _r, ch, comms, nb, selectRes, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; ch = $f.ch; comms = $f.comms; nb = $f.nb; selectRes = $f.selectRes; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + comms = new sliceType$11([new sliceType$8([ch, val.$get()])]); + if (nb) { + comms = $append(comms, new sliceType$8([])); + } + _r = selectHelper(new sliceType$3([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + selectRes = _r; + if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) { + $s = -1; return false; + } + $s = -1; return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: chansend }; } $f._r = _r; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.selectRes = selectRes; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + structField.ptr.prototype.offset = function() { + var f; + f = this; + return f.offsetAnon >>> 1 >>> 0; + }; + structField.prototype.offset = function() { return this.$val.offset(); }; + structField.ptr.prototype.anon = function() { + var f; + f = this; + return !((((f.offsetAnon & 1) >>> 0) === 0)); + }; + structField.prototype.anon = function() { return this.$val.anon(); }; + Kind.prototype.String = function() { + var k; + k = this.$val; + if (((k >> 0)) < kindNames.$length) { + return ((k < 0 || k >= kindNames.$length) ? ($throwRuntimeError("index out of range"), undefined) : kindNames.$array[kindNames.$offset + k]); + } + return "kind" + strconv.Itoa(((k >> 0))); + }; + $ptrType(Kind).prototype.String = function() { return new Kind(this.$get()).String(); }; + rtype.ptr.prototype.String = function() { + var s, t; + t = this; + s = $clone(t.nameOff(t.str), name).name(); + if (!((((t.tflag & 2) >>> 0) === 0))) { + return $substring(s, 1); + } + return s; + }; + rtype.prototype.String = function() { return this.$val.String(); }; + rtype.ptr.prototype.Size = function() { + var t; + t = this; + return t.size; + }; + rtype.prototype.Size = function() { return this.$val.Size(); }; + rtype.ptr.prototype.Bits = function() { + var k, t; + t = this; + if (t === ptrType$1.nil) { + $panic(new $String("reflect: Bits of nil Type")); + } + k = t.Kind(); + if (k < 2 || k > 16) { + $panic(new $String("reflect: Bits of non-arithmetic Type " + t.String())); + } + return $imul(((t.size >> 0)), 8); + }; + rtype.prototype.Bits = function() { return this.$val.Bits(); }; + rtype.ptr.prototype.Align = function() { + var t; + t = this; + return ((t.align >> 0)); + }; + rtype.prototype.Align = function() { return this.$val.Align(); }; + rtype.ptr.prototype.FieldAlign = function() { + var t; + t = this; + return ((t.fieldAlign >> 0)); + }; + rtype.prototype.FieldAlign = function() { return this.$val.FieldAlign(); }; + rtype.ptr.prototype.Kind = function() { + var t; + t = this; + return ((((t.kind & 31) >>> 0) >>> 0)); + }; + rtype.prototype.Kind = function() { return this.$val.Kind(); }; + rtype.ptr.prototype.common = function() { + var t; + t = this; + return t; + }; + rtype.prototype.common = function() { return this.$val.common(); }; + rtype.ptr.prototype.exportedMethods = function() { + var _i, _i$1, _r, _r$1, _ref, _ref$1, _tuple, _tuple$1, allExported, allm, found, m, m$1, methods, methodsi, name$1, name$2, t, ut, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; allExported = $f.allExported; allm = $f.allm; found = $f.found; m = $f.m; m$1 = $f.m$1; methods = $f.methods; methodsi = $f.methodsi; name$1 = $f.name$1; name$2 = $f.name$2; t = $f.t; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r = methodCache.Load(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + methodsi = _tuple[0]; + found = _tuple[1]; + if (found) { + $s = -1; return $assertType(methodsi, sliceType$5); + } + ut = t.uncommon(); + if (ut === ptrType$5.nil) { + $s = -1; return sliceType$5.nil; + } + allm = ut.methods(); + allExported = true; + _ref = allm; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + m = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), method); + name$1 = $clone(t.nameOff(m.name), name); + if (!$clone(name$1, name).isExported()) { + allExported = false; + break; + } + _i++; + } + methods = sliceType$5.nil; + if (allExported) { + methods = allm; + } else { + methods = $makeSlice(sliceType$5, 0, allm.$length); + _ref$1 = allm; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + m$1 = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]), method); + name$2 = $clone(t.nameOff(m$1.name), name); + if ($clone(name$2, name).isExported()) { + methods = $append(methods, m$1); + } + _i$1++; + } + methods = $subslice(methods, 0, methods.$length, methods.$length); + } + _r$1 = methodCache.LoadOrStore(t, methods); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$1 = _r$1; + methodsi = _tuple$1[0]; + $s = -1; return $assertType(methodsi, sliceType$5); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.exportedMethods }; } $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.allExported = allExported; $f.allm = allm; $f.found = found; $f.m = m; $f.m$1 = m$1; $f.methods = methods; $f.methodsi = methodsi; $f.name$1 = name$1; $f.name$2 = name$2; $f.t = t; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.exportedMethods = function() { return this.$val.exportedMethods(); }; + rtype.ptr.prototype.NumMethod = function() { + var _r, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (t.Kind() === 20) { + tt = (t.kindType); + $s = -1; return tt.NumMethod(); + } + if (((t.tflag & 1) >>> 0) === 0) { + $s = -1; return 0; + } + _r = t.exportedMethods(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r.$length; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.NumMethod }; } $f._r = _r; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + rtype.ptr.prototype.MethodByName = function(name$1) { + var _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, eidx, i, m, name$1, ok, p, pname, t, tt, ut, utmethods, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; eidx = $f.eidx; i = $f.i; m = $f.m; name$1 = $f.name$1; ok = $f.ok; p = $f.p; pname = $f.pname; t = $f.t; tt = $f.tt; ut = $f.ut; utmethods = $f.utmethods; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + ok = false; + t = this; + if (t.Kind() === 20) { + tt = (t.kindType); + _tuple = tt.MethodByName(name$1); + Method.copy(m, _tuple[0]); + ok = _tuple[1]; + $s = -1; return [m, ok]; + } + ut = t.uncommon(); + if (ut === ptrType$5.nil) { + _tmp = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + _tmp$1 = false; + Method.copy(m, _tmp); + ok = _tmp$1; + $s = -1; return [m, ok]; + } + utmethods = ut.methods(); + eidx = 0; + i = 0; + /* while (true) { */ case 1: + /* if (!(i < ((ut.mcount >> 0)))) { break; } */ if(!(i < ((ut.mcount >> 0)))) { $s = 2; continue; } + p = $clone(((i < 0 || i >= utmethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : utmethods.$array[utmethods.$offset + i]), method); + pname = $clone(t.nameOff(p.name), name); + /* */ if ($clone(pname, name).isExported()) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($clone(pname, name).isExported()) { */ case 3: + /* */ if ($clone(pname, name).name() === name$1) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ($clone(pname, name).name() === name$1) { */ case 5: + _r = t.Method(eidx); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tmp$2 = $clone(_r, Method); + _tmp$3 = true; + Method.copy(m, _tmp$2); + ok = _tmp$3; + $s = -1; return [m, ok]; + /* } */ case 6: + eidx = eidx + (1) >> 0; + /* } */ case 4: + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + _tmp$4 = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + _tmp$5 = false; + Method.copy(m, _tmp$4); + ok = _tmp$5; + $s = -1; return [m, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.MethodByName }; } $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.eidx = eidx; $f.i = i; $f.m = m; $f.name$1 = name$1; $f.ok = ok; $f.p = p; $f.pname = pname; $f.t = t; $f.tt = tt; $f.ut = ut; $f.utmethods = utmethods; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; + rtype.ptr.prototype.PkgPath = function() { + var t, ut; + t = this; + if (((t.tflag & 4) >>> 0) === 0) { + return ""; + } + ut = t.uncommon(); + if (ut === ptrType$5.nil) { + return ""; + } + return $clone(t.nameOff(ut.pkgPath), name).name(); + }; + rtype.prototype.PkgPath = function() { return this.$val.PkgPath(); }; + rtype.ptr.prototype.Name = function() { + var i, s, t; + t = this; + if (((t.tflag & 4) >>> 0) === 0) { + return ""; + } + s = t.String(); + i = s.length - 1 >> 0; + while (true) { + if (!(i >= 0)) { break; } + if (s.charCodeAt(i) === 46) { + break; + } + i = i - (1) >> 0; + } + return $substring(s, (i + 1 >> 0)); + }; + rtype.prototype.Name = function() { return this.$val.Name(); }; + rtype.ptr.prototype.ChanDir = function() { + var t, tt; + t = this; + if (!((t.Kind() === 18))) { + $panic(new $String("reflect: ChanDir of non-chan type")); + } + tt = (t.kindType); + return ((tt.dir >> 0)); + }; + rtype.prototype.ChanDir = function() { return this.$val.ChanDir(); }; + rtype.ptr.prototype.IsVariadic = function() { + var t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: IsVariadic of non-func type")); + } + tt = (t.kindType); + return !((((tt.outCount & 32768) >>> 0) === 0)); + }; + rtype.prototype.IsVariadic = function() { return this.$val.IsVariadic(); }; + rtype.ptr.prototype.Elem = function() { + var _1, t, tt, tt$1, tt$2, tt$3, tt$4; + t = this; + _1 = t.Kind(); + if (_1 === (17)) { + tt = (t.kindType); + return toType(tt.elem); + } else if (_1 === (18)) { + tt$1 = (t.kindType); + return toType(tt$1.elem); + } else if (_1 === (21)) { + tt$2 = (t.kindType); + return toType(tt$2.elem); + } else if (_1 === (22)) { + tt$3 = (t.kindType); + return toType(tt$3.elem); + } else if (_1 === (23)) { + tt$4 = (t.kindType); + return toType(tt$4.elem); + } + $panic(new $String("reflect: Elem of invalid type")); + }; + rtype.prototype.Elem = function() { return this.$val.Elem(); }; + rtype.ptr.prototype.Field = function(i) { + var i, t, tt; + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: Field of non-struct type")); + } + tt = (t.kindType); + return tt.Field(i); + }; + rtype.prototype.Field = function(i) { return this.$val.Field(i); }; + rtype.ptr.prototype.FieldByIndex = function(index) { + var _r, index, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; index = $f.index; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: FieldByIndex of non-struct type")); + } + tt = (t.kindType); + _r = tt.FieldByIndex(index); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByIndex }; } $f._r = _r; $f.index = index; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; + rtype.ptr.prototype.FieldByName = function(name$1) { + var _r, name$1, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; name$1 = $f.name$1; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: FieldByName of non-struct type")); + } + tt = (t.kindType); + _r = tt.FieldByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByName }; } $f._r = _r; $f.name$1 = name$1; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; + rtype.ptr.prototype.FieldByNameFunc = function(match) { + var _r, match, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; match = $f.match; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: FieldByNameFunc of non-struct type")); + } + tt = (t.kindType); + _r = tt.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByNameFunc }; } $f._r = _r; $f.match = match; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; + rtype.ptr.prototype.In = function(i) { + var i, t, tt, x; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: In of non-func type")); + } + tt = (t.kindType); + return toType((x = tt.in$(), ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]))); + }; + rtype.prototype.In = function(i) { return this.$val.In(i); }; + rtype.ptr.prototype.Key = function() { + var t, tt; + t = this; + if (!((t.Kind() === 21))) { + $panic(new $String("reflect: Key of non-map type")); + } + tt = (t.kindType); + return toType(tt.key); + }; + rtype.prototype.Key = function() { return this.$val.Key(); }; + rtype.ptr.prototype.Len = function() { + var t, tt; + t = this; + if (!((t.Kind() === 17))) { + $panic(new $String("reflect: Len of non-array type")); + } + tt = (t.kindType); + return ((tt.len >> 0)); + }; + rtype.prototype.Len = function() { return this.$val.Len(); }; + rtype.ptr.prototype.NumField = function() { + var t, tt; + t = this; + if (!((t.Kind() === 25))) { + $panic(new $String("reflect: NumField of non-struct type")); + } + tt = (t.kindType); + return tt.fields.$length; + }; + rtype.prototype.NumField = function() { return this.$val.NumField(); }; + rtype.ptr.prototype.NumIn = function() { + var t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: NumIn of non-func type")); + } + tt = (t.kindType); + return ((tt.inCount >> 0)); + }; + rtype.prototype.NumIn = function() { return this.$val.NumIn(); }; + rtype.ptr.prototype.NumOut = function() { + var t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: NumOut of non-func type")); + } + tt = (t.kindType); + return tt.out().$length; + }; + rtype.prototype.NumOut = function() { return this.$val.NumOut(); }; + rtype.ptr.prototype.Out = function(i) { + var i, t, tt, x; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: Out of non-func type")); + } + tt = (t.kindType); + return toType((x = tt.out(), ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i]))); + }; + rtype.prototype.Out = function(i) { return this.$val.Out(i); }; + ChanDir.prototype.String = function() { + var _1, d; + d = this.$val; + _1 = d; + if (_1 === (2)) { + return "chan<-"; + } else if (_1 === (1)) { + return "<-chan"; + } else if (_1 === (3)) { + return "chan"; + } + return "ChanDir" + strconv.Itoa(((d >> 0))); + }; + $ptrType(ChanDir).prototype.String = function() { return new ChanDir(this.$get()).String(); }; + interfaceType.ptr.prototype.Method = function(i) { + var i, m, p, pname, t, x; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + t = this; + if (i < 0 || i >= t.methods.$length) { + return m; + } + p = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + pname = $clone(t.rtype.nameOff(p.name), name); + m.Name = $clone(pname, name).name(); + if (!$clone(pname, name).isExported()) { + m.PkgPath = $clone(pname, name).pkgPath(); + if (m.PkgPath === "") { + m.PkgPath = $clone(t.pkgPath, name).name(); + } + } + m.Type = toType(t.rtype.typeOff(p.typ)); + m.Index = i; + return m; + }; + interfaceType.prototype.Method = function(i) { return this.$val.Method(i); }; + interfaceType.ptr.prototype.NumMethod = function() { + var t; + t = this; + return t.methods.$length; + }; + interfaceType.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + interfaceType.ptr.prototype.MethodByName = function(name$1) { + var _i, _ref, _tmp, _tmp$1, i, m, name$1, ok, p, t, x; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + ok = false; + t = this; + if (t === ptrType$7.nil) { + return [m, ok]; + } + p = ptrType$8.nil; + _ref = t.methods; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + p = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + if ($clone(t.rtype.nameOff(p.name), name).name() === name$1) { + _tmp = $clone(t.Method(i), Method); + _tmp$1 = true; + Method.copy(m, _tmp); + ok = _tmp$1; + return [m, ok]; + } + _i++; + } + return [m, ok]; + }; + interfaceType.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; + StructTag.prototype.Get = function(key) { + var _tuple, key, tag, v; + tag = this.$val; + _tuple = new StructTag(tag).Lookup(key); + v = _tuple[0]; + return v; + }; + $ptrType(StructTag).prototype.Get = function(key) { return new StructTag(this.$get()).Get(key); }; + StructTag.prototype.Lookup = function(key) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, err, i, key, name$1, ok, qvalue, tag, value, value$1; + value = ""; + ok = false; + tag = this.$val; + while (true) { + if (!(!(tag === ""))) { break; } + i = 0; + while (true) { + if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; } + i = i + (1) >> 0; + } + tag = $substring(tag, i); + if (tag === "") { + break; + } + i = 0; + while (true) { + if (!(i < tag.length && tag.charCodeAt(i) > 32 && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)) && !((tag.charCodeAt(i) === 127)))) { break; } + i = i + (1) >> 0; + } + if ((i === 0) || (i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) { + break; + } + name$1 = ($substring(tag, 0, i)); + tag = $substring(tag, (i + 1 >> 0)); + i = 1; + while (true) { + if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; } + if (tag.charCodeAt(i) === 92) { + i = i + (1) >> 0; + } + i = i + (1) >> 0; + } + if (i >= tag.length) { + break; + } + qvalue = ($substring(tag, 0, (i + 1 >> 0))); + tag = $substring(tag, (i + 1 >> 0)); + if (key === name$1) { + _tuple = strconv.Unquote(qvalue); + value$1 = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + break; + } + _tmp = value$1; + _tmp$1 = true; + value = _tmp; + ok = _tmp$1; + return [value, ok]; + } + } + _tmp$2 = ""; + _tmp$3 = false; + value = _tmp$2; + ok = _tmp$3; + return [value, ok]; + }; + $ptrType(StructTag).prototype.Lookup = function(key) { return new StructTag(this.$get()).Lookup(key); }; + structType.ptr.prototype.Field = function(i) { + var f, i, p, t, tag, x; + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + t = this; + if (i < 0 || i >= t.fields.$length) { + $panic(new $String("reflect: Field index out of bounds")); + } + p = (x = t.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + f.Type = toType(p.typ); + f.Name = $clone(p.name, name).name(); + f.Anonymous = p.anon(); + if (!$clone(p.name, name).isExported()) { + f.PkgPath = $clone(t.pkgPath, name).name(); + } + tag = $clone(p.name, name).tag(); + if (!(tag === "")) { + f.Tag = (tag); + } + f.Offset = p.offset(); + f.Index = new sliceType$13([i]); + return f; + }; + structType.prototype.Field = function(i) { return this.$val.Field(i); }; + structType.ptr.prototype.FieldByIndex = function(index) { + var _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, _v, f, ft, i, index, t, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _v = $f._v; f = $f.f; ft = $f.ft; i = $f.i; index = $f.index; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + t = this; + f.Type = toType(t.rtype); + _ref = index; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = _i; + x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + /* */ if (i > 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (i > 0) { */ case 3: + ft = f.Type; + _r = ft.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + if (!(_r === 22)) { _v = false; $s = 7; continue s; } + _r$1 = ft.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = _r$1.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v = _r$2 === 25; case 7: + /* */ if (_v) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_v) { */ case 5: + _r$3 = ft.Elem(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + ft = _r$3; + /* } */ case 6: + f.Type = ft; + /* } */ case 4: + _r$4 = f.Type.Field(x); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + StructField.copy(f, _r$4); + _i++; + /* } */ $s = 1; continue; case 2: + $s = -1; return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByIndex }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._v = _v; $f.f = f; $f.ft = ft; $f.i = i; $f.index = index; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; + structType.ptr.prototype.FieldByNameFunc = function(match) { + var _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _key$2, _key$3, _r, _r$1, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, count, current, f, fname, i, index, match, next, nextCount, ntyp, ok, result, scan, styp, t, t$1, visited, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; count = $f.count; current = $f.current; f = $f.f; fname = $f.fname; i = $f.i; index = $f.index; match = $f.match; next = $f.next; nextCount = $f.nextCount; ntyp = $f.ntyp; ok = $f.ok; result = $f.result; scan = $f.scan; styp = $f.styp; t = $f.t; t$1 = $f.t$1; visited = $f.visited; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + result = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + ok = false; + t = this; + current = new sliceType$14([]); + next = new sliceType$14([new fieldScan.ptr(t, sliceType$13.nil)]); + nextCount = false; + visited = $makeMap(ptrType$9.keyFor, []); + /* while (true) { */ case 1: + /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; } + _tmp = next; + _tmp$1 = $subslice(current, 0, 0); + current = _tmp; + next = _tmp$1; + count = nextCount; + nextCount = false; + _ref = current; + _i = 0; + /* while (true) { */ case 3: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } + scan = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), fieldScan); + t$1 = scan.typ; + /* */ if ((_entry = visited[ptrType$9.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((_entry = visited[ptrType$9.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { */ case 5: + _i++; + /* continue; */ $s = 3; continue; + /* } */ case 6: + _key = t$1; (visited || $throwRuntimeError("assignment to entry in nil map"))[ptrType$9.keyFor(_key)] = { k: _key, v: true }; + _ref$1 = t$1.fields; + _i$1 = 0; + /* while (true) { */ case 7: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; } + i = _i$1; + f = (x = t$1.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + fname = $clone(f.name, name).name(); + ntyp = ptrType$1.nil; + /* */ if (f.anon()) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (f.anon()) { */ case 9: + ntyp = f.typ; + /* */ if (ntyp.Kind() === 22) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (ntyp.Kind() === 22) { */ case 11: + _r = ntyp.Elem().common(); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ntyp = _r; + /* } */ case 12: + /* } */ case 10: + _r$1 = match(fname); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (_r$1) { */ case 14: + if ((_entry$1 = count[ptrType$9.keyFor(t$1)], _entry$1 !== undefined ? _entry$1.v : 0) > 1 || ok) { + _tmp$2 = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + _tmp$3 = false; + StructField.copy(result, _tmp$2); + ok = _tmp$3; + $s = -1; return [result, ok]; + } + StructField.copy(result, t$1.Field(i)); + result.Index = sliceType$13.nil; + result.Index = $appendSlice(result.Index, scan.index); + result.Index = $append(result.Index, i); + ok = true; + _i$1++; + /* continue; */ $s = 7; continue; + /* } */ case 15: + if (ok || ntyp === ptrType$1.nil || !((ntyp.Kind() === 25))) { + _i$1++; + /* continue; */ $s = 7; continue; + } + styp = (ntyp.kindType); + if ((_entry$2 = nextCount[ptrType$9.keyFor(styp)], _entry$2 !== undefined ? _entry$2.v : 0) > 0) { + _key$1 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$9.keyFor(_key$1)] = { k: _key$1, v: 2 }; + _i$1++; + /* continue; */ $s = 7; continue; + } + if (nextCount === false) { + nextCount = $makeMap(ptrType$9.keyFor, []); + } + _key$2 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$9.keyFor(_key$2)] = { k: _key$2, v: 1 }; + if ((_entry$3 = count[ptrType$9.keyFor(t$1)], _entry$3 !== undefined ? _entry$3.v : 0) > 1) { + _key$3 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$9.keyFor(_key$3)] = { k: _key$3, v: 2 }; + } + index = sliceType$13.nil; + index = $appendSlice(index, scan.index); + index = $append(index, i); + next = $append(next, new fieldScan.ptr(styp, index)); + _i$1++; + /* } */ $s = 7; continue; case 8: + _i++; + /* } */ $s = 3; continue; case 4: + if (ok) { + /* break; */ $s = 2; continue; + } + /* } */ $s = 1; continue; case 2: + $s = -1; return [result, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByNameFunc }; } $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.count = count; $f.current = current; $f.f = f; $f.fname = fname; $f.i = i; $f.index = index; $f.match = match; $f.next = next; $f.nextCount = nextCount; $f.ntyp = ntyp; $f.ok = ok; $f.result = result; $f.scan = scan; $f.styp = styp; $f.t = t; $f.t$1 = t$1; $f.visited = visited; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; + structType.ptr.prototype.FieldByName = function(name$1) { + var _i, _r, _ref, _tmp, _tmp$1, _tuple, f, hasAnon, i, name$1, present, t, tf, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; hasAnon = $f.hasAnon; i = $f.i; name$1 = $f.name$1; present = $f.present; t = $f.t; tf = $f.tf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name$1 = [name$1]; + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$13.nil, false); + present = false; + t = this; + hasAnon = false; + if (!(name$1[0] === "")) { + _ref = t.fields; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + tf = (x = t.fields, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + if ($clone(tf.name, name).name() === name$1[0]) { + _tmp = $clone(t.Field(i), StructField); + _tmp$1 = true; + StructField.copy(f, _tmp); + present = _tmp$1; + $s = -1; return [f, present]; + } + if (tf.anon()) { + hasAnon = true; + } + _i++; + } + } + if (!hasAnon) { + $s = -1; return [f, present]; + } + _r = t.FieldByNameFunc((function(name$1) { return function(s) { + var s; + return s === name$1[0]; + }; })(name$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + StructField.copy(f, _tuple[0]); + present = _tuple[1]; + $s = -1; return [f, present]; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByName }; } $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.hasAnon = hasAnon; $f.i = i; $f.name$1 = name$1; $f.present = present; $f.t = t; $f.tf = tf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; + PtrTo = function(t) { + var t; + return $assertType(t, ptrType$1).ptrTo(); + }; + $pkg.PtrTo = PtrTo; + rtype.ptr.prototype.Implements = function(u) { + var _r, t, u, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.Implements")); + } + _r = u.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 20))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 20))) { */ case 1: + $panic(new $String("reflect: non-interface type passed to Type.Implements")); + /* } */ case 2: + $s = -1; return implements$1($assertType(u, ptrType$1), t); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Implements }; } $f._r = _r; $f.t = t; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Implements = function(u) { return this.$val.Implements(u); }; + rtype.ptr.prototype.AssignableTo = function(u) { + var _r, t, u, uu, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.AssignableTo")); + } + uu = $assertType(u, ptrType$1); + _r = directlyAssignable(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r || implements$1(uu, t); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.AssignableTo }; } $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.AssignableTo = function(u) { return this.$val.AssignableTo(u); }; + rtype.ptr.prototype.ConvertibleTo = function(u) { + var _r, t, u, uu, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.ConvertibleTo")); + } + uu = $assertType(u, ptrType$1); + _r = convertOp(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return !(_r === $throwNilPointerError); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.ConvertibleTo }; } $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.ConvertibleTo = function(u) { return this.$val.ConvertibleTo(u); }; + implements$1 = function(T, V) { + var T, V, i, i$1, j, j$1, t, tm, tm$1, tmName, tmName$1, tmPkgPath, tmPkgPath$1, v, v$1, vm, vm$1, vmName, vmName$1, vmPkgPath, vmPkgPath$1, vmethods, x, x$1, x$2; + if (!((T.Kind() === 20))) { + return false; + } + t = (T.kindType); + if (t.methods.$length === 0) { + return true; + } + if (V.Kind() === 20) { + v = (V.kindType); + i = 0; + j = 0; + while (true) { + if (!(j < v.methods.$length)) { break; } + tm = (x = t.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + tmName = $clone(t.rtype.nameOff(tm.name), name); + vm = (x$1 = v.methods, ((j < 0 || j >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + j])); + vmName = $clone(V.nameOff(vm.name), name); + if ($clone(vmName, name).name() === $clone(tmName, name).name() && V.typeOff(vm.typ) === t.rtype.typeOff(tm.typ)) { + if (!$clone(tmName, name).isExported()) { + tmPkgPath = $clone(tmName, name).pkgPath(); + if (tmPkgPath === "") { + tmPkgPath = $clone(t.pkgPath, name).name(); + } + vmPkgPath = $clone(vmName, name).pkgPath(); + if (vmPkgPath === "") { + vmPkgPath = $clone(v.pkgPath, name).name(); + } + if (!(tmPkgPath === vmPkgPath)) { + j = j + (1) >> 0; + continue; + } + } + i = i + (1) >> 0; + if (i >= t.methods.$length) { + return true; + } + } + j = j + (1) >> 0; + } + return false; + } + v$1 = V.uncommon(); + if (v$1 === ptrType$5.nil) { + return false; + } + i$1 = 0; + vmethods = v$1.methods(); + j$1 = 0; + while (true) { + if (!(j$1 < ((v$1.mcount >> 0)))) { break; } + tm$1 = (x$2 = t.methods, ((i$1 < 0 || i$1 >= x$2.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$2.$array[x$2.$offset + i$1])); + tmName$1 = $clone(t.rtype.nameOff(tm$1.name), name); + vm$1 = $clone(((j$1 < 0 || j$1 >= vmethods.$length) ? ($throwRuntimeError("index out of range"), undefined) : vmethods.$array[vmethods.$offset + j$1]), method); + vmName$1 = $clone(V.nameOff(vm$1.name), name); + if ($clone(vmName$1, name).name() === $clone(tmName$1, name).name() && V.typeOff(vm$1.mtyp) === t.rtype.typeOff(tm$1.typ)) { + if (!$clone(tmName$1, name).isExported()) { + tmPkgPath$1 = $clone(tmName$1, name).pkgPath(); + if (tmPkgPath$1 === "") { + tmPkgPath$1 = $clone(t.pkgPath, name).name(); + } + vmPkgPath$1 = $clone(vmName$1, name).pkgPath(); + if (vmPkgPath$1 === "") { + vmPkgPath$1 = $clone(V.nameOff(v$1.pkgPath), name).name(); + } + if (!(tmPkgPath$1 === vmPkgPath$1)) { + j$1 = j$1 + (1) >> 0; + continue; + } + } + i$1 = i$1 + (1) >> 0; + if (i$1 >= t.methods.$length) { + return true; + } + } + j$1 = j$1 + (1) >> 0; + } + return false; + }; + directlyAssignable = function(T, V) { + var T, V, _r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _r = $f._r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (T === V) { + $s = -1; return true; + } + if (!(T.Name() === "") && !(V.Name() === "") || !((T.Kind() === V.Kind()))) { + $s = -1; return false; + } + _r = haveIdenticalUnderlyingType(T, V, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: directlyAssignable }; } $f.T = T; $f.V = V; $f._r = _r; $f.$s = $s; $f.$r = $r; return $f; + }; + haveIdenticalType = function(T, V, cmpTags) { + var T, V, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _v, cmpTags, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _v = $f._v; cmpTags = $f.cmpTags; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (cmpTags) { + $s = -1; return $interfaceIsEqual(T, V); + } + _r = T.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = V.Name(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + if (!(_r === _r$1)) { _v = true; $s = 3; continue s; } + _r$2 = T.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = V.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _v = !((_r$2 === _r$3)); case 3: + /* */ if (_v) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_v) { */ case 1: + $s = -1; return false; + /* } */ case 2: + _r$4 = T.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _arg = _r$4; + _r$5 = V.common(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = _r$5; + _r$6 = haveIdenticalUnderlyingType(_arg, _arg$1, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + $s = -1; return _r$6; + /* */ } return; } if ($f === undefined) { $f = { $blk: haveIdenticalType }; } $f.T = T; $f.V = V; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._v = _v; $f.cmpTags = cmpTags; $f.$s = $s; $f.$r = $r; return $f; + }; + haveIdenticalUnderlyingType = function(T, V, cmpTags) { + var T, V, _1, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _v, _v$1, _v$2, _v$3, cmpTags, i, i$1, i$2, kind, t, t$1, t$2, tf, v, v$1, v$2, vf, x, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; T = $f.T; V = $f.V; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; cmpTags = $f.cmpTags; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; kind = $f.kind; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; tf = $f.tf; v = $f.v; v$1 = $f.v$1; v$2 = $f.v$2; vf = $f.vf; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (T === V) { + $s = -1; return true; + } + kind = T.Kind(); + if (!((kind === V.Kind()))) { + $s = -1; return false; + } + if (1 <= kind && kind <= 16 || (kind === 24) || (kind === 26)) { + $s = -1; return true; + } + _1 = kind; + /* */ if (_1 === (17)) { $s = 2; continue; } + /* */ if (_1 === (18)) { $s = 3; continue; } + /* */ if (_1 === (19)) { $s = 4; continue; } + /* */ if (_1 === (20)) { $s = 5; continue; } + /* */ if (_1 === (21)) { $s = 6; continue; } + /* */ if ((_1 === (22)) || (_1 === (23))) { $s = 7; continue; } + /* */ if (_1 === (25)) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (_1 === (17)) { */ case 2: + if (!(T.Len() === V.Len())) { _v = false; $s = 10; continue s; } + _r = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r; case 10: + $s = -1; return _v; + /* } else if (_1 === (18)) { */ case 3: + if (!(V.ChanDir() === 3)) { _v$1 = false; $s = 14; continue s; } + _r$1 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 15; case 15: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v$1 = _r$1; case 14: + /* */ if (_v$1) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_v$1) { */ case 12: + $s = -1; return true; + /* } */ case 13: + if (!(V.ChanDir() === T.ChanDir())) { _v$2 = false; $s = 16; continue s; } + _r$2 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$2 = _r$2; case 16: + $s = -1; return _v$2; + /* } else if (_1 === (19)) { */ case 4: + t = (T.kindType); + v = (V.kindType); + if (!((t.outCount === v.outCount)) || !((t.inCount === v.inCount))) { + $s = -1; return false; + } + i = 0; + /* while (true) { */ case 18: + /* if (!(i < t.rtype.NumIn())) { break; } */ if(!(i < t.rtype.NumIn())) { $s = 19; continue; } + _r$3 = haveIdenticalType(t.rtype.In(i), v.rtype.In(i), cmpTags); /* */ $s = 22; case 22: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!_r$3) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (!_r$3) { */ case 20: + $s = -1; return false; + /* } */ case 21: + i = i + (1) >> 0; + /* } */ $s = 18; continue; case 19: + i$1 = 0; + /* while (true) { */ case 23: + /* if (!(i$1 < t.rtype.NumOut())) { break; } */ if(!(i$1 < t.rtype.NumOut())) { $s = 24; continue; } + _r$4 = haveIdenticalType(t.rtype.Out(i$1), v.rtype.Out(i$1), cmpTags); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!_r$4) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (!_r$4) { */ case 25: + $s = -1; return false; + /* } */ case 26: + i$1 = i$1 + (1) >> 0; + /* } */ $s = 23; continue; case 24: + $s = -1; return true; + /* } else if (_1 === (20)) { */ case 5: + t$1 = (T.kindType); + v$1 = (V.kindType); + if ((t$1.methods.$length === 0) && (v$1.methods.$length === 0)) { + $s = -1; return true; + } + $s = -1; return false; + /* } else if (_1 === (21)) { */ case 6: + _r$5 = haveIdenticalType(T.Key(), V.Key(), cmpTags); /* */ $s = 29; case 29: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + if (!(_r$5)) { _v$3 = false; $s = 28; continue s; } + _r$6 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 30; case 30: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _v$3 = _r$6; case 28: + $s = -1; return _v$3; + /* } else if ((_1 === (22)) || (_1 === (23))) { */ case 7: + _r$7 = haveIdenticalType(T.Elem(), V.Elem(), cmpTags); /* */ $s = 31; case 31: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + $s = -1; return _r$7; + /* } else if (_1 === (25)) { */ case 8: + t$2 = (T.kindType); + v$2 = (V.kindType); + if (!((t$2.fields.$length === v$2.fields.$length))) { + $s = -1; return false; + } + if (!($clone(t$2.pkgPath, name).name() === $clone(v$2.pkgPath, name).name())) { + $s = -1; return false; + } + _ref = t$2.fields; + _i = 0; + /* while (true) { */ case 32: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 33; continue; } + i$2 = _i; + tf = (x = t$2.fields, ((i$2 < 0 || i$2 >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i$2])); + vf = (x$1 = v$2.fields, ((i$2 < 0 || i$2 >= x$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : x$1.$array[x$1.$offset + i$2])); + if (!($clone(tf.name, name).name() === $clone(vf.name, name).name())) { + $s = -1; return false; + } + _r$8 = haveIdenticalType(tf.typ, vf.typ, cmpTags); /* */ $s = 36; case 36: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + /* */ if (!_r$8) { $s = 34; continue; } + /* */ $s = 35; continue; + /* if (!_r$8) { */ case 34: + $s = -1; return false; + /* } */ case 35: + if (cmpTags && !($clone(tf.name, name).tag() === $clone(vf.name, name).tag())) { + $s = -1; return false; + } + if (!((tf.offsetAnon === vf.offsetAnon))) { + $s = -1; return false; + } + _i++; + /* } */ $s = 32; continue; case 33: + $s = -1; return true; + /* } */ case 9: + case 1: + $s = -1; return false; + /* */ } return; } if ($f === undefined) { $f = { $blk: haveIdenticalUnderlyingType }; } $f.T = T; $f.V = V; $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f.cmpTags = cmpTags; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.kind = kind; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.tf = tf; $f.v = v; $f.v$1 = v$1; $f.v$2 = v$2; $f.vf = vf; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + toType = function(t) { + var t; + if (t === ptrType$1.nil) { + return $ifaceNil; + } + return t; + }; + ifaceIndir = function(t) { + var t; + return ((t.kind & 32) >>> 0) === 0; + }; + flag.prototype.kind = function() { + var f; + f = this.$val; + return ((((f & 31) >>> 0) >>> 0)); + }; + $ptrType(flag).prototype.kind = function() { return new flag(this.$get()).kind(); }; + flag.prototype.ro = function() { + var f; + f = this.$val; + if (!((((f & 96) >>> 0) === 0))) { + return 32; + } + return 0; + }; + $ptrType(flag).prototype.ro = function() { return new flag(this.$get()).ro(); }; + Value.ptr.prototype.pointer = function() { + var v; + v = this; + if (!((v.typ.size === 4)) || !v.typ.pointers()) { + $panic(new $String("can't call pointer on a non-pointer Value")); + } + if (!((((v.flag & 128) >>> 0) === 0))) { + return (v.ptr).$get(); + } + return v.ptr; + }; + Value.prototype.pointer = function() { return this.$val.pointer(); }; + ValueError.ptr.prototype.Error = function() { + var e; + e = this; + if (e.Kind === 0) { + return "reflect: call of " + e.Method + " on zero Value"; + } + return "reflect: call of " + e.Method + " on " + new Kind(e.Kind).String() + " Value"; + }; + ValueError.prototype.Error = function() { return this.$val.Error(); }; + flag.prototype.mustBe = function(expected) { + var expected, f; + f = this.$val; + if (!((new flag(f).kind() === expected))) { + $panic(new ValueError.ptr(methodName(), new flag(f).kind())); + } + }; + $ptrType(flag).prototype.mustBe = function(expected) { return new flag(this.$get()).mustBe(expected); }; + flag.prototype.mustBeExported = function() { + var f; + f = this.$val; + if (f === 0) { + $panic(new ValueError.ptr(methodName(), 0)); + } + if (!((((f & 96) >>> 0) === 0))) { + $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field")); + } + }; + $ptrType(flag).prototype.mustBeExported = function() { return new flag(this.$get()).mustBeExported(); }; + flag.prototype.mustBeAssignable = function() { + var f; + f = this.$val; + if (f === 0) { + $panic(new ValueError.ptr(methodName(), 0)); + } + if (!((((f & 96) >>> 0) === 0))) { + $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field")); + } + if (((f & 256) >>> 0) === 0) { + $panic(new $String("reflect: " + methodName() + " using unaddressable value")); + } + }; + $ptrType(flag).prototype.mustBeAssignable = function() { return new flag(this.$get()).mustBeAssignable(); }; + Value.ptr.prototype.Addr = function() { + var v; + v = this; + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.Addr of unaddressable value")); + } + return new Value.ptr(v.typ.ptrTo(), v.ptr, (new flag(v.flag).ro() | 22) >>> 0); + }; + Value.prototype.Addr = function() { return this.$val.Addr(); }; + Value.ptr.prototype.Bool = function() { + var v; + v = this; + new flag(v.flag).mustBe(1); + return (v.ptr).$get(); + }; + Value.prototype.Bool = function() { return this.$val.Bool(); }; + Value.ptr.prototype.Bytes = function() { + var _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 8))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 8))) { */ case 1: + $panic(new $String("reflect.Value.Bytes of non-byte slice")); + /* } */ case 2: + $s = -1; return (v.ptr).$get(); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Bytes }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Bytes = function() { return this.$val.Bytes(); }; + Value.ptr.prototype.runes = function() { + var _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 5))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 5))) { */ case 1: + $panic(new $String("reflect.Value.Bytes of non-rune slice")); + /* } */ case 2: + $s = -1; return (v.ptr).$get(); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.runes }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.runes = function() { return this.$val.runes(); }; + Value.ptr.prototype.CanAddr = function() { + var v; + v = this; + return !((((v.flag & 256) >>> 0) === 0)); + }; + Value.prototype.CanAddr = function() { return this.$val.CanAddr(); }; + Value.ptr.prototype.CanSet = function() { + var v; + v = this; + return ((v.flag & 352) >>> 0) === 256; + }; + Value.prototype.CanSet = function() { return this.$val.CanSet(); }; + Value.ptr.prototype.Call = function(in$1) { + var _r, in$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(19); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).call("Call", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Call }; } $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Call = function(in$1) { return this.$val.Call(in$1); }; + Value.ptr.prototype.CallSlice = function(in$1) { + var _r, in$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(19); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).call("CallSlice", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.CallSlice }; } $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.CallSlice = function(in$1) { return this.$val.CallSlice(in$1); }; + Value.ptr.prototype.Complex = function() { + var _1, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (15)) { + return ((x = (v.ptr).$get(), new $Complex128(x.$real, x.$imag))); + } else if (_1 === (16)) { + return (v.ptr).$get(); + } + $panic(new ValueError.ptr("reflect.Value.Complex", new flag(v.flag).kind())); + }; + Value.prototype.Complex = function() { return this.$val.Complex(); }; + Value.ptr.prototype.FieldByIndex = function(index) { + var _i, _r, _r$1, _r$2, _r$3, _ref, _v, i, index, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _v = $f._v; i = $f.i; index = $f.index; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + /* */ if (index.$length === 1) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (index.$length === 1) { */ case 1: + _r = $clone(v, Value).Field((0 >= index.$length ? ($throwRuntimeError("index out of range"), undefined) : index.$array[index.$offset + 0])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* } */ case 2: + new flag(v.flag).mustBe(25); + _ref = index; + _i = 0; + /* while (true) { */ case 4: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; } + i = _i; + x = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + /* */ if (i > 0) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (i > 0) { */ case 6: + if (!($clone(v, Value).Kind() === 22)) { _v = false; $s = 10; continue s; } + _r$1 = v.typ.Elem().Kind(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = _r$1 === 25; case 10: + /* */ if (_v) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (_v) { */ case 8: + if ($clone(v, Value).IsNil()) { + $panic(new $String("reflect: indirection through nil pointer to embedded struct")); + } + _r$2 = $clone(v, Value).Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + /* } */ case 9: + /* } */ case 7: + _r$3 = $clone(v, Value).Field(x); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + _i++; + /* } */ $s = 4; continue; case 5: + $s = -1; return v; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByIndex }; } $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._v = _v; $f.i = i; $f.index = index; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); }; + Value.ptr.prototype.FieldByName = function(name$1) { + var _r, _r$1, _tuple, f, name$1, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; name$1 = $f.name$1; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(25); + _r = v.typ.FieldByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + f = $clone(_tuple[0], StructField); + ok = _tuple[1]; + /* */ if (ok) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (ok) { */ case 2: + _r$1 = $clone(v, Value).FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 3: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByName }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.name$1 = name$1; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByName = function(name$1) { return this.$val.FieldByName(name$1); }; + Value.ptr.prototype.FieldByNameFunc = function(match) { + var _r, _r$1, _tuple, f, match, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; match = $f.match; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + _r = v.typ.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + f = $clone(_tuple[0], StructField); + ok = _tuple[1]; + /* */ if (ok) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (ok) { */ case 2: + _r$1 = $clone(v, Value).FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 3: + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByNameFunc }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.match = match; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); }; + Value.ptr.prototype.Float = function() { + var _1, k, v; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (13)) { + return ((v.ptr).$get()); + } else if (_1 === (14)) { + return (v.ptr).$get(); + } + $panic(new ValueError.ptr("reflect.Value.Float", new flag(v.flag).kind())); + }; + Value.prototype.Float = function() { return this.$val.Float(); }; + Value.ptr.prototype.Int = function() { + var _1, k, p, v; + v = this; + k = new flag(v.flag).kind(); + p = v.ptr; + _1 = k; + if (_1 === (2)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (3)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (4)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (5)) { + return (new $Int64(0, (p).$get())); + } else if (_1 === (6)) { + return (p).$get(); + } + $panic(new ValueError.ptr("reflect.Value.Int", new flag(v.flag).kind())); + }; + Value.prototype.Int = function() { return this.$val.Int(); }; + Value.ptr.prototype.CanInterface = function() { + var v; + v = this; + if (v.flag === 0) { + $panic(new ValueError.ptr("reflect.Value.CanInterface", 0)); + } + return ((v.flag & 96) >>> 0) === 0; + }; + Value.prototype.CanInterface = function() { return this.$val.CanInterface(); }; + Value.ptr.prototype.Interface = function() { + var _r, i, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; i = $f.i; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = $ifaceNil; + v = this; + _r = valueInterface($clone(v, Value), true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + i = _r; + $s = -1; return i; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Interface }; } $f._r = _r; $f.i = i; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Interface = function() { return this.$val.Interface(); }; + Value.ptr.prototype.IsValid = function() { + var v; + v = this; + return !((v.flag === 0)); + }; + Value.prototype.IsValid = function() { return this.$val.IsValid(); }; + Value.ptr.prototype.Kind = function() { + var v; + v = this; + return new flag(v.flag).kind(); + }; + Value.prototype.Kind = function() { return this.$val.Kind(); }; + Value.ptr.prototype.MapIndex = function(key) { + var _r, c, e, fl, k, key, tt, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; e = $f.e; fl = $f.fl; k = $f.k; key = $f.key; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(21); + tt = (v.typ.kindType); + _r = $clone(key, Value).assignTo("reflect.Value.MapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + key = _r; + k = 0; + if (!((((key.flag & 128) >>> 0) === 0))) { + k = key.ptr; + } else { + k = ((key.$ptr_ptr || (key.$ptr_ptr = new ptrType$15(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)))); + } + e = mapaccess(v.typ, $clone(v, Value).pointer(), k); + if (e === 0) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + typ = tt.elem; + fl = new flag((((v.flag | key.flag) >>> 0))).ro(); + fl = (fl | (((typ.Kind() >>> 0)))) >>> 0; + if (!ifaceIndir(typ)) { + $s = -1; return new Value.ptr(typ, (e).$get(), fl); + } + c = unsafe_New(typ); + typedmemmove(typ, c, e); + $s = -1; return new Value.ptr(typ, c, (fl | 128) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapIndex }; } $f._r = _r; $f.c = c; $f.e = e; $f.fl = fl; $f.k = k; $f.key = key; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.MapIndex = function(key) { return this.$val.MapIndex(key); }; + Value.ptr.prototype.MapKeys = function() { + var _r, a, c, fl, i, it, key, keyType, m, mlen, tt, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; c = $f.c; fl = $f.fl; i = $f.i; it = $f.it; key = $f.key; keyType = $f.keyType; m = $f.m; mlen = $f.mlen; tt = $f.tt; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(21); + tt = (v.typ.kindType); + keyType = tt.key; + fl = (new flag(v.flag).ro() | ((keyType.Kind() >>> 0))) >>> 0; + m = $clone(v, Value).pointer(); + mlen = 0; + if (!(m === 0)) { + mlen = maplen(m); + } + it = mapiterinit(v.typ, m); + a = $makeSlice(sliceType$9, mlen); + i = 0; + i = 0; + /* while (true) { */ case 1: + /* if (!(i < a.$length)) { break; } */ if(!(i < a.$length)) { $s = 2; continue; } + _r = mapiterkey(it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + key = _r; + if (key === 0) { + /* break; */ $s = 2; continue; + } + if (ifaceIndir(keyType)) { + c = unsafe_New(keyType); + typedmemmove(keyType, c, key); + ((i < 0 || i >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + i] = new Value.ptr(keyType, c, (fl | 128) >>> 0)); + } else { + ((i < 0 || i >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + i] = new Value.ptr(keyType, (key).$get(), fl)); + } + mapiternext(it); + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + $s = -1; return $subslice(a, 0, i); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapKeys }; } $f._r = _r; $f.a = a; $f.c = c; $f.fl = fl; $f.i = i; $f.it = it; $f.key = key; $f.keyType = keyType; $f.m = m; $f.mlen = mlen; $f.tt = tt; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.MapKeys = function() { return this.$val.MapKeys(); }; + Value.ptr.prototype.Method = function(i) { + var _r, _v, fl, i, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _v = $f._v; fl = $f.fl; i = $f.i; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.Method", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0))) { _v = true; $s = 3; continue s; } + _r = v.typ.NumMethod(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = ((i >>> 0)) >= ((_r >>> 0)); case 3: + /* */ if (_v) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_v) { */ case 1: + $panic(new $String("reflect: Method index out of range")); + /* } */ case 2: + if ((v.typ.Kind() === 20) && $clone(v, Value).IsNil()) { + $panic(new $String("reflect: Method on nil interface value")); + } + fl = (v.flag & 160) >>> 0; + fl = (fl | (19)) >>> 0; + fl = (fl | ((((((i >>> 0)) << 10 >>> 0) | 512) >>> 0))) >>> 0; + $s = -1; return new Value.ptr(v.typ, v.ptr, fl); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Method }; } $f._r = _r; $f._v = _v; $f.fl = fl; $f.i = i; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Method = function(i) { return this.$val.Method(i); }; + Value.ptr.prototype.NumMethod = function() { + var _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.NumMethod", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0))) { + $s = -1; return 0; + } + _r = v.typ.NumMethod(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.NumMethod }; } $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + Value.ptr.prototype.MethodByName = function(name$1) { + var _r, _r$1, _tuple, m, name$1, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; m = $f.m; name$1 = $f.name$1; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.MethodByName", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0))) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + _r = v.typ.MethodByName(name$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + m = $clone(_tuple[0], Method); + ok = _tuple[1]; + if (!ok) { + $s = -1; return new Value.ptr(ptrType$1.nil, 0, 0); + } + _r$1 = $clone(v, Value).Method(m.Index); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MethodByName }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.m = m; $f.name$1 = name$1; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.MethodByName = function(name$1) { return this.$val.MethodByName(name$1); }; + Value.ptr.prototype.NumField = function() { + var tt, v; + v = this; + new flag(v.flag).mustBe(25); + tt = (v.typ.kindType); + return tt.fields.$length; + }; + Value.prototype.NumField = function() { return this.$val.NumField(); }; + Value.ptr.prototype.OverflowComplex = function(x) { + var _1, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (15)) { + return overflowFloat32(x.$real) || overflowFloat32(x.$imag); + } else if (_1 === (16)) { + return false; + } + $panic(new ValueError.ptr("reflect.Value.OverflowComplex", new flag(v.flag).kind())); + }; + Value.prototype.OverflowComplex = function(x) { return this.$val.OverflowComplex(x); }; + Value.ptr.prototype.OverflowFloat = function(x) { + var _1, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (13)) { + return overflowFloat32(x); + } else if (_1 === (14)) { + return false; + } + $panic(new ValueError.ptr("reflect.Value.OverflowFloat", new flag(v.flag).kind())); + }; + Value.prototype.OverflowFloat = function(x) { return this.$val.OverflowFloat(x); }; + overflowFloat32 = function(x) { + var x; + if (x < 0) { + x = -x; + } + return 3.4028234663852886e+38 < x && x <= 1.7976931348623157e+308; + }; + Value.ptr.prototype.OverflowInt = function(x) { + var _1, bitSize, k, trunc, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + bitSize = $imul(v.typ.size, 8) >>> 0; + trunc = $shiftRightInt64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0))); + return !((x.$high === trunc.$high && x.$low === trunc.$low)); + } + $panic(new ValueError.ptr("reflect.Value.OverflowInt", new flag(v.flag).kind())); + }; + Value.prototype.OverflowInt = function(x) { return this.$val.OverflowInt(x); }; + Value.ptr.prototype.OverflowUint = function(x) { + var _1, bitSize, k, trunc, v, x; + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if ((_1 === (7)) || (_1 === (12)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11))) { + bitSize = $imul(v.typ.size, 8) >>> 0; + trunc = $shiftRightUint64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0))); + return !((x.$high === trunc.$high && x.$low === trunc.$low)); + } + $panic(new ValueError.ptr("reflect.Value.OverflowUint", new flag(v.flag).kind())); + }; + Value.prototype.OverflowUint = function(x) { return this.$val.OverflowUint(x); }; + Value.ptr.prototype.Recv = function() { + var _r, _tuple, ok, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = new Value.ptr(ptrType$1.nil, 0, 0); + ok = false; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).recv(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + x = _tuple[0]; + ok = _tuple[1]; + $s = -1; return [x, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Recv }; } $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Recv = function() { return this.$val.Recv(); }; + Value.ptr.prototype.recv = function(nb) { + var _r, _tuple, nb, ok, p, selected, t, tt, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; nb = $f.nb; ok = $f.ok; p = $f.p; selected = $f.selected; t = $f.t; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + val = new Value.ptr(ptrType$1.nil, 0, 0); + ok = false; + v = this; + tt = (v.typ.kindType); + if ((((tt.dir >> 0)) & 1) === 0) { + $panic(new $String("reflect: recv on send-only channel")); + } + t = tt.elem; + val = new Value.ptr(t, 0, ((t.Kind() >>> 0))); + p = 0; + if (ifaceIndir(t)) { + p = unsafe_New(t); + val.ptr = p; + val.flag = (val.flag | (128)) >>> 0; + } else { + p = ((val.$ptr_ptr || (val.$ptr_ptr = new ptrType$15(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)))); + } + _r = chanrecv($clone(v, Value).pointer(), nb, p); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + selected = _tuple[0]; + ok = _tuple[1]; + if (!selected) { + val = new Value.ptr(ptrType$1.nil, 0, 0); + } + $s = -1; return [val, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.recv }; } $f._r = _r; $f._tuple = _tuple; $f.nb = nb; $f.ok = ok; $f.p = p; $f.selected = selected; $f.t = t; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.recv = function(nb) { return this.$val.recv(nb); }; + Value.ptr.prototype.Send = function(x) { + var _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).send($clone(x, Value), false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Send }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Send = function(x) { return this.$val.Send(x); }; + Value.ptr.prototype.send = function(x, nb) { + var _r, _r$1, nb, p, selected, tt, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; nb = $f.nb; p = $f.p; selected = $f.selected; tt = $f.tt; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + selected = false; + v = this; + tt = (v.typ.kindType); + if ((((tt.dir >> 0)) & 2) === 0) { + $panic(new $String("reflect: send on recv-only channel")); + } + new flag(x.flag).mustBeExported(); + _r = $clone(x, Value).assignTo("reflect.Value.Send", tt.elem, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + x = _r; + p = 0; + if (!((((x.flag & 128) >>> 0) === 0))) { + p = x.ptr; + } else { + p = ((x.$ptr_ptr || (x.$ptr_ptr = new ptrType$15(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, x)))); + } + _r$1 = chansend($clone(v, Value).pointer(), p, nb); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + selected = _r$1; + $s = -1; return selected; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.send }; } $f._r = _r; $f._r$1 = _r$1; $f.nb = nb; $f.p = p; $f.selected = selected; $f.tt = tt; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.send = function(x, nb) { return this.$val.send(x, nb); }; + Value.ptr.prototype.SetBool = function(x) { + var v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(1); + (v.ptr).$set(x); + }; + Value.prototype.SetBool = function(x) { return this.$val.SetBool(x); }; + Value.ptr.prototype.setRunes = function(x) { + var _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(23); + _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (!((_r === 5))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r === 5))) { */ case 1: + $panic(new $String("reflect.Value.setRunes of non-rune slice")); + /* } */ case 2: + (v.ptr).$set(x); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.setRunes }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.setRunes = function(x) { return this.$val.setRunes(x); }; + Value.ptr.prototype.SetComplex = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (15)) { + (v.ptr).$set((new $Complex64(x.$real, x.$imag))); + } else if (_1 === (16)) { + (v.ptr).$set(x); + } else { + $panic(new ValueError.ptr("reflect.Value.SetComplex", new flag(v.flag).kind())); + } + }; + Value.prototype.SetComplex = function(x) { return this.$val.SetComplex(x); }; + Value.ptr.prototype.SetFloat = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (13)) { + (v.ptr).$set(($fround(x))); + } else if (_1 === (14)) { + (v.ptr).$set(x); + } else { + $panic(new ValueError.ptr("reflect.Value.SetFloat", new flag(v.flag).kind())); + } + }; + Value.prototype.SetFloat = function(x) { return this.$val.SetFloat(x); }; + Value.ptr.prototype.SetInt = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (2)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) >> 0))); + } else if (_1 === (3)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) << 24 >> 24))); + } else if (_1 === (4)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) << 16 >> 16))); + } else if (_1 === (5)) { + (v.ptr).$set((((x.$low + ((x.$high >> 31) * 4294967296)) >> 0))); + } else if (_1 === (6)) { + (v.ptr).$set(x); + } else { + $panic(new ValueError.ptr("reflect.Value.SetInt", new flag(v.flag).kind())); + } + }; + Value.prototype.SetInt = function(x) { return this.$val.SetInt(x); }; + Value.ptr.prototype.SetMapIndex = function(key, val) { + var _r, _r$1, e, k, key, tt, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; e = $f.e; k = $f.k; key = $f.key; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(21); + new flag(v.flag).mustBeExported(); + new flag(key.flag).mustBeExported(); + tt = (v.typ.kindType); + _r = $clone(key, Value).assignTo("reflect.Value.SetMapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + key = _r; + k = 0; + if (!((((key.flag & 128) >>> 0) === 0))) { + k = key.ptr; + } else { + k = ((key.$ptr_ptr || (key.$ptr_ptr = new ptrType$15(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)))); + } + if (val.typ === ptrType$1.nil) { + mapdelete(v.typ, $clone(v, Value).pointer(), k); + $s = -1; return; + } + new flag(val.flag).mustBeExported(); + _r$1 = $clone(val, Value).assignTo("reflect.Value.SetMapIndex", tt.elem, 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + val = _r$1; + e = 0; + if (!((((val.flag & 128) >>> 0) === 0))) { + e = val.ptr; + } else { + e = ((val.$ptr_ptr || (val.$ptr_ptr = new ptrType$15(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)))); + } + $r = mapassign(v.typ, $clone(v, Value).pointer(), k, e); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetMapIndex }; } $f._r = _r; $f._r$1 = _r$1; $f.e = e; $f.k = k; $f.key = key; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.SetMapIndex = function(key, val) { return this.$val.SetMapIndex(key, val); }; + Value.ptr.prototype.SetUint = function(x) { + var _1, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (7)) { + (v.ptr).$set(((x.$low >>> 0))); + } else if (_1 === (8)) { + (v.ptr).$set(((x.$low << 24 >>> 24))); + } else if (_1 === (9)) { + (v.ptr).$set(((x.$low << 16 >>> 16))); + } else if (_1 === (10)) { + (v.ptr).$set(((x.$low >>> 0))); + } else if (_1 === (11)) { + (v.ptr).$set(x); + } else if (_1 === (12)) { + (v.ptr).$set(((x.$low >>> 0))); + } else { + $panic(new ValueError.ptr("reflect.Value.SetUint", new flag(v.flag).kind())); + } + }; + Value.prototype.SetUint = function(x) { return this.$val.SetUint(x); }; + Value.ptr.prototype.SetPointer = function(x) { + var v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(26); + (v.ptr).$set(x); + }; + Value.prototype.SetPointer = function(x) { return this.$val.SetPointer(x); }; + Value.ptr.prototype.SetString = function(x) { + var v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(v.flag).mustBe(24); + (v.ptr).$set(x); + }; + Value.prototype.SetString = function(x) { return this.$val.SetString(x); }; + Value.ptr.prototype.String = function() { + var _1, _r, _r$1, k, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; k = $f.k; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + k = new flag(v.flag).kind(); + _1 = k; + if (_1 === (0)) { + $s = -1; return ""; + } else if (_1 === (24)) { + $s = -1; return (v.ptr).$get(); + } + _r = $clone(v, Value).Type(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.String(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return "<" + _r$1 + " Value>"; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.String }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f.k = k; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.String = function() { return this.$val.String(); }; + Value.ptr.prototype.TryRecv = function() { + var _r, _tuple, ok, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = new Value.ptr(ptrType$1.nil, 0, 0); + ok = false; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).recv(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + x = _tuple[0]; + ok = _tuple[1]; + $s = -1; return [x, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TryRecv }; } $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.TryRecv = function() { return this.$val.TryRecv(); }; + Value.ptr.prototype.TrySend = function(x) { + var _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = $clone(v, Value).send($clone(x, Value), true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TrySend }; } $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.TrySend = function(x) { return this.$val.TrySend(x); }; + Value.ptr.prototype.Type = function() { + var _r, f, i, m, m$1, ms, tt, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; f = $f.f; i = $f.i; m = $f.m; m$1 = $f.m$1; ms = $f.ms; tt = $f.tt; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + f = v.flag; + if (f === 0) { + $panic(new ValueError.ptr("reflect.Value.Type", 0)); + } + if (((f & 512) >>> 0) === 0) { + $s = -1; return v.typ; + } + i = ((v.flag >> 0)) >> 10 >> 0; + if (v.typ.Kind() === 20) { + tt = (v.typ.kindType); + if (((i >>> 0)) >= ((tt.methods.$length >>> 0))) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m = (x = tt.methods, ((i < 0 || i >= x.$length) ? ($throwRuntimeError("index out of range"), undefined) : x.$array[x.$offset + i])); + $s = -1; return v.typ.typeOff(m.typ); + } + _r = v.typ.exportedMethods(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ms = _r; + if (((i >>> 0)) >= ((ms.$length >>> 0))) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m$1 = $clone(((i < 0 || i >= ms.$length) ? ($throwRuntimeError("index out of range"), undefined) : ms.$array[ms.$offset + i]), method); + $s = -1; return v.typ.typeOff(m$1.mtyp); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Type }; } $f._r = _r; $f.f = f; $f.i = i; $f.m = m; $f.m$1 = m$1; $f.ms = ms; $f.tt = tt; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Type = function() { return this.$val.Type(); }; + Value.ptr.prototype.Uint = function() { + var _1, k, p, v, x; + v = this; + k = new flag(v.flag).kind(); + p = v.ptr; + _1 = k; + if (_1 === (7)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (8)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (9)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (10)) { + return (new $Uint64(0, (p).$get())); + } else if (_1 === (11)) { + return (p).$get(); + } else if (_1 === (12)) { + return ((x = (p).$get(), new $Uint64(0, x.constructor === Number ? x : 1))); + } + $panic(new ValueError.ptr("reflect.Value.Uint", new flag(v.flag).kind())); + }; + Value.prototype.Uint = function() { return this.$val.Uint(); }; + Value.ptr.prototype.UnsafeAddr = function() { + var v; + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.UnsafeAddr", 0)); + } + if (((v.flag & 256) >>> 0) === 0) { + $panic(new $String("reflect.Value.UnsafeAddr of unaddressable value")); + } + return (v.ptr); + }; + Value.prototype.UnsafeAddr = function() { return this.$val.UnsafeAddr(); }; + New = function(typ) { + var _r, _r$1, fl, ptr, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; fl = $f.fl; ptr = $f.ptr; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($interfaceIsEqual(typ, $ifaceNil)) { + $panic(new $String("reflect: New(nil)")); + } + ptr = unsafe_New($assertType(typ, ptrType$1)); + fl = 22; + _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.ptrTo(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r$1, ptr, fl); + /* */ } return; } if ($f === undefined) { $f = { $blk: New }; } $f._r = _r; $f._r$1 = _r$1; $f.fl = fl; $f.ptr = ptr; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.New = New; + Value.ptr.prototype.Convert = function(t) { + var _r, _r$1, _r$2, _r$3, _r$4, op, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; op = $f.op; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = this; + /* */ if (!((((v.flag & 512) >>> 0) === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((((v.flag & 512) >>> 0) === 0))) { */ case 1: + _r = makeMethodValue("Convert", $clone(v, Value)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + _r$1 = t.common(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = convertOp(_r$1, v.typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + op = _r$2; + /* */ if (op === $throwNilPointerError) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (op === $throwNilPointerError) { */ case 6: + _r$3 = t.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $panic(new $String("reflect.Value.Convert: value of type " + v.typ.String() + " cannot be converted to type " + _r$3)); + /* } */ case 7: + _r$4 = op($clone(v, Value), t); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Convert }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.op = op; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.Convert = function(t) { return this.$val.Convert(t); }; + convertOp = function(dst, src) { + var _1, _2, _3, _4, _5, _6, _7, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _v, _v$1, _v$2, dst, src, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _5 = $f._5; _6 = $f._6; _7 = $f._7; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; dst = $f.dst; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _1 = src.Kind(); + /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 2; continue; } + /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 3; continue; } + /* */ if ((_1 === (13)) || (_1 === (14))) { $s = 4; continue; } + /* */ if ((_1 === (15)) || (_1 === (16))) { $s = 5; continue; } + /* */ if (_1 === (24)) { $s = 6; continue; } + /* */ if (_1 === (23)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 2: + _2 = dst.Kind(); + if ((_2 === (2)) || (_2 === (3)) || (_2 === (4)) || (_2 === (5)) || (_2 === (6)) || (_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10)) || (_2 === (11)) || (_2 === (12))) { + $s = -1; return cvtInt; + } else if ((_2 === (13)) || (_2 === (14))) { + $s = -1; return cvtIntFloat; + } else if (_2 === (24)) { + $s = -1; return cvtIntString; + } + $s = 8; continue; + /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 3: + _3 = dst.Kind(); + if ((_3 === (2)) || (_3 === (3)) || (_3 === (4)) || (_3 === (5)) || (_3 === (6)) || (_3 === (7)) || (_3 === (8)) || (_3 === (9)) || (_3 === (10)) || (_3 === (11)) || (_3 === (12))) { + $s = -1; return cvtUint; + } else if ((_3 === (13)) || (_3 === (14))) { + $s = -1; return cvtUintFloat; + } else if (_3 === (24)) { + $s = -1; return cvtUintString; + } + $s = 8; continue; + /* } else if ((_1 === (13)) || (_1 === (14))) { */ case 4: + _4 = dst.Kind(); + if ((_4 === (2)) || (_4 === (3)) || (_4 === (4)) || (_4 === (5)) || (_4 === (6))) { + $s = -1; return cvtFloatInt; + } else if ((_4 === (7)) || (_4 === (8)) || (_4 === (9)) || (_4 === (10)) || (_4 === (11)) || (_4 === (12))) { + $s = -1; return cvtFloatUint; + } else if ((_4 === (13)) || (_4 === (14))) { + $s = -1; return cvtFloat; + } + $s = 8; continue; + /* } else if ((_1 === (15)) || (_1 === (16))) { */ case 5: + _5 = dst.Kind(); + if ((_5 === (15)) || (_5 === (16))) { + $s = -1; return cvtComplex; + } + $s = 8; continue; + /* } else if (_1 === (24)) { */ case 6: + if (!(dst.Kind() === 23)) { _v = false; $s = 11; continue s; } + _r = dst.Elem().PkgPath(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _v = _r === ""; case 11: + /* */ if (_v) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_v) { */ case 9: + _r$1 = dst.Elem().Kind(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _6 = _r$1; + if (_6 === (8)) { + $s = -1; return cvtStringBytes; + } else if (_6 === (5)) { + $s = -1; return cvtStringRunes; + } + case 13: + /* } */ case 10: + $s = 8; continue; + /* } else if (_1 === (23)) { */ case 7: + if (!(dst.Kind() === 24)) { _v$1 = false; $s = 17; continue s; } + _r$2 = src.Elem().PkgPath(); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v$1 = _r$2 === ""; case 17: + /* */ if (_v$1) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (_v$1) { */ case 15: + _r$3 = src.Elem().Kind(); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _7 = _r$3; + if (_7 === (8)) { + $s = -1; return cvtBytesString; + } else if (_7 === (5)) { + $s = -1; return cvtRunesString; + } + case 19: + /* } */ case 16: + /* } */ case 8: + case 1: + _r$4 = haveIdenticalUnderlyingType(dst, src, false); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (_r$4) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (_r$4) { */ case 21: + $s = -1; return cvtDirect; + /* } */ case 22: + if (!((dst.Kind() === 22) && dst.Name() === "" && (src.Kind() === 22) && src.Name() === "")) { _v$2 = false; $s = 26; continue s; } + _r$5 = dst.Elem().common(); /* */ $s = 27; case 27: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg = _r$5; + _r$6 = src.Elem().common(); /* */ $s = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _arg$1 = _r$6; + _r$7 = haveIdenticalUnderlyingType(_arg, _arg$1, false); /* */ $s = 29; case 29: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _v$2 = _r$7; case 26: + /* */ if (_v$2) { $s = 24; continue; } + /* */ $s = 25; continue; + /* if (_v$2) { */ case 24: + $s = -1; return cvtDirect; + /* } */ case 25: + if (implements$1(dst, src)) { + if (src.Kind() === 20) { + $s = -1; return cvtI2I; + } + $s = -1; return cvtT2I; + } + $s = -1; return $throwNilPointerError; + /* */ } return; } if ($f === undefined) { $f = { $blk: convertOp }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._5 = _5; $f._6 = _6; $f._7 = _7; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.dst = dst; $f.src = src; $f.$s = $s; $f.$r = $r; return $f; + }; + makeFloat = function(f, v, t) { + var _1, _r, f, ptr, t, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + typ = _r; + ptr = unsafe_New(typ); + _1 = typ.size; + if (_1 === (4)) { + (ptr).$set(($fround(v))); + } else if (_1 === (8)) { + (ptr).$set(v); + } + $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeFloat }; } $f._1 = _1; $f._r = _r; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeComplex = function(f, v, t) { + var _1, _r, f, ptr, t, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + typ = _r; + ptr = unsafe_New(typ); + _1 = typ.size; + if (_1 === (8)) { + (ptr).$set((new $Complex64(v.$real, v.$imag))); + } else if (_1 === (16)) { + (ptr).$set(v); + } + $s = -1; return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | ((typ.Kind() >>> 0))) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeComplex }; } $f._1 = _1; $f._r = _r; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeString = function(f, v, t) { + var _r, _r$1, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = $clone(_r, Value).Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ret = _r$1; + $clone(ret, Value).SetString(v); + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeString }; } $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeBytes = function(f, v, t) { + var _r, _r$1, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = $clone(_r, Value).Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ret = _r$1; + $r = $clone(ret, Value).SetBytes(v); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeBytes }; } $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + makeRunes = function(f, v, t) { + var _r, _r$1, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = $clone(_r, Value).Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ret = _r$1; + $r = $clone(ret, Value).setRunes(v); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + $s = -1; return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeRunes }; } $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtInt = function(v, t) { + var _r, t, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), ((x = $clone(v, Value).Int(), new $Uint64(x.$high, x.$low))), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtInt }; } $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUint = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), $clone(v, Value).Uint(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUint }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloatInt = function(v, t) { + var _r, t, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), ((x = (new $Int64(0, $clone(v, Value).Float())), new $Uint64(x.$high, x.$low))), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatInt }; } $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloatUint = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeInt(new flag(v.flag).ro(), (new $Uint64(0, $clone(v, Value).Float())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatUint }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtIntFloat = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeFloat(new flag(v.flag).ro(), ($flatten64($clone(v, Value).Int())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUintFloat = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeFloat(new flag(v.flag).ro(), ($flatten64($clone(v, Value).Uint())), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloat = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeFloat(new flag(v.flag).ro(), $clone(v, Value).Float(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloat }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtComplex = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeComplex(new flag(v.flag).ro(), $clone(v, Value).Complex(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtComplex }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtIntString = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeString(new flag(v.flag).ro(), ($encodeRune($clone(v, Value).Int().$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntString }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUintString = function(v, t) { + var _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = makeString(new flag(v.flag).ro(), ($encodeRune($clone(v, Value).Uint().$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintString }; } $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtBytesString = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = ($bytesToString(_r)); + _arg$2 = t; + _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtBytesString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtStringBytes = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = (new sliceType$15($stringToBytes(_r))); + _arg$2 = t; + _r$1 = makeBytes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringBytes }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtRunesString = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).runes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = ($runesToString(_r)); + _arg$2 = t; + _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtRunesString }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtStringRunes = function(v, t) { + var _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _arg = new flag(v.flag).ro(); + _r = $clone(v, Value).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = (new sliceType$17($stringToRunes(_r))); + _arg$2 = t; + _r$1 = makeRunes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringRunes }; } $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtT2I = function(v, typ) { + var _r, _r$1, _r$2, _r$3, _r$4, target, typ, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; target = $f.target; typ = $f.typ; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = unsafe_New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + target = _r$1; + _r$2 = valueInterface($clone(v, Value), false); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + x = _r$2; + _r$3 = typ.NumMethod(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 0) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$3 === 0) { */ case 4: + (target).$set(x); + $s = 6; continue; + /* } else { */ case 5: + ifaceE2I($assertType(typ, ptrType$1), x, target); + /* } */ case 6: + _r$4 = typ.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $s = -1; return new Value.ptr(_r$4, target, (((new flag(v.flag).ro() | 128) >>> 0) | 20) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtT2I }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.target = target; $f.typ = typ; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtI2I = function(v, typ) { + var _r, _r$1, _r$2, ret, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; ret = $f.ret; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if ($clone(v, Value).IsNil()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($clone(v, Value).IsNil()) { */ case 1: + _r = Zero(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ret = _r; + ret.flag = (ret.flag | (new flag(v.flag).ro())) >>> 0; + $s = -1; return ret; + /* } */ case 2: + _r$1 = $clone(v, Value).Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = cvtT2I($clone(_r$1, Value), typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $s = -1; return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtI2I }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.ret = ret; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ptrType$5.methods = [{prop: "methods", name: "methods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}]; + ptrType$16.methods = [{prop: "in$", name: "in", pkg: "reflect", typ: $funcType([], [sliceType$2], false)}, {prop: "out", name: "out", pkg: "reflect", typ: $funcType([], [sliceType$2], false)}]; + name.methods = [{prop: "name", name: "name", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "tag", name: "tag", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: $funcType([], [$String], false)}, {prop: "isExported", name: "isExported", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "data", name: "data", pkg: "reflect", typ: $funcType([$Int, $String], [ptrType$4], false)}, {prop: "nameLen", name: "nameLen", pkg: "reflect", typ: $funcType([], [$Int], false)}, {prop: "tagLen", name: "tagLen", pkg: "reflect", typ: $funcType([], [$Int], false)}]; + Kind.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$5], false)}, {prop: "nameOff", name: "nameOff", pkg: "reflect", typ: $funcType([nameOff], [name], false)}, {prop: "typeOff", name: "typeOff", pkg: "reflect", typ: $funcType([typeOff], [ptrType$1], false)}, {prop: "ptrTo", name: "ptrTo", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "pointers", name: "pointers", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "textOff", name: "textOff", pkg: "reflect", typ: $funcType([textOff], [$UnsafePointer], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "exportedMethods", name: "exportedMethods", pkg: "reflect", typ: $funcType([], [sliceType$5], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}]; + ChanDir.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$7.methods = [{prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}]; + ptrType$17.methods = [{prop: "offset", name: "offset", pkg: "reflect", typ: $funcType([], [$Uintptr], false)}, {prop: "anon", name: "anon", pkg: "reflect", typ: $funcType([], [$Bool], false)}]; + ptrType$9.methods = [{prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}]; + StructTag.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [$String, $Bool], false)}]; + Value.methods = [{prop: "object", name: "object", pkg: "reflect", typ: $funcType([], [ptrType$2], false)}, {prop: "assignTo", name: "assignTo", pkg: "reflect", typ: $funcType([$String, ptrType$1, $UnsafePointer], [Value], false)}, {prop: "call", name: "call", pkg: "reflect", typ: $funcType([$String, sliceType$9], [sliceType$9], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "InterfaceData", name: "InterfaceData", pkg: "", typ: $funcType([], [arrayType$12], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Pointer", name: "Pointer", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([Value], [], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType$15], [], false)}, {prop: "SetCap", name: "SetCap", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Slice", name: "Slice", pkg: "", typ: $funcType([$Int, $Int], [Value], false)}, {prop: "Slice3", name: "Slice3", pkg: "", typ: $funcType([$Int, $Int, $Int], [Value], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [], false)}, {prop: "pointer", name: "pointer", pkg: "reflect", typ: $funcType([], [$UnsafePointer], false)}, {prop: "Addr", name: "Addr", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$15], false)}, {prop: "runes", name: "runes", pkg: "reflect", typ: $funcType([], [sliceType$17], false)}, {prop: "CanAddr", name: "CanAddr", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "CanSet", name: "CanSet", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([sliceType$9], [sliceType$9], false)}, {prop: "CallSlice", name: "CallSlice", pkg: "", typ: $funcType([sliceType$9], [sliceType$9], false)}, {prop: "Complex", name: "Complex", pkg: "", typ: $funcType([], [$Complex128], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [Value], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [Value], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "CanInterface", name: "CanInterface", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "IsValid", name: "IsValid", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "MapIndex", name: "MapIndex", pkg: "", typ: $funcType([Value], [Value], false)}, {prop: "MapKeys", name: "MapKeys", pkg: "", typ: $funcType([], [sliceType$9], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "OverflowComplex", name: "OverflowComplex", pkg: "", typ: $funcType([$Complex128], [$Bool], false)}, {prop: "OverflowFloat", name: "OverflowFloat", pkg: "", typ: $funcType([$Float64], [$Bool], false)}, {prop: "OverflowInt", name: "OverflowInt", pkg: "", typ: $funcType([$Int64], [$Bool], false)}, {prop: "OverflowUint", name: "OverflowUint", pkg: "", typ: $funcType([$Uint64], [$Bool], false)}, {prop: "Recv", name: "Recv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "recv", name: "recv", pkg: "reflect", typ: $funcType([$Bool], [Value, $Bool], false)}, {prop: "Send", name: "Send", pkg: "", typ: $funcType([Value], [], false)}, {prop: "send", name: "send", pkg: "reflect", typ: $funcType([Value, $Bool], [$Bool], false)}, {prop: "SetBool", name: "SetBool", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "setRunes", name: "setRunes", pkg: "reflect", typ: $funcType([sliceType$17], [], false)}, {prop: "SetComplex", name: "SetComplex", pkg: "", typ: $funcType([$Complex128], [], false)}, {prop: "SetFloat", name: "SetFloat", pkg: "", typ: $funcType([$Float64], [], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "SetMapIndex", name: "SetMapIndex", pkg: "", typ: $funcType([Value, Value], [], false)}, {prop: "SetUint", name: "SetUint", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "SetPointer", name: "SetPointer", pkg: "", typ: $funcType([$UnsafePointer], [], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "TryRecv", name: "TryRecv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "TrySend", name: "TrySend", pkg: "", typ: $funcType([Value], [$Bool], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Uint", name: "Uint", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "UnsafeAddr", name: "UnsafeAddr", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Convert", name: "Convert", pkg: "", typ: $funcType([Type], [Value], false)}]; + flag.methods = [{prop: "kind", name: "kind", pkg: "reflect", typ: $funcType([], [Kind], false)}, {prop: "ro", name: "ro", pkg: "reflect", typ: $funcType([], [flag], false)}, {prop: "mustBe", name: "mustBe", pkg: "reflect", typ: $funcType([Kind], [], false)}, {prop: "mustBeExported", name: "mustBeExported", pkg: "reflect", typ: $funcType([], [], false)}, {prop: "mustBeAssignable", name: "mustBeAssignable", pkg: "reflect", typ: $funcType([], [], false)}]; + ptrType$18.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + uncommonType.init("reflect", [{prop: "pkgPath", name: "pkgPath", anonymous: false, exported: false, typ: nameOff, tag: ""}, {prop: "mcount", name: "mcount", anonymous: false, exported: false, typ: $Uint16, tag: ""}, {prop: "_$2", name: "_", anonymous: false, exported: false, typ: $Uint16, tag: ""}, {prop: "moff", name: "moff", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "_$4", name: "_", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "_methods", name: "_methods", anonymous: false, exported: false, typ: sliceType$5, tag: ""}]); + funcType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"func\""}, {prop: "inCount", name: "inCount", anonymous: false, exported: false, typ: $Uint16, tag: ""}, {prop: "outCount", name: "outCount", anonymous: false, exported: false, typ: $Uint16, tag: ""}, {prop: "_in", name: "_in", anonymous: false, exported: false, typ: sliceType$2, tag: ""}, {prop: "_out", name: "_out", anonymous: false, exported: false, typ: sliceType$2, tag: ""}]); + name.init("reflect", [{prop: "bytes", name: "bytes", anonymous: false, exported: false, typ: ptrType$4, tag: ""}]); + nameData.init("reflect", [{prop: "name", name: "name", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "tag", name: "tag", anonymous: false, exported: false, typ: $String, tag: ""}, {prop: "exported", name: "exported", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + mapIter.init("reflect", [{prop: "t", name: "t", anonymous: false, exported: false, typ: Type, tag: ""}, {prop: "m", name: "m", anonymous: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "keys", name: "keys", anonymous: false, exported: false, typ: ptrType$2, tag: ""}, {prop: "i", name: "i", anonymous: false, exported: false, typ: $Int, tag: ""}]); + Type.init([{prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$13], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$5], false)}]); + rtype.init("reflect", [{prop: "size", name: "size", anonymous: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "ptrdata", name: "ptrdata", anonymous: false, exported: false, typ: $Uintptr, tag: ""}, {prop: "hash", name: "hash", anonymous: false, exported: false, typ: $Uint32, tag: ""}, {prop: "tflag", name: "tflag", anonymous: false, exported: false, typ: tflag, tag: ""}, {prop: "align", name: "align", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "fieldAlign", name: "fieldAlign", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "kind", name: "kind", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "alg", name: "alg", anonymous: false, exported: false, typ: ptrType$3, tag: ""}, {prop: "gcdata", name: "gcdata", anonymous: false, exported: false, typ: ptrType$4, tag: ""}, {prop: "str", name: "str", anonymous: false, exported: false, typ: nameOff, tag: ""}, {prop: "ptrToThis", name: "ptrToThis", anonymous: false, exported: false, typ: typeOff, tag: ""}]); + typeAlg.init("reflect", [{prop: "hash", name: "hash", anonymous: false, exported: false, typ: funcType$4, tag: ""}, {prop: "equal", name: "equal", anonymous: false, exported: false, typ: funcType$5, tag: ""}]); + method.init("reflect", [{prop: "name", name: "name", anonymous: false, exported: false, typ: nameOff, tag: ""}, {prop: "mtyp", name: "mtyp", anonymous: false, exported: false, typ: typeOff, tag: ""}, {prop: "ifn", name: "ifn", anonymous: false, exported: false, typ: textOff, tag: ""}, {prop: "tfn", name: "tfn", anonymous: false, exported: false, typ: textOff, tag: ""}]); + arrayType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"array\""}, {prop: "elem", name: "elem", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "slice", name: "slice", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "len", name: "len", anonymous: false, exported: false, typ: $Uintptr, tag: ""}]); + chanType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"chan\""}, {prop: "elem", name: "elem", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "dir", name: "dir", anonymous: false, exported: false, typ: $Uintptr, tag: ""}]); + imethod.init("reflect", [{prop: "name", name: "name", anonymous: false, exported: false, typ: nameOff, tag: ""}, {prop: "typ", name: "typ", anonymous: false, exported: false, typ: typeOff, tag: ""}]); + interfaceType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"interface\""}, {prop: "pkgPath", name: "pkgPath", anonymous: false, exported: false, typ: name, tag: ""}, {prop: "methods", name: "methods", anonymous: false, exported: false, typ: sliceType$6, tag: ""}]); + mapType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"map\""}, {prop: "key", name: "key", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "elem", name: "elem", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "bucket", name: "bucket", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "hmap", name: "hmap", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "keysize", name: "keysize", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "indirectkey", name: "indirectkey", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "valuesize", name: "valuesize", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "indirectvalue", name: "indirectvalue", anonymous: false, exported: false, typ: $Uint8, tag: ""}, {prop: "bucketsize", name: "bucketsize", anonymous: false, exported: false, typ: $Uint16, tag: ""}, {prop: "reflexivekey", name: "reflexivekey", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "needkeyupdate", name: "needkeyupdate", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + ptrType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"ptr\""}, {prop: "elem", name: "elem", anonymous: false, exported: false, typ: ptrType$1, tag: ""}]); + sliceType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"slice\""}, {prop: "elem", name: "elem", anonymous: false, exported: false, typ: ptrType$1, tag: ""}]); + structField.init("reflect", [{prop: "name", name: "name", anonymous: false, exported: false, typ: name, tag: ""}, {prop: "typ", name: "typ", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "offsetAnon", name: "offsetAnon", anonymous: false, exported: false, typ: $Uintptr, tag: ""}]); + structType.init("reflect", [{prop: "rtype", name: "rtype", anonymous: true, exported: false, typ: rtype, tag: "reflect:\"struct\""}, {prop: "pkgPath", name: "pkgPath", anonymous: false, exported: false, typ: name, tag: ""}, {prop: "fields", name: "fields", anonymous: false, exported: false, typ: sliceType$7, tag: ""}]); + Method.init("", [{prop: "Name", name: "Name", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Type", name: "Type", anonymous: false, exported: true, typ: Type, tag: ""}, {prop: "Func", name: "Func", anonymous: false, exported: true, typ: Value, tag: ""}, {prop: "Index", name: "Index", anonymous: false, exported: true, typ: $Int, tag: ""}]); + StructField.init("", [{prop: "Name", name: "Name", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Type", name: "Type", anonymous: false, exported: true, typ: Type, tag: ""}, {prop: "Tag", name: "Tag", anonymous: false, exported: true, typ: StructTag, tag: ""}, {prop: "Offset", name: "Offset", anonymous: false, exported: true, typ: $Uintptr, tag: ""}, {prop: "Index", name: "Index", anonymous: false, exported: true, typ: sliceType$13, tag: ""}, {prop: "Anonymous", name: "Anonymous", anonymous: false, exported: true, typ: $Bool, tag: ""}]); + fieldScan.init("reflect", [{prop: "typ", name: "typ", anonymous: false, exported: false, typ: ptrType$9, tag: ""}, {prop: "index", name: "index", anonymous: false, exported: false, typ: sliceType$13, tag: ""}]); + Value.init("reflect", [{prop: "typ", name: "typ", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "ptr", name: "ptr", anonymous: false, exported: false, typ: $UnsafePointer, tag: ""}, {prop: "flag", name: "flag", anonymous: true, exported: false, typ: flag, tag: ""}]); + ValueError.init("", [{prop: "Method", name: "Method", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Kind", name: "Kind", anonymous: false, exported: true, typ: Kind, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + nameOffList = sliceType$1.nil; + typeOffList = sliceType$2.nil; + methodCache = new sync.Map.ptr(new sync.Mutex.ptr(0, 0), new $packages["sync/atomic"].Value.ptr($ifaceNil), false, 0); + initialized = false; + uncommonTypeMap = {}; + nameMap = {}; + callHelper = $assertType($internalize($call, $emptyInterface), funcType$1); + selectHelper = $assertType($internalize($select, $emptyInterface), funcType$1); + jsObjectPtr = reflectType($jsObjectPtr); + kindNames = new sliceType$4(["invalid", "bool", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "array", "chan", "func", "interface", "map", "ptr", "slice", "string", "struct", "unsafe.Pointer"]); + uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); + $r = init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["fmt"] = (function() { + var $pkg = {}, $init, errors, io, math, os, reflect, strconv, sync, utf8, fmtFlags, fmt, State, Formatter, Stringer, GoStringer, buffer, pp, scanError, ss, ssave, sliceType, ptrType, ptrType$1, arrayType, arrayType$1, sliceType$1, sliceType$2, arrayType$2, ptrType$2, ptrType$5, ptrType$25, funcType, ppFree, space, ssFree, complexError, boolError, newPrinter, Fprintf, Printf, Sprintf, Errorf, Fprintln, Println, getField, tooLarge, parsenum, intFromArg, parseArgNumber, isSpace, notSpace, indexRune; + errors = $packages["errors"]; + io = $packages["io"]; + math = $packages["math"]; + os = $packages["os"]; + reflect = $packages["reflect"]; + strconv = $packages["strconv"]; + sync = $packages["sync"]; + utf8 = $packages["unicode/utf8"]; + fmtFlags = $pkg.fmtFlags = $newType(0, $kindStruct, "fmt.fmtFlags", true, "fmt", false, function(widPresent_, precPresent_, minus_, plus_, sharp_, space_, zero_, plusV_, sharpV_) { + this.$val = this; + if (arguments.length === 0) { + this.widPresent = false; + this.precPresent = false; + this.minus = false; + this.plus = false; + this.sharp = false; + this.space = false; + this.zero = false; + this.plusV = false; + this.sharpV = false; + return; + } + this.widPresent = widPresent_; + this.precPresent = precPresent_; + this.minus = minus_; + this.plus = plus_; + this.sharp = sharp_; + this.space = space_; + this.zero = zero_; + this.plusV = plusV_; + this.sharpV = sharpV_; + }); + fmt = $pkg.fmt = $newType(0, $kindStruct, "fmt.fmt", true, "fmt", false, function(buf_, fmtFlags_, wid_, prec_, intbuf_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = ptrType$1.nil; + this.fmtFlags = new fmtFlags.ptr(false, false, false, false, false, false, false, false, false); + this.wid = 0; + this.prec = 0; + this.intbuf = arrayType.zero(); + return; + } + this.buf = buf_; + this.fmtFlags = fmtFlags_; + this.wid = wid_; + this.prec = prec_; + this.intbuf = intbuf_; + }); + State = $pkg.State = $newType(8, $kindInterface, "fmt.State", true, "fmt", true, null); + Formatter = $pkg.Formatter = $newType(8, $kindInterface, "fmt.Formatter", true, "fmt", true, null); + Stringer = $pkg.Stringer = $newType(8, $kindInterface, "fmt.Stringer", true, "fmt", true, null); + GoStringer = $pkg.GoStringer = $newType(8, $kindInterface, "fmt.GoStringer", true, "fmt", true, null); + buffer = $pkg.buffer = $newType(12, $kindSlice, "fmt.buffer", true, "fmt", false, null); + pp = $pkg.pp = $newType(0, $kindStruct, "fmt.pp", true, "fmt", false, function(buf_, arg_, value_, fmt_, reordered_, goodArgNum_, panicking_, erroring_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = buffer.nil; + this.arg = $ifaceNil; + this.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + this.fmt = new fmt.ptr(ptrType$1.nil, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false), 0, 0, arrayType.zero()); + this.reordered = false; + this.goodArgNum = false; + this.panicking = false; + this.erroring = false; + return; + } + this.buf = buf_; + this.arg = arg_; + this.value = value_; + this.fmt = fmt_; + this.reordered = reordered_; + this.goodArgNum = goodArgNum_; + this.panicking = panicking_; + this.erroring = erroring_; + }); + scanError = $pkg.scanError = $newType(0, $kindStruct, "fmt.scanError", true, "fmt", false, function(err_) { + this.$val = this; + if (arguments.length === 0) { + this.err = $ifaceNil; + return; + } + this.err = err_; + }); + ss = $pkg.ss = $newType(0, $kindStruct, "fmt.ss", true, "fmt", false, function(rs_, buf_, count_, atEOF_, ssave_) { + this.$val = this; + if (arguments.length === 0) { + this.rs = $ifaceNil; + this.buf = buffer.nil; + this.count = 0; + this.atEOF = false; + this.ssave = new ssave.ptr(false, false, false, 0, 0, 0); + return; + } + this.rs = rs_; + this.buf = buf_; + this.count = count_; + this.atEOF = atEOF_; + this.ssave = ssave_; + }); + ssave = $pkg.ssave = $newType(0, $kindStruct, "fmt.ssave", true, "fmt", false, function(validSave_, nlIsEnd_, nlIsSpace_, argLimit_, limit_, maxWid_) { + this.$val = this; + if (arguments.length === 0) { + this.validSave = false; + this.nlIsEnd = false; + this.nlIsSpace = false; + this.argLimit = 0; + this.limit = 0; + this.maxWid = 0; + return; + } + this.validSave = validSave_; + this.nlIsEnd = nlIsEnd_; + this.nlIsSpace = nlIsSpace_; + this.argLimit = argLimit_; + this.limit = limit_; + this.maxWid = maxWid_; + }); + sliceType = $sliceType($emptyInterface); + ptrType = $ptrType(reflect.rtype); + ptrType$1 = $ptrType(buffer); + arrayType = $arrayType($Uint8, 68); + arrayType$1 = $arrayType($Uint16, 2); + sliceType$1 = $sliceType(arrayType$1); + sliceType$2 = $sliceType($Uint8); + arrayType$2 = $arrayType($Uint8, 5); + ptrType$2 = $ptrType(pp); + ptrType$5 = $ptrType(ss); + ptrType$25 = $ptrType(fmt); + funcType = $funcType([$Int32], [$Bool], false); + fmt.ptr.prototype.clearflags = function() { + var f; + f = this; + fmtFlags.copy(f.fmtFlags, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false)); + }; + fmt.prototype.clearflags = function() { return this.$val.clearflags(); }; + fmt.ptr.prototype.init = function(buf) { + var buf, f; + f = this; + f.buf = buf; + f.clearflags(); + }; + fmt.prototype.init = function(buf) { return this.$val.init(buf); }; + fmt.ptr.prototype.writePadding = function(n) { + var _i, _ref, buf, f, i, n, newLen, oldLen, padByte, padding; + f = this; + if (n <= 0) { + return; + } + buf = f.buf.$get(); + oldLen = buf.$length; + newLen = oldLen + n >> 0; + if (newLen > buf.$capacity) { + buf = $makeSlice(buffer, (($imul(buf.$capacity, 2)) + n >> 0)); + $copySlice(buf, f.buf.$get()); + } + padByte = 32; + if (f.fmtFlags.zero) { + padByte = 48; + } + padding = $subslice(buf, oldLen, newLen); + _ref = padding; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + ((i < 0 || i >= padding.$length) ? ($throwRuntimeError("index out of range"), undefined) : padding.$array[padding.$offset + i] = padByte); + _i++; + } + f.buf.$set($subslice(buf, 0, newLen)); + }; + fmt.prototype.writePadding = function(n) { return this.$val.writePadding(n); }; + fmt.ptr.prototype.pad = function(b) { + var b, f, width; + f = this; + if (!f.fmtFlags.widPresent || (f.wid === 0)) { + f.buf.Write(b); + return; + } + width = f.wid - utf8.RuneCount(b) >> 0; + if (!f.fmtFlags.minus) { + f.writePadding(width); + f.buf.Write(b); + } else { + f.buf.Write(b); + f.writePadding(width); + } + }; + fmt.prototype.pad = function(b) { return this.$val.pad(b); }; + fmt.ptr.prototype.padString = function(s) { + var f, s, width; + f = this; + if (!f.fmtFlags.widPresent || (f.wid === 0)) { + f.buf.WriteString(s); + return; + } + width = f.wid - utf8.RuneCountInString(s) >> 0; + if (!f.fmtFlags.minus) { + f.writePadding(width); + f.buf.WriteString(s); + } else { + f.buf.WriteString(s); + f.writePadding(width); + } + }; + fmt.prototype.padString = function(s) { return this.$val.padString(s); }; + fmt.ptr.prototype.fmt_boolean = function(v) { + var f, v; + f = this; + if (v) { + f.padString("true"); + } else { + f.padString("false"); + } + }; + fmt.prototype.fmt_boolean = function(v) { return this.$val.fmt_boolean(v); }; + fmt.ptr.prototype.fmt_unicode = function(u) { + var buf, f, i, oldZero, prec, u, width; + f = this; + buf = $subslice(new sliceType$2(f.intbuf), 0); + prec = 4; + if (f.fmtFlags.precPresent && f.prec > 4) { + prec = f.prec; + width = (((2 + prec >> 0) + 2 >> 0) + 4 >> 0) + 1 >> 0; + if (width > buf.$length) { + buf = $makeSlice(sliceType$2, width); + } + } + i = buf.$length; + if (f.fmtFlags.sharp && (u.$high < 0 || (u.$high === 0 && u.$low <= 1114111)) && strconv.IsPrint(((u.$low >> 0)))) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 39); + i = i - (utf8.RuneLen(((u.$low >> 0)))) >> 0; + utf8.EncodeRune($subslice(buf, i), ((u.$low >> 0))); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 39); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 32); + } + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 16)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = "0123456789ABCDEFX".charCodeAt($flatten64(new $Uint64(u.$high & 0, (u.$low & 15) >>> 0)))); + prec = prec - (1) >> 0; + u = $shiftRightUint64(u, (4)); + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = "0123456789ABCDEFX".charCodeAt($flatten64(u))); + prec = prec - (1) >> 0; + while (true) { + if (!(prec > 0)) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + prec = prec - (1) >> 0; + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 43); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 85); + oldZero = f.fmtFlags.zero; + f.fmtFlags.zero = false; + f.pad($subslice(buf, i)); + f.fmtFlags.zero = oldZero; + }; + fmt.prototype.fmt_unicode = function(u) { return this.$val.fmt_unicode(u); }; + fmt.ptr.prototype.fmt_integer = function(u, base, isSigned, digits) { + var _1, _2, base, buf, digits, f, i, isSigned, negative, next, oldZero, oldZero$1, prec, u, width, x, x$1, x$2, x$3, x$4; + f = this; + negative = isSigned && (x = (new $Int64(u.$high, u.$low)), (x.$high < 0 || (x.$high === 0 && x.$low < 0))); + if (negative) { + u = new $Uint64(-u.$high, -u.$low); + } + buf = $subslice(new sliceType$2(f.intbuf), 0); + if (f.fmtFlags.widPresent || f.fmtFlags.precPresent) { + width = (3 + f.wid >> 0) + f.prec >> 0; + if (width > buf.$length) { + buf = $makeSlice(sliceType$2, width); + } + } + prec = 0; + if (f.fmtFlags.precPresent) { + prec = f.prec; + if ((prec === 0) && (u.$high === 0 && u.$low === 0)) { + oldZero = f.fmtFlags.zero; + f.fmtFlags.zero = false; + f.writePadding(f.wid); + f.fmtFlags.zero = oldZero; + return; + } + } else if (f.fmtFlags.zero && f.fmtFlags.widPresent) { + prec = f.wid; + if (negative || f.fmtFlags.plus || f.fmtFlags.space) { + prec = prec - (1) >> 0; + } + } + i = buf.$length; + _1 = base; + if (_1 === (10)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 10)))) { break; } + i = i - (1) >> 0; + next = $div64(u, new $Uint64(0, 10), false); + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$1 = new $Uint64(0 + u.$high, 48 + u.$low), x$2 = $mul64(next, new $Uint64(0, 10)), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low)).$low << 24 >>> 24))); + u = next; + } + } else if (_1 === (16)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 16)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(new $Uint64(u.$high & 0, (u.$low & 15) >>> 0)))); + u = $shiftRightUint64(u, (4)); + } + } else if (_1 === (8)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 8)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$3 = new $Uint64(u.$high & 0, (u.$low & 7) >>> 0), new $Uint64(0 + x$3.$high, 48 + x$3.$low)).$low << 24 >>> 24))); + u = $shiftRightUint64(u, (3)); + } + } else if (_1 === (2)) { + while (true) { + if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 2)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = (((x$4 = new $Uint64(u.$high & 0, (u.$low & 1) >>> 0), new $Uint64(0 + x$4.$high, 48 + x$4.$low)).$low << 24 >>> 24))); + u = $shiftRightUint64(u, (1)); + } + } else { + $panic(new $String("fmt: unknown base; can't happen")); + } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(u))); + while (true) { + if (!(i > 0 && prec > (buf.$length - i >> 0))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + } + if (f.fmtFlags.sharp) { + _2 = base; + if (_2 === (8)) { + if (!((((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i]) === 48))) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + } + } else if (_2 === (16)) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = digits.charCodeAt(16)); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 48); + } + } + if (negative) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 45); + } else if (f.fmtFlags.plus) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 43); + } else if (f.fmtFlags.space) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? ($throwRuntimeError("index out of range"), undefined) : buf.$array[buf.$offset + i] = 32); + } + oldZero$1 = f.fmtFlags.zero; + f.fmtFlags.zero = false; + f.pad($subslice(buf, i)); + f.fmtFlags.zero = oldZero$1; + }; + fmt.prototype.fmt_integer = function(u, base, isSigned, digits) { return this.$val.fmt_integer(u, base, isSigned, digits); }; + fmt.ptr.prototype.truncate = function(s) { + var _i, _ref, _rune, f, i, n, s; + f = this; + if (f.fmtFlags.precPresent) { + n = f.prec; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + n = n - (1) >> 0; + if (n < 0) { + return $substring(s, 0, i); + } + _i += _rune[1]; + } + } + return s; + }; + fmt.prototype.truncate = function(s) { return this.$val.truncate(s); }; + fmt.ptr.prototype.fmt_s = function(s) { + var f, s; + f = this; + s = f.truncate(s); + f.padString(s); + }; + fmt.prototype.fmt_s = function(s) { return this.$val.fmt_s(s); }; + fmt.ptr.prototype.fmt_sbx = function(s, b, digits) { + var b, buf, c, digits, f, i, length, s, width; + f = this; + length = b.$length; + if (b === sliceType$2.nil) { + length = s.length; + } + if (f.fmtFlags.precPresent && f.prec < length) { + length = f.prec; + } + width = $imul(2, length); + if (width > 0) { + if (f.fmtFlags.space) { + if (f.fmtFlags.sharp) { + width = $imul(width, (2)); + } + width = width + ((length - 1 >> 0)) >> 0; + } else if (f.fmtFlags.sharp) { + width = width + (2) >> 0; + } + } else { + if (f.fmtFlags.widPresent) { + f.writePadding(f.wid); + } + return; + } + if (f.fmtFlags.widPresent && f.wid > width && !f.fmtFlags.minus) { + f.writePadding(f.wid - width >> 0); + } + buf = f.buf.$get(); + if (f.fmtFlags.sharp) { + buf = $append(buf, 48, digits.charCodeAt(16)); + } + c = 0; + i = 0; + while (true) { + if (!(i < length)) { break; } + if (f.fmtFlags.space && i > 0) { + buf = $append(buf, 32); + if (f.fmtFlags.sharp) { + buf = $append(buf, 48, digits.charCodeAt(16)); + } + } + if (!(b === sliceType$2.nil)) { + c = ((i < 0 || i >= b.$length) ? ($throwRuntimeError("index out of range"), undefined) : b.$array[b.$offset + i]); + } else { + c = s.charCodeAt(i); + } + buf = $append(buf, digits.charCodeAt((c >>> 4 << 24 >>> 24)), digits.charCodeAt(((c & 15) >>> 0))); + i = i + (1) >> 0; + } + f.buf.$set(buf); + if (f.fmtFlags.widPresent && f.wid > width && f.fmtFlags.minus) { + f.writePadding(f.wid - width >> 0); + } + }; + fmt.prototype.fmt_sbx = function(s, b, digits) { return this.$val.fmt_sbx(s, b, digits); }; + fmt.ptr.prototype.fmt_sx = function(s, digits) { + var digits, f, s; + f = this; + f.fmt_sbx(s, sliceType$2.nil, digits); + }; + fmt.prototype.fmt_sx = function(s, digits) { return this.$val.fmt_sx(s, digits); }; + fmt.ptr.prototype.fmt_bx = function(b, digits) { + var b, digits, f; + f = this; + f.fmt_sbx("", b, digits); + }; + fmt.prototype.fmt_bx = function(b, digits) { return this.$val.fmt_bx(b, digits); }; + fmt.ptr.prototype.fmt_q = function(s) { + var buf, f, s; + f = this; + s = f.truncate(s); + if (f.fmtFlags.sharp && strconv.CanBackquote(s)) { + f.padString("`" + s + "`"); + return; + } + buf = $subslice(new sliceType$2(f.intbuf), 0, 0); + if (f.fmtFlags.plus) { + f.pad(strconv.AppendQuoteToASCII(buf, s)); + } else { + f.pad(strconv.AppendQuote(buf, s)); + } + }; + fmt.prototype.fmt_q = function(s) { return this.$val.fmt_q(s); }; + fmt.ptr.prototype.fmt_c = function(c) { + var buf, c, f, r, w; + f = this; + r = ((c.$low >> 0)); + if ((c.$high > 0 || (c.$high === 0 && c.$low > 1114111))) { + r = 65533; + } + buf = $subslice(new sliceType$2(f.intbuf), 0, 0); + w = utf8.EncodeRune($subslice(buf, 0, 4), r); + f.pad($subslice(buf, 0, w)); + }; + fmt.prototype.fmt_c = function(c) { return this.$val.fmt_c(c); }; + fmt.ptr.prototype.fmt_qc = function(c) { + var buf, c, f, r; + f = this; + r = ((c.$low >> 0)); + if ((c.$high > 0 || (c.$high === 0 && c.$low > 1114111))) { + r = 65533; + } + buf = $subslice(new sliceType$2(f.intbuf), 0, 0); + if (f.fmtFlags.plus) { + f.pad(strconv.AppendQuoteRuneToASCII(buf, r)); + } else { + f.pad(strconv.AppendQuoteRune(buf, r)); + } + }; + fmt.prototype.fmt_qc = function(c) { return this.$val.fmt_qc(c); }; + fmt.ptr.prototype.fmt_float = function(v, size, verb, prec) { + var _1, _2, digits, f, hasDecimalPoint, i, num, oldZero, prec, size, tail, tailBuf, v, verb; + f = this; + if (f.fmtFlags.precPresent) { + prec = f.prec; + } + num = strconv.AppendFloat($subslice(new sliceType$2(f.intbuf), 0, 1), v, ((verb << 24 >>> 24)), prec, size); + if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 45) || ((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 43)) { + num = $subslice(num, 1); + } else { + (0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0] = 43); + } + if (f.fmtFlags.space && ((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0]) === 43) && !f.fmtFlags.plus) { + (0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0] = 32); + } + if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 73) || ((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 78)) { + oldZero = f.fmtFlags.zero; + f.fmtFlags.zero = false; + if (((1 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 1]) === 78) && !f.fmtFlags.space && !f.fmtFlags.plus) { + num = $subslice(num, 1); + } + f.pad(num); + f.fmtFlags.zero = oldZero; + return; + } + if (f.fmtFlags.sharp && !((verb === 98))) { + digits = 0; + _1 = verb; + if ((_1 === (118)) || (_1 === (103)) || (_1 === (71))) { + digits = prec; + if (digits === -1) { + digits = 6; + } + } + tailBuf = arrayType$2.zero(); + tail = $subslice(new sliceType$2(tailBuf), 0, 0); + hasDecimalPoint = false; + i = 1; + while (true) { + if (!(i < num.$length)) { break; } + _2 = ((i < 0 || i >= num.$length) ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + i]); + if (_2 === (46)) { + hasDecimalPoint = true; + } else if ((_2 === (101)) || (_2 === (69))) { + tail = $appendSlice(tail, $subslice(num, i)); + num = $subslice(num, 0, i); + } else { + digits = digits - (1) >> 0; + } + i = i + (1) >> 0; + } + if (!hasDecimalPoint) { + num = $append(num, 46); + } + while (true) { + if (!(digits > 0)) { break; } + num = $append(num, 48); + digits = digits - (1) >> 0; + } + num = $appendSlice(num, tail); + } + if (f.fmtFlags.plus || !(((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0]) === 43))) { + if (f.fmtFlags.zero && f.fmtFlags.widPresent && f.wid > num.$length) { + f.buf.WriteByte((0 >= num.$length ? ($throwRuntimeError("index out of range"), undefined) : num.$array[num.$offset + 0])); + f.writePadding(f.wid - num.$length >> 0); + f.buf.Write($subslice(num, 1)); + return; + } + f.pad(num); + return; + } + f.pad($subslice(num, 1)); + }; + fmt.prototype.fmt_float = function(v, size, verb, prec) { return this.$val.fmt_float(v, size, verb, prec); }; + $ptrType(buffer).prototype.Write = function(p) { + var b, p; + b = this; + b.$set($appendSlice(b.$get(), p)); + }; + $ptrType(buffer).prototype.WriteString = function(s) { + var b, s; + b = this; + b.$set($appendSlice(b.$get(), s)); + }; + $ptrType(buffer).prototype.WriteByte = function(c) { + var b, c; + b = this; + b.$set($append(b.$get(), c)); + }; + $ptrType(buffer).prototype.WriteRune = function(r) { + var b, bp, n, r, w, x; + bp = this; + if (r < 128) { + bp.$set($append(bp.$get(), ((r << 24 >>> 24)))); + return; + } + b = bp.$get(); + n = b.$length; + while (true) { + if (!((n + 4 >> 0) > b.$capacity)) { break; } + b = $append(b, 0); + } + w = utf8.EncodeRune((x = $subslice(b, n, (n + 4 >> 0)), $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)), r); + bp.$set($subslice(b, 0, (n + w >> 0))); + }; + newPrinter = function() { + var _r, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = ppFree.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = $assertType(_r, ptrType$2); + p.panicking = false; + p.erroring = false; + p.fmt.init((p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p)))); + $s = -1; return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: newPrinter }; } $f._r = _r; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.ptr.prototype.free = function() { + var p; + p = this; + p.buf = $subslice(p.buf, 0, 0); + p.arg = $ifaceNil; + p.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + ppFree.Put(p); + }; + pp.prototype.free = function() { return this.$val.free(); }; + pp.ptr.prototype.Width = function() { + var _tmp, _tmp$1, ok, p, wid; + wid = 0; + ok = false; + p = this; + _tmp = p.fmt.wid; + _tmp$1 = p.fmt.fmtFlags.widPresent; + wid = _tmp; + ok = _tmp$1; + return [wid, ok]; + }; + pp.prototype.Width = function() { return this.$val.Width(); }; + pp.ptr.prototype.Precision = function() { + var _tmp, _tmp$1, ok, p, prec; + prec = 0; + ok = false; + p = this; + _tmp = p.fmt.prec; + _tmp$1 = p.fmt.fmtFlags.precPresent; + prec = _tmp; + ok = _tmp$1; + return [prec, ok]; + }; + pp.prototype.Precision = function() { return this.$val.Precision(); }; + pp.ptr.prototype.Flag = function(b) { + var _1, b, p; + p = this; + _1 = b; + if (_1 === (45)) { + return p.fmt.fmtFlags.minus; + } else if (_1 === (43)) { + return p.fmt.fmtFlags.plus || p.fmt.fmtFlags.plusV; + } else if (_1 === (35)) { + return p.fmt.fmtFlags.sharp || p.fmt.fmtFlags.sharpV; + } else if (_1 === (32)) { + return p.fmt.fmtFlags.space; + } else if (_1 === (48)) { + return p.fmt.fmtFlags.zero; + } + return false; + }; + pp.prototype.Flag = function(b) { return this.$val.Flag(b); }; + pp.ptr.prototype.Write = function(b) { + var _tmp, _tmp$1, b, err, p, ret; + ret = 0; + err = $ifaceNil; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(b); + _tmp = b.$length; + _tmp$1 = $ifaceNil; + ret = _tmp; + err = _tmp$1; + return [ret, err]; + }; + pp.prototype.Write = function(b) { return this.$val.Write(b); }; + pp.ptr.prototype.WriteString = function(s) { + var _tmp, _tmp$1, err, p, ret, s; + ret = 0; + err = $ifaceNil; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(s); + _tmp = s.length; + _tmp$1 = $ifaceNil; + ret = _tmp; + err = _tmp$1; + return [ret, err]; + }; + pp.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + Fprintf = function(w, format, a) { + var _r, _r$1, _tuple, a, err, format, n, p, w, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; format = $f.format; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$1 = w.Write((x = p.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprintf }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.format = format; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Fprintf = Fprintf; + Printf = function(format, a) { + var _r, _tuple, a, err, format, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; a = $f.a; err = $f.err; format = $f.format; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = Fprintf(os.Stdout, format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Printf }; } $f._r = _r; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.format = format; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Printf = Printf; + Sprintf = function(format, a) { + var _r, a, format, p, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; a = $f.a; format = $f.format; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + s = ($bytesToString(p.buf)); + p.free(); + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sprintf }; } $f._r = _r; $f.a = a; $f.format = format; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sprintf = Sprintf; + Errorf = function(format, a) { + var _r, _r$1, a, format, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; a = $f.a; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = Sprintf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = errors.New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Errorf }; } $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.format = format; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Errorf = Errorf; + Fprintln = function(w, a) { + var _r, _r$1, _tuple, a, err, n, p, w, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p = _r; + $r = p.doPrintln(a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$1 = w.Write((x = p.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprintln }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Fprintln = Fprintln; + Println = function(a) { + var _r, _tuple, a, err, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + n = 0; + err = $ifaceNil; + _r = Fprintln(os.Stdout, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + n = _tuple[0]; + err = _tuple[1]; + $s = -1; return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Println }; } $f._r = _r; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Println = Println; + getField = function(v, i) { + var _r, _r$1, i, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; i = $f.i; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $clone(v, reflect.Value).Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + val = _r; + /* */ if (($clone(val, reflect.Value).Kind() === 20) && !$clone(val, reflect.Value).IsNil()) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (($clone(val, reflect.Value).Kind() === 20) && !$clone(val, reflect.Value).IsNil()) { */ case 2: + _r$1 = $clone(val, reflect.Value).Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + val = _r$1; + /* } */ case 3: + $s = -1; return val; + /* */ } return; } if ($f === undefined) { $f = { $blk: getField }; } $f._r = _r; $f._r$1 = _r$1; $f.i = i; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + tooLarge = function(x) { + var x; + return x > 1000000 || x < -1000000; + }; + parsenum = function(s, start, end) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, end, isnum, newi, num, s, start; + num = 0; + isnum = false; + newi = 0; + if (start >= end) { + _tmp = 0; + _tmp$1 = false; + _tmp$2 = end; + num = _tmp; + isnum = _tmp$1; + newi = _tmp$2; + return [num, isnum, newi]; + } + newi = start; + while (true) { + if (!(newi < end && 48 <= s.charCodeAt(newi) && s.charCodeAt(newi) <= 57)) { break; } + if (tooLarge(num)) { + _tmp$3 = 0; + _tmp$4 = false; + _tmp$5 = end; + num = _tmp$3; + isnum = _tmp$4; + newi = _tmp$5; + return [num, isnum, newi]; + } + num = ($imul(num, 10)) + (((s.charCodeAt(newi) - 48 << 24 >>> 24) >> 0)) >> 0; + isnum = true; + newi = newi + (1) >> 0; + } + return [num, isnum, newi]; + }; + pp.ptr.prototype.unknownType = function(v) { + var _r, _r$1, p, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; p = $f.p; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + if (!$clone(v, reflect.Value).IsValid()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63); + _r = $clone(v, reflect.Value).Type(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.String(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.unknownType }; } $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.unknownType = function(v) { return this.$val.unknownType(v); }; + pp.ptr.prototype.badVerb = function(verb) { + var _r, _r$1, _r$2, p, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + p.erroring = true; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); + /* */ if (!($interfaceIsEqual(p.arg, $ifaceNil))) { $s = 2; continue; } + /* */ if ($clone(p.value, reflect.Value).IsValid()) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!($interfaceIsEqual(p.arg, $ifaceNil))) { */ case 2: + _r = reflect.TypeOf(p.arg).String(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + $r = p.printArg(p.arg, 118); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 5; continue; + /* } else if ($clone(p.value, reflect.Value).IsValid()) { */ case 3: + _r$1 = $clone(p.value, reflect.Value).Type(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = _r$1.String(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + $r = p.printValue($clone(p.value, reflect.Value), 118, 0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 5; continue; + /* } else { */ case 4: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + /* } */ case 5: + case 1: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + p.erroring = false; + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.badVerb }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.badVerb = function(verb) { return this.$val.badVerb(verb); }; + pp.ptr.prototype.fmtBool = function(v, verb) { + var _1, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if ((_1 === (116)) || (_1 === (118))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_1 === (116)) || (_1 === (118))) { */ case 2: + p.fmt.fmt_boolean(v); + $s = 4; continue; + /* } else { */ case 3: + $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBool }; } $f._1 = _1; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtBool = function(v, verb) { return this.$val.fmtBool(v, verb); }; + pp.ptr.prototype.fmt0x64 = function(v, leading0x) { + var leading0x, p, sharp, v; + p = this; + sharp = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = leading0x; + p.fmt.fmt_integer(v, 16, false, "0123456789abcdefx"); + p.fmt.fmtFlags.sharp = sharp; + }; + pp.prototype.fmt0x64 = function(v, leading0x) { return this.$val.fmt0x64(v, leading0x); }; + pp.ptr.prototype.fmtInteger = function(v, isSigned, verb) { + var _1, isSigned, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; isSigned = $f.isSigned; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if (_1 === (118)) { $s = 2; continue; } + /* */ if (_1 === (100)) { $s = 3; continue; } + /* */ if (_1 === (98)) { $s = 4; continue; } + /* */ if (_1 === (111)) { $s = 5; continue; } + /* */ if (_1 === (120)) { $s = 6; continue; } + /* */ if (_1 === (88)) { $s = 7; continue; } + /* */ if (_1 === (99)) { $s = 8; continue; } + /* */ if (_1 === (113)) { $s = 9; continue; } + /* */ if (_1 === (85)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_1 === (118)) { */ case 2: + if (p.fmt.fmtFlags.sharpV && !isSigned) { + p.fmt0x64(v, true); + } else { + p.fmt.fmt_integer(v, 10, isSigned, "0123456789abcdefx"); + } + $s = 12; continue; + /* } else if (_1 === (100)) { */ case 3: + p.fmt.fmt_integer(v, 10, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (98)) { */ case 4: + p.fmt.fmt_integer(v, 2, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (111)) { */ case 5: + p.fmt.fmt_integer(v, 8, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (120)) { */ case 6: + p.fmt.fmt_integer(v, 16, isSigned, "0123456789abcdefx"); + $s = 12; continue; + /* } else if (_1 === (88)) { */ case 7: + p.fmt.fmt_integer(v, 16, isSigned, "0123456789ABCDEFX"); + $s = 12; continue; + /* } else if (_1 === (99)) { */ case 8: + p.fmt.fmt_c(v); + $s = 12; continue; + /* } else if (_1 === (113)) { */ case 9: + /* */ if ((v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if ((v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 13: + p.fmt.fmt_qc(v); + $s = 15; continue; + /* } else { */ case 14: + $r = p.badVerb(verb); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 15: + $s = 12; continue; + /* } else if (_1 === (85)) { */ case 10: + p.fmt.fmt_unicode(v); + $s = 12; continue; + /* } else { */ case 11: + $r = p.badVerb(verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 12: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtInteger }; } $f._1 = _1; $f.isSigned = isSigned; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtInteger = function(v, isSigned, verb) { return this.$val.fmtInteger(v, isSigned, verb); }; + pp.ptr.prototype.fmtFloat = function(v, size, verb) { + var _1, p, size, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; size = $f.size; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if (_1 === (118)) { $s = 2; continue; } + /* */ if ((_1 === (98)) || (_1 === (103)) || (_1 === (71))) { $s = 3; continue; } + /* */ if ((_1 === (102)) || (_1 === (101)) || (_1 === (69))) { $s = 4; continue; } + /* */ if (_1 === (70)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_1 === (118)) { */ case 2: + p.fmt.fmt_float(v, size, 103, -1); + $s = 7; continue; + /* } else if ((_1 === (98)) || (_1 === (103)) || (_1 === (71))) { */ case 3: + p.fmt.fmt_float(v, size, verb, -1); + $s = 7; continue; + /* } else if ((_1 === (102)) || (_1 === (101)) || (_1 === (69))) { */ case 4: + p.fmt.fmt_float(v, size, verb, 6); + $s = 7; continue; + /* } else if (_1 === (70)) { */ case 5: + p.fmt.fmt_float(v, size, 102, 6); + $s = 7; continue; + /* } else { */ case 6: + $r = p.badVerb(verb); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 7: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat }; } $f._1 = _1; $f.p = p; $f.size = size; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtFloat = function(v, size, verb) { return this.$val.fmtFloat(v, size, verb); }; + pp.ptr.prototype.fmtComplex = function(v, size, verb) { + var _1, _q, _q$1, oldPlus, p, size, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _q = $f._q; _q$1 = $f._q$1; oldPlus = $f.oldPlus; p = $f.p; size = $f.size; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if ((_1 === (118)) || (_1 === (98)) || (_1 === (103)) || (_1 === (71)) || (_1 === (102)) || (_1 === (70)) || (_1 === (101)) || (_1 === (69))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_1 === (118)) || (_1 === (98)) || (_1 === (103)) || (_1 === (71)) || (_1 === (102)) || (_1 === (70)) || (_1 === (101)) || (_1 === (69))) { */ case 2: + oldPlus = p.fmt.fmtFlags.plus; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); + $r = p.fmtFloat(v.$real, (_q = size / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + p.fmt.fmtFlags.plus = true; + $r = p.fmtFloat(v.$imag, (_q$1 = size / 2, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")), verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("i)"); + p.fmt.fmtFlags.plus = oldPlus; + $s = 4; continue; + /* } else { */ case 3: + $r = p.badVerb(verb); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 4: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex }; } $f._1 = _1; $f._q = _q; $f._q$1 = _q$1; $f.oldPlus = oldPlus; $f.p = p; $f.size = size; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtComplex = function(v, size, verb) { return this.$val.fmtComplex(v, size, verb); }; + pp.ptr.prototype.fmtString = function(v, verb) { + var _1, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if (_1 === (118)) { $s = 2; continue; } + /* */ if (_1 === (115)) { $s = 3; continue; } + /* */ if (_1 === (120)) { $s = 4; continue; } + /* */ if (_1 === (88)) { $s = 5; continue; } + /* */ if (_1 === (113)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (_1 === (118)) { */ case 2: + if (p.fmt.fmtFlags.sharpV) { + p.fmt.fmt_q(v); + } else { + p.fmt.fmt_s(v); + } + $s = 8; continue; + /* } else if (_1 === (115)) { */ case 3: + p.fmt.fmt_s(v); + $s = 8; continue; + /* } else if (_1 === (120)) { */ case 4: + p.fmt.fmt_sx(v, "0123456789abcdefx"); + $s = 8; continue; + /* } else if (_1 === (88)) { */ case 5: + p.fmt.fmt_sx(v, "0123456789ABCDEFX"); + $s = 8; continue; + /* } else if (_1 === (113)) { */ case 6: + p.fmt.fmt_q(v); + $s = 8; continue; + /* } else { */ case 7: + $r = p.badVerb(verb); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 8: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtString }; } $f._1 = _1; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtString = function(v, verb) { return this.$val.fmtString(v, verb); }; + pp.ptr.prototype.fmtBytes = function(v, verb, typeString) { + var _1, _i, _i$1, _r, _ref, _ref$1, c, c$1, i, i$1, p, typeString, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; c$1 = $f.c$1; i = $f.i; i$1 = $f.i$1; p = $f.p; typeString = $f.typeString; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _1 = verb; + /* */ if ((_1 === (118)) || (_1 === (100))) { $s = 2; continue; } + /* */ if (_1 === (115)) { $s = 3; continue; } + /* */ if (_1 === (120)) { $s = 4; continue; } + /* */ if (_1 === (88)) { $s = 5; continue; } + /* */ if (_1 === (113)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((_1 === (118)) || (_1 === (100))) { */ case 2: + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(typeString); + if (v === sliceType$2.nil) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + _ref = v; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (i > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } + p.fmt0x64((new $Uint64(0, c)), true); + _i++; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); + _ref$1 = v; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + c$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref$1.$array[_ref$1.$offset + _i$1]); + if (i$1 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + p.fmt.fmt_integer((new $Uint64(0, c$1)), 10, false, "0123456789abcdefx"); + _i$1++; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); + } + $s = 8; continue; + /* } else if (_1 === (115)) { */ case 3: + p.fmt.fmt_s(($bytesToString(v))); + $s = 8; continue; + /* } else if (_1 === (120)) { */ case 4: + p.fmt.fmt_bx(v, "0123456789abcdefx"); + $s = 8; continue; + /* } else if (_1 === (88)) { */ case 5: + p.fmt.fmt_bx(v, "0123456789ABCDEFX"); + $s = 8; continue; + /* } else if (_1 === (113)) { */ case 6: + p.fmt.fmt_q(($bytesToString(v))); + $s = 8; continue; + /* } else { */ case 7: + _r = reflect.ValueOf(v); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r, reflect.Value), verb, 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 8: + case 1: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBytes }; } $f._1 = _1; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.c$1 = c$1; $f.i = i; $f.i$1 = i$1; $f.p = p; $f.typeString = typeString; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtBytes = function(v, verb, typeString) { return this.$val.fmtBytes(v, verb, typeString); }; + pp.ptr.prototype.fmtPointer = function(value, verb) { + var _1, _2, _r, _r$1, p, u, value, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; _r$1 = $f._r$1; p = $f.p; u = $f.u; value = $f.value; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + u = 0; + _1 = $clone(value, reflect.Value).Kind(); + /* */ if ((_1 === (18)) || (_1 === (19)) || (_1 === (21)) || (_1 === (22)) || (_1 === (23)) || (_1 === (26))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_1 === (18)) || (_1 === (19)) || (_1 === (21)) || (_1 === (22)) || (_1 === (23)) || (_1 === (26))) { */ case 2: + u = $clone(value, reflect.Value).Pointer(); + $s = 4; continue; + /* } else { */ case 3: + $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 4: + case 1: + _2 = verb; + /* */ if (_2 === (118)) { $s = 7; continue; } + /* */ if (_2 === (112)) { $s = 8; continue; } + /* */ if ((_2 === (98)) || (_2 === (111)) || (_2 === (100)) || (_2 === (120)) || (_2 === (88))) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_2 === (118)) { */ case 7: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 12: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(40); + _r = $clone(value, reflect.Value).Type(); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.String(); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$1); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(")("); + if (u === 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("nil"); + } else { + p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), true); + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + $s = 14; continue; + /* } else { */ case 13: + if (u === 0) { + p.fmt.padString(""); + } else { + p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), !p.fmt.fmtFlags.sharp); + } + /* } */ case 14: + $s = 11; continue; + /* } else if (_2 === (112)) { */ case 8: + p.fmt0x64((new $Uint64(0, u.constructor === Number ? u : 1)), !p.fmt.fmtFlags.sharp); + $s = 11; continue; + /* } else if ((_2 === (98)) || (_2 === (111)) || (_2 === (100)) || (_2 === (120)) || (_2 === (88))) { */ case 9: + $r = p.fmtInteger((new $Uint64(0, u.constructor === Number ? u : 1)), false, verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 11; continue; + /* } else { */ case 10: + $r = p.badVerb(verb); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 11: + case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtPointer }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.u = u; $f.value = value; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtPointer = function(value, verb) { return this.$val.fmtPointer(value, verb); }; + pp.ptr.prototype.catchPanic = function(arg, verb) { + var _r, arg, err, oldFlags, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; arg = $f.arg; err = $f.err; oldFlags = $f.oldFlags; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + err = $recover(); + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 1: + _r = reflect.ValueOf(arg); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + if (($clone(v, reflect.Value).Kind() === 22) && $clone(v, reflect.Value).IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = -1; return; + } + if (p.panicking) { + $panic(err); + } + oldFlags = $clone(p.fmt.fmtFlags, fmtFlags); + p.fmt.clearflags(); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(PANIC="); + p.panicking = true; + $r = p.printArg(err, 118); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + p.panicking = false; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + fmtFlags.copy(p.fmt.fmtFlags, oldFlags); + /* } */ case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.catchPanic }; } $f._r = _r; $f.arg = arg; $f.err = err; $f.oldFlags = oldFlags; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.catchPanic = function(arg, verb) { return this.$val.catchPanic(arg, verb); }; + pp.ptr.prototype.handleMethods = function(verb) { + var _1, _r, _r$1, _r$2, _ref, _tuple, _tuple$1, formatter, handled, ok, ok$1, p, stringer, v, v$1, verb, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; formatter = $f.formatter; handled = $f.handled; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; stringer = $f.stringer; v = $f.v; v$1 = $f.v$1; verb = $f.verb; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + handled = false; + p = this; + if (p.erroring) { + $s = -1; return handled; + } + _tuple = $assertType(p.arg, Formatter, true); + formatter = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (ok) { */ case 1: + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]); + $r = formatter.Format(p, verb); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } */ case 2: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 4: + _tuple$1 = $assertType(p.arg, GoStringer, true); + stringer = _tuple$1[0]; + ok$1 = _tuple$1[1]; + /* */ if (ok$1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (ok$1) { */ case 7: + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]); + _r = stringer.GoString(); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = p.fmt.fmt_s(_r); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } */ case 8: + $s = 6; continue; + /* } else { */ case 5: + _1 = verb; + /* */ if ((_1 === (118)) || (_1 === (115)) || (_1 === (120)) || (_1 === (88)) || (_1 === (113))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((_1 === (118)) || (_1 === (115)) || (_1 === (120)) || (_1 === (88)) || (_1 === (113))) { */ case 12: + _ref = p.arg; + /* */ if ($assertType(_ref, $error, true)[1]) { $s = 14; continue; } + /* */ if ($assertType(_ref, Stringer, true)[1]) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if ($assertType(_ref, $error, true)[1]) { */ case 14: + v = _ref; + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]); + _r$1 = v.Error(); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = p.fmtString(_r$1, verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } else if ($assertType(_ref, Stringer, true)[1]) { */ case 15: + v$1 = _ref; + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]); + _r$2 = v$1.String(); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = p.fmtString(_r$2, verb); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return handled; + /* } */ case 16: + /* } */ case 13: + case 11: + /* } */ case 6: + handled = false; + $s = -1; return handled; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return handled; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: pp.ptr.prototype.handleMethods }; } $f._1 = _1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.formatter = formatter; $f.handled = handled; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.stringer = stringer; $f.v = v; $f.v$1 = v$1; $f.verb = verb; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + pp.prototype.handleMethods = function(verb) { return this.$val.handleMethods(verb); }; + pp.ptr.prototype.printArg = function(arg, verb) { + var _1, _2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, arg, f, f$1, f$10, f$11, f$12, f$13, f$14, f$15, f$16, f$17, f$18, f$19, f$2, f$3, f$4, f$5, f$6, f$7, f$8, f$9, p, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; arg = $f.arg; f = $f.f; f$1 = $f.f$1; f$10 = $f.f$10; f$11 = $f.f$11; f$12 = $f.f$12; f$13 = $f.f$13; f$14 = $f.f$14; f$15 = $f.f$15; f$16 = $f.f$16; f$17 = $f.f$17; f$18 = $f.f$18; f$19 = $f.f$19; f$2 = $f.f$2; f$3 = $f.f$3; f$4 = $f.f$4; f$5 = $f.f$5; f$6 = $f.f$6; f$7 = $f.f$7; f$8 = $f.f$8; f$9 = $f.f$9; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + p.arg = arg; + p.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 1: + _1 = verb; + /* */ if ((_1 === (84)) || (_1 === (118))) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((_1 === (84)) || (_1 === (118))) { */ case 4: + p.fmt.padString(""); + $s = 6; continue; + /* } else { */ case 5: + $r = p.badVerb(verb); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + case 3: + $s = -1; return; + /* } */ case 2: + _2 = verb; + /* */ if (_2 === (84)) { $s = 9; continue; } + /* */ if (_2 === (112)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_2 === (84)) { */ case 9: + _r = reflect.TypeOf(arg).String(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $r = p.fmt.fmt_s(_r); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } else if (_2 === (112)) { */ case 10: + _r$1 = reflect.ValueOf(arg); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $r = p.fmtPointer($clone(_r$1, reflect.Value), 112); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 11: + case 8: + _ref = arg; + /* */ if ($assertType(_ref, $Bool, true)[1]) { $s = 16; continue; } + /* */ if ($assertType(_ref, $Float32, true)[1]) { $s = 17; continue; } + /* */ if ($assertType(_ref, $Float64, true)[1]) { $s = 18; continue; } + /* */ if ($assertType(_ref, $Complex64, true)[1]) { $s = 19; continue; } + /* */ if ($assertType(_ref, $Complex128, true)[1]) { $s = 20; continue; } + /* */ if ($assertType(_ref, $Int, true)[1]) { $s = 21; continue; } + /* */ if ($assertType(_ref, $Int8, true)[1]) { $s = 22; continue; } + /* */ if ($assertType(_ref, $Int16, true)[1]) { $s = 23; continue; } + /* */ if ($assertType(_ref, $Int32, true)[1]) { $s = 24; continue; } + /* */ if ($assertType(_ref, $Int64, true)[1]) { $s = 25; continue; } + /* */ if ($assertType(_ref, $Uint, true)[1]) { $s = 26; continue; } + /* */ if ($assertType(_ref, $Uint8, true)[1]) { $s = 27; continue; } + /* */ if ($assertType(_ref, $Uint16, true)[1]) { $s = 28; continue; } + /* */ if ($assertType(_ref, $Uint32, true)[1]) { $s = 29; continue; } + /* */ if ($assertType(_ref, $Uint64, true)[1]) { $s = 30; continue; } + /* */ if ($assertType(_ref, $Uintptr, true)[1]) { $s = 31; continue; } + /* */ if ($assertType(_ref, $String, true)[1]) { $s = 32; continue; } + /* */ if ($assertType(_ref, sliceType$2, true)[1]) { $s = 33; continue; } + /* */ if ($assertType(_ref, reflect.Value, true)[1]) { $s = 34; continue; } + /* */ $s = 35; continue; + /* if ($assertType(_ref, $Bool, true)[1]) { */ case 16: + f = _ref.$val; + $r = p.fmtBool(f, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Float32, true)[1]) { */ case 17: + f$1 = _ref.$val; + $r = p.fmtFloat((f$1), 32, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Float64, true)[1]) { */ case 18: + f$2 = _ref.$val; + $r = p.fmtFloat(f$2, 64, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Complex64, true)[1]) { */ case 19: + f$3 = _ref.$val; + $r = p.fmtComplex((new $Complex128(f$3.$real, f$3.$imag)), 64, verb); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Complex128, true)[1]) { */ case 20: + f$4 = _ref.$val; + $r = p.fmtComplex(f$4, 128, verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int, true)[1]) { */ case 21: + f$5 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$5)), true, verb); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int8, true)[1]) { */ case 22: + f$6 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$6)), true, verb); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int16, true)[1]) { */ case 23: + f$7 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$7)), true, verb); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int32, true)[1]) { */ case 24: + f$8 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$8)), true, verb); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Int64, true)[1]) { */ case 25: + f$9 = _ref.$val; + $r = p.fmtInteger((new $Uint64(f$9.$high, f$9.$low)), true, verb); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint, true)[1]) { */ case 26: + f$10 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$10)), false, verb); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint8, true)[1]) { */ case 27: + f$11 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$11)), false, verb); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint16, true)[1]) { */ case 28: + f$12 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$12)), false, verb); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint32, true)[1]) { */ case 29: + f$13 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$13)), false, verb); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uint64, true)[1]) { */ case 30: + f$14 = _ref.$val; + $r = p.fmtInteger(f$14, false, verb); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $Uintptr, true)[1]) { */ case 31: + f$15 = _ref.$val; + $r = p.fmtInteger((new $Uint64(0, f$15.constructor === Number ? f$15 : 1)), false, verb); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, $String, true)[1]) { */ case 32: + f$16 = _ref.$val; + $r = p.fmtString(f$16, verb); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, sliceType$2, true)[1]) { */ case 33: + f$17 = _ref.$val; + $r = p.fmtBytes(f$17, verb, "[]byte"); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else if ($assertType(_ref, reflect.Value, true)[1]) { */ case 34: + f$18 = _ref.$val; + /* */ if ($clone(f$18, reflect.Value).IsValid() && $clone(f$18, reflect.Value).CanInterface()) { $s = 55; continue; } + /* */ $s = 56; continue; + /* if ($clone(f$18, reflect.Value).IsValid() && $clone(f$18, reflect.Value).CanInterface()) { */ case 55: + _r$2 = $clone(f$18, reflect.Value).Interface(); /* */ $s = 57; case 57: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p.arg = _r$2; + _r$3 = p.handleMethods(verb); /* */ $s = 60; case 60: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3) { $s = 58; continue; } + /* */ $s = 59; continue; + /* if (_r$3) { */ case 58: + $s = -1; return; + /* } */ case 59: + /* } */ case 56: + $r = p.printValue($clone(f$18, reflect.Value), verb, 0); /* */ $s = 61; case 61: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 36; continue; + /* } else { */ case 35: + f$19 = _ref; + _r$4 = p.handleMethods(verb); /* */ $s = 64; case 64: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (!_r$4) { $s = 62; continue; } + /* */ $s = 63; continue; + /* if (!_r$4) { */ case 62: + _r$5 = reflect.ValueOf(f$19); /* */ $s = 65; case 65: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$5, reflect.Value), verb, 0); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 63: + /* } */ case 36: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printArg }; } $f._1 = _1; $f._2 = _2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.arg = arg; $f.f = f; $f.f$1 = f$1; $f.f$10 = f$10; $f.f$11 = f$11; $f.f$12 = f$12; $f.f$13 = f$13; $f.f$14 = f$14; $f.f$15 = f$15; $f.f$16 = f$16; $f.f$17 = f$17; $f.f$18 = f$18; $f.f$19 = f$19; $f.f$2 = f$2; $f.f$3 = f$3; $f.f$4 = f$4; $f.f$5 = f$5; $f.f$6 = f$6; $f.f$7 = f$7; $f.f$8 = f$8; $f.f$9 = f$9; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printArg = function(arg, verb) { return this.$val.printArg(arg, verb); }; + pp.ptr.prototype.printValue = function(value, verb, depth) { + var _1, _2, _3, _4, _arg, _arg$1, _arg$2, _i, _i$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, a, bytes, depth, f, i, i$1, i$2, i$3, i$4, key, keys, name, p, t, value, value$1, verb, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _2 = $f._2; _3 = $f._3; _4 = $f._4; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; a = $f.a; bytes = $f.bytes; depth = $f.depth; f = $f.f; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; key = $f.key; keys = $f.keys; name = $f.name; p = $f.p; t = $f.t; value = $f.value; value$1 = $f.value$1; verb = $f.verb; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if (depth > 0 && $clone(value, reflect.Value).IsValid() && $clone(value, reflect.Value).CanInterface()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (depth > 0 && $clone(value, reflect.Value).IsValid() && $clone(value, reflect.Value).CanInterface()) { */ case 1: + _r = $clone(value, reflect.Value).Interface(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + p.arg = _r; + _r$1 = p.handleMethods(verb); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$1) { */ case 4: + $s = -1; return; + /* } */ case 5: + /* } */ case 2: + p.arg = $ifaceNil; + p.value = value; + f = value; + _1 = $clone(value, reflect.Value).Kind(); + /* */ if (_1 === (0)) { $s = 8; continue; } + /* */ if (_1 === (1)) { $s = 9; continue; } + /* */ if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { $s = 10; continue; } + /* */ if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { $s = 11; continue; } + /* */ if (_1 === (13)) { $s = 12; continue; } + /* */ if (_1 === (14)) { $s = 13; continue; } + /* */ if (_1 === (15)) { $s = 14; continue; } + /* */ if (_1 === (16)) { $s = 15; continue; } + /* */ if (_1 === (24)) { $s = 16; continue; } + /* */ if (_1 === (21)) { $s = 17; continue; } + /* */ if (_1 === (25)) { $s = 18; continue; } + /* */ if (_1 === (20)) { $s = 19; continue; } + /* */ if ((_1 === (17)) || (_1 === (23))) { $s = 20; continue; } + /* */ if (_1 === (22)) { $s = 21; continue; } + /* */ if ((_1 === (18)) || (_1 === (19)) || (_1 === (26))) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (_1 === (0)) { */ case 8: + /* */ if (depth === 0) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (depth === 0) { */ case 25: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 27; continue; + /* } else { */ case 26: + _2 = verb; + /* */ if (_2 === (118)) { $s = 29; continue; } + /* */ $s = 30; continue; + /* if (_2 === (118)) { */ case 29: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 31; continue; + /* } else { */ case 30: + $r = p.badVerb(verb); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 31: + case 28: + /* } */ case 27: + $s = 24; continue; + /* } else if (_1 === (1)) { */ case 9: + $r = p.fmtBool($clone(f, reflect.Value).Bool(), verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { */ case 10: + $r = p.fmtInteger(((x = $clone(f, reflect.Value).Int(), new $Uint64(x.$high, x.$low))), true, verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { */ case 11: + $r = p.fmtInteger($clone(f, reflect.Value).Uint(), false, verb); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (13)) { */ case 12: + $r = p.fmtFloat($clone(f, reflect.Value).Float(), 32, verb); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (14)) { */ case 13: + $r = p.fmtFloat($clone(f, reflect.Value).Float(), 64, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (15)) { */ case 14: + $r = p.fmtComplex($clone(f, reflect.Value).Complex(), 64, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (16)) { */ case 15: + $r = p.fmtComplex($clone(f, reflect.Value).Complex(), 128, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (24)) { */ case 16: + _r$2 = $clone(f, reflect.Value).String(); /* */ $s = 40; case 40: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = p.fmtString(_r$2, verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if (_1 === (21)) { */ case 17: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 42; continue; } + /* */ $s = 43; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 42: + _r$3 = $clone(f, reflect.Value).Type(); /* */ $s = 45; case 45: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = _r$3.String(); /* */ $s = 46; case 46: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$4); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if ($clone(f, reflect.Value).IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + $s = 44; continue; + /* } else { */ case 43: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("map["); + /* } */ case 44: + _r$5 = $clone(f, reflect.Value).MapKeys(); /* */ $s = 48; case 48: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + keys = _r$5; + _ref = keys; + _i = 0; + /* while (true) { */ case 49: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 50; continue; } + i = _i; + key = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (i > 0) { + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + } + $r = p.printValue($clone(key, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); + _r$6 = $clone(f, reflect.Value).MapIndex($clone(key, reflect.Value)); /* */ $s = 52; case 52: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$6, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 49; continue; case 50: + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); + } + $s = 24; continue; + /* } else if (_1 === (25)) { */ case 18: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 54; continue; } + /* */ $s = 55; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 54: + _r$7 = $clone(f, reflect.Value).Type(); /* */ $s = 56; case 56: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$8 = _r$7.String(); /* */ $s = 57; case 57: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$8); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 55: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + i$1 = 0; + /* while (true) { */ case 59: + /* if (!(i$1 < $clone(f, reflect.Value).NumField())) { break; } */ if(!(i$1 < $clone(f, reflect.Value).NumField())) { $s = 60; continue; } + if (i$1 > 0) { + if (p.fmt.fmtFlags.sharpV) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } else { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + } + /* */ if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { $s = 61; continue; } + /* */ $s = 62; continue; + /* if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { */ case 61: + _r$9 = $clone(f, reflect.Value).Type(); /* */ $s = 63; case 63: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$10 = _r$9.Field(i$1); /* */ $s = 64; case 64: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + name = _r$10.Name; + if (!(name === "")) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(name); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); + } + /* } */ case 62: + _r$11 = getField($clone(f, reflect.Value), i$1); /* */ $s = 65; case 65: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$11, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$1 = i$1 + (1) >> 0; + /* } */ $s = 59; continue; case 60: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + $s = 24; continue; + /* } else if (_1 === (20)) { */ case 19: + _r$12 = $clone(f, reflect.Value).Elem(); /* */ $s = 67; case 67: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + value$1 = _r$12; + /* */ if (!$clone(value$1, reflect.Value).IsValid()) { $s = 68; continue; } + /* */ $s = 69; continue; + /* if (!$clone(value$1, reflect.Value).IsValid()) { */ case 68: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 71; continue; } + /* */ $s = 72; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 71: + _r$13 = $clone(f, reflect.Value).Type(); /* */ $s = 74; case 74: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + _r$14 = _r$13.String(); /* */ $s = 75; case 75: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$14); /* */ $s = 76; case 76: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = 73; continue; + /* } else { */ case 72: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + /* } */ case 73: + $s = 70; continue; + /* } else { */ case 69: + $r = p.printValue($clone(value$1, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 70: + $s = 24; continue; + /* } else if ((_1 === (17)) || (_1 === (23))) { */ case 20: + _3 = verb; + /* */ if ((_3 === (115)) || (_3 === (113)) || (_3 === (120)) || (_3 === (88))) { $s = 79; continue; } + /* */ $s = 80; continue; + /* if ((_3 === (115)) || (_3 === (113)) || (_3 === (120)) || (_3 === (88))) { */ case 79: + _r$15 = $clone(f, reflect.Value).Type(); /* */ $s = 81; case 81: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + t = _r$15; + _r$16 = t.Elem(); /* */ $s = 84; case 84: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + _r$17 = _r$16.Kind(); /* */ $s = 85; case 85: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + /* */ if (_r$17 === 8) { $s = 82; continue; } + /* */ $s = 83; continue; + /* if (_r$17 === 8) { */ case 82: + bytes = sliceType$2.nil; + /* */ if ($clone(f, reflect.Value).Kind() === 23) { $s = 86; continue; } + /* */ if ($clone(f, reflect.Value).CanAddr()) { $s = 87; continue; } + /* */ $s = 88; continue; + /* if ($clone(f, reflect.Value).Kind() === 23) { */ case 86: + _r$18 = $clone(f, reflect.Value).Bytes(); /* */ $s = 90; case 90: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + bytes = _r$18; + $s = 89; continue; + /* } else if ($clone(f, reflect.Value).CanAddr()) { */ case 87: + _r$19 = $clone(f, reflect.Value).Slice(0, $clone(f, reflect.Value).Len()); /* */ $s = 91; case 91: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; } + _r$20 = $clone(_r$19, reflect.Value).Bytes(); /* */ $s = 92; case 92: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; } + bytes = _r$20; + $s = 89; continue; + /* } else { */ case 88: + bytes = $makeSlice(sliceType$2, $clone(f, reflect.Value).Len()); + _ref$1 = bytes; + _i$1 = 0; + /* while (true) { */ case 93: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 94; continue; } + i$2 = _i$1; + _r$21 = $clone(f, reflect.Value).Index(i$2); /* */ $s = 95; case 95: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; } + _r$22 = $clone(_r$21, reflect.Value).Uint(); /* */ $s = 96; case 96: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; } + ((i$2 < 0 || i$2 >= bytes.$length) ? ($throwRuntimeError("index out of range"), undefined) : bytes.$array[bytes.$offset + i$2] = ((_r$22.$low << 24 >>> 24))); + _i$1++; + /* } */ $s = 93; continue; case 94: + /* } */ case 89: + _arg = bytes; + _arg$1 = verb; + _r$23 = t.String(); /* */ $s = 97; case 97: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; } + _arg$2 = _r$23; + $r = p.fmtBytes(_arg, _arg$1, _arg$2); /* */ $s = 98; case 98: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 83: + /* } */ case 80: + case 78: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 99; continue; } + /* */ $s = 100; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 99: + _r$24 = $clone(f, reflect.Value).Type(); /* */ $s = 102; case 102: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; } + _r$25 = _r$24.String(); /* */ $s = 103; case 103: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$25); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (($clone(f, reflect.Value).Kind() === 23) && $clone(f, reflect.Value).IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + $s = -1; return; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + i$3 = 0; + /* while (true) { */ case 105: + /* if (!(i$3 < $clone(f, reflect.Value).Len())) { break; } */ if(!(i$3 < $clone(f, reflect.Value).Len())) { $s = 106; continue; } + if (i$3 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } + _r$26 = $clone(f, reflect.Value).Index(i$3); /* */ $s = 107; case 107: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$26, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 108; case 108: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$3 = i$3 + (1) >> 0; + /* } */ $s = 105; continue; case 106: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + $s = 101; continue; + /* } else { */ case 100: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); + i$4 = 0; + /* while (true) { */ case 109: + /* if (!(i$4 < $clone(f, reflect.Value).Len())) { break; } */ if(!(i$4 < $clone(f, reflect.Value).Len())) { $s = 110; continue; } + if (i$4 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + _r$27 = $clone(f, reflect.Value).Index(i$4); /* */ $s = 111; case 111: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; } + $r = p.printValue($clone(_r$27, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 112; case 112: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + i$4 = i$4 + (1) >> 0; + /* } */ $s = 109; continue; case 110: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93); + /* } */ case 101: + $s = 24; continue; + /* } else if (_1 === (22)) { */ case 21: + /* */ if ((depth === 0) && !(($clone(f, reflect.Value).Pointer() === 0))) { $s = 113; continue; } + /* */ $s = 114; continue; + /* if ((depth === 0) && !(($clone(f, reflect.Value).Pointer() === 0))) { */ case 113: + _r$28 = $clone(f, reflect.Value).Elem(); /* */ $s = 116; case 116: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; } + a = _r$28; + _4 = $clone(a, reflect.Value).Kind(); + /* */ if ((_4 === (17)) || (_4 === (23)) || (_4 === (25)) || (_4 === (21))) { $s = 117; continue; } + /* */ $s = 118; continue; + /* if ((_4 === (17)) || (_4 === (23)) || (_4 === (25)) || (_4 === (21))) { */ case 117: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38); + $r = p.printValue($clone(a, reflect.Value), verb, depth + 1 >> 0); /* */ $s = 119; case 119: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 118: + case 115: + /* } */ case 114: + $r = p.fmtPointer($clone(f, reflect.Value), verb); /* */ $s = 120; case 120: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else if ((_1 === (18)) || (_1 === (19)) || (_1 === (26))) { */ case 22: + $r = p.fmtPointer($clone(f, reflect.Value), verb); /* */ $s = 121; case 121: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 24; continue; + /* } else { */ case 23: + $r = p.unknownType($clone(f, reflect.Value)); /* */ $s = 122; case 122: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 24: + case 7: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printValue }; } $f._1 = _1; $f._2 = _2; $f._3 = _3; $f._4 = _4; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f.a = a; $f.bytes = bytes; $f.depth = depth; $f.f = f; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.key = key; $f.keys = keys; $f.name = name; $f.p = p; $f.t = t; $f.value = value; $f.value$1 = value$1; $f.verb = verb; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printValue = function(value, verb, depth) { return this.$val.printValue(value, verb, depth); }; + intFromArg = function(a, argNum) { + var _1, _r, _tuple, a, argNum, isInt, n, n$1, newArgNum, num, v, x, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _r = $f._r; _tuple = $f._tuple; a = $f.a; argNum = $f.argNum; isInt = $f.isInt; n = $f.n; n$1 = $f.n$1; newArgNum = $f.newArgNum; num = $f.num; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + num = 0; + isInt = false; + newArgNum = 0; + newArgNum = argNum; + /* */ if (argNum < a.$length) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (argNum < a.$length) { */ case 1: + _tuple = $assertType(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), $Int, true); + num = _tuple[0]; + isInt = _tuple[1]; + /* */ if (!isInt) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!isInt) { */ case 3: + _r = reflect.ValueOf(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum])); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + _1 = $clone(v, reflect.Value).Kind(); + if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + n = $clone(v, reflect.Value).Int(); + if ((x = (new $Int64(0, (((n.$low + ((n.$high >> 31) * 4294967296)) >> 0)))), (x.$high === n.$high && x.$low === n.$low))) { + num = (((n.$low + ((n.$high >> 31) * 4294967296)) >> 0)); + isInt = true; + } + } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { + n$1 = $clone(v, reflect.Value).Uint(); + if ((x$1 = (new $Int64(n$1.$high, n$1.$low)), (x$1.$high > 0 || (x$1.$high === 0 && x$1.$low >= 0))) && (x$2 = (new $Uint64(0, ((n$1.$low >> 0)))), (x$2.$high === n$1.$high && x$2.$low === n$1.$low))) { + num = ((n$1.$low >> 0)); + isInt = true; + } + } + case 5: + /* } */ case 4: + newArgNum = argNum + 1 >> 0; + if (tooLarge(num)) { + num = 0; + isInt = false; + } + /* } */ case 2: + $s = -1; return [num, isInt, newArgNum]; + /* */ } return; } if ($f === undefined) { $f = { $blk: intFromArg }; } $f._1 = _1; $f._r = _r; $f._tuple = _tuple; $f.a = a; $f.argNum = argNum; $f.isInt = isInt; $f.n = n; $f.n$1 = n$1; $f.newArgNum = newArgNum; $f.num = num; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + parseArgNumber = function(format) { + var _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, format, i, index, newi, ok, ok$1, wid, width; + index = 0; + wid = 0; + ok = false; + if (format.length < 3) { + _tmp = 0; + _tmp$1 = 1; + _tmp$2 = false; + index = _tmp; + wid = _tmp$1; + ok = _tmp$2; + return [index, wid, ok]; + } + i = 1; + while (true) { + if (!(i < format.length)) { break; } + if (format.charCodeAt(i) === 93) { + _tuple = parsenum(format, 1, i); + width = _tuple[0]; + ok$1 = _tuple[1]; + newi = _tuple[2]; + if (!ok$1 || !((newi === i))) { + _tmp$3 = 0; + _tmp$4 = i + 1 >> 0; + _tmp$5 = false; + index = _tmp$3; + wid = _tmp$4; + ok = _tmp$5; + return [index, wid, ok]; + } + _tmp$6 = width - 1 >> 0; + _tmp$7 = i + 1 >> 0; + _tmp$8 = true; + index = _tmp$6; + wid = _tmp$7; + ok = _tmp$8; + return [index, wid, ok]; + } + i = i + (1) >> 0; + } + _tmp$9 = 0; + _tmp$10 = 1; + _tmp$11 = false; + index = _tmp$9; + wid = _tmp$10; + ok = _tmp$11; + return [index, wid, ok]; + }; + pp.ptr.prototype.argNumber = function(argNum, format, i, numArgs) { + var _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, argNum, format, found, i, index, newArgNum, newi, numArgs, ok, p, wid; + newArgNum = 0; + newi = 0; + found = false; + p = this; + if (format.length <= i || !((format.charCodeAt(i) === 91))) { + _tmp = argNum; + _tmp$1 = i; + _tmp$2 = false; + newArgNum = _tmp; + newi = _tmp$1; + found = _tmp$2; + return [newArgNum, newi, found]; + } + p.reordered = true; + _tuple = parseArgNumber($substring(format, i)); + index = _tuple[0]; + wid = _tuple[1]; + ok = _tuple[2]; + if (ok && 0 <= index && index < numArgs) { + _tmp$3 = index; + _tmp$4 = i + wid >> 0; + _tmp$5 = true; + newArgNum = _tmp$3; + newi = _tmp$4; + found = _tmp$5; + return [newArgNum, newi, found]; + } + p.goodArgNum = false; + _tmp$6 = argNum; + _tmp$7 = i + wid >> 0; + _tmp$8 = ok; + newArgNum = _tmp$6; + newi = _tmp$7; + found = _tmp$8; + return [newArgNum, newi, found]; + }; + pp.prototype.argNumber = function(argNum, format, i, numArgs) { return this.$val.argNumber(argNum, format, i, numArgs); }; + pp.ptr.prototype.badArgNum = function(verb) { + var p, verb; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(BADINDEX)"); + }; + pp.prototype.badArgNum = function(verb) { return this.$val.badArgNum(verb); }; + pp.ptr.prototype.missingArg = function(verb) { + var p, verb; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!"); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(MISSING)"); + }; + pp.prototype.missingArg = function(verb) { return this.$val.missingArg(verb); }; + pp.ptr.prototype.doPrintf = function(format, a) { + var _1, _i, _r, _r$1, _r$2, _ref, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, a, afterIndex, arg, argNum, c, end, format, i, i$1, lasti, p, size, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _1 = $f._1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; a = $f.a; afterIndex = $f.afterIndex; arg = $f.arg; argNum = $f.argNum; c = $f.c; end = $f.end; format = $f.format; i = $f.i; i$1 = $f.i$1; lasti = $f.lasti; p = $f.p; size = $f.size; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + end = format.length; + argNum = 0; + afterIndex = false; + p.reordered = false; + i = 0; + /* while (true) { */ case 1: + /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 2; continue; } + p.goodArgNum = true; + lasti = i; + while (true) { + if (!(i < end && !((format.charCodeAt(i) === 37)))) { break; } + i = i + (1) >> 0; + } + if (i > lasti) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString($substring(format, lasti, i)); + } + if (i >= end) { + /* break; */ $s = 2; continue; + } + i = i + (1) >> 0; + p.fmt.clearflags(); + /* while (true) { */ case 3: + /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 4; continue; } + c = format.charCodeAt(i); + _1 = c; + /* */ if (_1 === (35)) { $s = 6; continue; } + /* */ if (_1 === (48)) { $s = 7; continue; } + /* */ if (_1 === (43)) { $s = 8; continue; } + /* */ if (_1 === (45)) { $s = 9; continue; } + /* */ if (_1 === (32)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_1 === (35)) { */ case 6: + p.fmt.fmtFlags.sharp = true; + $s = 12; continue; + /* } else if (_1 === (48)) { */ case 7: + p.fmt.fmtFlags.zero = !p.fmt.fmtFlags.minus; + $s = 12; continue; + /* } else if (_1 === (43)) { */ case 8: + p.fmt.fmtFlags.plus = true; + $s = 12; continue; + /* } else if (_1 === (45)) { */ case 9: + p.fmt.fmtFlags.minus = true; + p.fmt.fmtFlags.zero = false; + $s = 12; continue; + /* } else if (_1 === (32)) { */ case 10: + p.fmt.fmtFlags.space = true; + $s = 12; continue; + /* } else { */ case 11: + /* */ if (97 <= c && c <= 122 && argNum < a.$length) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (97 <= c && c <= 122 && argNum < a.$length) { */ case 13: + if (c === 118) { + p.fmt.fmtFlags.sharpV = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = false; + p.fmt.fmtFlags.plusV = p.fmt.fmtFlags.plus; + p.fmt.fmtFlags.plus = false; + } + $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), ((c >> 0))); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + argNum = argNum + (1) >> 0; + i = i + (1) >> 0; + /* continue formatLoop; */ $s = 1; continue s; + /* } */ case 14: + /* break simpleFormat; */ $s = 4; continue s; + /* } */ case 12: + case 5: + i = i + (1) >> 0; + /* } */ $s = 3; continue; case 4: + _tuple = p.argNumber(argNum, format, i, a.$length); + argNum = _tuple[0]; + i = _tuple[1]; + afterIndex = _tuple[2]; + /* */ if (i < end && (format.charCodeAt(i) === 42)) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 16: + i = i + (1) >> 0; + _r = intFromArg(a, argNum); /* */ $s = 19; case 19: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + p.fmt.wid = _tuple$1[0]; + p.fmt.fmtFlags.widPresent = _tuple$1[1]; + argNum = _tuple$1[2]; + if (!p.fmt.fmtFlags.widPresent) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(BADWIDTH)"); + } + if (p.fmt.wid < 0) { + p.fmt.wid = -p.fmt.wid; + p.fmt.fmtFlags.minus = true; + p.fmt.fmtFlags.zero = false; + } + afterIndex = false; + $s = 18; continue; + /* } else { */ case 17: + _tuple$2 = parsenum(format, i, end); + p.fmt.wid = _tuple$2[0]; + p.fmt.fmtFlags.widPresent = _tuple$2[1]; + i = _tuple$2[2]; + if (afterIndex && p.fmt.fmtFlags.widPresent) { + p.goodArgNum = false; + } + /* } */ case 18: + /* */ if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { */ case 20: + i = i + (1) >> 0; + if (afterIndex) { + p.goodArgNum = false; + } + _tuple$3 = p.argNumber(argNum, format, i, a.$length); + argNum = _tuple$3[0]; + i = _tuple$3[1]; + afterIndex = _tuple$3[2]; + /* */ if (i < end && (format.charCodeAt(i) === 42)) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 22: + i = i + (1) >> 0; + _r$1 = intFromArg(a, argNum); /* */ $s = 25; case 25: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple$4 = _r$1; + p.fmt.prec = _tuple$4[0]; + p.fmt.fmtFlags.precPresent = _tuple$4[1]; + argNum = _tuple$4[2]; + if (p.fmt.prec < 0) { + p.fmt.prec = 0; + p.fmt.fmtFlags.precPresent = false; + } + if (!p.fmt.fmtFlags.precPresent) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(BADPREC)"); + } + afterIndex = false; + $s = 24; continue; + /* } else { */ case 23: + _tuple$5 = parsenum(format, i, end); + p.fmt.prec = _tuple$5[0]; + p.fmt.fmtFlags.precPresent = _tuple$5[1]; + i = _tuple$5[2]; + if (!p.fmt.fmtFlags.precPresent) { + p.fmt.prec = 0; + p.fmt.fmtFlags.precPresent = true; + } + /* } */ case 24: + /* } */ case 21: + if (!afterIndex) { + _tuple$6 = p.argNumber(argNum, format, i, a.$length); + argNum = _tuple$6[0]; + i = _tuple$6[1]; + afterIndex = _tuple$6[2]; + } + if (i >= end) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(NOVERB)"); + /* break; */ $s = 2; continue; + } + _tmp = ((format.charCodeAt(i) >> 0)); + _tmp$1 = 1; + verb = _tmp; + size = _tmp$1; + if (verb >= 128) { + _tuple$7 = utf8.DecodeRuneInString($substring(format, i)); + verb = _tuple$7[0]; + size = _tuple$7[1]; + } + i = i + (size) >> 0; + /* */ if ((verb === 37)) { $s = 27; continue; } + /* */ if (!p.goodArgNum) { $s = 28; continue; } + /* */ if (argNum >= a.$length) { $s = 29; continue; } + /* */ if ((verb === 118)) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if ((verb === 37)) { */ case 27: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(37); + $s = 32; continue; + /* } else if (!p.goodArgNum) { */ case 28: + p.badArgNum(verb); + $s = 32; continue; + /* } else if (argNum >= a.$length) { */ case 29: + p.missingArg(verb); + $s = 32; continue; + /* } else if ((verb === 118)) { */ case 30: + p.fmt.fmtFlags.sharpV = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = false; + p.fmt.fmtFlags.plusV = p.fmt.fmtFlags.plus; + p.fmt.fmtFlags.plus = false; + $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + argNum = argNum + (1) >> 0; + $s = 32; continue; + /* } else { */ case 31: + $r = p.printArg(((argNum < 0 || argNum >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + argNum]), verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + argNum = argNum + (1) >> 0; + /* } */ case 32: + case 26: + /* } */ $s = 1; continue; case 2: + /* */ if (!p.reordered && argNum < a.$length) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (!p.reordered && argNum < a.$length) { */ case 35: + p.fmt.clearflags(); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("%!(EXTRA "); + _ref = $subslice(a, argNum); + _i = 0; + /* while (true) { */ case 37: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 38; continue; } + i$1 = _i; + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (i$1 > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(", "); + } + /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 39; continue; } + /* */ $s = 40; continue; + /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 39: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 41; continue; + /* } else { */ case 40: + _r$2 = reflect.TypeOf(arg).String(); /* */ $s = 42; case 42: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + $r = p.printArg(arg, 118); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 41: + _i++; + /* } */ $s = 37; continue; case 38: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + /* } */ case 36: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintf }; } $f._1 = _1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.a = a; $f.afterIndex = afterIndex; $f.arg = arg; $f.argNum = argNum; $f.c = c; $f.end = end; $f.format = format; $f.i = i; $f.i$1 = i$1; $f.lasti = lasti; $f.p = p; $f.size = size; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.doPrintf = function(format, a) { return this.$val.doPrintf(format, a); }; + pp.ptr.prototype.doPrintln = function(a) { + var _i, _ref, a, arg, argNum, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _i = $f._i; _ref = $f._ref; a = $f.a; arg = $f.arg; argNum = $f.argNum; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _ref = a; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + argNum = _i; + arg = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + if (argNum > 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32); + } + $r = p.printArg(arg, 118); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 1; continue; case 2: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(10); + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintln }; } $f._i = _i; $f._ref = _ref; $f.a = a; $f.arg = arg; $f.argNum = argNum; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.doPrintln = function(a) { return this.$val.doPrintln(a); }; + ss.ptr.prototype.Read = function(buf) { + var _tmp, _tmp$1, buf, err, n, s; + n = 0; + err = $ifaceNil; + s = this; + _tmp = 0; + _tmp$1 = errors.New("ScanState's Read should not be called. Use ReadRune"); + n = _tmp; + err = _tmp$1; + return [n, err]; + }; + ss.prototype.Read = function(buf) { return this.$val.Read(buf); }; + ss.ptr.prototype.ReadRune = function() { + var _r, _tuple, err, r, s, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = 0; + size = 0; + err = $ifaceNil; + s = this; + if (s.atEOF || s.count >= s.ssave.argLimit) { + err = io.EOF; + $s = -1; return [r, size, err]; + } + _r = s.rs.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + size = _tuple[1]; + err = _tuple[2]; + if ($interfaceIsEqual(err, $ifaceNil)) { + s.count = s.count + (1) >> 0; + if (s.ssave.nlIsEnd && (r === 10)) { + s.atEOF = true; + } + } else if ($interfaceIsEqual(err, io.EOF)) { + s.atEOF = true; + } + $s = -1; return [r, size, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.ReadRune }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.size = size; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.ReadRune = function() { return this.$val.ReadRune(); }; + ss.ptr.prototype.Width = function() { + var _tmp, _tmp$1, _tmp$2, _tmp$3, ok, s, wid; + wid = 0; + ok = false; + s = this; + if (s.ssave.maxWid === 1073741824) { + _tmp = 0; + _tmp$1 = false; + wid = _tmp; + ok = _tmp$1; + return [wid, ok]; + } + _tmp$2 = s.ssave.maxWid; + _tmp$3 = true; + wid = _tmp$2; + ok = _tmp$3; + return [wid, ok]; + }; + ss.prototype.Width = function() { return this.$val.Width(); }; + ss.ptr.prototype.getRune = function() { + var _r, _tuple, err, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = 0; + s = this; + _r = s.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + r = _tuple[0]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if ($interfaceIsEqual(err, io.EOF)) { + r = -1; + $s = -1; return r; + } + s.error(err); + } + $s = -1; return r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.getRune }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.getRune = function() { return this.$val.getRune(); }; + ss.ptr.prototype.UnreadRune = function() { + var _r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + _r = s.rs.UnreadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + s.atEOF = false; + s.count = s.count - (1) >> 0; + $s = -1; return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.UnreadRune }; } $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + ss.ptr.prototype.error = function(err) { + var err, s, x; + s = this; + $panic((x = new scanError.ptr(err), new x.constructor.elem(x))); + }; + ss.prototype.error = function(err) { return this.$val.error(err); }; + ss.ptr.prototype.errorString = function(err) { + var err, s, x; + s = this; + $panic((x = new scanError.ptr(errors.New(err)), new x.constructor.elem(x))); + }; + ss.prototype.errorString = function(err) { return this.$val.errorString(err); }; + ss.ptr.prototype.Token = function(skipSpace, f) { + var _r, err, f, s, skipSpace, tok, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; err = $f.err; f = $f.f; s = $f.s; skipSpace = $f.skipSpace; tok = $f.tok; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + err = [err]; + tok = sliceType$2.nil; + err[0] = $ifaceNil; + s = this; + $deferred.push([(function(err) { return function() { + var _tuple, e, ok, se; + e = $recover(); + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tuple = $assertType(e, scanError, true); + se = $clone(_tuple[0], scanError); + ok = _tuple[1]; + if (ok) { + err[0] = se.err; + } else { + $panic(e); + } + } + }; })(err), []]); + if (f === $throwNilPointerError) { + f = notSpace; + } + s.buf = $subslice(s.buf, 0, 0); + _r = s.token(skipSpace, f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + tok = _r; + $s = -1; return [tok, err[0]]; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [tok, err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ss.ptr.prototype.Token }; } $f._r = _r; $f.err = err; $f.f = f; $f.s = s; $f.skipSpace = skipSpace; $f.tok = tok; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + ss.prototype.Token = function(skipSpace, f) { return this.$val.Token(skipSpace, f); }; + isSpace = function(r) { + var _i, _ref, r, rng, rx; + if (r >= 65536) { + return false; + } + rx = ((r << 16 >>> 16)); + _ref = space; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + rng = $clone(((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]), arrayType$1); + if (rx < rng[0]) { + return false; + } + if (rx <= rng[1]) { + return true; + } + _i++; + } + return false; + }; + notSpace = function(r) { + var r; + return !isSpace(r); + }; + ss.ptr.prototype.free = function(old) { + var old, s; + s = this; + if (old.validSave) { + ssave.copy(s.ssave, old); + return; + } + if (s.buf.$capacity > 1024) { + return; + } + s.buf = $subslice(s.buf, 0, 0); + s.rs = $ifaceNil; + ssFree.Put(s); + }; + ss.prototype.free = function(old) { return this.$val.free(old); }; + ss.ptr.prototype.SkipSpace = function() { + var _r, _r$1, _r$2, _v, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _v = $f._v; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + /* while (true) { */ case 1: + _r = s.getRune(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + if (r === -1) { + $s = -1; return; + } + if (!(r === 13)) { _v = false; $s = 6; continue s; } + _r$1 = s.peek("\n"); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _v = _r$1; case 6: + /* */ if (_v) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_v) { */ case 4: + /* continue; */ $s = 1; continue; + /* } */ case 5: + /* */ if (r === 10) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (r === 10) { */ case 8: + if (s.ssave.nlIsSpace) { + /* continue; */ $s = 1; continue; + } + s.errorString("unexpected newline"); + $s = -1; return; + /* } */ case 9: + /* */ if (!isSpace(r)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (!isSpace(r)) { */ case 10: + _r$2 = s.UnreadRune(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + /* break; */ $s = 2; continue; + /* } */ case 11: + /* } */ $s = 1; continue; case 2: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.SkipSpace }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._v = _v; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.SkipSpace = function() { return this.$val.SkipSpace(); }; + ss.ptr.prototype.token = function(skipSpace, f) { + var _r, _r$1, _r$2, f, r, s, skipSpace, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; f = $f.f; r = $f.r; s = $f.s; skipSpace = $f.skipSpace; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + /* */ if (skipSpace) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (skipSpace) { */ case 1: + $r = s.SkipSpace(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 2: + /* while (true) { */ case 4: + _r = s.getRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + if (r === -1) { + /* break; */ $s = 5; continue; + } + _r$1 = f(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (!_r$1) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!_r$1) { */ case 7: + _r$2 = s.UnreadRune(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + /* break; */ $s = 5; continue; + /* } */ case 8: + (s.$ptr_buf || (s.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, s))).WriteRune(r); + /* } */ $s = 4; continue; case 5: + $s = -1; return (x = s.buf, $subslice(new sliceType$2(x.$array), x.$offset, x.$offset + x.$length)); + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.token }; } $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.f = f; $f.r = r; $f.s = s; $f.skipSpace = skipSpace; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.token = function(skipSpace, f) { return this.$val.token(skipSpace, f); }; + indexRune = function(s, r) { + var _i, _ref, _rune, c, i, r, s; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + c = _rune[0]; + if (c === r) { + return i; + } + _i += _rune[1]; + } + return -1; + }; + ss.ptr.prototype.peek = function(ok) { + var _r, _r$1, ok, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; ok = $f.ok; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + _r = s.getRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + r = _r; + /* */ if (!((r === -1))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((r === -1))) { */ case 2: + _r$1 = s.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + /* } */ case 3: + $s = -1; return indexRune(ok, r) >= 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.peek }; } $f._r = _r; $f._r$1 = _r$1; $f.ok = ok; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.peek = function(ok) { return this.$val.peek(ok); }; + ptrType$25.methods = [{prop: "clearflags", name: "clearflags", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "init", name: "init", pkg: "fmt", typ: $funcType([ptrType$1], [], false)}, {prop: "writePadding", name: "writePadding", pkg: "fmt", typ: $funcType([$Int], [], false)}, {prop: "pad", name: "pad", pkg: "fmt", typ: $funcType([sliceType$2], [], false)}, {prop: "padString", name: "padString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_boolean", name: "fmt_boolean", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "fmt_unicode", name: "fmt_unicode", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmt_integer", name: "fmt_integer", pkg: "fmt", typ: $funcType([$Uint64, $Int, $Bool, $String], [], false)}, {prop: "truncate", name: "truncate", pkg: "fmt", typ: $funcType([$String], [$String], false)}, {prop: "fmt_s", name: "fmt_s", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_sbx", name: "fmt_sbx", pkg: "fmt", typ: $funcType([$String, sliceType$2, $String], [], false)}, {prop: "fmt_sx", name: "fmt_sx", pkg: "fmt", typ: $funcType([$String, $String], [], false)}, {prop: "fmt_bx", name: "fmt_bx", pkg: "fmt", typ: $funcType([sliceType$2, $String], [], false)}, {prop: "fmt_q", name: "fmt_q", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_c", name: "fmt_c", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmt_qc", name: "fmt_qc", pkg: "fmt", typ: $funcType([$Uint64], [], false)}, {prop: "fmt_float", name: "fmt_float", pkg: "fmt", typ: $funcType([$Float64, $Int, $Int32, $Int], [], false)}]; + ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [], false)}]; + ptrType$2.methods = [{prop: "free", name: "free", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "unknownType", name: "unknownType", pkg: "fmt", typ: $funcType([reflect.Value], [], false)}, {prop: "badVerb", name: "badVerb", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "fmtBool", name: "fmtBool", pkg: "fmt", typ: $funcType([$Bool, $Int32], [], false)}, {prop: "fmt0x64", name: "fmt0x64", pkg: "fmt", typ: $funcType([$Uint64, $Bool], [], false)}, {prop: "fmtInteger", name: "fmtInteger", pkg: "fmt", typ: $funcType([$Uint64, $Bool, $Int32], [], false)}, {prop: "fmtFloat", name: "fmtFloat", pkg: "fmt", typ: $funcType([$Float64, $Int, $Int32], [], false)}, {prop: "fmtComplex", name: "fmtComplex", pkg: "fmt", typ: $funcType([$Complex128, $Int, $Int32], [], false)}, {prop: "fmtString", name: "fmtString", pkg: "fmt", typ: $funcType([$String, $Int32], [], false)}, {prop: "fmtBytes", name: "fmtBytes", pkg: "fmt", typ: $funcType([sliceType$2, $Int32, $String], [], false)}, {prop: "fmtPointer", name: "fmtPointer", pkg: "fmt", typ: $funcType([reflect.Value, $Int32], [], false)}, {prop: "catchPanic", name: "catchPanic", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32], [], false)}, {prop: "handleMethods", name: "handleMethods", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "printArg", name: "printArg", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32], [], false)}, {prop: "printValue", name: "printValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [], false)}, {prop: "argNumber", name: "argNumber", pkg: "fmt", typ: $funcType([$Int, $String, $Int, $Int], [$Int, $Int, $Bool], false)}, {prop: "badArgNum", name: "badArgNum", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "missingArg", name: "missingArg", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "doPrintf", name: "doPrintf", pkg: "fmt", typ: $funcType([$String, sliceType], [], false)}, {prop: "doPrint", name: "doPrint", pkg: "fmt", typ: $funcType([sliceType], [], false)}, {prop: "doPrintln", name: "doPrintln", pkg: "fmt", typ: $funcType([sliceType], [], false)}]; + ptrType$5.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "getRune", name: "getRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "mustReadRune", name: "mustReadRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "error", name: "error", pkg: "fmt", typ: $funcType([$error], [], false)}, {prop: "errorString", name: "errorString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType$2, $error], false)}, {prop: "free", name: "free", pkg: "fmt", typ: $funcType([ssave], [], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "token", name: "token", pkg: "fmt", typ: $funcType([$Bool, funcType], [sliceType$2], false)}, {prop: "consume", name: "consume", pkg: "fmt", typ: $funcType([$String, $Bool], [$Bool], false)}, {prop: "peek", name: "peek", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "notEOF", name: "notEOF", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "accept", name: "accept", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "okVerb", name: "okVerb", pkg: "fmt", typ: $funcType([$Int32, $String, $String], [$Bool], false)}, {prop: "scanBool", name: "scanBool", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "getBase", name: "getBase", pkg: "fmt", typ: $funcType([$Int32], [$Int, $String], false)}, {prop: "scanNumber", name: "scanNumber", pkg: "fmt", typ: $funcType([$String, $Bool], [$String], false)}, {prop: "scanRune", name: "scanRune", pkg: "fmt", typ: $funcType([$Int], [$Int64], false)}, {prop: "scanBasePrefix", name: "scanBasePrefix", pkg: "fmt", typ: $funcType([], [$Int, $String, $Bool], false)}, {prop: "scanInt", name: "scanInt", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Int64], false)}, {prop: "scanUint", name: "scanUint", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Uint64], false)}, {prop: "floatToken", name: "floatToken", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "complexTokens", name: "complexTokens", pkg: "fmt", typ: $funcType([], [$String, $String], false)}, {prop: "convertFloat", name: "convertFloat", pkg: "fmt", typ: $funcType([$String, $Int], [$Float64], false)}, {prop: "scanComplex", name: "scanComplex", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Complex128], false)}, {prop: "convertString", name: "convertString", pkg: "fmt", typ: $funcType([$Int32], [$String], false)}, {prop: "quotedString", name: "quotedString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "hexByte", name: "hexByte", pkg: "fmt", typ: $funcType([], [$Uint8, $Bool], false)}, {prop: "hexString", name: "hexString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "scanOne", name: "scanOne", pkg: "fmt", typ: $funcType([$Int32, $emptyInterface], [], false)}, {prop: "doScan", name: "doScan", pkg: "fmt", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "advance", name: "advance", pkg: "fmt", typ: $funcType([$String], [$Int], false)}, {prop: "doScanf", name: "doScanf", pkg: "fmt", typ: $funcType([$String, sliceType], [$Int, $error], false)}]; + fmtFlags.init("fmt", [{prop: "widPresent", name: "widPresent", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "precPresent", name: "precPresent", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "minus", name: "minus", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "plus", name: "plus", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "sharp", name: "sharp", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "space", name: "space", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "zero", name: "zero", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "plusV", name: "plusV", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "sharpV", name: "sharpV", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + fmt.init("fmt", [{prop: "buf", name: "buf", anonymous: false, exported: false, typ: ptrType$1, tag: ""}, {prop: "fmtFlags", name: "fmtFlags", anonymous: true, exported: false, typ: fmtFlags, tag: ""}, {prop: "wid", name: "wid", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "prec", name: "prec", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "intbuf", name: "intbuf", anonymous: false, exported: false, typ: arrayType, tag: ""}]); + State.init([{prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$2], [$Int, $error], false)}]); + Formatter.init([{prop: "Format", name: "Format", pkg: "", typ: $funcType([State, $Int32], [], false)}]); + Stringer.init([{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]); + GoStringer.init([{prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]); + buffer.init($Uint8); + pp.init("fmt", [{prop: "buf", name: "buf", anonymous: false, exported: false, typ: buffer, tag: ""}, {prop: "arg", name: "arg", anonymous: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "value", name: "value", anonymous: false, exported: false, typ: reflect.Value, tag: ""}, {prop: "fmt", name: "fmt", anonymous: false, exported: false, typ: fmt, tag: ""}, {prop: "reordered", name: "reordered", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "goodArgNum", name: "goodArgNum", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "panicking", name: "panicking", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "erroring", name: "erroring", anonymous: false, exported: false, typ: $Bool, tag: ""}]); + scanError.init("fmt", [{prop: "err", name: "err", anonymous: false, exported: false, typ: $error, tag: ""}]); + ss.init("fmt", [{prop: "rs", name: "rs", anonymous: false, exported: false, typ: io.RuneScanner, tag: ""}, {prop: "buf", name: "buf", anonymous: false, exported: false, typ: buffer, tag: ""}, {prop: "count", name: "count", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "atEOF", name: "atEOF", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "ssave", name: "ssave", anonymous: true, exported: false, typ: ssave, tag: ""}]); + ssave.init("fmt", [{prop: "validSave", name: "validSave", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "nlIsEnd", name: "nlIsEnd", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "nlIsSpace", name: "nlIsSpace", anonymous: false, exported: false, typ: $Bool, tag: ""}, {prop: "argLimit", name: "argLimit", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "limit", name: "limit", anonymous: false, exported: false, typ: $Int, tag: ""}, {prop: "maxWid", name: "maxWid", anonymous: false, exported: false, typ: $Int, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = os.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ppFree = new sync.Pool.ptr(0, 0, sliceType.nil, (function() { + return new pp.ptr(buffer.nil, $ifaceNil, new reflect.Value.ptr(ptrType.nil, 0, 0), new fmt.ptr(ptrType$1.nil, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false), 0, 0, arrayType.zero()), false, false, false, false); + })); + space = new sliceType$1([$toNativeArray($kindUint16, [9, 13]), $toNativeArray($kindUint16, [32, 32]), $toNativeArray($kindUint16, [133, 133]), $toNativeArray($kindUint16, [160, 160]), $toNativeArray($kindUint16, [5760, 5760]), $toNativeArray($kindUint16, [8192, 8202]), $toNativeArray($kindUint16, [8232, 8233]), $toNativeArray($kindUint16, [8239, 8239]), $toNativeArray($kindUint16, [8287, 8287]), $toNativeArray($kindUint16, [12288, 12288])]); + ssFree = new sync.Pool.ptr(0, 0, sliceType.nil, (function() { + return new ss.ptr($ifaceNil, buffer.nil, 0, false, new ssave.ptr(false, false, false, 0, 0, 0)); + })); + complexError = errors.New("syntax error scanning complex number"); + boolError = errors.New("syntax error scanning boolean"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["context"] = (function() { + var $pkg = {}, $init, errors, fmt, reflect, sync, time, Context, deadlineExceededError, emptyCtx, canceler, cancelCtx, timerCtx, valueCtx, ptrType, structType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, sliceType, ptrType$5, chanType, chanType$1, mapType, background, todo, closedchan, x, Background, TODO, WithCancel, newCancelCtx, propagateCancel, parentCancelCtx, removeChild, init, WithDeadline, WithTimeout; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + reflect = $packages["reflect"]; + sync = $packages["sync"]; + time = $packages["time"]; + Context = $pkg.Context = $newType(8, $kindInterface, "context.Context", true, "context", true, null); + deadlineExceededError = $pkg.deadlineExceededError = $newType(0, $kindStruct, "context.deadlineExceededError", true, "context", false, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + emptyCtx = $pkg.emptyCtx = $newType(4, $kindInt, "context.emptyCtx", true, "context", false, null); + canceler = $pkg.canceler = $newType(8, $kindInterface, "context.canceler", true, "context", false, null); + cancelCtx = $pkg.cancelCtx = $newType(0, $kindStruct, "context.cancelCtx", true, "context", false, function(Context_, mu_, done_, children_, err_) { + this.$val = this; + if (arguments.length === 0) { + this.Context = $ifaceNil; + this.mu = new sync.Mutex.ptr(0, 0); + this.done = $chanNil; + this.children = false; + this.err = $ifaceNil; + return; + } + this.Context = Context_; + this.mu = mu_; + this.done = done_; + this.children = children_; + this.err = err_; + }); + timerCtx = $pkg.timerCtx = $newType(0, $kindStruct, "context.timerCtx", true, "context", false, function(cancelCtx_, timer_, deadline_) { + this.$val = this; + if (arguments.length === 0) { + this.cancelCtx = new cancelCtx.ptr($ifaceNil, new sync.Mutex.ptr(0, 0), $chanNil, false, $ifaceNil); + this.timer = ptrType$5.nil; + this.deadline = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$1.nil); + return; + } + this.cancelCtx = cancelCtx_; + this.timer = timer_; + this.deadline = deadline_; + }); + valueCtx = $pkg.valueCtx = $newType(0, $kindStruct, "context.valueCtx", true, "context", false, function(Context_, key_, val_) { + this.$val = this; + if (arguments.length === 0) { + this.Context = $ifaceNil; + this.key = $ifaceNil; + this.val = $ifaceNil; + return; + } + this.Context = Context_; + this.key = key_; + this.val = val_; + }); + ptrType = $ptrType(emptyCtx); + structType = $structType("", []); + ptrType$1 = $ptrType(time.Location); + ptrType$2 = $ptrType(cancelCtx); + ptrType$3 = $ptrType(timerCtx); + ptrType$4 = $ptrType(valueCtx); + sliceType = $sliceType($emptyInterface); + ptrType$5 = $ptrType(time.Timer); + chanType = $chanType(structType, false, true); + chanType$1 = $chanType(structType, false, false); + mapType = $mapType(canceler, structType); + deadlineExceededError.ptr.prototype.Error = function() { + return "context deadline exceeded"; + }; + deadlineExceededError.prototype.Error = function() { return this.$val.Error(); }; + deadlineExceededError.ptr.prototype.Timeout = function() { + return true; + }; + deadlineExceededError.prototype.Timeout = function() { return this.$val.Timeout(); }; + deadlineExceededError.ptr.prototype.Temporary = function() { + return true; + }; + deadlineExceededError.prototype.Temporary = function() { return this.$val.Temporary(); }; + $ptrType(emptyCtx).prototype.Deadline = function() { + var deadline, ok; + deadline = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$1.nil); + ok = false; + return [deadline, ok]; + }; + $ptrType(emptyCtx).prototype.Done = function() { + return $chanNil; + }; + $ptrType(emptyCtx).prototype.Err = function() { + return $ifaceNil; + }; + $ptrType(emptyCtx).prototype.Value = function(key) { + var key; + return $ifaceNil; + }; + $ptrType(emptyCtx).prototype.String = function() { + var _1, e; + e = this; + _1 = e; + if (_1 === (background)) { + return "context.Background"; + } else if (_1 === (todo)) { + return "context.TODO"; + } + return "unknown empty Context"; + }; + Background = function() { + return background; + }; + $pkg.Background = Background; + TODO = function() { + return todo; + }; + $pkg.TODO = TODO; + WithCancel = function(parent) { + var _tmp, _tmp$1, c, cancel, ctx, parent, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; c = $f.c; cancel = $f.cancel; ctx = $f.ctx; parent = $f.parent; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = [c]; + ctx = $ifaceNil; + cancel = $throwNilPointerError; + c[0] = $clone(newCancelCtx(parent), cancelCtx); + $r = propagateCancel(parent, c[0]); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _tmp = c[0]; + _tmp$1 = (function(c) { return function $b() { + var $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = c[0].cancel(true, $pkg.Canceled); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$s = $s; $f.$r = $r; return $f; + }; })(c); + ctx = _tmp; + cancel = _tmp$1; + $s = -1; return [ctx, cancel]; + /* */ } return; } if ($f === undefined) { $f = { $blk: WithCancel }; } $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.c = c; $f.cancel = cancel; $f.ctx = ctx; $f.parent = parent; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.WithCancel = WithCancel; + newCancelCtx = function(parent) { + var parent; + return new cancelCtx.ptr(parent, new sync.Mutex.ptr(0, 0), $chanNil, false, $ifaceNil); + }; + propagateCancel = function(parent, child) { + var _key, _r, _tuple, child, ok, p, parent, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _key = $f._key; _r = $f._r; _tuple = $f._tuple; child = $f.child; ok = $f.ok; p = $f.p; parent = $f.parent; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + child = [child]; + parent = [parent]; + _r = parent[0].Done(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === $chanNil) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r === $chanNil) { */ case 1: + $s = -1; return; + /* } */ case 2: + _tuple = parentCancelCtx(parent[0]); + p = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (ok) { */ case 4: + $r = p.mu.Lock(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ if (!($interfaceIsEqual(p.err, $ifaceNil))) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!($interfaceIsEqual(p.err, $ifaceNil))) { */ case 8: + $r = child[0].cancel(false, p.err); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 10; continue; + /* } else { */ case 9: + if (p.children === false) { + p.children = {}; + } + _key = child[0]; (p.children || $throwRuntimeError("assignment to entry in nil map"))[canceler.keyFor(_key)] = { k: _key, v: new structType.ptr() }; + /* } */ case 10: + $r = p.mu.Unlock(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 6; continue; + /* } else { */ case 5: + $go((function(child, parent) { return function $b() { + var _arg, _r$1, _r$2, _r$3, _r$4, _selection, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _arg = $f._arg; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _selection = $f._selection; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$1 = parent[0].Done(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = child[0].Done(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = $select([[_r$1], [_r$2]]); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _selection = _r$3; + /* */ if (_selection[0] === 0) { $s = 4; continue; } + /* */ if (_selection[0] === 1) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (_selection[0] === 0) { */ case 4: + _r$4 = parent[0].Err(); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _arg = _r$4; + $r = child[0].cancel(false, _arg); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 6; continue; + /* } else if (_selection[0] === 1) { */ case 5: + /* } */ case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f._arg = _arg; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._selection = _selection; $f.$s = $s; $f.$r = $r; return $f; + }; })(child, parent), []); + /* } */ case 6: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: propagateCancel }; } $f._key = _key; $f._r = _r; $f._tuple = _tuple; $f.child = child; $f.ok = ok; $f.p = p; $f.parent = parent; $f.$s = $s; $f.$r = $r; return $f; + }; + parentCancelCtx = function(parent) { + var _ref, c, c$1, c$2, c$3, parent; + while (true) { + _ref = parent; + if ($assertType(_ref, ptrType$2, true)[1]) { + c = _ref.$val; + return [c, true]; + } else if ($assertType(_ref, ptrType$3, true)[1]) { + c$1 = _ref.$val; + return [c$1.cancelCtx, true]; + } else if ($assertType(_ref, ptrType$4, true)[1]) { + c$2 = _ref.$val; + parent = c$2.Context; + } else { + c$3 = _ref; + return [ptrType$2.nil, false]; + } + } + }; + removeChild = function(parent, child) { + var _tuple, child, ok, p, parent, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _tuple = $f._tuple; child = $f.child; ok = $f.ok; p = $f.p; parent = $f.parent; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _tuple = parentCancelCtx(parent); + p = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + $s = -1; return; + } + $r = p.mu.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (!(p.children === false)) { + delete p.children[canceler.keyFor(child)]; + } + $r = p.mu.Unlock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: removeChild }; } $f._tuple = _tuple; $f.child = child; $f.ok = ok; $f.p = p; $f.parent = parent; $f.$s = $s; $f.$r = $r; return $f; + }; + init = function() { + $close(closedchan); + }; + cancelCtx.ptr.prototype.Done = function() { + var c, d, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; c = $f.c; d = $f.d; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + $r = c.mu.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (c.done === $chanNil) { + c.done = new $Chan(structType, 0); + } + d = c.done; + $r = c.mu.Unlock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return d; + /* */ } return; } if ($f === undefined) { $f = { $blk: cancelCtx.ptr.prototype.Done }; } $f.c = c; $f.d = d; $f.$s = $s; $f.$r = $r; return $f; + }; + cancelCtx.prototype.Done = function() { return this.$val.Done(); }; + cancelCtx.ptr.prototype.Err = function() { + var c, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; c = $f.c; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + c = this; + $r = c.mu.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(c.mu, "Unlock"), []]); + $s = -1; return c.err; + /* */ } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: cancelCtx.ptr.prototype.Err }; } $f.c = c; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + cancelCtx.prototype.Err = function() { return this.$val.Err(); }; + cancelCtx.ptr.prototype.String = function() { + var _r, c, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + _r = fmt.Sprintf("%v.WithCancel", new sliceType([c.Context])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cancelCtx.ptr.prototype.String }; } $f._r = _r; $f.c = c; $f.$s = $s; $f.$r = $r; return $f; + }; + cancelCtx.prototype.String = function() { return this.$val.String(); }; + cancelCtx.ptr.prototype.cancel = function(removeFromParent, err) { + var _entry, _i, _keys, _ref, c, child, err, removeFromParent, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _ref = $f._ref; c = $f.c; child = $f.child; err = $f.err; removeFromParent = $f.removeFromParent; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + if ($interfaceIsEqual(err, $ifaceNil)) { + $panic(new $String("context: internal error: missing cancel error")); + } + $r = c.mu.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ if (!($interfaceIsEqual(c.err, $ifaceNil))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!($interfaceIsEqual(c.err, $ifaceNil))) { */ case 2: + $r = c.mu.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* } */ case 3: + c.err = err; + if (c.done === $chanNil) { + c.done = closedchan; + } else { + $close(c.done); + } + _ref = c.children; + _i = 0; + _keys = $keys(_ref); + /* while (true) { */ case 5: + /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 6; continue; } + _entry = _ref[_keys[_i]]; + if (_entry === undefined) { + _i++; + /* continue; */ $s = 5; continue; + } + child = _entry.k; + $r = child.cancel(false, err); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 5; continue; case 6: + c.children = false; + $r = c.mu.Unlock(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ if (removeFromParent) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (removeFromParent) { */ case 9: + $r = removeChild(c.Context, c); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 10: + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: cancelCtx.ptr.prototype.cancel }; } $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._ref = _ref; $f.c = c; $f.child = child; $f.err = err; $f.removeFromParent = removeFromParent; $f.$s = $s; $f.$r = $r; return $f; + }; + cancelCtx.prototype.cancel = function(removeFromParent, err) { return this.$val.cancel(removeFromParent, err); }; + WithDeadline = function(parent, d) { + var _r, _r$1, _tuple, c, cur, d, dur, ok, parent, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; c = $f.c; cur = $f.cur; d = $f.d; dur = $f.dur; ok = $f.ok; parent = $f.parent; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + c = [c]; + _r = parent.Deadline(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + cur = $clone(_tuple[0], time.Time); + ok = _tuple[1]; + /* */ if (ok && $clone(cur, time.Time).Before($clone(d, time.Time))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (ok && $clone(cur, time.Time).Before($clone(d, time.Time))) { */ case 2: + _r$1 = WithCancel(parent); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + $s = -1; return _r$1; + /* } */ case 3: + c[0] = new timerCtx.ptr($clone(newCancelCtx(parent), cancelCtx), ptrType$5.nil, $clone(d, time.Time)); + $r = propagateCancel(parent, c[0]); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + dur = time.Until($clone(d, time.Time)); + /* */ if ((dur.$high < 0 || (dur.$high === 0 && dur.$low <= 0))) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if ((dur.$high < 0 || (dur.$high === 0 && dur.$low <= 0))) { */ case 6: + $r = c[0].cancel(true, $pkg.DeadlineExceeded); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return [c[0], (function(c) { return function $b() { + var $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = c[0].cancel(true, $pkg.Canceled); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$s = $s; $f.$r = $r; return $f; + }; })(c)]; + /* } */ case 7: + $r = c[0].cancelCtx.mu.Lock(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(c[0].cancelCtx.mu, "Unlock"), []]); + if ($interfaceIsEqual(c[0].cancelCtx.err, $ifaceNil)) { + c[0].timer = time.AfterFunc(dur, (function(c) { return function $b() { + var $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = c[0].cancel(true, $pkg.DeadlineExceeded); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$s = $s; $f.$r = $r; return $f; + }; })(c)); + } + $s = -1; return [c[0], (function(c) { return function $b() { + var $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = c[0].cancel(true, $pkg.Canceled); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$s = $s; $f.$r = $r; return $f; + }; })(c)]; + /* */ } return; } } catch(err) { $err = err; $s = -1; return [$ifaceNil, $throwNilPointerError]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: WithDeadline }; } $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.c = c; $f.cur = cur; $f.d = d; $f.dur = dur; $f.ok = ok; $f.parent = parent; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + $pkg.WithDeadline = WithDeadline; + timerCtx.ptr.prototype.Deadline = function() { + var _tmp, _tmp$1, c, deadline, ok; + deadline = new time.Time.ptr(new $Uint64(0, 0), new $Int64(0, 0), ptrType$1.nil); + ok = false; + c = this; + _tmp = $clone(c.deadline, time.Time); + _tmp$1 = true; + time.Time.copy(deadline, _tmp); + ok = _tmp$1; + return [deadline, ok]; + }; + timerCtx.prototype.Deadline = function() { return this.$val.Deadline(); }; + timerCtx.ptr.prototype.String = function() { + var _r, c, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + _r = fmt.Sprintf("%v.WithDeadline(%s [%s])", new sliceType([c.cancelCtx.Context, (x$1 = c.deadline, new x$1.constructor.elem(x$1)), time.Until($clone(c.deadline, time.Time))])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: timerCtx.ptr.prototype.String }; } $f._r = _r; $f.c = c; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }; + timerCtx.prototype.String = function() { return this.$val.String(); }; + timerCtx.ptr.prototype.cancel = function(removeFromParent, err) { + var c, err, removeFromParent, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; c = $f.c; err = $f.err; removeFromParent = $f.removeFromParent; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + $r = c.cancelCtx.cancel(false, err); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ if (removeFromParent) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (removeFromParent) { */ case 2: + $r = removeChild(c.cancelCtx.Context, c); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + $r = c.cancelCtx.mu.Lock(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (!(c.timer === ptrType$5.nil)) { + c.timer.Stop(); + c.timer = ptrType$5.nil; + } + $r = c.cancelCtx.mu.Unlock(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = -1; return; + /* */ } return; } if ($f === undefined) { $f = { $blk: timerCtx.ptr.prototype.cancel }; } $f.c = c; $f.err = err; $f.removeFromParent = removeFromParent; $f.$s = $s; $f.$r = $r; return $f; + }; + timerCtx.prototype.cancel = function(removeFromParent, err) { return this.$val.cancel(removeFromParent, err); }; + WithTimeout = function(parent, timeout) { + var _r, parent, timeout, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; parent = $f.parent; timeout = $f.timeout; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = WithDeadline(parent, $clone($clone(time.Now(), time.Time).Add(timeout), time.Time)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: WithTimeout }; } $f._r = _r; $f.parent = parent; $f.timeout = timeout; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.WithTimeout = WithTimeout; + valueCtx.ptr.prototype.String = function() { + var _r, c, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + _r = fmt.Sprintf("%v.WithValue(%#v, %#v)", new sliceType([c.Context, c.key, c.val])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: valueCtx.ptr.prototype.String }; } $f._r = _r; $f.c = c; $f.$s = $s; $f.$r = $r; return $f; + }; + valueCtx.prototype.String = function() { return this.$val.String(); }; + valueCtx.ptr.prototype.Value = function(key) { + var _r, c, key, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; c = $f.c; key = $f.key; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + c = this; + if ($interfaceIsEqual(c.key, key)) { + $s = -1; return c.val; + } + _r = c.Context.Value(key); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + $s = -1; return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: valueCtx.ptr.prototype.Value }; } $f._r = _r; $f.c = c; $f.key = key; $f.$s = $s; $f.$r = $r; return $f; + }; + valueCtx.prototype.Value = function(key) { return this.$val.Value(key); }; + deadlineExceededError.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType.methods = [{prop: "Deadline", name: "Deadline", pkg: "", typ: $funcType([], [time.Time, $Bool], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Err", name: "Err", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$2.methods = [{prop: "Done", name: "Done", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Err", name: "Err", pkg: "", typ: $funcType([], [$error], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "cancel", name: "cancel", pkg: "context", typ: $funcType([$Bool, $error], [], false)}]; + ptrType$3.methods = [{prop: "Deadline", name: "Deadline", pkg: "", typ: $funcType([], [time.Time, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "cancel", name: "cancel", pkg: "context", typ: $funcType([$Bool, $error], [], false)}]; + ptrType$4.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface], false)}]; + Context.init([{prop: "Deadline", name: "Deadline", pkg: "", typ: $funcType([], [time.Time, $Bool], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "Err", name: "Err", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Value", name: "Value", pkg: "", typ: $funcType([$emptyInterface], [$emptyInterface], false)}]); + deadlineExceededError.init("", []); + canceler.init([{prop: "Done", name: "Done", pkg: "", typ: $funcType([], [chanType], false)}, {prop: "cancel", name: "cancel", pkg: "context", typ: $funcType([$Bool, $error], [], false)}]); + cancelCtx.init("context", [{prop: "Context", name: "Context", anonymous: true, exported: true, typ: Context, tag: ""}, {prop: "mu", name: "mu", anonymous: false, exported: false, typ: sync.Mutex, tag: ""}, {prop: "done", name: "done", anonymous: false, exported: false, typ: chanType$1, tag: ""}, {prop: "children", name: "children", anonymous: false, exported: false, typ: mapType, tag: ""}, {prop: "err", name: "err", anonymous: false, exported: false, typ: $error, tag: ""}]); + timerCtx.init("context", [{prop: "cancelCtx", name: "cancelCtx", anonymous: true, exported: false, typ: cancelCtx, tag: ""}, {prop: "timer", name: "timer", anonymous: false, exported: false, typ: ptrType$5, tag: ""}, {prop: "deadline", name: "deadline", anonymous: false, exported: false, typ: time.Time, tag: ""}]); + valueCtx.init("context", [{prop: "Context", name: "Context", anonymous: true, exported: true, typ: Context, tag: ""}, {prop: "key", name: "key", anonymous: false, exported: false, typ: $emptyInterface, tag: ""}, {prop: "val", name: "val", anonymous: false, exported: false, typ: $emptyInterface, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.Canceled = errors.New("context canceled"); + $pkg.DeadlineExceeded = (x = new deadlineExceededError.ptr(), new x.constructor.elem(x)); + background = $newDataPointer(0, ptrType); + todo = $newDataPointer(0, ptrType); + closedchan = new $Chan(structType, 0); + init(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); + (function() { +!function(e,t){for(var r in t)e[r]=t[r]}(this,function(e){function t(n){if(r[n])return r[n].exports;var o=r[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var r={};return t.m=e,t.c=r,t.d=function(e,r,n){t.o(e,r)||Object.defineProperty(e,r,{configurable:!1,enumerable:!0,get:n})},t.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(r,"a",r),r},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=29)}([function(e,t){var r;r=function(){return this}();try{r=r||Function("return this")()||(0,eval)("this")}catch(e){"object"==typeof window&&(r=window)}e.exports=r},function(e,t,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(13);t.Metadata=n.BrowserHeaders},function(e,t){"function"==typeof Object.create?e.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:e.exports=function(e,t){e.super_=t;var r=function(){};r.prototype=t.prototype,e.prototype=new r,e.prototype.constructor=e}},function(e,t,r){"use strict";(function(e){function n(){return i.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function o(e,t){if(n()=n())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+n().toString(16)+" bytes");return 0|e}function g(e){return+e!=e&&(e=0),i.alloc(+e)}function y(e,t){if(i.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return z(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return V(e).length;default:if(n)return z(e).length;t=(""+t).toLowerCase(),n=!0}}function v(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if(r>>>=0,t>>>=0,r<=t)return"";for(e||(e="utf8");;)switch(e){case"hex":return P(this,t,r);case"utf8":case"utf-8":return M(this,t,r);case"ascii":return O(this,t,r);case"latin1":case"binary":return k(this,t,r);case"base64":return C(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return L(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function b(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function m(e,t,r,n,o){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=o?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(o)return-1;r=e.length-1}else if(r<0){if(!o)return-1;r=0}if("string"==typeof t&&(t=i.from(t,n)),i.isBuffer(t))return 0===t.length?-1:w(e,t,r,n,o);if("number"==typeof t)return t&=255,i.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):w(e,[t],r,n,o);throw new TypeError("val must be string, number or Buffer")}function w(e,t,r,n,o){function i(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}var s=1,a=e.length,u=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;s=2,a/=2,u/=2,r/=2}var h;if(o){var f=-1;for(h=r;ha&&(r=a-u),h=r;h>=0;h--){for(var c=!0,l=0;lo&&(n=o):n=o;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");n>i/2&&(n=i/2);for(var s=0;s239?4:i>223?3:i>191?2:1;if(o+a<=r){var u,h,f,c;switch(a){case 1:i<128&&(s=i);break;case 2:u=e[o+1],128==(192&u)&&(c=(31&i)<<6|63&u)>127&&(s=c);break;case 3:u=e[o+1],h=e[o+2],128==(192&u)&&128==(192&h)&&(c=(15&i)<<12|(63&u)<<6|63&h)>2047&&(c<55296||c>57343)&&(s=c);break;case 4:u=e[o+1],h=e[o+2],f=e[o+3],128==(192&u)&&128==(192&h)&&128==(192&f)&&(c=(15&i)<<18|(63&u)<<12|(63&h)<<6|63&f)>65535&&c<1114112&&(s=c)}}null===s?(s=65533,a=1):s>65535&&(s-=65536,n.push(s>>>10&1023|55296),s=56320|1023&s),n.push(s),o+=a}return x(n)}function x(e){var t=e.length;if(t<=Q)return String.fromCharCode.apply(String,e);for(var r="",n=0;nn)&&(r=n);for(var o="",i=t;ir)throw new RangeError("Trying to access beyond buffer length")}function U(e,t,r,n,o,s){if(!i.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function H(e,t,r,n){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-r,2);o>>8*(n?o:1-o)}function j(e,t,r,n){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-r,4);o>>8*(n?o:3-o)&255}function N(e,t,r,n,o,i){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function B(e,t,r,n,o){return o||N(e,t,r,4,3.4028234663852886e38,-3.4028234663852886e38),Z.write(e,t,r,n,23,4),r+4}function q(e,t,r,n,o){return o||N(e,t,r,8,1.7976931348623157e308,-1.7976931348623157e308),Z.write(e,t,r,n,52,8),r+8}function D(e){if(e=F(e).replace(ee,""),e.length<2)return"";for(;e.length%4!=0;)e+="=";return e}function F(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function Y(e){return e<16?"0"+e.toString(16):e.toString(16)}function z(e,t){t=t||1/0;for(var r,n=e.length,o=null,i=[],s=0;s55295&&r<57344){if(!o){if(r>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(s+1===n){(t-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(t-=3)>-1&&i.push(239,191,189),o=r;continue}r=65536+(o-55296<<10|r-56320)}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((t-=1)<0)break;i.push(r)}else if(r<2048){if((t-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function X(e){for(var t=[],r=0;r>8,o=r%256,i.push(o),i.push(n);return i}function V(e){return $.toByteArray(D(e))}function G(e,t,r,n){for(var o=0;o=t.length||o>=e.length);++o)t[o+r]=e[o];return o}function K(e){return e!==e}/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var $=r(38),Z=r(39),J=r(15);t.Buffer=i,t.SlowBuffer=g,t.INSPECT_MAX_BYTES=50,i.TYPED_ARRAY_SUPPORT=void 0!==e.TYPED_ARRAY_SUPPORT?e.TYPED_ARRAY_SUPPORT:function(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()&&"function"==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(e){return!1}}(),t.kMaxLength=n(),i.poolSize=8192,i._augment=function(e){return e.__proto__=i.prototype,e},i.from=function(e,t,r){return s(null,e,t,r)},i.TYPED_ARRAY_SUPPORT&&(i.prototype.__proto__=Uint8Array.prototype,i.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&i[Symbol.species]===i&&Object.defineProperty(i,Symbol.species,{value:null,configurable:!0})),i.alloc=function(e,t,r){return u(null,e,t,r)},i.allocUnsafe=function(e){return h(null,e)},i.allocUnsafeSlow=function(e){return h(null,e)},i.isBuffer=function(e){return!(null==e||!e._isBuffer)},i.compare=function(e,t){if(!i.isBuffer(e)||!i.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,o=0,s=Math.min(r,n);o0&&(e=this.toString("hex",0,r).match(/.{2}/g).join(" "),this.length>r&&(e+=" ... ")),""},i.prototype.compare=function(e,t,r,n,o){if(!i.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===o&&(o=this.length),t<0||r>e.length||n<0||o>this.length)throw new RangeError("out of range index");if(n>=o&&t>=r)return 0;if(n>=o)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,o>>>=0,this===e)return 0;for(var s=o-n,a=r-t,u=Math.min(s,a),h=this.slice(n,o),f=e.slice(t,r),c=0;co)&&(r=o),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var i=!1;;)switch(n){case"hex":return _(this,e,t,r);case"utf8":case"utf-8":return E(this,e,t,r);case"ascii":return S(this,e,t,r);case"latin1":case"binary":return R(this,e,t,r);case"base64":return A(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return T(this,e,t,r);default:if(i)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),i=!0}},i.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var Q=4096;i.prototype.slice=function(e,t){var r=this.length;e=~~e,t=void 0===t?r:~~t,e<0?(e+=r)<0&&(e=0):e>r&&(e=r),t<0?(t+=r)<0&&(t=0):t>r&&(t=r),t0&&(o*=256);)n+=this[e+--t]*o;return n},i.prototype.readUInt8=function(e,t){return t||I(e,1,this.length),this[e]},i.prototype.readUInt16LE=function(e,t){return t||I(e,2,this.length),this[e]|this[e+1]<<8},i.prototype.readUInt16BE=function(e,t){return t||I(e,2,this.length),this[e]<<8|this[e+1]},i.prototype.readUInt32LE=function(e,t){return t||I(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},i.prototype.readUInt32BE=function(e,t){return t||I(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},i.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||I(e,t,this.length);for(var n=this[e],o=1,i=0;++i=o&&(n-=Math.pow(2,8*t)),n},i.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||I(e,t,this.length);for(var n=t,o=1,i=this[e+--n];n>0&&(o*=256);)i+=this[e+--n]*o;return o*=128,i>=o&&(i-=Math.pow(2,8*t)),i},i.prototype.readInt8=function(e,t){return t||I(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},i.prototype.readInt16LE=function(e,t){t||I(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},i.prototype.readInt16BE=function(e,t){t||I(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},i.prototype.readInt32LE=function(e,t){return t||I(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},i.prototype.readInt32BE=function(e,t){return t||I(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},i.prototype.readFloatLE=function(e,t){return t||I(e,4,this.length),Z.read(this,e,!0,23,4)},i.prototype.readFloatBE=function(e,t){return t||I(e,4,this.length),Z.read(this,e,!1,23,4)},i.prototype.readDoubleLE=function(e,t){return t||I(e,8,this.length),Z.read(this,e,!0,52,8)},i.prototype.readDoubleBE=function(e,t){return t||I(e,8,this.length),Z.read(this,e,!1,52,8)},i.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t|=0,r|=0,!n){U(this,e,t,r,Math.pow(2,8*r)-1,0)}var o=1,i=0;for(this[t]=255&e;++i=0&&(i*=256);)this[t+o]=e/i&255;return t+r},i.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,1,255,0),i.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},i.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,2,65535,0),i.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):H(this,e,t,!0),t+2},i.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,2,65535,0),i.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):H(this,e,t,!1),t+2},i.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,4,4294967295,0),i.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):j(this,e,t,!0),t+4},i.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,4,4294967295,0),i.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):j(this,e,t,!1),t+4},i.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);U(this,e,t,r,o-1,-o)}var i=0,s=1,a=0;for(this[t]=255&e;++i>0)-a&255;return t+r},i.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);U(this,e,t,r,o-1,-o)}var i=r-1,s=1,a=0;for(this[t+i]=255&e;--i>=0&&(s*=256);)e<0&&0===a&&0!==this[t+i+1]&&(a=1),this[t+i]=(e/s>>0)-a&255;return t+r},i.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,1,127,-128),i.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},i.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,2,32767,-32768),i.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):H(this,e,t,!0),t+2},i.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,2,32767,-32768),i.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):H(this,e,t,!1),t+2},i.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,4,2147483647,-2147483648),i.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):j(this,e,t,!0),t+4},i.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||U(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),i.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):j(this,e,t,!1),t+4},i.prototype.writeFloatLE=function(e,t,r){return B(this,e,t,!0,r)},i.prototype.writeFloatBE=function(e,t,r){return B(this,e,t,!1,r)},i.prototype.writeDoubleLE=function(e,t,r){return q(this,e,t,!0,r)},i.prototype.writeDoubleBE=function(e,t,r){return q(this,e,t,!1,r)},i.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t=0;--o)e[o+t]=this[o+r];else if(s<1e3||!i.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,r=void 0===r?this.length:r>>>0,e||(e=0);var s;if("number"==typeof e)for(s=t;s1)for(var r=1;rt;r--)i.unshift(e[r]);throw o}}}function o(e){if(null!==i)return void i.push(e);i=[e],setTimeout(function(){n()},0)}Object.defineProperty(t,"__esModule",{value:!0});var i=null;t.default=o},function(e,t,r){(function(e){function r(e){return Array.isArray?Array.isArray(e):"[object Array]"===y(e)}function n(e){return"boolean"==typeof e}function o(e){return null===e}function i(e){return null==e}function s(e){return"number"==typeof e}function a(e){return"string"==typeof e}function u(e){return"symbol"==typeof e}function h(e){return void 0===e}function f(e){return"[object RegExp]"===y(e)}function c(e){return"object"==typeof e&&null!==e}function l(e){return"[object Date]"===y(e)}function d(e){return"[object Error]"===y(e)||e instanceof Error}function p(e){return"function"==typeof e}function g(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e}function y(e){return Object.prototype.toString.call(e)}t.isArray=r,t.isBoolean=n,t.isNull=o,t.isNullOrUndefined=i,t.isNumber=s,t.isString=a,t.isSymbol=u,t.isUndefined=h,t.isRegExp=f,t.isObject=c,t.isDate=l,t.isError=d,t.isFunction=p,t.isPrimitive=g,t.isBuffer=e.isBuffer}).call(t,r(3).Buffer)},function(e,t,r){"use strict";(function(t){function r(e,r,n,o){if("function"!=typeof e)throw new TypeError('"callback" argument must be a function');var i,s,a=arguments.length;switch(a){case 0:case 1:return t.nextTick(e);case 2:return t.nextTick(function(){e.call(null,r)});case 3:return t.nextTick(function(){e.call(null,r,n)});case 4:return t.nextTick(function(){e.call(null,r,n,o)});default:for(i=new Array(a-1),s=0;s",'"',"`"," ","\r","\n","\t"],p=["{","}","|","\\","^","`"].concat(d),g=["'"].concat(p),y=["%","/","?",";","#"].concat(g),v=["/","?","#"],b=/^[+a-z0-9A-Z_-]{0,63}$/,m=/^([+a-z0-9A-Z_-]{0,63})(.*)$/,w={javascript:!0,"javascript:":!0},_={javascript:!0,"javascript:":!0},E={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},S=r(53);n.prototype.parse=function(e,t,r){if(!h.isString(e))throw new TypeError("Parameter 'url' must be a string, not "+typeof e);var n=e.indexOf("?"),o=-1!==n&&n127?I+="x":I+=L[U];if(!I.match(b)){var j=k.slice(0,T),N=k.slice(T+1),B=L.match(m);B&&(j.push(B[1]),N.unshift(B[2])),N.length&&(a="/"+N.join(".")+a),this.hostname=j.join(".");break}}}this.hostname.length>255?this.hostname="":this.hostname=this.hostname.toLowerCase(),O||(this.hostname=u.toASCII(this.hostname));var q=this.port?":"+this.port:"",D=this.hostname||"";this.host=D+q,this.href+=this.host,O&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),"/"!==a[0]&&(a="/"+a))}if(!w[p])for(var T=0,P=g.length;T0)&&r.host.split("@");A&&(r.auth=A.shift(),r.host=r.hostname=A.shift())}return r.search=e.search,r.query=e.query,h.isNull(r.pathname)&&h.isNull(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.href=r.format(),r}if(!S.length)return r.pathname=null,r.search?r.path="/"+r.search:r.path=null,r.href=r.format(),r;for(var T=S.slice(-1)[0],C=(r.host||e.host||S.length>1)&&("."===T||".."===T)||""===T,M=0,x=S.length;x>=0;x--)T=S[x],"."===T?S.splice(x,1):".."===T?(S.splice(x,1),M++):M&&(S.splice(x,1),M--);if(!m&&!w)for(;M--;M)S.unshift("..");!m||""===S[0]||S[0]&&"/"===S[0].charAt(0)||S.unshift(""),C&&"/"!==S.join("/").substr(-1)&&S.push("");var O=""===S[0]||S[0]&&"/"===S[0].charAt(0);if(R){r.hostname=r.host=O?"":S.length?S.shift():"";var A=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@");A&&(r.auth=A.shift(),r.host=r.hostname=A.shift())}return m=m||r.host&&S.length,m&&!O&&S.unshift(""),S.length?r.pathname=S.join("/"):(r.pathname=null,r.path=null),h.isNull(r.pathname)&&h.isNull(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.auth=e.auth||r.auth,r.slashes=r.slashes||e.slashes,r.href=r.format(),r},n.prototype.parseHost=function(){var e=this.host,t=c.exec(e);t&&(t=t[0],":"!==t&&(this.port=t.substr(1)),e=e.substr(0,e.length-t.length)),e&&(this.hostname=e)}},function(e,t,r){"use strict";function n(e,t){return new l(e,t)}function o(e){var t=e.get("grpc-status")||[];if(t.length>0)try{var r=t[0];return parseInt(r,10)}catch(e){return null}return null}Object.defineProperty(t,"__esModule",{value:!0});var i=r(1),s=r(27),a=r(28),u=r(6),h=r(7),f=r(14),c=r(59);t.client=n;var l=function(){function e(e,t){this.started=!1,this.sentFirstMessage=!1,this.completed=!1,this.closed=!1,this.finishedSending=!1,this.onHeadersCallbacks=[],this.onMessageCallbacks=[],this.onEndCallbacks=[],this.parser=new s.ChunkParser,this.methodDefinition=e,this.props=t,this.createTransport()}return e.prototype.createTransport=function(){var e=this.props.host+"/"+this.methodDefinition.service.serviceName+"/"+this.methodDefinition.methodName,t={methodDefinition:this.methodDefinition,debug:this.props.debug||!1,url:e,onHeaders:this.onTransportHeaders.bind(this),onChunk:this.onTransportChunk.bind(this),onEnd:this.onTransportEnd.bind(this)},r=this.props.transport;if(r){var n=r(t);if(n instanceof Error)throw n;this.transport=n}else{var o=f.DefaultTransportFactory(t);if(o instanceof Error)throw o;this.transport=o}},e.prototype.onTransportHeaders=function(e,t){if(this.props.debug&&u.debug("onHeaders",e,t),this.closed)return void(this.props.debug&&u.debug("grpc.onHeaders received after request was closed - ignoring"));if(0===t);else{this.responseHeaders=e,this.props.debug&&u.debug("onHeaders.responseHeaders",JSON.stringify(this.responseHeaders,null,2));var r=a.httpStatusToCode(t);this.props.debug&&u.debug("onHeaders.code",r);var n=e.get("grpc-message")||[];if(this.props.debug&&u.debug("onHeaders.gRPCMessage",n),r!==a.Code.OK)return void this.rawOnError(r,n[0]);this.rawOnHeaders(e)}},e.prototype.onTransportChunk=function(e){var t=this;if(this.closed)return void(this.props.debug&&u.debug("grpc.onChunk received after request was closed - ignoring"));var r=[];try{r=this.parser.parse(e)}catch(e){return this.props.debug&&u.debug("onChunk.parsing error",e,e.message),void this.rawOnError(a.Code.Internal,"parsing error: "+e.message)}r.forEach(function(e){if(e.chunkType===s.ChunkType.MESSAGE){var r=t.methodDefinition.responseType.deserializeBinary(e.data);t.rawOnMessage(r)}else e.chunkType===s.ChunkType.TRAILERS&&(t.responseHeaders?(t.responseTrailers=new i.Metadata(e.trailers),t.props.debug&&u.debug("onChunk.trailers",t.responseTrailers)):(t.responseHeaders=new i.Metadata(e.trailers),t.rawOnHeaders(t.responseHeaders)))})},e.prototype.onTransportEnd=function(){if(this.props.debug&&u.debug("grpc.onEnd"),this.closed)return void(this.props.debug&&u.debug("grpc.onEnd received after request was closed - ignoring"));if(void 0===this.responseTrailers){if(void 0===this.responseHeaders)return void this.rawOnError(a.Code.Unknown,"Response closed without headers");var e=o(this.responseHeaders),t=this.responseHeaders.get("grpc-message");return this.props.debug&&u.debug("grpc.headers only response ",e,t),null===e?void this.rawOnEnd(a.Code.Unknown,"Response closed without grpc-status (Headers only)",this.responseHeaders):void this.rawOnEnd(e,t[0],this.responseHeaders)}var r=o(this.responseTrailers);if(null===r)return void this.rawOnError(a.Code.Internal,"Response closed without grpc-status (Trailers provided)");var n=this.responseTrailers.get("grpc-message");this.rawOnEnd(r,n[0],this.responseTrailers)},e.prototype.rawOnEnd=function(e,t,r){this.props.debug&&u.debug("rawOnEnd",e,t,r),this.completed||(this.completed=!0,this.onEndCallbacks.forEach(function(n){h.default(function(){n(e,t,r)})}))},e.prototype.rawOnHeaders=function(e){this.props.debug&&u.debug("rawOnHeaders",e),this.completed||this.onHeadersCallbacks.forEach(function(t){h.default(function(){t(e)})})},e.prototype.rawOnError=function(e,t){this.props.debug&&u.debug("rawOnError",e,t),this.completed||(this.completed=!0,this.onEndCallbacks.forEach(function(r){h.default(function(){r(e,t,new i.Metadata)})}))},e.prototype.rawOnMessage=function(e){this.props.debug&&u.debug("rawOnMessage",e.toObject()),this.completed||this.onMessageCallbacks.forEach(function(t){h.default(function(){t(e)})})},e.prototype.onHeaders=function(e){this.onHeadersCallbacks.push(e)},e.prototype.onMessage=function(e){this.onMessageCallbacks.push(e)},e.prototype.onEnd=function(e){this.onEndCallbacks.push(e)},e.prototype.start=function(e){if(this.started)throw new Error("Client already started - cannot .start()");this.started=!0;var t=new i.Metadata(e||{});t.set("content-type","application/grpc-web+proto"),t.set("x-grpc-web","1"),this.transport.start(t)},e.prototype.send=function(e){if(!this.started)throw new Error("Client not started - .start() must be called before .send()");if(this.closed)throw new Error("Client already closed - cannot .send()");if(this.finishedSending)throw new Error("Client already finished sending - cannot .send()");if(!this.methodDefinition.requestStream&&this.sentFirstMessage)throw new Error("Message already sent for non-client-streaming method - cannot .send()");this.sentFirstMessage=!0;var t=c.frameRequest(e);this.transport.sendMessage(t)},e.prototype.finishSend=function(){if(!this.started)throw new Error("Client not started - .finishSend() must be called before .close()");if(this.closed)throw new Error("Client already closed - cannot .send()");if(this.finishedSending)throw new Error("Client already finished sending - cannot .finishSend()");this.finishedSending=!0,this.transport.finishSend()},e.prototype.close=function(){if(!this.started)throw new Error("Client not started - .start() must be called before .close()");if(this.closed)throw new Error("Client already closed - cannot .close()");this.closed=!0,this.props.debug&&u.debug("request.abort aborting request"),this.transport.cancel()},e}()},function(e,t,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(30);t.BrowserHeaders=n.BrowserHeaders},function(e,t,r){"use strict";function n(e){return e.methodDefinition.requestStream?new Error("No transport available for client-streaming (requestStream) method"):(s||(s=o()),s(e))}function o(){if(a.detectFetchSupport())return a.default;if(h.detectMozXHRSupport())return h.default;if(u.detectXHRSupport())return u.default;if(f.detectNodeHTTPSupport())return f.default;throw new Error("No suitable transport found for gRPC-Web")}function i(e){return c.default(e)}Object.defineProperty(t,"__esModule",{value:!0});var s,a=r(33),u=r(34),h=r(35),f=r(37),c=r(57);t.DefaultTransportFactory=n,t.WebsocketTransportFactory=i},function(e,t){var r={}.toString;e.exports=Array.isArray||function(e){return"[object Array]"==r.call(e)}},function(e,t,r){(function(e){var n=r(40),o=r(18),i=r(48),s=r(49),a=r(11),u=t;u.request=function(t,r){t="string"==typeof t?a.parse(t):i(t);var o=-1===e.location.protocol.search(/^https?:$/)?"http:":"",s=t.protocol||o,u=t.hostname||t.host,h=t.port,f=t.path||"/";u&&-1!==u.indexOf(":")&&(u="["+u+"]"),t.url=(u?s+"//"+u:"")+(h?":"+h:"")+f,t.method=(t.method||"GET").toUpperCase(),t.headers=t.headers||{};var c=new n(t);return r&&c.on("response",r),c},u.get=function(e,t){var r=u.request(e,t);return r.end(),r},u.ClientRequest=n,u.IncomingMessage=o,u.Agent=function(){},u.Agent.defaultMaxSockets=4,u.STATUS_CODES=s,u.METHODS=["CHECKOUT","CONNECT","COPY","DELETE","GET","HEAD","LOCK","M-SEARCH","MERGE","MKACTIVITY","MKCOL","MOVE","NOTIFY","OPTIONS","PATCH","POST","PROPFIND","PROPPATCH","PURGE","PUT","REPORT","SEARCH","SUBSCRIBE","TRACE","UNLOCK","UNSUBSCRIBE"]}).call(t,r(0))},function(e,t,r){(function(e){function r(){if(void 0!==i)return i;if(e.XMLHttpRequest){i=new e.XMLHttpRequest;try{i.open("GET",e.XDomainRequest?"/":"https://example.com")}catch(e){i=null}}else i=null;return i}function n(e){var t=r();if(!t)return!1;try{return t.responseType=e,t.responseType===e}catch(e){}return!1}function o(e){return"function"==typeof e}t.fetch=o(e.fetch)&&o(e.ReadableStream),t.writableStream=o(e.WritableStream),t.abortController=o(e.AbortController),t.blobConstructor=!1;try{new Blob([new ArrayBuffer(1)]),t.blobConstructor=!0}catch(e){}var i,s=void 0!==e.ArrayBuffer,a=s&&o(e.ArrayBuffer.prototype.slice);t.arraybuffer=t.fetch||s&&n("arraybuffer"),t.msstream=!t.fetch&&a&&n("ms-stream"),t.mozchunkedarraybuffer=!t.fetch&&s&&n("moz-chunked-arraybuffer"),t.overrideMimeType=t.fetch||!!r()&&o(r().overrideMimeType),t.vbArray=o(e.VBArray),i=null}).call(t,r(0))},function(e,t,r){(function(e,n,o){var i=r(17),s=r(2),a=r(19),u=t.readyStates={UNSENT:0,OPENED:1,HEADERS_RECEIVED:2,LOADING:3,DONE:4},h=t.IncomingMessage=function(t,r,o){function s(){f.read().then(function(e){if(!u._destroyed){if(e.done)return void u.push(null);u.push(new n(e.value)),s()}}).catch(function(e){u._destroyed||u.emit("error",e)})}var u=this;if(a.Readable.call(u),u._mode=o,u.headers={},u.rawHeaders=[],u.trailers={},u.rawTrailers=[],u.on("end",function(){e.nextTick(function(){u.emit("close")})}),"fetch"===o){if(u._fetchResponse=r,u.url=r.url,u.statusCode=r.status,u.statusMessage=r.statusText,r.headers.forEach(function(e,t){u.headers[t.toLowerCase()]=e,u.rawHeaders.push(t,e)}),i.writableStream){var h=new WritableStream({write:function(e){return new Promise(function(t,r){u._destroyed||(u.push(new n(e))?t():u._resumeFetch=t)})},close:function(){u._destroyed||u.push(null)},abort:function(e){u._destroyed||u.emit("error",e)}});try{return void r.body.pipeTo(h)}catch(e){}}var f=r.body.getReader();s()}else{u._xhr=t,u._pos=0,u.url=t.responseURL,u.statusCode=t.status,u.statusMessage=t.statusText;if(t.getAllResponseHeaders().split(/\r?\n/).forEach(function(e){var t=e.match(/^([^:]+):\s*(.*)/);if(t){var r=t[1].toLowerCase();"set-cookie"===r?(void 0===u.headers[r]&&(u.headers[r]=[]),u.headers[r].push(t[2])):void 0!==u.headers[r]?u.headers[r]+=", "+t[2]:u.headers[r]=t[2],u.rawHeaders.push(t[1],t[2])}}),u._charset="x-user-defined",!i.overrideMimeType){var c=u.rawHeaders["mime-type"];if(c){var l=c.match(/;\s*charset=([^;])(;|$)/);l&&(u._charset=l[1].toLowerCase())}u._charset||(u._charset="utf-8")}}};s(h,a.Readable),h.prototype._read=function(){var e=this,t=e._resumeFetch;t&&(e._resumeFetch=null,t())},h.prototype._onXHRProgress=function(){var e=this,t=e._xhr,r=null;switch(e._mode){case"text:vbarray":if(t.readyState!==u.DONE)break;try{r=new o.VBArray(t.responseBody).toArray()}catch(e){}if(null!==r){e.push(new n(r));break}case"text":try{r=t.responseText}catch(t){e._mode="text:vbarray";break}if(r.length>e._pos){var i=r.substr(e._pos);if("x-user-defined"===e._charset){for(var s=new n(i.length),a=0;ae._pos&&(e.push(new n(new Uint8Array(h.result.slice(e._pos)))),e._pos=h.result.byteLength)},h.onload=function(){e.push(null)},h.readAsArrayBuffer(r)}e._xhr.readyState===u.DONE&&"ms-stream"!==e._mode&&e.push(null)}}).call(t,r(4),r(3).Buffer,r(0))},function(e,t,r){t=e.exports=r(20),t.Stream=t,t.Readable=t,t.Writable=r(24),t.Duplex=r(5),t.Transform=r(26),t.PassThrough=r(46)},function(e,t,r){"use strict";(function(t,n){function o(e){return j.from(e)}function i(e){return j.isBuffer(e)||e instanceof N}function s(e,t,r){if("function"==typeof e.prependListener)return e.prependListener(t,r);e._events&&e._events[t]?I(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r)}function a(e,t){L=L||r(5),e=e||{},this.objectMode=!!e.objectMode,t instanceof L&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var n=e.highWaterMark,o=this.objectMode?16:16384;this.highWaterMark=n||0===n?n:o,this.highWaterMark=Math.floor(this.highWaterMark),this.buffer=new Y,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.destroyed=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(F||(F=r(25).StringDecoder),this.decoder=new F(e.encoding),this.encoding=e.encoding)}function u(e){if(L=L||r(5),!(this instanceof u))return new u(e);this._readableState=new a(e,this),this.readable=!0,e&&("function"==typeof e.read&&(this._read=e.read),"function"==typeof e.destroy&&(this._destroy=e.destroy)),H.call(this)}function h(e,t,r,n,i){var s=e._readableState;if(null===t)s.reading=!1,g(e,s);else{var a;i||(a=c(s,t)),a?e.emit("error",a):s.objectMode||t&&t.length>0?("string"==typeof t||s.objectMode||Object.getPrototypeOf(t)===j.prototype||(t=o(t)),n?s.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):f(e,s,t,!0):s.ended?e.emit("error",new Error("stream.push() after EOF")):(s.reading=!1,s.decoder&&!r?(t=s.decoder.write(t),s.objectMode||0!==t.length?f(e,s,t,!1):b(e,s)):f(e,s,t,!1))):n||(s.reading=!1)}return l(s)}function f(e,t,r,n){t.flowing&&0===t.length&&!t.sync?(e.emit("data",r),e.read(0)):(t.length+=t.objectMode?1:r.length,n?t.buffer.unshift(r):t.buffer.push(r),t.needReadable&&y(e)),b(e,t)}function c(e,t){var r;return i(t)||"string"==typeof t||void 0===t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk")),r}function l(e){return!e.ended&&(e.needReadable||e.length=W?e=W:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}function p(e,t){return e<=0||0===t.length&&t.ended?0:t.objectMode?1:e!==e?t.flowing&&t.length?t.buffer.head.data.length:t.length:(e>t.highWaterMark&&(t.highWaterMark=d(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function g(e,t){if(!t.ended){if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,y(e)}}function y(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(D("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?P(v,e):v(e))}function v(e){D("emit readable"),e.emit("readable"),R(e)}function b(e,t){t.readingMore||(t.readingMore=!0,P(m,e,t))}function m(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=T(e,t.buffer,t.decoder),r}function T(e,t,r){var n;return ei.length?i.length:e;if(s===i.length?o+=i:o+=i.slice(0,e),0===(e-=s)){s===i.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=i.slice(s));break}++n}return t.length-=n,o}function M(e,t){var r=j.allocUnsafe(e),n=t.head,o=1;for(n.data.copy(r),e-=n.data.length;n=n.next;){var i=n.data,s=e>i.length?i.length:e;if(i.copy(r,r.length-e,0,s),0===(e-=s)){s===i.length?(++o,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n,n.data=i.slice(s));break}++o}return t.length-=o,r}function x(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,P(O,t,e))}function O(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function k(e,t){for(var r=0,n=e.length;r=t.highWaterMark||t.ended))return D("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?x(this):y(this),null;if(0===(e=p(e,t))&&t.ended)return 0===t.length&&x(this),null;var n=t.needReadable;D("need readable",n),(0===t.length||t.length-e0?A(e,t):null,null===o?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&x(this)),null!==o&&this.emit("data",o),o},u.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},u.prototype.pipe=function(e,t){function r(e,t){D("onunpipe"),e===l&&t&&!1===t.hasUnpiped&&(t.hasUnpiped=!0,i())}function o(){D("onend"),e.end()}function i(){D("cleanup"),e.removeListener("close",h),e.removeListener("finish",f),e.removeListener("drain",y),e.removeListener("error",u),e.removeListener("unpipe",r),l.removeListener("end",o),l.removeListener("end",c),l.removeListener("data",a),v=!0,!d.awaitDrain||e._writableState&&!e._writableState.needDrain||y()}function a(t){D("ondata"),b=!1,!1!==e.write(t)||b||((1===d.pipesCount&&d.pipes===e||d.pipesCount>1&&-1!==k(d.pipes,e))&&!v&&(D("false write response, pause",l._readableState.awaitDrain),l._readableState.awaitDrain++,b=!0),l.pause())}function u(t){D("onerror",t),c(),e.removeListener("error",u),0===U(e,"error")&&e.emit("error",t)}function h(){e.removeListener("finish",f),c()}function f(){D("onfinish"),e.removeListener("close",h),c()}function c(){D("unpipe"),l.unpipe(e)}var l=this,d=this._readableState;switch(d.pipesCount){case 0:d.pipes=e;break;case 1:d.pipes=[d.pipes,e];break;default:d.pipes.push(e)}d.pipesCount+=1,D("pipe count=%d opts=%j",d.pipesCount,t);var p=(!t||!1!==t.end)&&e!==n.stdout&&e!==n.stderr,g=p?o:c;d.endEmitted?P(g):l.once("end",g),e.on("unpipe",r);var y=w(l);e.on("drain",y);var v=!1,b=!1;return l.on("data",a),s(e,"error",u),e.once("close",h),e.once("finish",f),e.emit("pipe",l),d.flowing||(D("pipe resume"),l.resume()),e},u.prototype.unpipe=function(e){var t=this._readableState,r={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,r),this);if(!e){var n=t.pipes,o=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i0&&this._events[e].length>o&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},r.prototype.on=r.prototype.addListener,r.prototype.once=function(e,t){function r(){this.removeListener(e,r),o||(o=!0,t.apply(this,arguments))}if(!n(t))throw TypeError("listener must be a function");var o=!1;return r.listener=t,this.on(e,r),this},r.prototype.removeListener=function(e,t){var r,o,s,a;if(!n(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(r=this._events[e],s=r.length,o=-1,r===t||n(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(i(r)){for(a=s;a-- >0;)if(r[a]===t||r[a].listener&&r[a].listener===t){o=a;break}if(o<0)return this;1===r.length?(r.length=0,delete this._events[e]):r.splice(o,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},r.prototype.removeAllListeners=function(e){var t,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(r=this._events[e],n(r))this.removeListener(e,r);else if(r)for(;r.length;)this.removeListener(e,r[r.length-1]);return delete this._events[e],this},r.prototype.listeners=function(e){return this._events&&this._events[e]?n(this._events[e])?[this._events[e]]:this._events[e].slice():[]},r.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(n(t))return 1;if(t)return t.length}return 0},r.listenerCount=function(e,t){return e.listenerCount(t)}},function(e,t,r){e.exports=r(21).EventEmitter},function(e,t,r){"use strict";function n(e,t){var r=this,n=this._readableState&&this._readableState.destroyed,o=this._writableState&&this._writableState.destroyed;if(n||o)return void(t?t(e):!e||this._writableState&&this._writableState.errorEmitted||s(i,this,e));this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(e||null,function(e){!t&&e?(s(i,r,e),r._writableState&&(r._writableState.errorEmitted=!0)):t&&t(e)})}function o(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}function i(e,t){e.emit("error",t)}var s=r(9);e.exports={destroy:n,undestroy:o}},function(e,t,r){"use strict";(function(t,n,o){function i(e){var t=this;this.next=null,this.entry=null,this.finish=function(){C(t,e)}}function s(e){return I.from(e)}function a(e){return I.isBuffer(e)||e instanceof U}function u(){}function h(e,t){x=x||r(5),e=e||{},this.objectMode=!!e.objectMode,t instanceof x&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var n=e.highWaterMark,o=this.objectMode?16:16384;this.highWaterMark=n||0===n?n:o,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var s=!1===e.decodeStrings;this.decodeStrings=!s,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){b(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new i(this)}function f(e){if(x=x||r(5),!(j.call(f,this)||this instanceof x))return new f(e);this._writableState=new h(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),L.call(this)}function c(e,t){var r=new Error("write after end");e.emit("error",r),M(t,r)}function l(e,t,r,n){var o=!0,i=!1;return null===r?i=new TypeError("May not write null values to stream"):"string"==typeof r||void 0===r||t.objectMode||(i=new TypeError("Invalid non-string/buffer chunk")),i&&(e.emit("error",i),M(n,i),o=!1),o}function d(e,t,r){return e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=I.from(t,r)),t}function p(e,t,r,n,o,i){if(!r){var s=d(t,n,o);n!==s&&(r=!0,o="buffer",n=s)}var a=t.objectMode?1:n.length;t.length+=a;var u=t.length-1?n:M;f.WritableState=h;var k=r(8);k.inherits=r(2);var P={deprecate:r(45)},L=r(22),I=r(10).Buffer,U=o.Uint8Array||function(){},H=r(23);k.inherits(f,L),h.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(h.prototype,"buffer",{get:P.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}();var j;"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(j=Function.prototype[Symbol.hasInstance],Object.defineProperty(f,Symbol.hasInstance,{value:function(e){return!!j.call(this,e)||e&&e._writableState instanceof h}})):j=function(e){return e instanceof this},f.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},f.prototype.write=function(e,t,r){var n=this._writableState,o=!1,i=a(e)&&!n.objectMode;return i&&!I.isBuffer(e)&&(e=s(e)),"function"==typeof t&&(r=t,t=null),i?t="buffer":t||(t=n.defaultEncoding),"function"!=typeof r&&(r=u),n.ended?c(this,r):(i||l(this,n,e,r))&&(n.pendingcb++,o=p(this,n,i,e,t,r)),o},f.prototype.cork=function(){this._writableState.corked++},f.prototype.uncork=function(){var e=this._writableState;e.corked&&(e.corked--,e.writing||e.corked||e.finished||e.bufferProcessing||!e.bufferedRequest||_(this,e))},f.prototype.setDefaultEncoding=function(e){if("string"==typeof e&&(e=e.toLowerCase()),!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((e+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},f.prototype._write=function(e,t,r){r(new Error("_write() is not implemented"))},f.prototype._writev=null,f.prototype.end=function(e,t,r){var n=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!==e&&void 0!==e&&this.write(e,t),n.corked&&(n.corked=1,this.uncork()),n.ending||n.finished||T(this,n,r)},Object.defineProperty(f.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),f.prototype.destroy=H.destroy,f.prototype._undestroy=H.undestroy,f.prototype._destroy=function(e,t){this.end(),t(e)}}).call(t,r(4),r(43).setImmediate,r(0))},function(e,t,r){"use strict";function n(e){if(!e)return"utf8";for(var t;;)switch(e){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return e;default:if(t)return;e=(""+e).toLowerCase(),t=!0}}function o(e){var t=n(e);if("string"!=typeof t&&(b.isEncoding===m||!m(e)))throw new Error("Unknown encoding: "+e);return t||e}function i(e){this.encoding=o(e);var t;switch(this.encoding){case"utf16le":this.text=l,this.end=d,t=4;break;case"utf8":this.fillLast=h,t=4;break;case"base64":this.text=p,this.end=g,t=3;break;default:return this.write=y,void(this.end=v)}this.lastNeed=0,this.lastTotal=0,this.lastChar=b.allocUnsafe(t)}function s(e){return e<=127?0:e>>5==6?2:e>>4==14?3:e>>3==30?4:-1}function a(e,t,r){var n=t.length-1;if(n=0?(o>0&&(e.lastNeed=o-1),o):--n=0?(o>0&&(e.lastNeed=o-2),o):--n=0?(o>0&&(2===o?o=0:e.lastNeed=o-3),o):0)}function u(e,t,r){if(128!=(192&t[0]))return e.lastNeed=0,"�".repeat(r);if(e.lastNeed>1&&t.length>1){if(128!=(192&t[1]))return e.lastNeed=1,"�".repeat(r+1);if(e.lastNeed>2&&t.length>2&&128!=(192&t[2]))return e.lastNeed=2,"�".repeat(r+2)}}function h(e){var t=this.lastTotal-this.lastNeed,r=u(this,e,t);return void 0!==r?r:this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(e.copy(this.lastChar,t,0,e.length),void(this.lastNeed-=e.length))}function f(e,t){var r=a(this,e,t);if(!this.lastNeed)return e.toString("utf8",t);this.lastTotal=r;var n=e.length-(r-this.lastNeed);return e.copy(this.lastChar,0,n),e.toString("utf8",t,n)}function c(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+"�".repeat(this.lastTotal-this.lastNeed):t}function l(e,t){if((e.length-t)%2==0){var r=e.toString("utf16le",t);if(r){var n=r.charCodeAt(r.length-1);if(n>=55296&&n<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],r.slice(0,-1)}return r}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString("utf16le",t,e.length-1)}function d(e){var t=e&&e.length?this.write(e):"";if(this.lastNeed){var r=this.lastTotal-this.lastNeed;return t+this.lastChar.toString("utf16le",0,r)}return t}function p(e,t){var r=(e.length-t)%3;return 0===r?e.toString("base64",t):(this.lastNeed=3-r,this.lastTotal=3,1===r?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString("base64",t,e.length-r))}function g(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+this.lastChar.toString("base64",0,3-this.lastNeed):t}function y(e){return e.toString(this.encoding)}function v(e){return e&&e.length?this.write(e):""}var b=r(10).Buffer,m=b.isEncoding||function(e){switch((e=""+e)&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};t.StringDecoder=i,i.prototype.write=function(e){if(0===e.length)return"";var t,r;if(this.lastNeed){if(void 0===(t=this.fillLast(e)))return"";r=this.lastNeed,this.lastNeed=0}else r=0;return r=32&&e<=126}function o(e){for(var t=0;t!==e.length;++t)if(!n(e[t]))throw new Error("Metadata is not valid (printable) ASCII");return String.fromCharCode.apply(String,Array.prototype.slice.call(e))}function i(e){for(var t=new Uint8Array(e.length),r=0;r!==e.length;++r){var o=e.charCodeAt(r);if(!n(o))throw new Error("Metadata contains invalid ASCII");t[r]=o}return t}function s(e){return 128==(128&e.getUint8(0))}function a(e){return new c.Metadata(o(e))}function u(e){return e.getUint32(1,!1)}function h(e,t,r){return e.byteLength-t>=r}function f(e,t,r){if(e.slice)return e.slice(t,r);var n=e.length;void 0!==r&&(n=r);for(var o=n-t,i=new Uint8Array(o),s=0,a=t;a0){var i=n.substring(0,o).trim(),s=n.substring(o+1).trim();this.append(i,s)}}},e.prototype.delete=function(e,t){var r=o.normalizeName(e);if(void 0===t)delete this.headersMap[r];else{var n=this.headersMap[r];if(n){var i=n.indexOf(t);i>=0&&n.splice(i,1),0===n.length&&delete this.headersMap[r]}}},e.prototype.append=function(e,t){var r=this,n=o.normalizeName(e);Array.isArray(this.headersMap[n])||(this.headersMap[n]=[]),Array.isArray(t)?t.forEach(function(e){r.headersMap[n].push(o.normalizeValue(e))}):this.headersMap[n].push(o.normalizeValue(t))},e.prototype.set=function(e,t){var r=o.normalizeName(e);if(Array.isArray(t)){var n=[];t.forEach(function(e){n.push(o.normalizeValue(e))}),this.headersMap[r]=n}else this.headersMap[r]=[o.normalizeValue(t)]},e.prototype.has=function(e,t){var r=this.headersMap[o.normalizeName(e)];if(!Array.isArray(r))return!1;if(void 0!==t){var n=o.normalizeValue(t);return r.indexOf(n)>=0}return!0},e.prototype.get=function(e){var t=this.headersMap[o.normalizeName(e)];return void 0!==t?t.concat():[]},e.prototype.forEach=function(e){var t=this;Object.getOwnPropertyNames(this.headersMap).forEach(function(r){e(r,t.headersMap[r])},this)},e.prototype.toHeaders=function(){if("undefined"!=typeof Headers){var e=new Headers;return this.forEach(function(t,r){r.forEach(function(r){e.append(t,r)})}),e}throw new Error("Headers class is not defined")},e}();t.BrowserHeaders=i},function(e,t,r){"use strict";function n(e){if("string"!=typeof e&&(e=String(e)),/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(e))throw new TypeError("Invalid character in header field name");return e.toLowerCase()}function o(e){return"string"!=typeof e&&(e=String(e)),e}function i(e,t){var r=s(e);if(r instanceof Headers&&r.getAll)return r.getAll(t);var n=r.get(t);return n&&"string"==typeof n?[n]:n}function s(e){return e}function a(e){var t=s(e),r={},n=[];return t.keys?h.iterateHeadersKeys(t,function(e){r[e]||(r[e]=!0,n.push(e))}):t.forEach?t.forEach(function(e,t){r[t]||(r[t]=!0,n.push(t))}):h.iterateHeaders(t,function(e){var t=e[0];r[t]||(r[t]=!0,n.push(t))}),n}function u(e){var t=[];return e.split(", ").forEach(function(e){e.split(",").forEach(function(e){t.push(e)})}),t}Object.defineProperty(t,"__esModule",{value:!0});var h=r(32);t.normalizeName=n,t.normalizeValue=o,t.getHeaderValues=i,t.getHeaderKeys=a,t.splitHeaderValue=u},function(e,t){function r(e,t){for(var r=e[Symbol.iterator](),n=r.next();!n.done;)t(n.value[0]),n=r.next()}function n(e,t){for(var r=e.keys(),n=r.next();!n.done;)t(n.value),n=r.next()}e.exports={iterateHeaders:r,iterateHeadersKeys:n}},function(e,t,r){"use strict";function n(e){return e.debug&&s.debug("fetchRequest",e),new u(e)}function o(){return"undefined"!=typeof Response&&Response.prototype.hasOwnProperty("body")&&"function"==typeof Headers}Object.defineProperty(t,"__esModule",{value:!0});var i=r(1),s=r(6),a=r(7);t.default=n;var u=function(){function e(e){this.cancelled=!1,this.options=e}return e.prototype.pump=function(e,t){var r=this;return this.reader=e,this.cancelled?(this.options.debug&&s.debug("Fetch.pump.cancel at first pump"),this.reader.cancel()):this.reader.read().then(function(e){return e.done?(a.default(function(){r.options.onEnd()}),t):(a.default(function(){r.options.onChunk(e.value)}),r.pump(r.reader,t))})},e.prototype.send=function(e){var t=this;fetch(this.options.url,{headers:this.metadata.toHeaders(),method:"POST",body:e,credentials:"same-origin"}).then(function(e){return t.options.debug&&s.debug("Fetch.response",e),a.default(function(){t.options.onHeaders(new i.Metadata(e.headers),e.status)}),e.body?t.pump(e.body.getReader(),e):e}).catch(function(e){if(t.cancelled)return void(t.options.debug&&s.debug("Fetch.catch - request cancelled"));t.options.debug&&s.debug("Fetch.catch",e.message),a.default(function(){t.options.onEnd(e)})})},e.prototype.sendMessage=function(e){this.send(e)},e.prototype.finishSend=function(){},e.prototype.start=function(e){this.metadata=e},e.prototype.cancel=function(){this.cancelled=!0,this.reader?(this.options.debug&&s.debug("Fetch.abort.cancel"),this.reader.cancel()):this.options.debug&&s.debug("Fetch.abort.cancel before reader")},e}();t.detectFetchSupport=o},function(e,t,r){"use strict";function n(e){return e.debug&&u.debug("xhrRequest",e),new f(e)}function o(e,t){var r=e.charCodeAt(t);if(r>=55296&&r<=56319){var n=e.charCodeAt(t+1);n>=56320&&n<=57343&&(r=65536+(r-55296<<10)+(n-56320))}return r}function i(e){for(var t=new Uint8Array(e.length),r=0,n=0;n0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[t-2]?2:"="===e[t-1]?1:0}function o(e){return 3*e.length/4-n(e)}function i(e){var t,r,o,i,s,a=e.length;i=n(e),s=new c(3*a/4-i),r=i>0?a-4:a;var u=0;for(t=0;t>16&255,s[u++]=o>>8&255,s[u++]=255&o;return 2===i?(o=f[e.charCodeAt(t)]<<2|f[e.charCodeAt(t+1)]>>4,s[u++]=255&o):1===i&&(o=f[e.charCodeAt(t)]<<10|f[e.charCodeAt(t+1)]<<4|f[e.charCodeAt(t+2)]>>2,s[u++]=o>>8&255,s[u++]=255&o),s}function s(e){return h[e>>18&63]+h[e>>12&63]+h[e>>6&63]+h[63&e]}function a(e,t,r){for(var n,o=[],i=t;iu?u:s+16383));return 1===n?(t=e[r-1],o+=h[t>>2],o+=h[t<<4&63],o+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],o+=h[t>>10],o+=h[t>>4&63],o+=h[t<<2&63],o+="="),i.push(o),i.join("")}t.byteLength=o,t.toByteArray=i,t.fromByteArray=u;for(var h=[],f=[],c="undefined"!=typeof Uint8Array?Uint8Array:Array,l="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",d=0,p=l.length;d>1,f=-7,c=r?o-1:0,l=r?-1:1,d=e[t+c];for(c+=l,i=d&(1<<-f)-1,d>>=-f,f+=a;f>0;i=256*i+e[t+c],c+=l,f-=8);for(s=i&(1<<-f)-1,i>>=-f,f+=n;f>0;s=256*s+e[t+c],c+=l,f-=8);if(0===i)i=1-h;else{if(i===u)return s?NaN:1/0*(d?-1:1);s+=Math.pow(2,n),i-=h}return(d?-1:1)*s*Math.pow(2,i-n)},t.write=function(e,t,r,n,o,i){var s,a,u,h=8*i-o-1,f=(1<>1,l=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,d=n?0:i-1,p=n?1:-1,g=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=f):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),t+=s+c>=1?l/u:l*Math.pow(2,1-c),t*u>=2&&(s++,u/=2),s+c>=f?(a=0,s=f):s+c>=1?(a=(t*u-1)*Math.pow(2,o),s+=c):(a=t*Math.pow(2,c-1)*Math.pow(2,o),s=0));o>=8;e[r+d]=255&a,d+=p,a/=256,o-=8);for(s=s<0;e[r+d]=255&s,d+=p,s/=256,h-=8);e[r+d-p]|=128*g}},function(e,t,r){(function(t,n,o){function i(e,t){return a.fetch&&t?"fetch":a.mozchunkedarraybuffer?"moz-chunked-arraybuffer":a.msstream?"ms-stream":a.arraybuffer&&e?"arraybuffer":a.vbArray&&e?"text:vbarray":"text"}function s(e){try{var t=e.status;return null!==t&&0!==t}catch(e){return!1}}var a=r(17),u=r(2),h=r(18),f=r(19),c=r(47),l=h.IncomingMessage,d=h.readyStates,p=e.exports=function(e){var r=this;f.Writable.call(r),r._opts=e,r._body=[],r._headers={},e.auth&&r.setHeader("Authorization","Basic "+new t(e.auth).toString("base64")),Object.keys(e.headers).forEach(function(t){r.setHeader(t,e.headers[t])});var n,o=!0;if("disable-fetch"===e.mode||"requestTimeout"in e&&!a.abortController)o=!1,n=!0;else if("prefer-streaming"===e.mode)n=!1;else if("allow-wrong-content-type"===e.mode)n=!a.overrideMimeType;else{if(e.mode&&"default"!==e.mode&&"prefer-fast"!==e.mode)throw new Error("Invalid value for opts.mode");n=!0}r._mode=i(n,o),r.on("finish",function(){r._onFinish()})};u(p,f.Writable),p.prototype.setHeader=function(e,t){var r=this,n=e.toLowerCase();-1===g.indexOf(n)&&(r._headers[n]={name:e,value:t})},p.prototype.getHeader=function(e){var t=this._headers[e.toLowerCase()];return t?t.value:null},p.prototype.removeHeader=function(e){delete this._headers[e.toLowerCase()]},p.prototype._onFinish=function(){var e=this;if(!e._destroyed){var r=e._opts,i=e._headers,s=null;"GET"!==r.method&&"HEAD"!==r.method&&(s=a.arraybuffer?c(t.concat(e._body)):a.blobConstructor?new n.Blob(e._body.map(function(e){return c(e)}),{type:(i["content-type"]||{}).value||""}):t.concat(e._body).toString());var u=[];if(Object.keys(i).forEach(function(e){var t=i[e].name,r=i[e].value;Array.isArray(r)?r.forEach(function(e){u.push([t,e])}):u.push([t,r])}),"fetch"===e._mode){var h=null;if(a.abortController){var f=new AbortController;h=f.signal,e._fetchAbortController=f,"requestTimeout"in r&&0!==r.requestTimeout&&n.setTimeout(function(){e.emit("requestTimeout"),e._fetchAbortController&&e._fetchAbortController.abort()},r.requestTimeout)}n.fetch(e._opts.url,{method:e._opts.method,headers:u,body:s||void 0,mode:"cors",credentials:r.withCredentials?"include":"same-origin",signal:h}).then(function(t){e._fetchResponse=t,e._connect()},function(t){e.emit("error",t)})}else{var l=e._xhr=new n.XMLHttpRequest;try{l.open(e._opts.method,e._opts.url,!0)}catch(t){return void o.nextTick(function(){e.emit("error",t)})}"responseType"in l&&(l.responseType=e._mode.split(":")[0]),"withCredentials"in l&&(l.withCredentials=!!r.withCredentials),"text"===e._mode&&"overrideMimeType"in l&&l.overrideMimeType("text/plain; charset=x-user-defined"),"requestTimeout"in r&&(l.timeout=r.requestTimeout,l.ontimeout=function(){e.emit("requestTimeout")}),u.forEach(function(e){l.setRequestHeader(e[0],e[1])}),e._response=null,l.onreadystatechange=function(){switch(l.readyState){case d.LOADING:case d.DONE:e._onXHRProgress()}},"moz-chunked-arraybuffer"===e._mode&&(l.onprogress=function(){e._onXHRProgress()}),l.onerror=function(){e._destroyed||e.emit("error",new Error("XHR error"))};try{l.send(s)}catch(t){return void o.nextTick(function(){e.emit("error",t)})}}}},p.prototype._onXHRProgress=function(){var e=this;s(e._xhr)&&!e._destroyed&&(e._response||e._connect(),e._response._onXHRProgress())},p.prototype._connect=function(){var e=this;e._destroyed||(e._response=new l(e._xhr,e._fetchResponse,e._mode),e._response.on("error",function(t){e.emit("error",t)}),e.emit("response",e._response))},p.prototype._write=function(e,t,r){this._body.push(e),r()},p.prototype.abort=p.prototype.destroy=function(){var e=this;e._destroyed=!0,e._response&&(e._response._destroyed=!0),e._xhr?e._xhr.abort():e._fetchAbortController&&e._fetchAbortController.abort()},p.prototype.end=function(e,t,r){var n=this;"function"==typeof e&&(r=e,e=void 0),f.Writable.prototype.end.call(n,e,t,r)},p.prototype.flushHeaders=function(){},p.prototype.setTimeout=function(){},p.prototype.setNoDelay=function(){},p.prototype.setSocketKeepAlive=function(){};var g=["accept-charset","accept-encoding","access-control-request-headers","access-control-request-method","connection","content-length","cookie","cookie2","date","dnt","expect","host","keep-alive","origin","referer","te","trailer","transfer-encoding","upgrade","user-agent","via"]}).call(t,r(3).Buffer,r(0),r(4))},function(e,t){},function(e,t,r){"use strict";function n(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e,t,r){e.copy(t,r)}var i=r(10).Buffer;e.exports=function(){function e(){n(this,e),this.head=null,this.tail=null,this.length=0}return e.prototype.push=function(e){var t={data:e,next:null};this.length>0?this.tail.next=t:this.head=t,this.tail=t,++this.length},e.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},e.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},e.prototype.clear=function(){this.head=this.tail=null,this.length=0},e.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,r=""+t.data;t=t.next;)r+=e+t.data;return r},e.prototype.concat=function(e){if(0===this.length)return i.alloc(0);if(1===this.length)return this.head.data;for(var t=i.allocUnsafe(e>>>0),r=this.head,n=0;r;)o(r.data,t,n),n+=r.data.length,r=r.next;return t},e}()},function(e,t,r){(function(e){function n(e,t){this._id=e,this._clearFn=t}var o=Function.prototype.apply;t.setTimeout=function(){return new n(o.call(setTimeout,window,arguments),clearTimeout)},t.setInterval=function(){return new n(o.call(setInterval,window,arguments),clearInterval)},t.clearTimeout=t.clearInterval=function(e){e&&e.close()},n.prototype.unref=n.prototype.ref=function(){},n.prototype.close=function(){this._clearFn.call(window,this._id)},t.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},t.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},t._unrefActive=t.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout(function(){e._onTimeout&&e._onTimeout()},t))},r(44),t.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==e&&e.setImmediate||this&&this.setImmediate,t.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==e&&e.clearImmediate||this&&this.clearImmediate}).call(t,r(0))},function(e,t,r){(function(e,t){!function(e,r){"use strict";function n(e){"function"!=typeof e&&(e=new Function(""+e));for(var t=new Array(arguments.length-1),r=0;r1&&(n=r[0]+"@",e=r[1]),e=e.replace(k,"."),n+a(e.split("."),t).join(".")}function h(e){for(var t,r,n=[],o=0,i=e.length;o=55296&&t<=56319&&o65535&&(e-=65536,t+=U(e>>>10&1023|55296),e=56320|1023&e),t+=U(e)}).join("")}function c(e){return e-48<10?e-22:e-65<26?e-65:e-97<26?e-97:_}function l(e,t){return e+22+75*(e<26)-((0!=t)<<5)}function d(e,t,r){var n=0;for(e=r?I(e/A):e>>1,e+=I(e/t);e>L*S>>1;n+=_)e=I(e/L);return I(n+(L+1)*e/(e+R))}function p(e){var t,r,n,o,i,a,u,h,l,p,g=[],y=e.length,v=0,b=C,m=T;for(r=e.lastIndexOf(M),r<0&&(r=0),n=0;n=128&&s("not-basic"),g.push(e.charCodeAt(n));for(o=r>0?r+1:0;o=y&&s("invalid-input"),h=c(e.charCodeAt(o++)),(h>=_||h>I((w-v)/a))&&s("overflow"),v+=h*a,l=u<=m?E:u>=m+S?S:u-m,!(hI(w/p)&&s("overflow"),a*=p;t=g.length+1,m=d(v-i,t,0==i),I(v/t)>w-b&&s("overflow"),b+=I(v/t),v%=t,g.splice(v++,0,b)}return f(g)}function g(e){var t,r,n,o,i,a,u,f,c,p,g,y,v,b,m,R=[];for(e=h(e),y=e.length,t=C,r=0,i=T,a=0;a=t&&gI((w-r)/v)&&s("overflow"),r+=(u-t)*v,t=u,a=0;aw&&s("overflow"),g==t){for(f=r,c=_;p=c<=i?E:c>=i+S?S:c-i,!(f= 0x80 (not a basic code point)","invalid-input":"Invalid input"},L=_-E,I=Math.floor,U=String.fromCharCode;m={version:"1.4.1",ucs2:{decode:h,encode:f},decode:p,encode:g,toASCII:v,toUnicode:y},void 0!==(o=function(){return m}.call(t,r,t,e))&&(e.exports=o)}()}).call(t,r(51)(e),r(0))},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},function(e,t,r){"use strict";e.exports={isString:function(e){return"string"==typeof e},isObject:function(e){return"object"==typeof e&&null!==e},isNull:function(e){return null===e},isNullOrUndefined:function(e){return null==e}}},function(e,t,r){"use strict";t.decode=t.parse=r(54),t.encode=t.stringify=r(55)},function(e,t,r){"use strict";function n(e,t){return Object.prototype.hasOwnProperty.call(e,t)}e.exports=function(e,t,r,i){t=t||"&",r=r||"=";var s={};if("string"!=typeof e||0===e.length)return s;var a=/\+/g;e=e.split(t);var u=1e3;i&&"number"==typeof i.maxKeys&&(u=i.maxKeys);var h=e.length;u>0&&h>u&&(h=u);for(var f=0;f=0?(c=g.substr(0,y),l=g.substr(y+1)):(c=g,l=""),d=decodeURIComponent(c),p=decodeURIComponent(l),n(s,d)?o(s[d])?s[d].push(p):s[d]=[s[d],p]:s[d]=p}return s};var o=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)}},function(e,t,r){"use strict";function n(e,t){if(e.map)return e.map(t);for(var r=[],n=0;n= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]); + } else if (_1 === (2)) { + return (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]) + sep + (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]); + } else if (_1 === (3)) { + return (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0]) + sep + (1 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 1]) + sep + (2 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 2]); + } + n = $imul(sep.length, ((a.$length - 1 >> 0))); + i = 0; + while (true) { + if (!(i < a.$length)) { break; } + n = n + (((i < 0 || i >= a.$length) ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + i]).length) >> 0; + i = i + (1) >> 0; + } + b = $makeSlice(sliceType, n); + bp = $copyString(b, (0 >= a.$length ? ($throwRuntimeError("index out of range"), undefined) : a.$array[a.$offset + 0])); + _ref = $subslice(a, 1); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + s = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + bp = bp + ($copyString($subslice(b, bp), sep)) >> 0; + bp = bp + ($copyString($subslice(b, bp), s)) >> 0; + _i++; + } + return ($bytesToString(b)); + }; + $pkg.Join = Join; + HasSuffix = function(s, suffix) { + var s, suffix; + return s.length >= suffix.length && $substring(s, (s.length - suffix.length >> 0)) === suffix; + }; + $pkg.HasSuffix = HasSuffix; + TrimSuffix = function(s, suffix) { + var s, suffix; + if (HasSuffix(s, suffix)) { + return $substring(s, 0, (s.length - suffix.length >> 0)); + } + return s; + }; + $pkg.TrimSuffix = TrimSuffix; + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/johanbrandhorst/protobuf/vendor/google.golang.org/grpc/metadata"] = (function() { + var $pkg = {}, $init, fmt, context, strings, MD, mdOutgoingKey, sliceType, sliceType$2, Join, FromOutgoingContext; + fmt = $packages["fmt"]; + context = $packages["github.com/johanbrandhorst/protobuf/vendor/golang.org/x/net/context"]; + strings = $packages["strings"]; + MD = $pkg.MD = $newType(4, $kindMap, "metadata.MD", true, "github.com/johanbrandhorst/protobuf/vendor/google.golang.org/grpc/metadata", true, null); + mdOutgoingKey = $pkg.mdOutgoingKey = $newType(0, $kindStruct, "metadata.mdOutgoingKey", true, "github.com/johanbrandhorst/protobuf/vendor/google.golang.org/grpc/metadata", false, function() { + this.$val = this; + if (arguments.length === 0) { + return; + } + }); + sliceType = $sliceType($String); + sliceType$2 = $sliceType(MD); + MD.prototype.Len = function() { + var md; + md = this.$val; + return $keys(md).length; + }; + $ptrType(MD).prototype.Len = function() { return new MD(this.$get()).Len(); }; + MD.prototype.Copy = function() { + var md; + md = this.$val; + return Join(new sliceType$2([md])); + }; + $ptrType(MD).prototype.Copy = function() { return new MD(this.$get()).Copy(); }; + Join = function(mds) { + var _entry, _entry$1, _i, _i$1, _key, _keys, _ref, _ref$1, k, md, mds, out, v; + out = $makeMap($String.keyFor, []); + _ref = mds; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + md = ((_i < 0 || _i >= _ref.$length) ? ($throwRuntimeError("index out of range"), undefined) : _ref.$array[_ref.$offset + _i]); + _ref$1 = md; + _i$1 = 0; + _keys = $keys(_ref$1); + while (true) { + if (!(_i$1 < _keys.length)) { break; } + _entry = _ref$1[_keys[_i$1]]; + if (_entry === undefined) { + _i$1++; + continue; + } + k = _entry.k; + v = _entry.v; + _key = k; (out || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: $appendSlice((_entry$1 = out[$String.keyFor(k)], _entry$1 !== undefined ? _entry$1.v : sliceType.nil), v) }; + _i$1++; + } + _i++; + } + return out; + }; + $pkg.Join = Join; + FromOutgoingContext = function(ctx) { + var _r, _tuple, ctx, md, ok, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; ctx = $f.ctx; md = $f.md; ok = $f.ok; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + md = false; + ok = false; + _r = ctx.Value((x = new mdOutgoingKey.ptr(), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = $assertType(_r, MD, true); + md = _tuple[0]; + ok = _tuple[1]; + $s = -1; return [md, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: FromOutgoingContext }; } $f._r = _r; $f._tuple = _tuple; $f.ctx = ctx; $f.md = md; $f.ok = ok; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.FromOutgoingContext = FromOutgoingContext; + MD.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Copy", name: "Copy", pkg: "", typ: $funcType([], [MD], false)}]; + MD.init($String, sliceType); + mdOutgoingKey.init("", []); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = fmt.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = context.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/johanbrandhorst/protobuf/grpcweb/status"] = (function() { + var $pkg = {}, $init, grpcwebjs, codes, metadata, Status, ptrType, FromError; + grpcwebjs = $packages["github.com/johanbrandhorst/protobuf/grpcweb/grpcwebjs"]; + codes = $packages["github.com/johanbrandhorst/protobuf/vendor/google.golang.org/grpc/codes"]; + metadata = $packages["github.com/johanbrandhorst/protobuf/vendor/google.golang.org/grpc/metadata"]; + Status = $pkg.Status = $newType(0, $kindStruct, "status.Status", true, "github.com/johanbrandhorst/protobuf/grpcweb/status", true, function(Code_, Message_, Trailers_) { + this.$val = this; + if (arguments.length === 0) { + this.Code = 0; + this.Message = ""; + this.Trailers = false; + return; + } + this.Code = Code_; + this.Message = Message_; + this.Trailers = Trailers_; + }); + ptrType = $ptrType(Status); + Status.ptr.prototype.Error = function() { + var s; + s = this; + return "rpc error: code = " + new codes.Code(s.Code).String() + " desc = " + s.Message; + }; + Status.prototype.Error = function() { return this.$val.Error(); }; + FromError = function(err) { + var _r, _tuple, err, ok, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; _r = $f._r; _tuple = $f._tuple; err = $f.err; ok = $f.ok; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($interfaceIsEqual(err, $ifaceNil)) { + $s = -1; return ptrType.nil; + } + _tuple = $assertType(err, ptrType, true); + s = _tuple[0]; + ok = _tuple[1]; + /* */ if (!ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!ok) { */ case 1: + _r = err.Error(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = new Status.ptr(2, _r, false); + /* } */ case 2: + $s = -1; return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: FromError }; } $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.ok = ok; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.FromError = FromError; + Status.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + Status.init("", [{prop: "Code", name: "Code", anonymous: false, exported: true, typ: codes.Code, tag: ""}, {prop: "Message", name: "Message", anonymous: false, exported: true, typ: $String, tag: ""}, {prop: "Trailers", name: "Trailers", anonymous: false, exported: true, typ: metadata.MD, tag: ""}]); + $init = function() { + $pkg.$init = function() {}; + /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = grpcwebjs.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = codes.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = metadata.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); + (function() { +!function(e,t){for(var r in t)e[r]=t[r]}(this,function(e){var t={};function r(o){if(t[o])return t[o].exports;var n=t[o]={i:o,l:!1,exports:{}};return e[o].call(n.exports,n,n.exports,r),n.l=!0,n.exports}return r.m=e,r.c=t,r.d=function(e,t,o){r.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:o})},r.r=function(e){Object.defineProperty(e,"__esModule",{value:!0})},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=1)}([function(e,t){var r;r=function(){return this}();try{r=r||Function("return this")()||(0,eval)("this")}catch(e){"object"==typeof window&&(r=window)}e.exports=r},function(module,exports,__webpack_require__){(function(global){var $jscomp={scope:{},getGlobal:function(e){return"undefined"!=typeof window&&window===e?e:void 0!==global?global:e}};$jscomp.global=$jscomp.getGlobal(this),$jscomp.initSymbol=function(){$jscomp.global.Symbol||($jscomp.global.Symbol=$jscomp.Symbol),$jscomp.initSymbol=function(){}},$jscomp.symbolCounter_=0,$jscomp.Symbol=function(e){return"jscomp_symbol_"+e+$jscomp.symbolCounter_++},$jscomp.initSymbolIterator=function(){$jscomp.initSymbol(),$jscomp.global.Symbol.iterator||($jscomp.global.Symbol.iterator=$jscomp.global.Symbol("iterator")),$jscomp.initSymbolIterator=function(){}},$jscomp.makeIterator=function(e){$jscomp.initSymbolIterator(),$jscomp.initSymbol(),$jscomp.initSymbolIterator();var t=e[Symbol.iterator];if(t)return t.call(e);var r=0;return{next:function(){return rt;)--r in this?this[--e]=this[r]:delete this[e];return this},$jscomp.array.copyWithin$install=function(){$jscomp.array.installHelper_("copyWithin",$jscomp.array.copyWithin)},$jscomp.array.fill=function(e,t,r){var o=this.length||0;for(0>t&&(t=Math.max(0,o+t)),(null==r||r>o)&&(r=o),0>(r=Number(r))&&(r=Math.max(0,o+r)),t=Number(t||0);t>>0))return 32;var t=0;return 0==(4294901760&e)&&(e<<=16,t+=16),0==(4278190080&e)&&(e<<=8,t+=8),0==(4026531840&e)&&(e<<=4,t+=4),0==(3221225472&e)&&(e<<=2,t+=2),0==(2147483648&e)&&t++,t},$jscomp.math.imul=function(e,t){var r=65535&(e=Number(e)),o=65535&(t=Number(t));return r*o+((e>>>16&65535)*o+r*(t>>>16&65535)<<16>>>0)|0},$jscomp.math.sign=function(e){return 0===(e=Number(e))||isNaN(e)?e:0(e=Number(e))&&-.25(e=Number(e))&&-.25e?-t:t},$jscomp.math.acosh=function(e){return e=Number(e),Math.log(e+Math.sqrt(e*e-1))},$jscomp.math.asinh=function(e){if(0===(e=Number(e)))return e;var t=Math.log(Math.abs(e)+Math.sqrt(e*e+1));return 0>e?-t:t},$jscomp.math.atanh=function(e){return e=Number(e),($jscomp.math.log1p(e)-$jscomp.math.log1p(-e))/2},$jscomp.math.hypot=function(e,t,r){e=Number(e),t=Number(t);var o,n,s,i=Math.max(Math.abs(e),Math.abs(t));for(o=2;oi){for(s=(e/=i)*e+(t/=i)*t,o=2;oe?-t:t},$jscomp.math.cbrt=function(e){if(0===e)return e;e=Number(e);var t=Math.pow(Math.abs(e),1/3);return 0>e?-t:t},$jscomp.number=$jscomp.number||{},$jscomp.number.isFinite=function(e){return"number"==typeof e&&(!isNaN(e)&&1/0!==e&&-1/0!==e)},$jscomp.number.isInteger=function(e){return!!$jscomp.number.isFinite(e)&&e===Math.floor(e)},$jscomp.number.isNaN=function(e){return"number"==typeof e&&isNaN(e)},$jscomp.number.isSafeInteger=function(e){return $jscomp.number.isInteger(e)&&Math.abs(e)<=$jscomp.number.MAX_SAFE_INTEGER},$jscomp.number.EPSILON=Math.pow(2,-52),$jscomp.number.MAX_SAFE_INTEGER=9007199254740991,$jscomp.number.MIN_SAFE_INTEGER=-9007199254740991,$jscomp.object=$jscomp.object||{},$jscomp.object.assign=function(e,t){for(var r=1;ro||1114111=o?t+=String.fromCharCode(o):(o-=65536,t+=String.fromCharCode(o>>>10&1023|55296),t+=String.fromCharCode(1023&o|56320))}return t},$jscomp.string.repeat=function(e){var t=$jscomp.checkStringArgs(this,null,"repeat");if(0>e||1342177279>>=1)&&(t+=t);return r},$jscomp.string.repeat$install=function(){String.prototype.repeat||(String.prototype.repeat=$jscomp.string.repeat)},$jscomp.string.codePointAt=function(e){var t=$jscomp.checkStringArgs(this,null,"codePointAt"),r=t.length;if(0<=(e=Number(e)||0)&&eo||56319(e=t.charCodeAt(e+1))||57343=n},$jscomp.string.startsWith$install=function(){String.prototype.startsWith||(String.prototype.startsWith=$jscomp.string.startsWith)},$jscomp.string.endsWith=function(e,t){var r=$jscomp.checkStringArgs(this,e,"endsWith");e+="",void 0===t&&(t=r.length);for(var o=Math.max(0,Math.min(0|t,r.length)),n=e.length;0=n},$jscomp.string.endsWith$install=function(){String.prototype.endsWith||(String.prototype.endsWith=$jscomp.string.endsWith)};var COMPILED=!0,goog=goog||{};goog.global=this,goog.isDef=function(e){return void 0!==e},goog.exportPath_=function(e,t,r){e=e.split("."),r=r||goog.global,e[0]in r||!r.execScript||r.execScript("var "+e[0]);for(var o;e.length&&(o=e.shift());)!e.length&&goog.isDef(t)?r[o]=t:r=r[o]?r[o]:r[o]={}},goog.define=function(e,t){var r=t;COMPILED||(goog.global.CLOSURE_UNCOMPILED_DEFINES&&Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_UNCOMPILED_DEFINES,e)?r=goog.global.CLOSURE_UNCOMPILED_DEFINES[e]:goog.global.CLOSURE_DEFINES&&Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_DEFINES,e)&&(r=goog.global.CLOSURE_DEFINES[e])),goog.exportPath_(e,r)},goog.DEBUG=!0,goog.LOCALE="en",goog.TRUSTED_SITE=!0,goog.STRICT_MODE_COMPATIBLE=!1,goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG,goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1,goog.provide=function(e){if(!COMPILED&&goog.isProvided_(e))throw Error('Namespace "'+e+'" already declared.');goog.constructNamespace_(e)},goog.constructNamespace_=function(e,t){if(!COMPILED){delete goog.implicitNamespaces_[e];for(var r=e;(r=r.substring(0,r.lastIndexOf(".")))&&!goog.getObjectByName(r);)goog.implicitNamespaces_[r]=!0}goog.exportPath_(e,t)},goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/,goog.module=function(e){if(!goog.isString(e)||!e||-1==e.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInModuleLoader_())throw Error("Module "+e+" has been loaded incorrectly.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");if(goog.moduleLoaderState_.moduleName=e,!COMPILED){if(goog.isProvided_(e))throw Error('Namespace "'+e+'" already declared.');delete goog.implicitNamespaces_[e]}},goog.module.get=function(e){return goog.module.getInternal_(e)},goog.module.getInternal_=function(e){if(!COMPILED)return goog.isProvided_(e)?e in goog.loadedModules_?goog.loadedModules_[e]:goog.getObjectByName(e):null},goog.moduleLoaderState_=null,goog.isInModuleLoader_=function(){return null!=goog.moduleLoaderState_},goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0},goog.setTestOnly=function(e){if(goog.DISALLOW_TEST_ONLY_CODE)throw e=e||"",Error("Importing test-only code into non-debug environment"+(e?": "+e:"."))},goog.forwardDeclare=function(e){},COMPILED||(goog.isProvided_=function(e){return e in goog.loadedModules_||!goog.implicitNamespaces_[e]&&goog.isDefAndNotNull(goog.getObjectByName(e))},goog.implicitNamespaces_={"goog.module":!0}),goog.getObjectByName=function(e,t){for(var r,o=e.split("."),n=t||goog.global;r=o.shift();){if(!goog.isDefAndNotNull(n[r]))return null;n=n[r]}return n},goog.globalize=function(e,t){var r,o=t||goog.global;for(r in e)o[r]=e[r]},goog.addDependency=function(e,t,r,o){if(goog.DEPENDENCIES_ENABLED){var n;e=e.replace(/\\/g,"/");for(var s=goog.dependencies_,i=0;n=t[i];i++)s.nameToPath[n]=e,s.pathIsModule[e]=!!o;for(o=0;t=r[o];o++)e in s.requires||(s.requires[e]={}),s.requires[e][t]=!0}},goog.ENABLE_DEBUG_LOADER=!0,goog.logToConsole_=function(e){goog.global.console&&goog.global.console.error(e)},goog.require=function(e){if(!COMPILED){if(goog.ENABLE_DEBUG_LOADER&&goog.IS_OLD_IE_&&goog.maybeProcessDeferredDep_(e),goog.isProvided_(e))return goog.isInModuleLoader_()?goog.module.getInternal_(e):null;if(goog.ENABLE_DEBUG_LOADER){var t=goog.getPathFromDeps_(e);if(t)return goog.writeScripts_(t),null}throw e="goog.require could not find: "+e,goog.logToConsole_(e),Error(e)}},goog.basePath="",goog.nullFunction=function(){},goog.abstractMethod=function(){throw Error("unimplemented abstract method")},goog.addSingletonGetter=function(e){e.getInstance=function(){return e.instance_?e.instance_:(goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=e),e.instance_=new e)}},goog.instantiatedSingletons_=[],goog.LOAD_MODULE_USING_EVAL=!0,goog.SEAL_MODULE_EXPORTS=goog.DEBUG,goog.loadedModules_={},goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER,goog.DEPENDENCIES_ENABLED&&(goog.dependencies_={pathIsModule:{},nameToPath:{},requires:{},visited:{},written:{},deferred:{}},goog.inHtmlDocument_=function(){var e=goog.global.document;return null!=e&&"write"in e},goog.findBasePath_=function(){if(goog.isDef(goog.global.CLOSURE_BASE_PATH))goog.basePath=goog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_())for(var e=goog.global.document.getElementsByTagName("SCRIPT"),t=e.length-1;0<=t;--t){var r=e[t].src,o=-1==(o=r.lastIndexOf("?"))?r.length:o;if("base.js"==r.substr(o-7,7)){goog.basePath=r.substr(0,o-7);break}}},goog.importScript_=function(e,t){(goog.global.CLOSURE_IMPORT_SCRIPT||goog.writeScriptTag_)(e,t)&&(goog.dependencies_.written[e]=!0)},goog.IS_OLD_IE_=!(goog.global.atob||!goog.global.document||!goog.global.document.all),goog.importModule_=function(e){goog.importScript_("",'goog.retrieveAndExecModule_("'+e+'");')&&(goog.dependencies_.written[e]=!0)},goog.queuedModules_=[],goog.wrapModule_=function(e,t){return goog.LOAD_MODULE_USING_EVAL&&goog.isDef(goog.global.JSON)?"goog.loadModule("+goog.global.JSON.stringify(t+"\n//# sourceURL="+e+"\n")+");":'goog.loadModule(function(exports) {"use strict";'+t+"\n;return exports});\n//# sourceURL="+e+"\n"},goog.loadQueuedModules_=function(){var e=goog.queuedModules_.length;if(0<\/script>')},goog.appendScriptSrcNode_=function(e){var t=goog.global.document,r=t.createElement("script");r.type="text/javascript",r.src=e,r.defer=!1,r.async=!1,t.head.appendChild(r)},goog.writeScriptTag_=function(e,t){if(goog.inHtmlDocument_()){var r=goog.global.document;if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&"complete"==r.readyState){if(/\bdeps.js$/.test(e))return!1;throw Error('Cannot write "'+e+'" after document load')}var o=goog.IS_OLD_IE_;return void 0===t?o?(o=" onreadystatechange='goog.onScriptLoad_(this, "+ ++goog.lastNonModuleScriptIndex_+")' ",r.write('