mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-13 02:59:59 +08:00
1a2f01efa6
Update the Go library to the 1.10beta1 release. Requires a few changes to the compiler for modifications to the map runtime code, and to handle some nowritebarrier cases in the runtime. Reviewed-on: https://go-review.googlesource.com/86455 gotools/: * Makefile.am (go_cmd_vet_files): New variable. (go_cmd_buildid_files, go_cmd_test2json_files): New variables. (s-zdefaultcc): Change from constants to functions. (noinst_PROGRAMS): Add vet, buildid, and test2json. (cgo$(EXEEXT)): Link against $(LIBGOTOOL). (vet$(EXEEXT)): New target. (buildid$(EXEEXT)): New target. (test2json$(EXEEXT)): New target. (install-exec-local): Install all $(noinst_PROGRAMS). (uninstall-local): Uninstasll all $(noinst_PROGRAMS). (check-go-tool): Depend on $(noinst_PROGRAMS). Copy down objabi.go. (check-runtime): Depend on $(noinst_PROGRAMS). (check-cgo-test, check-carchive-test): Likewise. (check-vet): New target. (check): Depend on check-vet. Look at cmd_vet-testlog. (.PHONY): Add check-vet. * Makefile.in: Rebuild. From-SVN: r256365
162 lines
4.2 KiB
Go
162 lines
4.2 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package ioutil implements some I/O utility functions.
|
|
package ioutil
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"os"
|
|
"sort"
|
|
"sync"
|
|
)
|
|
|
|
// readAll reads from r until an error or EOF and returns the data it read
|
|
// from the internal buffer allocated with a specified capacity.
|
|
func readAll(r io.Reader, capacity int64) (b []byte, err error) {
|
|
var buf bytes.Buffer
|
|
// If the buffer overflows, we will get bytes.ErrTooLarge.
|
|
// Return that as an error. Any other panic remains.
|
|
defer func() {
|
|
e := recover()
|
|
if e == nil {
|
|
return
|
|
}
|
|
if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
|
|
err = panicErr
|
|
} else {
|
|
panic(e)
|
|
}
|
|
}()
|
|
if int64(int(capacity)) == capacity {
|
|
buf.Grow(int(capacity))
|
|
}
|
|
_, err = buf.ReadFrom(r)
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
// ReadAll reads from r until an error or EOF and returns the data it read.
|
|
// A successful call returns err == nil, not err == EOF. Because ReadAll is
|
|
// defined to read from src until EOF, it does not treat an EOF from Read
|
|
// as an error to be reported.
|
|
func ReadAll(r io.Reader) ([]byte, error) {
|
|
return readAll(r, bytes.MinRead)
|
|
}
|
|
|
|
// ReadFile reads the file named by filename and returns the contents.
|
|
// A successful call returns err == nil, not err == EOF. Because ReadFile
|
|
// reads the whole file, it does not treat an EOF from Read as an error
|
|
// to be reported.
|
|
func ReadFile(filename string) ([]byte, error) {
|
|
f, err := os.Open(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
// It's a good but not certain bet that FileInfo will tell us exactly how much to
|
|
// read, so let's try it but be prepared for the answer to be wrong.
|
|
var n int64 = bytes.MinRead
|
|
|
|
if fi, err := f.Stat(); err == nil {
|
|
// As initial capacity for readAll, use Size + a little extra in case Size
|
|
// is zero, and to avoid another allocation after Read has filled the
|
|
// buffer. The readAll call will read into its allocated internal buffer
|
|
// cheaply. If the size was wrong, we'll either waste some space off the end
|
|
// or reallocate as needed, but in the overwhelmingly common case we'll get
|
|
// it just right.
|
|
if size := fi.Size() + bytes.MinRead; size > n {
|
|
n = size
|
|
}
|
|
}
|
|
return readAll(f, n)
|
|
}
|
|
|
|
// WriteFile writes data to a file named by filename.
|
|
// If the file does not exist, WriteFile creates it with permissions perm;
|
|
// otherwise WriteFile truncates it before writing.
|
|
func WriteFile(filename string, data []byte, perm os.FileMode) error {
|
|
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
n, err := f.Write(data)
|
|
if err == nil && n < len(data) {
|
|
err = io.ErrShortWrite
|
|
}
|
|
if err1 := f.Close(); err == nil {
|
|
err = err1
|
|
}
|
|
return err
|
|
}
|
|
|
|
// ReadDir reads the directory named by dirname and returns
|
|
// a list of directory entries sorted by filename.
|
|
func ReadDir(dirname string) ([]os.FileInfo, error) {
|
|
f, err := os.Open(dirname)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
list, err := f.Readdir(-1)
|
|
f.Close()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
|
|
return list, nil
|
|
}
|
|
|
|
type nopCloser struct {
|
|
io.Reader
|
|
}
|
|
|
|
func (nopCloser) Close() error { return nil }
|
|
|
|
// NopCloser returns a ReadCloser with a no-op Close method wrapping
|
|
// the provided Reader r.
|
|
func NopCloser(r io.Reader) io.ReadCloser {
|
|
return nopCloser{r}
|
|
}
|
|
|
|
type devNull int
|
|
|
|
// devNull implements ReaderFrom as an optimization so io.Copy to
|
|
// ioutil.Discard can avoid doing unnecessary work.
|
|
var _ io.ReaderFrom = devNull(0)
|
|
|
|
func (devNull) Write(p []byte) (int, error) {
|
|
return len(p), nil
|
|
}
|
|
|
|
func (devNull) WriteString(s string) (int, error) {
|
|
return len(s), nil
|
|
}
|
|
|
|
var blackHolePool = sync.Pool{
|
|
New: func() interface{} {
|
|
b := make([]byte, 8192)
|
|
return &b
|
|
},
|
|
}
|
|
|
|
func (devNull) ReadFrom(r io.Reader) (n int64, err error) {
|
|
bufp := blackHolePool.Get().(*[]byte)
|
|
readSize := 0
|
|
for {
|
|
readSize, err = r.Read(*bufp)
|
|
n += int64(readSize)
|
|
if err != nil {
|
|
blackHolePool.Put(bufp)
|
|
if err == io.EOF {
|
|
return n, nil
|
|
}
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// Discard is an io.Writer on which all Write calls succeed
|
|
// without doing anything.
|
|
var Discard io.Writer = devNull(0)
|