extend stdlib to allow import of more packages

src/os/env.go

@@ -0,0 +1,5 @@
+package os
+
+func Getenv(key string) string {
+	return ""
+}

src/os/errors.go

@@ -0,0 +1,32 @@
+package os
+
+import (
+	"errors"
+)
+
+var (
+	ErrInvalid    = errors.New("invalid argument")
+	ErrPermission = errors.New("permission denied")
+	ErrClosed     = errors.New("file already closed")
+)
+
+func IsPermission(err error) bool {
+	return err == ErrPermission
+}
+
+func NewSyscallError(syscall string, err error) error {
+	if err == nil {
+		return nil
+	}
+	return &SyscallError{syscall, err}
+}
+
+// SyscallError records an error from a specific system call.
+type SyscallError struct {
+	Syscall string
+	Err     error
+}
+
+func (e *SyscallError) Error() string { return e.Syscall + ": " + e.Err.Error() }
+
+func (e *SyscallError) Unwrap() error { return e.Err }

src/os/exec.go

@@ -0,0 +1,6 @@
+package os
+
+type Signal interface {
+	String() string
+	Signal() // to distinguish from other Stringers
+}

src/os/file.go

@@ -7,6 +7,7 @@ package os
 
 import (
 	"errors"
+	"syscall"
 )
 
 // Portable analogs of some common system call errors.
@@ -91,6 +92,10 @@ func (f *File) Read(b []byte) (n int, err error) {
 	return
 }
 
+func (f *File) ReadAt(b []byte, off int64) (n int, err error) {
+	return 0, ErrNotImplemented
+}
+
 // Write writes len(b) bytes to the File. It returns the number of bytes written
 // and an error, if any. Write returns a non-nil error when n != len(b).
 func (f *File) Write(b []byte) (n int, err error) {
@@ -125,6 +130,20 @@ func (f *File) Stat() (FileInfo, error) {
 	return nil, &PathError{"stat", f.name, ErrNotImplemented}
 }
 
+// Sync is a stub, not yet implemented
+func (f *File) Sync() error {
+	return ErrNotImplemented
+}
+
+func (f *File) SyscallConn() (syscall.RawConn, error) {
+	return nil, ErrNotImplemented
+}
+
+// Fd returns the file handle referencing the open file.
+func (f *File) Fd() uintptr {
+	panic("unimplemented: os.file.Fd()")
+}
+
 const (
 	PathSeparator     = '/' // OS-specific path separator
 	PathListSeparator = ':' // OS-specific path list separator
@@ -194,7 +213,7 @@ type FileInfo interface {
 	Name() string   // base name of the file
 	Size() int64    // length in bytes for regular files; system-dependent for others
 	Mode() FileMode // file mode bits
-	// ModTime() time.Time // modification time
+	// TODO ModTime() time.Time // modification time
 	IsDir() bool      // abbreviation for Mode().IsDir()
 	Sys() interface{} // underlying data source (can return nil)
 }

src/os/sys.go

@@ -0,0 +1,5 @@
+package os
+
+func Hostname() (name string, err error) {
+	return "", ErrNotImplemented
+}

src/reflect/deepequal.go

@@ -0,0 +1,9 @@
+package reflect
+
+func DeepEqual(x, y interface{}) bool {
+	if x == nil || y == nil {
+		return x == y
+	}
+
+	panic("unimplemented: reflect.DeepEqual()")
+}

src/reflect/type.go

@@ -227,7 +227,7 @@ func (t Type) Field(i int) StructField {
 			// There is a tag.
 			var tagNum uintptr
 			tagNum, p = readVarint(p)
-			field.Tag = readStringSidetable(unsafe.Pointer(&structNamesSidetable), tagNum)
+			field.Tag = StructTag(readStringSidetable(unsafe.Pointer(&structNamesSidetable), tagNum))
 		} else {
 			// There is no tag.
 			field.Tag = ""
@@ -445,6 +445,22 @@ func (t Type) Comparable() bool {
 	}
 }
 
+func (t Type) ConvertibleTo(u Type) bool {
+	panic("unimplemented: (reflect.Type).ConvertibleTo()")
+}
+
+func (t Type) NumMethod() int {
+	panic("unimplemented: (reflect.Type).NumMethod()")
+}
+
+func (t Type) Name() string {
+	panic("unimplemented: (reflect.Type).Name()")
+}
+
+func (t Type) Key() Type {
+	panic("unimplemented: (reflect.Type).Key()")
+}
+
 // A StructField describes a single field in a struct.
 type StructField struct {
 	// Name indicates the field name.
@@ -455,11 +471,74 @@ type StructField struct {
 	PkgPath string
 
 	Type      Type
-	Tag       string
+	Tag       StructTag // field tag string
 	Anonymous bool
 	Offset    uintptr
 }
 
+// A StructTag is the tag string in a struct field.
+type StructTag string
+
+// Get returns the value associated with key in the tag string.
+func (tag StructTag) Get(key string) string {
+	v, _ := tag.Lookup(key)
+	return v
+}
+
+// Lookup returns the value associated with key in the tag string.
+func (tag StructTag) Lookup(key string) (value string, ok bool) {
+	for tag != "" {
+		// Skip leading space.
+		i := 0
+		for i < len(tag) && tag[i] == ' ' {
+			i++
+		}
+		tag = tag[i:]
+		if tag == "" {
+			break
+		}
+
+		// Scan to colon. A space, a quote or a control character is a syntax error.
+		// Strictly speaking, control chars include the range [0x7f, 0x9f], not just
+		// [0x00, 0x1f], but in practice, we ignore the multi-byte control characters
+		// as it is simpler to inspect the tag's bytes than the tag's runes.
+		i = 0
+		for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
+			i++
+		}
+		if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
+			break
+		}
+		name := string(tag[:i])
+		tag = tag[i+1:]
+
+		// Scan quoted string to find value.
+		i = 1
+		for i < len(tag) && tag[i] != '"' {
+			if tag[i] == '\\' {
+				i++
+			}
+			i++
+		}
+		if i >= len(tag) {
+			break
+		}
+		qvalue := string(tag[:i+1])
+		tag = tag[i+1:]
+
+		if key == name {
+			// TODO strconv causes import cycle
+			//value, err := strconv.Unquote(qvalue)
+			//if err != nil {
+			//	break
+			//}
+			//return value, true
+			return qvalue, true
+		}
+	}
+	return "", false
+}
+
 // TypeError is the error that is used in a panic when invoking a method on a
 // type that is not applicable to that type.
 type TypeError struct {

src/reflect/value.go

@@ -661,6 +661,18 @@ func (v Value) checkAddressable() {
 	}
 }
 
+func (v Value) OverflowInt(x int64) bool {
+	panic("unimplemented: reflect.OverflowInt()")
+}
+
+func (v Value) OverflowUint(x uint64) bool {
+	panic("unimplemented: reflect.OverflowUint()")
+}
+
+func (v Value) Convert(t Type) Value {
+	panic("unimplemented: (reflect.Value).Convert()")
+}
+
 func MakeSlice(typ Type, len, cap int) Value {
 	panic("unimplemented: reflect.MakeSlice()")
 }
@@ -700,3 +712,33 @@ func (e *ValueError) Error() string {
 // Calls to this function are converted to LLVM intrinsic calls such as
 // llvm.memcpy.p0i8.p0i8.i32().
 func memcpy(dst, src unsafe.Pointer, size uintptr)
+
+// Copy copies the contents of src into dst until either
+// dst has been filled or src has been exhausted.
+func Copy(dst, src Value) int {
+	panic("unimplemented: reflect.Copy()")
+}
+
+// Append appends the values x to a slice s and returns the resulting slice.
+// As in Go, each x's value must be assignable to the slice's element type.
+func Append(s Value, x ...Value) Value {
+	panic("unimplemented: reflect.Append()")
+}
+
+func (v Value) SetMapIndex(key, elem Value) {
+	panic("unimplemented: (reflect.Value).SetMapIndex()")
+}
+
+// FieldByIndex returns the nested field corresponding to index.
+func (v Value) FieldByIndex(index []int) Value {
+	panic("unimplemented: (reflect.Value).FieldByIndex()")
+}
+
+func (v Value) FieldByName(name string) Value {
+	panic("unimplemented: (reflect.Value).FieldByName()")
+}
+
+// MakeMap creates a new map with the specified type.
+func MakeMap(typ Type) Value {
+	panic("unimplemented: reflect.MakeMap()")
+}

src/runtime/error.go

@@ -0,0 +1,8 @@
+package runtime
+
+// The Error interface identifies a run time error.
+type Error interface {
+	error
+
+	RuntimeError()
+}

src/runtime/mprof.go

@@ -0,0 +1,6 @@
+package runtime
+
+// Stack is a stub, not implemented
+func Stack(buf []byte, all bool) int {
+	return 0
+}

src/sync/map.go

@@ -42,3 +42,18 @@ func (m *Map) Store(key, value interface{}) {
 	}
 	m.m[key] = value
 }
+
+func (m *Map) Range(f func(key, value interface{}) bool) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	if m.m == nil {
+		return
+	}
+
+	for k, v := range m.m {
+		if !f(k, v) {
+			break
+		}
+	}
+}

