2008-09-11 14:03:46 -06:00
|
|
|
// 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 syscall "syscall"
|
|
|
|
|
2009-03-07 17:56:44 -07:00
|
|
|
// Error is a structure wrapping a string describing an error.
|
|
|
|
// Errors are singleton structures, created by NewError, so their addresses can
|
|
|
|
// be compared to test for equality. A nil Error pointer means ``no error''.
|
|
|
|
// Use the String() method to get the contents; it handles the nil case.
|
|
|
|
// The Error type is intended for use by any package that wishes to define
|
|
|
|
// error strings.
|
2009-01-20 15:40:40 -07:00
|
|
|
type Error struct {
|
2008-09-11 14:03:46 -06:00
|
|
|
s string
|
|
|
|
}
|
|
|
|
|
2009-01-07 17:37:43 -07:00
|
|
|
// Indexed by errno.
|
|
|
|
// If we worry about syscall speed (only relevant on failure), we could
|
|
|
|
// make it an array, but it's probably not important.
|
2009-01-16 12:36:44 -07:00
|
|
|
var errorTab = make(map[int64] *Error);
|
2008-09-11 14:03:46 -06:00
|
|
|
|
2009-01-07 17:37:43 -07:00
|
|
|
// Table of all known errors in system. Use the same error string twice,
|
|
|
|
// get the same *os.Error.
|
2009-01-16 12:36:44 -07:00
|
|
|
var errorStringTab = make(map[string] *Error);
|
2009-01-07 17:37:43 -07:00
|
|
|
|
|
|
|
// These functions contain a race if two goroutines add identical
|
|
|
|
// errors simultaneously but the consequences are unimportant.
|
|
|
|
|
2009-03-07 17:56:44 -07:00
|
|
|
// NewError allocates an Error object, but if s has been seen before,
|
|
|
|
// shares the Error associated with that message.
|
2009-01-20 15:40:40 -07:00
|
|
|
func NewError(s string) *Error {
|
2009-01-07 17:37:43 -07:00
|
|
|
if s == "" {
|
|
|
|
return nil
|
|
|
|
}
|
2009-01-16 12:36:44 -07:00
|
|
|
err, ok := errorStringTab[s];
|
2009-01-07 17:37:43 -07:00
|
|
|
if ok {
|
|
|
|
return err
|
|
|
|
}
|
2009-03-03 09:39:12 -07:00
|
|
|
err = &Error{s};
|
2009-01-16 12:36:44 -07:00
|
|
|
errorStringTab[s] = err;
|
2009-01-07 17:37:43 -07:00
|
|
|
return err;
|
2008-09-19 16:23:16 -06:00
|
|
|
}
|
|
|
|
|
2009-03-07 17:56:44 -07:00
|
|
|
// ErrnoToError calls NewError to create an Error object for the string
|
|
|
|
// associated with Unix error code errno.
|
2009-01-20 15:40:40 -07:00
|
|
|
func ErrnoToError(errno int64) *Error {
|
2008-09-11 14:03:46 -06:00
|
|
|
if errno == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2009-01-07 17:37:43 -07:00
|
|
|
// Quick lookup by errno.
|
2009-01-16 12:36:44 -07:00
|
|
|
err, ok := errorTab[errno];
|
2008-09-11 14:03:46 -06:00
|
|
|
if ok {
|
|
|
|
return err
|
|
|
|
}
|
2009-01-16 12:36:44 -07:00
|
|
|
err = NewError(syscall.Errstr(errno));
|
|
|
|
errorTab[errno] = err;
|
2009-01-07 17:37:43 -07:00
|
|
|
return err;
|
2008-09-11 14:03:46 -06:00
|
|
|
}
|
2009-01-07 17:37:43 -07:00
|
|
|
|
2009-03-07 17:56:44 -07:00
|
|
|
// Commonly known Unix errors.
|
2009-01-20 15:40:40 -07:00
|
|
|
var (
|
2008-09-11 14:03:46 -06:00
|
|
|
ENONE = ErrnoToError(syscall.ENONE);
|
|
|
|
EPERM = ErrnoToError(syscall.EPERM);
|
|
|
|
ENOENT = ErrnoToError(syscall.ENOENT);
|
|
|
|
ESRCH = ErrnoToError(syscall.ESRCH);
|
|
|
|
EINTR = ErrnoToError(syscall.EINTR);
|
|
|
|
EIO = ErrnoToError(syscall.EIO);
|
|
|
|
ENXIO = ErrnoToError(syscall.ENXIO);
|
|
|
|
E2BIG = ErrnoToError(syscall.E2BIG);
|
|
|
|
ENOEXEC = ErrnoToError(syscall.ENOEXEC);
|
|
|
|
EBADF = ErrnoToError(syscall.EBADF);
|
|
|
|
ECHILD = ErrnoToError(syscall.ECHILD);
|
|
|
|
EDEADLK = ErrnoToError(syscall.EDEADLK);
|
|
|
|
ENOMEM = ErrnoToError(syscall.ENOMEM);
|
|
|
|
EACCES = ErrnoToError(syscall.EACCES);
|
|
|
|
EFAULT = ErrnoToError(syscall.EFAULT);
|
|
|
|
ENOTBLK = ErrnoToError(syscall.ENOTBLK);
|
|
|
|
EBUSY = ErrnoToError(syscall.EBUSY);
|
|
|
|
EEXIST = ErrnoToError(syscall.EEXIST);
|
|
|
|
EXDEV = ErrnoToError(syscall.EXDEV);
|
|
|
|
ENODEV = ErrnoToError(syscall.ENODEV);
|
|
|
|
ENOTDIR = ErrnoToError(syscall.ENOTDIR);
|
|
|
|
EISDIR = ErrnoToError(syscall.EISDIR);
|
|
|
|
EINVAL = ErrnoToError(syscall.EINVAL);
|
|
|
|
ENFILE = ErrnoToError(syscall.ENFILE);
|
|
|
|
EMFILE = ErrnoToError(syscall.EMFILE);
|
|
|
|
ENOTTY = ErrnoToError(syscall.ENOTTY);
|
|
|
|
ETXTBSY = ErrnoToError(syscall.ETXTBSY);
|
|
|
|
EFBIG = ErrnoToError(syscall.EFBIG);
|
|
|
|
ENOSPC = ErrnoToError(syscall.ENOSPC);
|
|
|
|
ESPIPE = ErrnoToError(syscall.ESPIPE);
|
|
|
|
EROFS = ErrnoToError(syscall.EROFS);
|
|
|
|
EMLINK = ErrnoToError(syscall.EMLINK);
|
|
|
|
EPIPE = ErrnoToError(syscall.EPIPE);
|
|
|
|
EDOM = ErrnoToError(syscall.EDOM);
|
|
|
|
ERANGE = ErrnoToError(syscall.ERANGE);
|
|
|
|
EAGAIN = ErrnoToError(syscall.EAGAIN);
|
|
|
|
)
|
|
|
|
|
2009-03-07 17:56:44 -07:00
|
|
|
// String returns the string associated with the Error.
|
2008-09-11 14:03:46 -06:00
|
|
|
func (e *Error) String() string {
|
|
|
|
if e == nil {
|
2009-01-16 12:36:44 -07:00
|
|
|
return "No Error"
|
2008-09-11 14:03:46 -06:00
|
|
|
}
|
2008-09-11 16:48:42 -06:00
|
|
|
return e.s
|
2008-09-11 14:03:46 -06:00
|
|
|
}
|