Subversion Repositories openrisc

// 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"

)

// 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) {

        buf := bytes.NewBuffer(make([]byte, 0, capacity))

        // 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)

                }

        }()

        _, 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.

        fi, err := f.Stat()

        var n int64

        if size := fi.Size(); err == nil && size < 2e9 { // Don't preallocate a huge buffer, just in case.

                n = size

        }

        // As initial capacity for readAll, use n + 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.

        return readAll(f, n+bytes.MinRead)

}

// 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)

        f.Close()

        if err == nil && n < len(data) {

                err = io.ErrShortWrite

        }

        return err

}

// byName implements sort.Interface.

type byName []os.FileInfo

func (f byName) Len() int           { return len(f) }

func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }

func (f byName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }

// ReadDir reads the directory named by dirname and returns

// a list of sorted directory entries.

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.Sort(byName(list))

        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

}

var blackHole = make([]byte, 8192)

func (devNull) ReadFrom(r io.Reader) (n int64, err error) {

        readSize := 0

        for {

                readSize, err = r.Read(blackHole)

                n += int64(readSize)

                if err != nil {

                        if err == io.EOF {

                                return n, nil

                        }

                        return

                }

        }

        panic("unreachable")

}

// Discard is an io.Writer on which all Write calls succeed

// without doing anything.

var Discard io.Writer = devNull(0)