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 os

import "io"

// MkdirAll creates a directory named path,

// along with any necessary parents, and returns nil,

// or else returns an error.

// The permission bits perm are used for all

// directories that MkdirAll creates.

// If path is already a directory, MkdirAll does nothing

// and returns nil.

func MkdirAll(path string, perm FileMode) error {

        // If path exists, stop with success or error.

        dir, err := Stat(path)

        if err == nil {

                if dir.IsDir() {

                        return nil

                }

                return &PathError{"mkdir", path, ENOTDIR}

        }

        // Doesn't already exist; make sure parent does.

        i := len(path)

        for i > 0 && IsPathSeparator(path[i-1]) { // Skip trailing path separator.

                i--

        }

        j := i

        for j > 0 && !IsPathSeparator(path[j-1]) { // Scan backward over element.

                j--

        }

        if j > 1 {

                // Create parent

                err = MkdirAll(path[0:j-1], perm)

                if err != nil {

                        return err

                }

        }

        // Now parent exists, try to create.

        err = Mkdir(path, perm)

        if err != nil {

                // Handle arguments like "foo/." by

                // double-checking that directory doesn't exist.

                dir, err1 := Lstat(path)

                if err1 == nil && dir.IsDir() {

                        return nil

                }

                return err

        }

        return nil

}

// RemoveAll removes path and any children it contains.

// It removes everything it can but returns the first error

// it encounters.  If the path does not exist, RemoveAll

// returns nil (no error).

func RemoveAll(path string) error {

        // Simple case: if Remove works, we're done.

        err := Remove(path)

        if err == nil {

                return nil

        }

        // Otherwise, is this a directory we need to recurse into?

        dir, serr := Lstat(path)

        if serr != nil {

                if serr, ok := serr.(*PathError); ok && (serr.Err == ENOENT || serr.Err == ENOTDIR) {

                        return nil

                }

                return serr

        }

        if !dir.IsDir() {

                // Not a directory; return the error from Remove.

                return err

        }

        // Directory.

        fd, err := Open(path)

        if err != nil {

                return err

        }

        // Remove contents & return first error.

        err = nil

        for {

                names, err1 := fd.Readdirnames(100)

                for _, name := range names {

                        err1 := RemoveAll(path + string(PathSeparator) + name)

                        if err == nil {

                                err = err1

                        }

                }

                if err1 == io.EOF {

                        break

                }

                // If Readdirnames returned an error, use it.

                if err == nil {

                        err = err1

                }

                if len(names) == 0 {

                        break

                }

        }

        // Close directory, because windows won't remove opened directory.

        fd.Close()

        // Remove directory.

        err1 := Remove(path)

        if err == nil {

                err = err1

        }

        return err

}