src/sync/mutex.go

@@ -74,3 +74,14 @@ type Locker interface {
 	Lock()
 	Unlock()
 }
+
+// RLocker returns a Locker interface that implements
+// the Lock and Unlock methods by calling rw.RLock and rw.RUnlock.
+func (rw *RWMutex) RLocker() Locker {
+	return (*rlocker)(rw)
+}
+
+type rlocker RWMutex
+
+func (r *rlocker) Lock()   { (*RWMutex)(r).RLock() }
+func (r *rlocker) Unlock() { (*RWMutex)(r).RUnlock() }

src/syscall/net.go

@@ -0,0 +1,34 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package syscall
+
+// A RawConn is a raw network connection.
+type RawConn interface {
+	// Control invokes f on the underlying connection's file
+	// descriptor or handle.
+	// The file descriptor fd is guaranteed to remain valid while
+	// f executes but not after f returns.
+	Control(f func(fd uintptr)) error
+
+	// Read invokes f on the underlying connection's file
+	// descriptor or handle; f is expected to try to read from the
+	// file descriptor.
+	// If f returns true, Read returns. Otherwise Read blocks
+	// waiting for the connection to be ready for reading and
+	// tries again repeatedly.
+	// The file descriptor is guaranteed to remain valid while f
+	// executes but not after f returns.
+	Read(f func(fd uintptr) (done bool)) error
+
+	// Write is like Read but for writing.
+	Write(f func(fd uintptr) (done bool)) error
+}
+
+// Conn is implemented by some types in the net and os packages to provide
+// access to the underlying file descriptor or handle.
+type Conn interface {
+	// SyscallConn returns a raw network connection.
+	SyscallConn() (RawConn, error)
+}