libgo: Merge from revision 18783:00cce3a34d7e of master library.
[official-gcc.git] / libgo / go / io / ioutil / ioutil.go
blob909a8156326735dbfaca50dca573dcf38b8facfa
1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // Package ioutil implements some I/O utility functions.
6 package ioutil
8 import (
9 "bytes"
10 "io"
11 "os"
12 "sort"
13 "sync"
16 // readAll reads from r until an error or EOF and returns the data it read
17 // from the internal buffer allocated with a specified capacity.
18 func readAll(r io.Reader, capacity int64) (b []byte, err error) {
19 buf := bytes.NewBuffer(make([]byte, 0, capacity))
20 // If the buffer overflows, we will get bytes.ErrTooLarge.
21 // Return that as an error. Any other panic remains.
22 defer func() {
23 e := recover()
24 if e == nil {
25 return
27 if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
28 err = panicErr
29 } else {
30 panic(e)
32 }()
33 _, err = buf.ReadFrom(r)
34 return buf.Bytes(), err
37 // ReadAll reads from r until an error or EOF and returns the data it read.
38 // A successful call returns err == nil, not err == EOF. Because ReadAll is
39 // defined to read from src until EOF, it does not treat an EOF from Read
40 // as an error to be reported.
41 func ReadAll(r io.Reader) ([]byte, error) {
42 return readAll(r, bytes.MinRead)
45 // ReadFile reads the file named by filename and returns the contents.
46 // A successful call returns err == nil, not err == EOF. Because ReadFile
47 // reads the whole file, it does not treat an EOF from Read as an error
48 // to be reported.
49 func ReadFile(filename string) ([]byte, error) {
50 f, err := os.Open(filename)
51 if err != nil {
52 return nil, err
54 defer f.Close()
55 // It's a good but not certain bet that FileInfo will tell us exactly how much to
56 // read, so let's try it but be prepared for the answer to be wrong.
57 var n int64
59 if fi, err := f.Stat(); err == nil {
60 // Don't preallocate a huge buffer, just in case.
61 if size := fi.Size(); size < 1e9 {
62 n = size
65 // As initial capacity for readAll, use n + a little extra in case Size is zero,
66 // and to avoid another allocation after Read has filled the buffer. The readAll
67 // call will read into its allocated internal buffer cheaply. If the size was
68 // wrong, we'll either waste some space off the end or reallocate as needed, but
69 // in the overwhelmingly common case we'll get it just right.
70 return readAll(f, n+bytes.MinRead)
73 // WriteFile writes data to a file named by filename.
74 // If the file does not exist, WriteFile creates it with permissions perm;
75 // otherwise WriteFile truncates it before writing.
76 func WriteFile(filename string, data []byte, perm os.FileMode) error {
77 f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
78 if err != nil {
79 return err
81 n, err := f.Write(data)
82 if err == nil && n < len(data) {
83 err = io.ErrShortWrite
85 if err1 := f.Close(); err == nil {
86 err = err1
88 return err
91 // byName implements sort.Interface.
92 type byName []os.FileInfo
94 func (f byName) Len() int { return len(f) }
95 func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
96 func (f byName) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
98 // ReadDir reads the directory named by dirname and returns
99 // a list of sorted directory entries.
100 func ReadDir(dirname string) ([]os.FileInfo, error) {
101 f, err := os.Open(dirname)
102 if err != nil {
103 return nil, err
105 list, err := f.Readdir(-1)
106 f.Close()
107 if err != nil {
108 return nil, err
110 sort.Sort(byName(list))
111 return list, nil
114 type nopCloser struct {
115 io.Reader
118 func (nopCloser) Close() error { return nil }
120 // NopCloser returns a ReadCloser with a no-op Close method wrapping
121 // the provided Reader r.
122 func NopCloser(r io.Reader) io.ReadCloser {
123 return nopCloser{r}
126 type devNull int
128 // devNull implements ReaderFrom as an optimization so io.Copy to
129 // ioutil.Discard can avoid doing unnecessary work.
130 var _ io.ReaderFrom = devNull(0)
132 func (devNull) Write(p []byte) (int, error) {
133 return len(p), nil
136 func (devNull) WriteString(s string) (int, error) {
137 return len(s), nil
140 var blackHolePool = sync.Pool{
141 New: func() interface{} {
142 b := make([]byte, 8192)
143 return &b
147 func (devNull) ReadFrom(r io.Reader) (n int64, err error) {
148 bufp := blackHolePool.Get().(*[]byte)
149 readSize := 0
150 for {
151 readSize, err = r.Read(*bufp)
152 n += int64(readSize)
153 if err != nil {
154 blackHolePool.Put(bufp)
155 if err == io.EOF {
156 return n, nil
158 return
163 // Discard is an io.Writer on which all Write calls succeed
164 // without doing anything.
165 var Discard io.Writer = devNull(0)