Keep syscall and io separated; neither should depend on the other.
Change-Id: Icdd61bd0c05d874cabd7b5ae6631dd09dec90112
Reviewed-on: https://go-review.googlesource.com/c/go/+/243902
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
reflect !< sort;
# SYSCALL is RUNTIME plus the packages necessary for basic system calls.
- RUNTIME, unicode/utf8, unicode/utf16, io
+ RUNTIME, unicode/utf8, unicode/utf16
< internal/syscall/windows/sysdll, syscall/js
< syscall
< internal/syscall/unix, internal/syscall/windows, internal/syscall/windows/registry
//
package registry
-import (
- "io"
- "syscall"
-)
+import "syscall"
const (
// Registry key security and access rights.
}
// ReadSubKeyNames returns the names of subkeys of key k.
-// The parameter n controls the number of returned names,
-// analogous to the way os.File.Readdirnames works.
-func (k Key) ReadSubKeyNames(n int) ([]string, error) {
+func (k Key) ReadSubKeyNames() ([]string, error) {
names := make([]string, 0)
// Registry key size limit is 255 bytes and described there:
// https://msdn.microsoft.com/library/windows/desktop/ms724872.aspx
buf := make([]uint16, 256) //plus extra room for terminating zero byte
loopItems:
for i := uint32(0); ; i++ {
- if n > 0 {
- if len(names) == n {
- return names, nil
- }
- }
l := uint32(len(buf))
for {
err := syscall.RegEnumKeyEx(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
}
names = append(names, syscall.UTF16ToString(buf[:l]))
}
- if n > len(names) {
- return names, io.EOF
- }
return names, nil
}
}
defer k.Close()
- names, err := k.ReadSubKeyNames(-1)
+ names, err := k.ReadSubKeyNames()
if err != nil {
t.Fatal(err)
}
}
func enumerateValues(t *testing.T, k registry.Key) {
- names, err := k.ReadValueNames(-1)
+ names, err := k.ReadValueNames()
if err != nil {
t.Error(err)
return
continue
}
}
- names, err := k.ReadValueNames(-1)
+ names, err := k.ReadValueNames()
if err != nil {
t.Error(err)
return
import (
"errors"
- "io"
"syscall"
"unicode/utf16"
"unsafe"
}
// ReadValueNames returns the value names of key k.
-// The parameter n controls the number of returned names,
-// analogous to the way os.File.Readdirnames works.
-func (k Key) ReadValueNames(n int) ([]string, error) {
+func (k Key) ReadValueNames() ([]string, error) {
ki, err := k.Stat()
if err != nil {
return nil, err
buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character
loopItems:
for i := uint32(0); ; i++ {
- if n > 0 {
- if len(names) == n {
- return names, nil
- }
- }
l := uint32(len(buf))
for {
err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
}
names = append(names, syscall.UTF16ToString(buf[:l]))
}
- if n > len(names) {
- return names, io.EOF
- }
return names, nil
}
}
func initMimeWindows() {
- names, err := registry.CLASSES_ROOT.ReadSubKeyNames(-1)
+ names, err := registry.CLASSES_ROOT.ReadSubKeyNames()
if err != nil {
return
}
import (
"errors"
- "io"
"sync"
"syscall/js"
)
var newPos int64
switch whence {
- case io.SeekStart:
+ case 0:
newPos = offset
- case io.SeekCurrent:
+ case 1:
newPos = f.pos + offset
- case io.SeekEnd:
+ case 2:
var st Stat_t
if err := Fstat(fd, &st); err != nil {
return 0, err
}
defer k.Close()
- names, err := k.ReadSubKeyNames(-1)
+ names, err := k.ReadSubKeyNames()
if err != nil {
return "", err
}