OSDN Git Service

libgo: Update to weekly.2011-11-02.
authorian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Sat, 3 Dec 2011 02:17:34 +0000 (02:17 +0000)
committerian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Sat, 3 Dec 2011 02:17:34 +0000 (02:17 +0000)
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@181964 138bc75d-0d04-0410-961f-82ee72b054a4

499 files changed:
gcc/testsuite/go.test/test/chan/goroutines.go
gcc/testsuite/go.test/test/env.go
gcc/testsuite/go.test/test/fixedbugs/bug107.go
gcc/testsuite/go.test/test/fixedbugs/bug243.go
gcc/testsuite/go.test/test/fixedbugs/bug262.go
gcc/testsuite/go.test/test/fixedbugs/bug326.go
gcc/testsuite/go.test/test/fixedbugs/bug331.go
gcc/testsuite/go.test/test/fixedbugs/bug354.go
gcc/testsuite/go.test/test/func2.go
gcc/testsuite/go.test/test/import.go
gcc/testsuite/go.test/test/recover2.go
gcc/testsuite/go.test/test/recover3.go
libgo/MERGE
libgo/Makefile.am
libgo/Makefile.in
libgo/go/archive/tar/reader.go
libgo/go/archive/tar/reader_test.go
libgo/go/archive/tar/writer.go
libgo/go/archive/zip/reader.go
libgo/go/archive/zip/reader_test.go
libgo/go/archive/zip/struct.go
libgo/go/archive/zip/writer.go
libgo/go/archive/zip/zip_test.go
libgo/go/asn1/asn1.go
libgo/go/asn1/marshal.go
libgo/go/big/int.go
libgo/go/big/nat.go
libgo/go/big/nat_test.go
libgo/go/big/rat.go
libgo/go/bufio/bufio.go
libgo/go/bufio/bufio_test.go
libgo/go/bytes/buffer.go
libgo/go/bytes/buffer_test.go
libgo/go/compress/bzip2/bit_reader.go
libgo/go/compress/bzip2/bzip2.go
libgo/go/compress/bzip2/bzip2_test.go
libgo/go/compress/bzip2/huffman.go
libgo/go/compress/flate/deflate.go
libgo/go/compress/flate/deflate_test.go
libgo/go/compress/flate/huffman_bit_writer.go
libgo/go/compress/flate/inflate.go
libgo/go/compress/gzip/gunzip.go
libgo/go/compress/gzip/gunzip_test.go
libgo/go/compress/gzip/gzip.go
libgo/go/compress/lzw/reader.go
libgo/go/compress/lzw/reader_test.go
libgo/go/compress/lzw/writer.go
libgo/go/compress/lzw/writer_test.go
libgo/go/compress/zlib/reader.go
libgo/go/compress/zlib/reader_test.go
libgo/go/compress/zlib/writer.go
libgo/go/crypto/aes/cipher.go
libgo/go/crypto/bcrypt/base64.go
libgo/go/crypto/bcrypt/bcrypt.go
libgo/go/crypto/bcrypt/bcrypt_test.go
libgo/go/crypto/blowfish/cipher.go
libgo/go/crypto/cast5/cast5.go
libgo/go/crypto/cipher/io.go
libgo/go/crypto/des/cipher.go
libgo/go/crypto/dsa/dsa.go
libgo/go/crypto/ecdsa/ecdsa.go
libgo/go/crypto/elliptic/elliptic.go
libgo/go/crypto/hmac/hmac.go
libgo/go/crypto/md4/md4.go
libgo/go/crypto/md5/md5.go
libgo/go/crypto/ocsp/ocsp.go
libgo/go/crypto/openpgp/armor/armor.go
libgo/go/crypto/openpgp/armor/encode.go
libgo/go/crypto/openpgp/canonical_text.go
libgo/go/crypto/openpgp/canonical_text_test.go
libgo/go/crypto/openpgp/elgamal/elgamal.go
libgo/go/crypto/openpgp/error/error.go
libgo/go/crypto/openpgp/keys.go
libgo/go/crypto/openpgp/packet/compressed.go
libgo/go/crypto/openpgp/packet/compressed_test.go
libgo/go/crypto/openpgp/packet/encrypted_key.go
libgo/go/crypto/openpgp/packet/literal.go
libgo/go/crypto/openpgp/packet/one_pass_signature.go
libgo/go/crypto/openpgp/packet/packet.go
libgo/go/crypto/openpgp/packet/packet_test.go
libgo/go/crypto/openpgp/packet/private_key.go
libgo/go/crypto/openpgp/packet/public_key.go
libgo/go/crypto/openpgp/packet/reader.go
libgo/go/crypto/openpgp/packet/signature.go
libgo/go/crypto/openpgp/packet/symmetric_key_encrypted.go
libgo/go/crypto/openpgp/packet/symmetric_key_encrypted_test.go
libgo/go/crypto/openpgp/packet/symmetrically_encrypted.go
libgo/go/crypto/openpgp/packet/symmetrically_encrypted_test.go
libgo/go/crypto/openpgp/packet/userid.go
libgo/go/crypto/openpgp/read.go
libgo/go/crypto/openpgp/read_test.go
libgo/go/crypto/openpgp/s2k/s2k.go
libgo/go/crypto/openpgp/write.go
libgo/go/crypto/openpgp/write_test.go
libgo/go/crypto/rand/rand.go
libgo/go/crypto/rand/rand_unix.go
libgo/go/crypto/rand/rand_windows.go
libgo/go/crypto/rand/util.go
libgo/go/crypto/rc4/rc4.go
libgo/go/crypto/ripemd160/ripemd160.go
libgo/go/crypto/rsa/pkcs1v15.go
libgo/go/crypto/rsa/rsa.go
libgo/go/crypto/sha1/sha1.go
libgo/go/crypto/sha256/sha256.go
libgo/go/crypto/sha512/sha512.go
libgo/go/crypto/tls/cipher_suites.go
libgo/go/crypto/tls/conn.go
libgo/go/crypto/tls/handshake_client.go
libgo/go/crypto/tls/handshake_server.go
libgo/go/crypto/tls/handshake_server_test.go
libgo/go/crypto/tls/key_agreement.go
libgo/go/crypto/tls/prf.go
libgo/go/crypto/tls/tls.go
libgo/go/crypto/twofish/twofish.go
libgo/go/crypto/x509/pkcs1.go
libgo/go/crypto/x509/verify.go
libgo/go/crypto/x509/verify_test.go
libgo/go/crypto/x509/x509.go
libgo/go/crypto/xtea/cipher.go
libgo/go/csv/reader.go
libgo/go/csv/reader_test.go
libgo/go/csv/writer.go
libgo/go/debug/dwarf/buf.go
libgo/go/debug/dwarf/entry.go
libgo/go/debug/dwarf/open.go
libgo/go/debug/dwarf/type.go
libgo/go/debug/dwarf/unit.go
libgo/go/debug/elf/file.go
libgo/go/debug/gosym/symtab.go
libgo/go/debug/macho/file.go
libgo/go/debug/pe/file.go
libgo/go/encoding/ascii85/ascii85.go
libgo/go/encoding/ascii85/ascii85_test.go
libgo/go/encoding/base32/base32.go
libgo/go/encoding/base32/base32_test.go
libgo/go/encoding/base64/base64.go
libgo/go/encoding/base64/base64_test.go
libgo/go/encoding/binary/binary.go
libgo/go/encoding/binary/binary_test.go
libgo/go/encoding/binary/varint.go
libgo/go/encoding/binary/varint_test.go
libgo/go/encoding/git85/git.go
libgo/go/encoding/git85/git_test.go
libgo/go/encoding/hex/hex.go
libgo/go/encoding/pem/pem.go
libgo/go/errors/errors.go [new file with mode: 0644]
libgo/go/errors/errors_test.go [new file with mode: 0644]
libgo/go/exec/exec.go
libgo/go/exec/exec_test.go
libgo/go/exec/lp_plan9.go
libgo/go/exec/lp_unix.go
libgo/go/exec/lp_windows.go
libgo/go/exp/ebnf/ebnf.go
libgo/go/exp/ebnf/parser.go
libgo/go/exp/ebnflint/ebnflint.go
libgo/go/exp/gotype/gotype.go
libgo/go/exp/gui/gui.go
libgo/go/exp/gui/x11/auth.go
libgo/go/exp/gui/x11/conn.go
libgo/go/exp/inotify/inotify_linux.go
libgo/go/exp/norm/maketables.go
libgo/go/exp/norm/normregtest.go
libgo/go/exp/norm/readwriter.go
libgo/go/exp/norm/readwriter_test.go
libgo/go/exp/spdy/read.go
libgo/go/exp/spdy/types.go
libgo/go/exp/spdy/write.go
libgo/go/exp/sql/convert.go
libgo/go/exp/sql/convert_test.go
libgo/go/exp/sql/driver/driver.go
libgo/go/exp/sql/driver/types.go
libgo/go/exp/sql/fakedb_test.go
libgo/go/exp/sql/sql.go
libgo/go/exp/sql/sql_test.go
libgo/go/exp/ssh/channel.go
libgo/go/exp/ssh/client.go
libgo/go/exp/ssh/common.go
libgo/go/exp/ssh/messages.go
libgo/go/exp/ssh/server.go
libgo/go/exp/ssh/server_shell.go
libgo/go/exp/ssh/server_shell_test.go
libgo/go/exp/ssh/session.go
libgo/go/exp/ssh/transport.go
libgo/go/exp/template/html/error.go
libgo/go/exp/template/html/escape.go
libgo/go/exp/template/html/escape_test.go
libgo/go/exp/template/html/js.go
libgo/go/exp/terminal/shell.go
libgo/go/exp/terminal/shell_test.go
libgo/go/exp/terminal/terminal.go
libgo/go/exp/types/check.go
libgo/go/exp/types/check_test.go
libgo/go/exp/types/exportdata.go
libgo/go/exp/types/gcimporter.go
libgo/go/exp/types/universe.go
libgo/go/exp/winfsnotify/winfsnotify.go
libgo/go/flag/flag.go
libgo/go/fmt/print.go
libgo/go/fmt/scan.go
libgo/go/fmt/scan_test.go
libgo/go/go/ast/print.go
libgo/go/go/ast/resolve.go
libgo/go/go/build/build.go
libgo/go/go/build/dir.go
libgo/go/go/build/path.go
libgo/go/go/parser/interface.go
libgo/go/go/printer/printer.go
libgo/go/go/scanner/errors.go
libgo/go/go/token/serialize.go
libgo/go/go/token/serialize_test.go
libgo/go/gob/codec_test.go
libgo/go/gob/decode.go
libgo/go/gob/decoder.go
libgo/go/gob/encode.go
libgo/go/gob/encoder.go
libgo/go/gob/encoder_test.go
libgo/go/gob/error.go
libgo/go/gob/gobencdec_test.go
libgo/go/gob/timing_test.go
libgo/go/gob/type.go
libgo/go/gob/type_test.go
libgo/go/hash/adler32/adler32.go
libgo/go/hash/crc32/crc32.go
libgo/go/hash/crc64/crc64.go
libgo/go/hash/fnv/fnv.go
libgo/go/html/escape.go
libgo/go/html/parse.go
libgo/go/html/parse_test.go
libgo/go/html/render.go
libgo/go/html/token.go
libgo/go/html/token_test.go
libgo/go/http/cgi/child.go
libgo/go/http/cgi/host.go
libgo/go/http/cgi/host_test.go
libgo/go/http/chunked.go
libgo/go/http/client.go
libgo/go/http/client_test.go
libgo/go/http/cookie_test.go
libgo/go/http/dump.go
libgo/go/http/fcgi/child.go
libgo/go/http/fcgi/fcgi.go
libgo/go/http/fcgi/fcgi_test.go
libgo/go/http/filetransport.go
libgo/go/http/filetransport_test.go
libgo/go/http/fs.go
libgo/go/http/fs_test.go
libgo/go/http/header.go
libgo/go/http/httptest/recorder.go
libgo/go/http/httptest/server.go
libgo/go/http/persist.go
libgo/go/http/pprof/pprof.go
libgo/go/http/readrequest_test.go
libgo/go/http/request.go
libgo/go/http/request_test.go
libgo/go/http/requestwrite_test.go
libgo/go/http/response.go
libgo/go/http/response_test.go
libgo/go/http/reverseproxy.go
libgo/go/http/serve_test.go
libgo/go/http/server.go
libgo/go/http/transfer.go
libgo/go/http/transport.go
libgo/go/http/transport_test.go
libgo/go/http/transport_windows.go
libgo/go/image/bmp/reader.go
libgo/go/image/decode_test.go
libgo/go/image/format.go
libgo/go/image/gif/reader.go
libgo/go/image/jpeg/huffman.go
libgo/go/image/jpeg/reader.go
libgo/go/image/jpeg/writer.go
libgo/go/image/jpeg/writer_test.go
libgo/go/image/png/reader.go
libgo/go/image/png/reader_test.go
libgo/go/image/png/writer.go
libgo/go/image/png/writer_test.go
libgo/go/image/tiff/buffer.go
libgo/go/image/tiff/buffer_test.go
libgo/go/image/tiff/compress.go
libgo/go/image/tiff/reader.go
libgo/go/image/tiff/reader_test.go
libgo/go/index/suffixarray/suffixarray.go
libgo/go/io/io.go
libgo/go/io/io_test.go
libgo/go/io/ioutil/ioutil.go
libgo/go/io/ioutil/tempfile.go
libgo/go/io/multi.go
libgo/go/io/multi_test.go
libgo/go/io/pipe.go
libgo/go/io/pipe_test.go
libgo/go/json/decode.go
libgo/go/json/decode_test.go
libgo/go/json/encode.go
libgo/go/json/indent.go
libgo/go/json/scanner.go
libgo/go/json/scanner_test.go
libgo/go/json/stream.go
libgo/go/log/log.go
libgo/go/mail/message.go
libgo/go/mime/mediatype.go
libgo/go/mime/mediatype_test.go
libgo/go/mime/multipart/formdata.go
libgo/go/mime/multipart/multipart.go
libgo/go/mime/multipart/multipart_test.go
libgo/go/mime/multipart/writer.go
libgo/go/mime/type.go
libgo/go/net/cgo_stub.go
libgo/go/net/cgo_unix.go
libgo/go/net/dial.go
libgo/go/net/dict/dict.go
libgo/go/net/dnsclient.go
libgo/go/net/dnsclient_unix.go
libgo/go/net/dnsconfig.go
libgo/go/net/fd.go
libgo/go/net/fd_linux.go
libgo/go/net/fd_openbsd.go
libgo/go/net/fd_windows.go
libgo/go/net/file.go
libgo/go/net/file_plan9.go
libgo/go/net/file_test.go
libgo/go/net/file_windows.go
libgo/go/net/interface.go
libgo/go/net/interface_bsd.go
libgo/go/net/interface_darwin.go
libgo/go/net/interface_freebsd.go
libgo/go/net/interface_linux.go
libgo/go/net/interface_openbsd.go
libgo/go/net/interface_stub.go
libgo/go/net/interface_test.go
libgo/go/net/interface_windows.go
libgo/go/net/ip.go
libgo/go/net/ip_test.go
libgo/go/net/ipraw_test.go
libgo/go/net/iprawsock.go
libgo/go/net/iprawsock_plan9.go
libgo/go/net/iprawsock_posix.go
libgo/go/net/ipsock.go
libgo/go/net/ipsock_plan9.go
libgo/go/net/ipsock_posix.go
libgo/go/net/lookup_plan9.go
libgo/go/net/lookup_unix.go
libgo/go/net/lookup_windows.go
libgo/go/net/net.go
libgo/go/net/net_test.go
libgo/go/net/newpollserver.go
libgo/go/net/parse.go
libgo/go/net/pipe.go
libgo/go/net/pipe_test.go
libgo/go/net/port.go
libgo/go/net/sendfile_linux.go
libgo/go/net/sendfile_stub.go
libgo/go/net/sendfile_windows.go
libgo/go/net/server_test.go
libgo/go/net/sock.go
libgo/go/net/tcpsock.go
libgo/go/net/tcpsock_plan9.go
libgo/go/net/tcpsock_posix.go
libgo/go/net/textproto/reader.go
libgo/go/net/textproto/reader_test.go
libgo/go/net/textproto/textproto.go
libgo/go/net/textproto/writer.go
libgo/go/net/timeout_test.go
libgo/go/net/udpsock.go
libgo/go/net/udpsock_plan9.go
libgo/go/net/udpsock_posix.go
libgo/go/net/unixsock.go
libgo/go/net/unixsock_plan9.go
libgo/go/net/unixsock_posix.go
libgo/go/old/netchan/common.go
libgo/go/old/netchan/export.go
libgo/go/old/netchan/import.go
libgo/go/old/netchan/netchan_test.go
libgo/go/old/regexp/all_test.go
libgo/go/old/regexp/regexp.go
libgo/go/old/template/parse.go
libgo/go/old/template/template_test.go
libgo/go/os/dir.go
libgo/go/os/dir_plan9.go
libgo/go/os/dir_unix.go
libgo/go/os/env_plan9.go
libgo/go/os/env_unix.go
libgo/go/os/env_windows.go
libgo/go/os/error.go
libgo/go/os/error_plan9.go
libgo/go/os/error_posix.go
libgo/go/os/exec_plan9.go
libgo/go/os/exec_posix.go
libgo/go/os/exec_unix.go
libgo/go/os/exec_windows.go
libgo/go/os/file.go
libgo/go/os/file_plan9.go
libgo/go/os/file_posix.go
libgo/go/os/file_unix.go
libgo/go/os/getwd.go
libgo/go/os/os_test.go
libgo/go/os/path.go
libgo/go/os/path_test.go
libgo/go/os/proc.go
libgo/go/os/stat_plan9.go
libgo/go/os/sys_bsd.go
libgo/go/os/sys_linux.go
libgo/go/os/sys_plan9.go
libgo/go/os/time.go
libgo/go/os/user/lookup_stubs.go
libgo/go/os/user/lookup_unix.go
libgo/go/os/user/user.go
libgo/go/patch/apply.go
libgo/go/patch/git.go
libgo/go/patch/patch.go
libgo/go/patch/textdiff.go
libgo/go/path/filepath/match.go
libgo/go/path/filepath/match_test.go
libgo/go/path/filepath/path.go
libgo/go/path/filepath/path_test.go
libgo/go/path/match.go
libgo/go/path/match_test.go
libgo/go/rand/rand_test.go
libgo/go/reflect/all_test.go
libgo/go/reflect/value.go
libgo/go/regexp/all_test.go
libgo/go/regexp/exec_test.go
libgo/go/regexp/regexp.go
libgo/go/regexp/syntax/compile.go
libgo/go/regexp/syntax/parse.go
libgo/go/rpc/client.go
libgo/go/rpc/debug.go
libgo/go/rpc/jsonrpc/all_test.go
libgo/go/rpc/jsonrpc/client.go
libgo/go/rpc/jsonrpc/server.go
libgo/go/rpc/server.go
libgo/go/rpc/server_test.go
libgo/go/runtime/error.go
libgo/go/runtime/pprof/pprof.go
libgo/go/scanner/scanner.go
libgo/go/scanner/scanner_test.go
libgo/go/smtp/auth.go
libgo/go/smtp/smtp.go
libgo/go/smtp/smtp_test.go
libgo/go/strconv/atob.go
libgo/go/strconv/atob_test.go
libgo/go/strconv/atof.go
libgo/go/strconv/atof_test.go
libgo/go/strconv/atoi.go
libgo/go/strconv/atoi_test.go
libgo/go/strconv/fp_test.go
libgo/go/strconv/quote.go
libgo/go/strings/reader.go
libgo/go/strings/replace.go
libgo/go/strings/strings_test.go
libgo/go/syslog/syslog.go
libgo/go/syslog/syslog_unix.go
libgo/go/tabwriter/tabwriter.go
libgo/go/tabwriter/tabwriter_test.go
libgo/go/template/doc.go
libgo/go/template/exec.go
libgo/go/template/exec_test.go
libgo/go/template/funcs.go
libgo/go/template/helper.go
libgo/go/template/parse.go
libgo/go/template/parse/node.go
libgo/go/template/parse/parse.go
libgo/go/template/parse/set.go
libgo/go/template/set.go
libgo/go/testing/benchmark.go
libgo/go/testing/example.go
libgo/go/testing/iotest/logger.go
libgo/go/testing/iotest/reader.go
libgo/go/testing/iotest/writer.go
libgo/go/testing/quick/quick.go
libgo/go/testing/quick/quick_test.go
libgo/go/testing/script/script.go
libgo/go/testing/testing.go
libgo/go/time/format.go
libgo/go/time/sleep_test.go
libgo/go/time/sys.go
libgo/go/time/sys_plan9.go
libgo/go/time/sys_unix.go
libgo/go/time/sys_windows.go
libgo/go/time/tick.go
libgo/go/time/time_test.go
libgo/go/time/zoneinfo_windows.go
libgo/go/url/url.go
libgo/go/url/url_test.go
libgo/go/utf8/string.go
libgo/go/websocket/client.go
libgo/go/websocket/hixie.go
libgo/go/websocket/hixie_test.go
libgo/go/websocket/hybi.go
libgo/go/websocket/hybi_test.go
libgo/go/websocket/server.go
libgo/go/websocket/websocket.go
libgo/go/websocket/websocket_test.go
libgo/go/xml/marshal.go
libgo/go/xml/marshal_test.go
libgo/go/xml/read.go
libgo/go/xml/xml.go
libgo/go/xml/xml_test.go
libgo/merge.sh
libgo/testsuite/gotest

index d8f8803..371a173 100644 (file)
@@ -21,7 +21,7 @@ func f(left, right chan int) {
 func main() {
        var n = 10000
        if len(os.Args) > 1 {
-               var err os.Error
+               var err error
                n, err = strconv.Atoi(os.Args[1])
                if err != nil {
                        print("bad arg\n")
index 28113bc..a4b9d05 100644 (file)
@@ -14,7 +14,7 @@ import (
 func main() {
        ga, e0 := os.Getenverror("GOARCH")
        if e0 != nil {
-               print("$GOARCH: ", e0.String(), "\n")
+               print("$GOARCH: ", e0.Error(), "\n")
                os.Exit(1)
        }
        if ga != runtime.GOARCH {
@@ -23,7 +23,7 @@ func main() {
        }
        xxx, e1 := os.Getenverror("DOES_NOT_EXIST")
        if e1 != os.ENOENV {
-               print("$DOES_NOT_EXIST=", xxx, "; err = ", e1.String(), "\n")
+               print("$DOES_NOT_EXIST=", xxx, "; err = ", e1.Error(), "\n")
                os.Exit(1)
        }
 }
index d0b062a..0554bbc 100644 (file)
@@ -6,7 +6,7 @@
 
 package main
 import os "os"
-type _ os.Error
+type _ os.FileInfo
 func f() (os int) {
         // In the next line "os" should refer to the result variable, not
         // to the package.
index 95514cf..e3ddf0e 100644 (file)
@@ -6,7 +6,7 @@
 
 package main
 
-import "os"
+import "errors"
 
 // Issue 481: closures and var declarations
 // with multiple variables assigned from one
@@ -22,7 +22,7 @@ func main() {
                }
        }()
 
-       var conn, _ = Dial("tcp", "", listen.Addr().String())
+       var conn, _ = Dial("tcp", "", listen.Addr().Error())
        _ = conn
 }
 
@@ -37,8 +37,8 @@ func Listen(x, y string) (T, string) {
        return global, y
 }
 
-func (t T) Addr() os.Error {
-       return os.NewError("stringer")
+func (t T) Addr() error {
+       return errors.New("stringer")
 }
 
 func (t T) Accept() (int, string) {
index 66f580b..f5f2c35 100644 (file)
@@ -18,9 +18,9 @@ func f() string {
        return "abc"
 }
 
-func g() *os.Error {
+func g() *error {
        trace += "g"
-       var x os.Error
+       var x error
        return &x
 }
 
@@ -35,7 +35,6 @@ func i() *int {
        return &i
 }
 
-
 func main() {
        m := make(map[string]int)
        m[f()], *g() = strconv.Atoi(h())
@@ -43,7 +42,7 @@ func main() {
                println("BUG", m["abc"], trace)
                panic("fail")
        }
-       mm := make(map[string]os.Error)
+       mm := make(map[string]error)
        trace = ""
        mm["abc"] = os.EINVAL
        *i(), mm[f()] = strconv.Atoi(h())
index efdd0ef..7e123e3 100644 (file)
@@ -6,36 +6,34 @@
 
 package p
 
-import "os"
-
-func f() (_ int, err os.Error) {
+func f() (_ int, err error) {
        return
 }
 
-func g() (x int, _ os.Error) {
+func g() (x int, _ error) {
        return
 }
 
-func h() (_ int, _ os.Error) {
+func h() (_ int, _ error) {
        return
 }
 
-func i() (int, os.Error) {
-       return  // ERROR "not enough arguments to return"
+func i() (int, error) {
+       return // ERROR "not enough arguments to return"
 }
 
-func f1() (_ int, err os.Error) {
+func f1() (_ int, err error) {
        return 1, nil
 }
 
-func g1() (x int, _ os.Error) {
+func g1() (x int, _ error) {
        return 1, nil
 }
 
-func h1() (_ int, _ os.Error) {
+func h1() (_ int, _ error) {
        return 1, nil
 }
 
-func ii() (int, os.Error) {
+func ii() (int, error) {
        return 1, nil
 }
index 28aee1d..6c5acd1 100644 (file)
@@ -6,22 +6,22 @@
 
 package main
 
-import "os"
+import "io"
 
-func f() (_ string, x float64, err os.Error) {
+func f() (_ string, x float64, err error) {
        return
 }
 
-func g() (_ string, x float64, err os.Error) {
-       return "hello", 3.14, os.EOF
+func g() (_ string, x float64, err error) {
+       return "hello", 3.14, io.EOF
 }
 
-var _ func() (string, float64, os.Error) = f
-var _ func() (string, float64, os.Error) = g
+var _ func() (string, float64, error) = f
+var _ func() (string, float64, error) = g
 
 func main() {
        x, y, z := g()
-       if x != "hello" || y != 3.14 || z != os.EOF {
+       if x != "hello" || y != 3.14 || z != io.EOF {
                println("wrong", x, len(x), y, z)
        }
 }
index 1f6a6dc..a95256e 100644 (file)
@@ -9,12 +9,8 @@
 
 package main
 
-import (
-       "os"
-)
-
 type Inner struct {
-       F func() os.Error
+       F func() error
 }
 
 type Outer struct {
@@ -23,4 +19,4 @@ type Outer struct {
 
 // calls makeclosure twice on same closure
 
-var Foo = Outer{[]Inner{Inner{func() os.Error{ return nil }}}}
+var Foo = Outer{[]Inner{Inner{func() error { return nil }}}}
index 5a6d7d0..87e7819 100644 (file)
@@ -5,7 +5,6 @@
 // license that can be found in the LICENSE file.
 
 package main
-import os "os"
 
 type t1 int
 type t2 int
@@ -23,7 +22,7 @@ func f8(os int) int
 func f9(os int) int {
        return os
 }
-func f10(err os.Error) os.Error {
+func f10(err error) error {
        return err
 }
 func f11(t1 string) string {
index 9633034..bd83dc3 100644 (file)
@@ -13,13 +13,12 @@ import _os_ "os"
 import "os"
 import . "os"
 
-func f(e os.Error)
+func f(e *os.File)
 
 func main() {
-       var _e_ _os_.Error
-       var dot Error
+       var _e_ *_os_.File
+       var dot *File
 
        f(_e_)
        f(dot)
 }
-
index 9affe25..ccaf8ce 100644 (file)
 
 package main
 
-import (
-       "os"
-       "strings"
-)
+import "strings"
 
 var x = make([]byte, 10)
 
@@ -33,7 +30,7 @@ func mustRecover(s string) {
        if v == nil {
                panic("expected panic")
        }
-       if e := v.(os.Error).String(); strings.Index(e, s) < 0 {
+       if e := v.(error).Error(); strings.Index(e, s) < 0 {
                panic("want: " + s + "; have: " + e)
        }
 }
index 2aa1df6..60ade9b 100644 (file)
@@ -35,7 +35,7 @@ func check(name string, f func(), err string) {
                        println(name, "panicked but not with runtime.Error")
                        return
                }
-               s := runt.String()
+               s := runt.Error()
                if strings.Index(s, err) < 0 {
                        bug()
                        println(name, "panicked with", s, "not", err)
index 2a86f2f..f55d80b 100644 (file)
@@ -1,4 +1,4 @@
-941b8015061a
+780c85032b17
 
 The first line of this file holds the Mercurial revision number of the
 last merge done from the master library sources.
index 338f677..9a4588e 100644 (file)
@@ -107,6 +107,7 @@ toolexeclibgo_DATA = \
        cmath.gox \
        crypto.gox \
        csv.gox \
+       errors.gox \
        exec.gox \
        expvar.gox \
        flag.gox \
@@ -563,6 +564,9 @@ go_csv_files = \
        go/csv/reader.go \
        go/csv/writer.go
 
+go_errors_files = \
+       go/errors/errors.go
+
 go_exec_files = \
        go/exec/exec.go \
        go/exec/lp_unix.go
@@ -1623,6 +1627,7 @@ libgo_go_objs = \
        cmath/cmath.lo \
        crypto/crypto.lo \
        csv/csv.lo \
+       errors/errors.lo \
        exec/exec.lo \
        expvar/expvar.lo \
        flag/flag.lo \
@@ -1944,6 +1949,15 @@ csv/check: $(CHECK_DEPS)
        @$(CHECK)
 .PHONY: csv/check
 
+@go_include@ errors/errors.lo.dep
+errors/errors.lo.dep: $(go_errors_files)
+       $(BUILDDEPS)
+errors/errors.lo: $(go_errors_files)
+       $(BUILDPACKAGE)
+errors/check: $(CHECK_DEPS)
+       @$(CHECK)
+.PHONY: errors/check
+
 @go_include@ exec/exec.lo.dep
 exec/exec.lo.dep: $(go_exec_files)
        $(BUILDDEPS)
@@ -3445,6 +3459,8 @@ crypto.gox: crypto/crypto.lo
        $(BUILDGOX)
 csv.gox: csv/csv.lo
        $(BUILDGOX)
+errors.gox: errors/errors.lo
+       $(BUILDGOX)
 exec.gox: exec/exec.lo
        $(BUILDGOX)
 expvar.gox: expvar/expvar.lo
@@ -3791,6 +3807,7 @@ TEST_PACKAGES = \
        bytes/check \
        cmath/check \
        csv/check \
+       errors/check \
        exec/check \
        expvar/check \
        flag/check \
index f88e69e..4cb4b5f 100644 (file)
@@ -132,46 +132,46 @@ LTLIBRARIES = $(toolexeclib_LTLIBRARIES)
 am__DEPENDENCIES_1 =
 am__DEPENDENCIES_2 = asn1/asn1.lo big/big.lo bufio/bufio.lo \
        bytes/bytes.lo bytes/index.lo cmath/cmath.lo crypto/crypto.lo \
-       csv/csv.lo exec/exec.lo expvar/expvar.lo flag/flag.lo \
-       fmt/fmt.lo gob/gob.lo hash/hash.lo html/html.lo http/http.lo \
-       image/image.lo io/io.lo json/json.lo log/log.lo math/math.lo \
-       mail/mail.lo mime/mime.lo net/net.lo os/os.lo patch/patch.lo \
-       path/path.lo rand/rand.lo reflect/reflect.lo regexp/regexp.lo \
-       rpc/rpc.lo runtime/runtime.lo scanner/scanner.lo smtp/smtp.lo \
-       sort/sort.lo strconv/strconv.lo strings/strings.lo \
-       sync/sync.lo syslog/syslog.lo syslog/syslog_c.lo \
-       tabwriter/tabwriter.lo template/template.lo time/time.lo \
-       unicode/unicode.lo url/url.lo utf16/utf16.lo utf8/utf8.lo \
-       websocket/websocket.lo xml/xml.lo archive/tar.lo \
-       archive/zip.lo compress/bzip2.lo compress/flate.lo \
-       compress/gzip.lo compress/lzw.lo compress/zlib.lo \
-       container/heap.lo container/list.lo container/ring.lo \
-       crypto/aes.lo crypto/bcrypt.lo crypto/blowfish.lo \
-       crypto/cast5.lo crypto/cipher.lo crypto/des.lo crypto/dsa.lo \
-       crypto/ecdsa.lo crypto/elliptic.lo crypto/hmac.lo \
-       crypto/md4.lo crypto/md5.lo crypto/ocsp.lo crypto/openpgp.lo \
-       crypto/rand.lo crypto/rc4.lo crypto/ripemd160.lo crypto/rsa.lo \
-       crypto/sha1.lo crypto/sha256.lo crypto/sha512.lo \
-       crypto/subtle.lo crypto/tls.lo crypto/twofish.lo \
-       crypto/x509.lo crypto/xtea.lo crypto/openpgp/armor.lo \
-       crypto/openpgp/elgamal.lo crypto/openpgp/error.lo \
-       crypto/openpgp/packet.lo crypto/openpgp/s2k.lo \
-       crypto/x509/pkix.lo debug/dwarf.lo debug/elf.lo debug/gosym.lo \
-       debug/macho.lo debug/pe.lo encoding/ascii85.lo \
-       encoding/base32.lo encoding/base64.lo encoding/binary.lo \
-       encoding/git85.lo encoding/hex.lo encoding/pem.lo exp/ebnf.lo \
-       exp/gui.lo exp/norm.lo exp/spdy.lo exp/sql.lo exp/ssh.lo \
-       exp/terminal.lo exp/types.lo exp/gui/x11.lo exp/sql/driver.lo \
-       exp/template/html.lo go/ast.lo go/build.lo go/doc.lo \
-       go/parser.lo go/printer.lo go/scanner.lo go/token.lo \
-       hash/adler32.lo hash/crc32.lo hash/crc64.lo hash/fnv.lo \
-       http/cgi.lo http/fcgi.lo http/httptest.lo http/pprof.lo \
-       image/bmp.lo image/color.lo image/draw.lo image/gif.lo \
-       image/jpeg.lo image/png.lo image/tiff.lo image/ycbcr.lo \
-       index/suffixarray.lo io/ioutil.lo mime/multipart.lo \
-       net/dict.lo net/textproto.lo old/netchan.lo old/regexp.lo \
-       old/template.lo $(am__DEPENDENCIES_1) os/user.lo os/signal.lo \
-       path/filepath.lo regexp/syntax.lo rpc/jsonrpc.lo \
+       csv/csv.lo errors/errors.lo exec/exec.lo expvar/expvar.lo \
+       flag/flag.lo fmt/fmt.lo gob/gob.lo hash/hash.lo html/html.lo \
+       http/http.lo image/image.lo io/io.lo json/json.lo log/log.lo \
+       math/math.lo mail/mail.lo mime/mime.lo net/net.lo os/os.lo \
+       patch/patch.lo path/path.lo rand/rand.lo reflect/reflect.lo \
+       regexp/regexp.lo rpc/rpc.lo runtime/runtime.lo \
+       scanner/scanner.lo smtp/smtp.lo sort/sort.lo \
+       strconv/strconv.lo strings/strings.lo sync/sync.lo \
+       syslog/syslog.lo syslog/syslog_c.lo tabwriter/tabwriter.lo \
+       template/template.lo time/time.lo unicode/unicode.lo \
+       url/url.lo utf16/utf16.lo utf8/utf8.lo websocket/websocket.lo \
+       xml/xml.lo archive/tar.lo archive/zip.lo compress/bzip2.lo \
+       compress/flate.lo compress/gzip.lo compress/lzw.lo \
+       compress/zlib.lo container/heap.lo container/list.lo \
+       container/ring.lo crypto/aes.lo crypto/bcrypt.lo \
+       crypto/blowfish.lo crypto/cast5.lo crypto/cipher.lo \
+       crypto/des.lo crypto/dsa.lo crypto/ecdsa.lo crypto/elliptic.lo \
+       crypto/hmac.lo crypto/md4.lo crypto/md5.lo crypto/ocsp.lo \
+       crypto/openpgp.lo crypto/rand.lo crypto/rc4.lo \
+       crypto/ripemd160.lo crypto/rsa.lo crypto/sha1.lo \
+       crypto/sha256.lo crypto/sha512.lo crypto/subtle.lo \
+       crypto/tls.lo crypto/twofish.lo crypto/x509.lo crypto/xtea.lo \
+       crypto/openpgp/armor.lo crypto/openpgp/elgamal.lo \
+       crypto/openpgp/error.lo crypto/openpgp/packet.lo \
+       crypto/openpgp/s2k.lo crypto/x509/pkix.lo debug/dwarf.lo \
+       debug/elf.lo debug/gosym.lo debug/macho.lo debug/pe.lo \
+       encoding/ascii85.lo encoding/base32.lo encoding/base64.lo \
+       encoding/binary.lo encoding/git85.lo encoding/hex.lo \
+       encoding/pem.lo exp/ebnf.lo exp/gui.lo exp/norm.lo exp/spdy.lo \
+       exp/sql.lo exp/ssh.lo exp/terminal.lo exp/types.lo \
+       exp/gui/x11.lo exp/sql/driver.lo exp/template/html.lo \
+       go/ast.lo go/build.lo go/doc.lo go/parser.lo go/printer.lo \
+       go/scanner.lo go/token.lo hash/adler32.lo hash/crc32.lo \
+       hash/crc64.lo hash/fnv.lo http/cgi.lo http/fcgi.lo \
+       http/httptest.lo http/pprof.lo image/bmp.lo image/color.lo \
+       image/draw.lo image/gif.lo image/jpeg.lo image/png.lo \
+       image/tiff.lo image/ycbcr.lo index/suffixarray.lo io/ioutil.lo \
+       mime/multipart.lo net/dict.lo net/textproto.lo old/netchan.lo \
+       old/regexp.lo old/template.lo $(am__DEPENDENCIES_1) os/user.lo \
+       os/signal.lo path/filepath.lo regexp/syntax.lo rpc/jsonrpc.lo \
        runtime/debug.lo runtime/pprof.lo sync/atomic.lo \
        sync/atomic_c.lo syscall/syscall.lo syscall/errno.lo \
        syscall/wait.lo template/parse.lo testing/testing.lo \
@@ -568,6 +568,7 @@ toolexeclibgo_DATA = \
        cmath.gox \
        crypto.gox \
        csv.gox \
+       errors.gox \
        exec.gox \
        expvar.gox \
        flag.gox \
@@ -947,6 +948,9 @@ go_csv_files = \
        go/csv/reader.go \
        go/csv/writer.go
 
+go_errors_files = \
+       go/errors/errors.go
+
 go_exec_files = \
        go/exec/exec.go \
        go/exec/lp_unix.go
@@ -1900,6 +1904,7 @@ libgo_go_objs = \
        cmath/cmath.lo \
        crypto/crypto.lo \
        csv/csv.lo \
+       errors/errors.lo \
        exec/exec.lo \
        expvar/expvar.lo \
        flag/flag.lo \
@@ -2167,6 +2172,7 @@ TEST_PACKAGES = \
        bytes/check \
        cmath/check \
        csv/check \
+       errors/check \
        exec/check \
        expvar/check \
        flag/check \
@@ -4434,6 +4440,15 @@ csv/check: $(CHECK_DEPS)
        @$(CHECK)
 .PHONY: csv/check
 
+@go_include@ errors/errors.lo.dep
+errors/errors.lo.dep: $(go_errors_files)
+       $(BUILDDEPS)
+errors/errors.lo: $(go_errors_files)
+       $(BUILDPACKAGE)
+errors/check: $(CHECK_DEPS)
+       @$(CHECK)
+.PHONY: errors/check
+
 @go_include@ exec/exec.lo.dep
 exec/exec.lo.dep: $(go_exec_files)
        $(BUILDDEPS)
@@ -5930,6 +5945,8 @@ crypto.gox: crypto/crypto.lo
        $(BUILDGOX)
 csv.gox: csv/csv.lo
        $(BUILDGOX)
+errors.gox: errors/errors.lo
+       $(BUILDGOX)
 exec.gox: exec/exec.lo
        $(BUILDGOX)
 expvar.gox: expvar/expvar.lo
index 12de2ad..65bf120 100644 (file)
@@ -9,6 +9,7 @@ package tar
 
 import (
        "bytes"
+       "errors"
        "io"
        "io/ioutil"
        "os"
@@ -16,7 +17,7 @@ import (
 )
 
 var (
-       HeaderError = os.NewError("invalid tar header")
+       HeaderError = errors.New("invalid tar header")
 )
 
 // A Reader provides sequential access to the contents of a tar archive.
@@ -39,7 +40,7 @@ var (
 //     }
 type Reader struct {
        r   io.Reader
-       err os.Error
+       err error
        nb  int64 // number of unread bytes for current file entry
        pad int64 // amount of padding (ignored) after current file entry
 }
@@ -48,7 +49,7 @@ type Reader struct {
 func NewReader(r io.Reader) *Reader { return &Reader{r: r} }
 
 // Next advances to the next entry in the tar archive.
-func (tr *Reader) Next() (*Header, os.Error) {
+func (tr *Reader) Next() (*Header, error) {
        var hdr *Header
        if tr.err == nil {
                tr.skipUnread()
@@ -119,7 +120,7 @@ func (tr *Reader) readHeader() *Header {
                        return nil
                }
                if bytes.Equal(header, zeroBlock[0:blockSize]) {
-                       tr.err = os.EOF
+                       tr.err = io.EOF
                } else {
                        tr.err = HeaderError // zero block and then non-zero block
                }
@@ -201,10 +202,10 @@ func (tr *Reader) readHeader() *Header {
 // Read reads from the current entry in the tar archive.
 // It returns 0, os.EOF when it reaches the end of that entry,
 // until Next is called to advance to the next entry.
-func (tr *Reader) Read(b []byte) (n int, err os.Error) {
+func (tr *Reader) Read(b []byte) (n int, err error) {
        if tr.nb == 0 {
                // file consumed
-               return 0, os.EOF
+               return 0, io.EOF
        }
 
        if int64(len(b)) > tr.nb {
@@ -213,7 +214,7 @@ func (tr *Reader) Read(b []byte) (n int, err os.Error) {
        n, err = tr.r.Read(b)
        tr.nb -= int64(n)
 
-       if err == os.EOF && tr.nb > 0 {
+       if err == io.EOF && tr.nb > 0 {
                err = io.ErrUnexpectedEOF
        }
        tr.err = err
index f473c90..00eea6b 100644 (file)
@@ -132,7 +132,7 @@ testLoop:
                        }
                }
                hdr, err := tr.Next()
-               if err == os.EOF {
+               if err == io.EOF {
                        break
                }
                if hdr != nil || err != nil {
@@ -195,7 +195,7 @@ func TestIncrementalRead(t *testing.T) {
        // loop over all files
        for ; ; nread++ {
                hdr, err := tr.Next()
-               if hdr == nil || err == os.EOF {
+               if hdr == nil || err == io.EOF {
                        break
                }
 
@@ -211,7 +211,7 @@ func TestIncrementalRead(t *testing.T) {
                rdbuf := make([]uint8, 8)
                for {
                        nr, err := tr.Read(rdbuf)
-                       if err == os.EOF {
+                       if err == io.EOF {
                                break
                        }
                        if err != nil {
@@ -250,7 +250,7 @@ func TestNonSeekable(t *testing.T) {
                for {
                        nr, err := f.Read(rdbuf)
                        w.Write(rdbuf[0:nr])
-                       if err == os.EOF {
+                       if err == io.EOF {
                                break
                        }
                }
@@ -262,7 +262,7 @@ func TestNonSeekable(t *testing.T) {
 
        for ; ; nread++ {
                hdr, err := tr.Next()
-               if hdr == nil || err == os.EOF {
+               if hdr == nil || err == io.EOF {
                        break
                }
        }
index c6ce224..222df90 100644 (file)
@@ -8,15 +8,15 @@ package tar
 // - catch more errors (no first header, write after close, etc.)
 
 import (
+       "errors"
        "io"
-       "os"
        "strconv"
 )
 
 var (
-       ErrWriteTooLong    = os.NewError("write too long")
-       ErrFieldTooLong    = os.NewError("header field too long")
-       ErrWriteAfterClose = os.NewError("write after close")
+       ErrWriteTooLong    = errors.New("write too long")
+       ErrFieldTooLong    = errors.New("header field too long")
+       ErrWriteAfterClose = errors.New("write after close")
 )
 
 // A Writer provides sequential writing of a tar archive in POSIX.1 format.
@@ -36,7 +36,7 @@ var (
 //     tw.Close()
 type Writer struct {
        w          io.Writer
-       err        os.Error
+       err        error
        nb         int64 // number of unwritten bytes for current file entry
        pad        int64 // amount of padding to write after current file entry
        closed     bool
@@ -47,7 +47,7 @@ type Writer struct {
 func NewWriter(w io.Writer) *Writer { return &Writer{w: w} }
 
 // Flush finishes writing the current file (optional).
-func (tw *Writer) Flush() os.Error {
+func (tw *Writer) Flush() error {
        n := tw.nb + tw.pad
        for n > 0 && tw.err == nil {
                nr := n
@@ -107,7 +107,7 @@ func (tw *Writer) numeric(b []byte, x int64) {
 // WriteHeader writes hdr and prepares to accept the file's contents.
 // WriteHeader calls Flush if it is not the first header.
 // Calling after a Close will return ErrWriteAfterClose.
-func (tw *Writer) WriteHeader(hdr *Header) os.Error {
+func (tw *Writer) WriteHeader(hdr *Header) error {
        if tw.closed {
                return ErrWriteAfterClose
        }
@@ -165,7 +165,7 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 // Write writes to the current entry in the tar archive.
 // Write returns the error ErrWriteTooLong if more than
 // hdr.Size bytes are written after WriteHeader.
-func (tw *Writer) Write(b []byte) (n int, err os.Error) {
+func (tw *Writer) Write(b []byte) (n int, err error) {
        if tw.closed {
                err = ErrWriteTooLong
                return
@@ -187,7 +187,7 @@ func (tw *Writer) Write(b []byte) (n int, err os.Error) {
 
 // Close closes the tar archive, flushing any unwritten
 // data to the underlying writer.
-func (tw *Writer) Close() os.Error {
+func (tw *Writer) Close() error {
        if tw.err != nil || tw.closed {
                return tw.err
        }
index b0a5599..64152b4 100644 (file)
@@ -7,6 +7,7 @@ package zip
 import (
        "bufio"
        "compress/flate"
+       "errors"
        "hash"
        "hash/crc32"
        "encoding/binary"
@@ -16,9 +17,9 @@ import (
 )
 
 var (
-       FormatError       = os.NewError("zip: not a valid zip file")
-       UnsupportedMethod = os.NewError("zip: unsupported compression algorithm")
-       ChecksumError     = os.NewError("zip: checksum error")
+       FormatError       = errors.New("zip: not a valid zip file")
+       UnsupportedMethod = errors.New("zip: unsupported compression algorithm")
+       ChecksumError     = errors.New("zip: checksum error")
 )
 
 type Reader struct {
@@ -44,7 +45,7 @@ func (f *File) hasDataDescriptor() bool {
 }
 
 // OpenReader will open the Zip file specified by name and return a ReadCloser.
-func OpenReader(name string) (*ReadCloser, os.Error) {
+func OpenReader(name string) (*ReadCloser, error) {
        f, err := os.Open(name)
        if err != nil {
                return nil, err
@@ -64,7 +65,7 @@ func OpenReader(name string) (*ReadCloser, os.Error) {
 
 // NewReader returns a new Reader reading from r, which is assumed to
 // have the given size in bytes.
-func NewReader(r io.ReaderAt, size int64) (*Reader, os.Error) {
+func NewReader(r io.ReaderAt, size int64) (*Reader, error) {
        zr := new(Reader)
        if err := zr.init(r, size); err != nil {
                return nil, err
@@ -72,7 +73,7 @@ func NewReader(r io.ReaderAt, size int64) (*Reader, os.Error) {
        return zr, nil
 }
 
-func (z *Reader) init(r io.ReaderAt, size int64) os.Error {
+func (z *Reader) init(r io.ReaderAt, size int64) error {
        end, err := readDirectoryEnd(r, size)
        if err != nil {
                return err
@@ -110,13 +111,13 @@ func (z *Reader) init(r io.ReaderAt, size int64) os.Error {
 }
 
 // Close closes the Zip file, rendering it unusable for I/O.
-func (rc *ReadCloser) Close() os.Error {
+func (rc *ReadCloser) Close() error {
        return rc.f.Close()
 }
 
 // Open returns a ReadCloser that provides access to the File's contents.
 // It is safe to Open and Read from files concurrently.
-func (f *File) Open() (rc io.ReadCloser, err os.Error) {
+func (f *File) Open() (rc io.ReadCloser, err error) {
        bodyOffset, err := f.findBodyOffset()
        if err != nil {
                return
@@ -148,10 +149,10 @@ type checksumReader struct {
        zipr io.Reader // for reading the data descriptor
 }
 
-func (r *checksumReader) Read(b []byte) (n int, err os.Error) {
+func (r *checksumReader) Read(b []byte) (n int, err error) {
        n, err = r.rc.Read(b)
        r.hash.Write(b[:n])
-       if err != os.EOF {
+       if err != io.EOF {
                return
        }
        if r.f.hasDataDescriptor() {
@@ -165,9 +166,9 @@ func (r *checksumReader) Read(b []byte) (n int, err os.Error) {
        return
 }
 
-func (r *checksumReader) Close() os.Error { return r.rc.Close() }
+func (r *checksumReader) Close() error { return r.rc.Close() }
 
-func readFileHeader(f *File, r io.Reader) os.Error {
+func readFileHeader(f *File, r io.Reader) error {
        var b [fileHeaderLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return err
@@ -197,7 +198,7 @@ func readFileHeader(f *File, r io.Reader) os.Error {
 
 // findBodyOffset does the minimum work to verify the file has a header
 // and returns the file body offset.
-func (f *File) findBodyOffset() (int64, os.Error) {
+func (f *File) findBodyOffset() (int64, error) {
        r := io.NewSectionReader(f.zipr, f.headerOffset, f.zipsize-f.headerOffset)
        var b [fileHeaderLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
@@ -215,7 +216,7 @@ func (f *File) findBodyOffset() (int64, os.Error) {
 // readDirectoryHeader attempts to read a directory header from r.
 // It returns io.ErrUnexpectedEOF if it cannot read a complete header,
 // and FormatError if it doesn't find a valid header signature.
-func readDirectoryHeader(f *File, r io.Reader) os.Error {
+func readDirectoryHeader(f *File, r io.Reader) error {
        var b [directoryHeaderLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return err
@@ -250,7 +251,7 @@ func readDirectoryHeader(f *File, r io.Reader) os.Error {
        return nil
 }
 
-func readDataDescriptor(r io.Reader, f *File) os.Error {
+func readDataDescriptor(r io.Reader, f *File) error {
        var b [dataDescriptorLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return err
@@ -262,7 +263,7 @@ func readDataDescriptor(r io.Reader, f *File) os.Error {
        return nil
 }
 
-func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err os.Error) {
+func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err error) {
        // look for directoryEndSignature in the last 1k, then in the last 65k
        var b []byte
        for i, bLen := range []int64{1024, 65 * 1024} {
@@ -270,7 +271,7 @@ func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err os.Erro
                        bLen = size
                }
                b = make([]byte, int(bLen))
-               if _, err := r.ReadAt(b, size-bLen); err != nil && err != os.EOF {
+               if _, err := r.ReadAt(b, size-bLen); err != nil && err != io.EOF {
                        return nil, err
                }
                if p := findSignatureInBlock(b); p >= 0 {
index 3b7b0dc..4d80aab 100644 (file)
@@ -9,7 +9,6 @@ import (
        "encoding/binary"
        "io"
        "io/ioutil"
-       "os"
        "testing"
        "time"
 )
@@ -18,7 +17,7 @@ type ZipTest struct {
        Name    string
        Comment string
        File    []ZipTestFile
-       Error   os.Error // the error that Opening this file should return
+       Error   error // the error that Opening this file should return
 }
 
 type ZipTestFile struct {
@@ -245,7 +244,7 @@ func TestInvalidFiles(t *testing.T) {
 
 type sliceReaderAt []byte
 
-func (r sliceReaderAt) ReadAt(b []byte, off int64) (int, os.Error) {
+func (r sliceReaderAt) ReadAt(b []byte, off int64) (int, error) {
        copy(b, r[int(off):int(off)+len(b)])
        return len(b), nil
 }
index 4f9f599..b862b5a 100644 (file)
@@ -11,7 +11,7 @@ This package does not support ZIP64 or disk spanning.
 */
 package zip
 
-import "os"
+import "errors"
 import "time"
 
 // Compression methods.
@@ -60,9 +60,9 @@ type directoryEnd struct {
        comment            string
 }
 
-func recoverError(errp *os.Error) {
+func recoverError(errp *error) {
        if e := recover(); e != nil {
-               if err, ok := e.(os.Error); ok {
+               if err, ok := e.(error); ok {
                        *errp = err
                        return
                }
@@ -96,11 +96,11 @@ func (h *FileHeader) Mtime_ns() int64 {
 
 // Mode returns the permission and mode bits for the FileHeader.
 // An error is returned in case the information is not available.
-func (h *FileHeader) Mode() (mode uint32, err os.Error) {
+func (h *FileHeader) Mode() (mode uint32, err error) {
        if h.CreatorVersion>>8 == creatorUnix {
                return h.ExternalAttrs >> 16, nil
        }
-       return 0, os.NewError("file mode not available")
+       return 0, errors.New("file mode not available")
 }
 
 // SetMode changes the permission and mode bits for the FileHeader.
index 3a6dc38..a153064 100644 (file)
@@ -8,10 +8,10 @@ import (
        "bufio"
        "compress/flate"
        "encoding/binary"
+       "errors"
        "hash"
        "hash/crc32"
        "io"
-       "os"
 )
 
 // TODO(adg): support zip file comments
@@ -37,7 +37,7 @@ func NewWriter(w io.Writer) *Writer {
 
 // Close finishes writing the zip file by writing the central directory.
 // It does not (and can not) close the underlying writer.
-func (w *Writer) Close() (err os.Error) {
+func (w *Writer) Close() (err error) {
        if w.last != nil && !w.last.closed {
                if err = w.last.close(); err != nil {
                        return
@@ -45,7 +45,7 @@ func (w *Writer) Close() (err os.Error) {
                w.last = nil
        }
        if w.closed {
-               return os.NewError("zip: writer closed twice")
+               return errors.New("zip: writer closed twice")
        }
        w.closed = true
 
@@ -94,7 +94,7 @@ func (w *Writer) Close() (err os.Error) {
 // It returns a Writer to which the file contents should be written.
 // The file's contents must be written to the io.Writer before the next
 // call to Create, CreateHeader, or Close.
-func (w *Writer) Create(name string) (io.Writer, os.Error) {
+func (w *Writer) Create(name string) (io.Writer, error) {
        header := &FileHeader{
                Name:   name,
                Method: Deflate,
@@ -107,7 +107,7 @@ func (w *Writer) Create(name string) (io.Writer, os.Error) {
 // It returns a Writer to which the file contents should be written.
 // The file's contents must be written to the io.Writer before the next
 // call to Create, CreateHeader, or Close.
-func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, os.Error) {
+func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
        if w.last != nil && !w.last.closed {
                if err := w.last.close(); err != nil {
                        return nil, err
@@ -148,7 +148,7 @@ func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, os.Error) {
        return fw, nil
 }
 
-func writeHeader(w io.Writer, h *FileHeader) (err os.Error) {
+func writeHeader(w io.Writer, h *FileHeader) (err error) {
        defer recoverError(&err)
        write(w, uint32(fileHeaderSignature))
        write(w, h.ReaderVersion)
@@ -176,17 +176,17 @@ type fileWriter struct {
        closed    bool
 }
 
-func (w *fileWriter) Write(p []byte) (int, os.Error) {
+func (w *fileWriter) Write(p []byte) (int, error) {
        if w.closed {
-               return 0, os.NewError("zip: write to closed file")
+               return 0, errors.New("zip: write to closed file")
        }
        w.crc32.Write(p)
        return w.rawCount.Write(p)
 }
 
-func (w *fileWriter) close() (err os.Error) {
+func (w *fileWriter) close() (err error) {
        if w.closed {
-               return os.NewError("zip: file closed twice")
+               return errors.New("zip: file closed twice")
        }
        w.closed = true
        if err = w.comp.Close(); err != nil {
@@ -213,7 +213,7 @@ type countWriter struct {
        count int64
 }
 
-func (w *countWriter) Write(p []byte) (int, os.Error) {
+func (w *countWriter) Write(p []byte) (int, error) {
        n, err := w.w.Write(p)
        w.count += int64(n)
        return n, err
@@ -223,7 +223,7 @@ type nopCloser struct {
        io.Writer
 }
 
-func (w nopCloser) Close() os.Error {
+func (w nopCloser) Close() error {
        return nil
 }
 
index 0f71fdf..2075715 100644 (file)
@@ -9,15 +9,15 @@ package zip
 import (
        "bytes"
        "fmt"
-       "os"
+       "io"
        "testing"
 )
 
 type stringReaderAt string
 
-func (s stringReaderAt) ReadAt(p []byte, off int64) (n int, err os.Error) {
+func (s stringReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
        if off >= int64(len(s)) {
-               return 0, os.EOF
+               return 0, io.EOF
        }
        n = copy(p, s[off:])
        return
index e7bd62e..73e733e 100644 (file)
@@ -22,7 +22,6 @@ package asn1
 import (
        "big"
        "fmt"
-       "os"
        "reflect"
        "time"
 )
@@ -33,20 +32,20 @@ type StructuralError struct {
        Msg string
 }
 
-func (e StructuralError) String() string { return "ASN.1 structure error: " + e.Msg }
+func (e StructuralError) Error() string { return "ASN.1 structure error: " + e.Msg }
 
 // A SyntaxError suggests that the ASN.1 data is invalid.
 type SyntaxError struct {
        Msg string
 }
 
-func (e SyntaxError) String() string { return "ASN.1 syntax error: " + e.Msg }
+func (e SyntaxError) Error() string { return "ASN.1 syntax error: " + e.Msg }
 
 // We start by dealing with each of the primitive types in turn.
 
 // BOOLEAN
 
-func parseBool(bytes []byte) (ret bool, err os.Error) {
+func parseBool(bytes []byte) (ret bool, err error) {
        if len(bytes) != 1 {
                err = SyntaxError{"invalid boolean"}
                return
@@ -59,7 +58,7 @@ func parseBool(bytes []byte) (ret bool, err os.Error) {
 
 // parseInt64 treats the given bytes as a big-endian, signed integer and
 // returns the result.
-func parseInt64(bytes []byte) (ret int64, err os.Error) {
+func parseInt64(bytes []byte) (ret int64, err error) {
        if len(bytes) > 8 {
                // We'll overflow an int64 in this case.
                err = StructuralError{"integer too large"}
@@ -78,7 +77,7 @@ func parseInt64(bytes []byte) (ret int64, err os.Error) {
 
 // parseInt treats the given bytes as a big-endian, signed integer and returns
 // the result.
-func parseInt(bytes []byte) (int, os.Error) {
+func parseInt(bytes []byte) (int, error) {
        ret64, err := parseInt64(bytes)
        if err != nil {
                return 0, err
@@ -150,7 +149,7 @@ func (b BitString) RightAlign() []byte {
 }
 
 // parseBitString parses an ASN.1 bit string from the given byte slice and returns it.
-func parseBitString(bytes []byte) (ret BitString, err os.Error) {
+func parseBitString(bytes []byte) (ret BitString, err error) {
        if len(bytes) == 0 {
                err = SyntaxError{"zero length BIT STRING"}
                return
@@ -189,7 +188,7 @@ func (oi ObjectIdentifier) Equal(other ObjectIdentifier) bool {
 // parseObjectIdentifier parses an OBJECT IDENTIFIER from the given bytes and
 // returns it. An object identifier is a sequence of variable length integers
 // that are assigned in a hierarchy.
-func parseObjectIdentifier(bytes []byte) (s []int, err os.Error) {
+func parseObjectIdentifier(bytes []byte) (s []int, err error) {
        if len(bytes) == 0 {
                err = SyntaxError{"zero length OBJECT IDENTIFIER"}
                return
@@ -227,7 +226,7 @@ type Flag bool
 
 // parseBase128Int parses a base-128 encoded int from the given offset in the
 // given byte slice. It returns the value and the new offset.
-func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err os.Error) {
+func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err error) {
        offset = initOffset
        for shifted := 0; offset < len(bytes); shifted++ {
                if shifted > 4 {
@@ -248,7 +247,7 @@ func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err os.Erro
 
 // UTCTime
 
-func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) {
+func parseUTCTime(bytes []byte) (ret *time.Time, err error) {
        s := string(bytes)
        ret, err = time.Parse("0601021504Z0700", s)
        if err == nil {
@@ -260,7 +259,7 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) {
 
 // parseGeneralizedTime parses the GeneralizedTime from the given byte slice
 // and returns the resulting time.
-func parseGeneralizedTime(bytes []byte) (ret *time.Time, err os.Error) {
+func parseGeneralizedTime(bytes []byte) (ret *time.Time, err error) {
        return time.Parse("20060102150405Z0700", string(bytes))
 }
 
@@ -268,7 +267,7 @@ func parseGeneralizedTime(bytes []byte) (ret *time.Time, err os.Error) {
 
 // parsePrintableString parses a ASN.1 PrintableString from the given byte
 // array and returns it.
-func parsePrintableString(bytes []byte) (ret string, err os.Error) {
+func parsePrintableString(bytes []byte) (ret string, err error) {
        for _, b := range bytes {
                if !isPrintable(b) {
                        err = SyntaxError{"PrintableString contains invalid character"}
@@ -300,7 +299,7 @@ func isPrintable(b byte) bool {
 
 // parseIA5String parses a ASN.1 IA5String (ASCII string) from the given
 // byte slice and returns it.
-func parseIA5String(bytes []byte) (ret string, err os.Error) {
+func parseIA5String(bytes []byte) (ret string, err error) {
        for _, b := range bytes {
                if b >= 0x80 {
                        err = SyntaxError{"IA5String contains invalid character"}
@@ -315,7 +314,7 @@ func parseIA5String(bytes []byte) (ret string, err os.Error) {
 
 // parseT61String parses a ASN.1 T61String (8-bit clean string) from the given
 // byte slice and returns it.
-func parseT61String(bytes []byte) (ret string, err os.Error) {
+func parseT61String(bytes []byte) (ret string, err error) {
        return string(bytes), nil
 }
 
@@ -323,7 +322,7 @@ func parseT61String(bytes []byte) (ret string, err os.Error) {
 
 // parseUTF8String parses a ASN.1 UTF8String (raw UTF-8) from the given byte
 // array and returns it.
-func parseUTF8String(bytes []byte) (ret string, err os.Error) {
+func parseUTF8String(bytes []byte) (ret string, err error) {
        return string(bytes), nil
 }
 
@@ -346,7 +345,7 @@ type RawContent []byte
 // into a byte slice. It returns the parsed data and the new offset. SET and
 // SET OF (tag 17) are mapped to SEQUENCE and SEQUENCE OF (tag 16) since we
 // don't distinguish between ordered and unordered objects in this code.
-func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset int, err os.Error) {
+func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset int, err error) {
        offset = initOffset
        b := bytes[offset]
        offset++
@@ -402,7 +401,7 @@ func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset i
 // parseSequenceOf is used for SEQUENCE OF and SET OF values. It tries to parse
 // a number of ASN.1 values from the given byte slice and returns them as a
 // slice of Go values of the given type.
-func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err os.Error) {
+func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
        expectedTag, compoundType, ok := getUniversalType(elemType)
        if !ok {
                err = StructuralError{"unknown Go type for slice"}
@@ -466,7 +465,7 @@ func invalidLength(offset, length, sliceLength int) bool {
 // parseField is the main parsing function. Given a byte slice and an offset
 // into the array, it will try to parse a suitable ASN.1 value out and store it
 // in the given Value.
-func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err os.Error) {
+func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err error) {
        offset = initOffset
        fieldType := v.Type()
 
@@ -649,7 +648,7 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
                return
        case timeType:
                var time *time.Time
-               var err1 os.Error
+               var err1 error
                if universalTag == tagUTCTime {
                        time, err1 = parseUTCTime(innerBytes)
                } else {
@@ -826,13 +825,13 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
 //
 // Other ASN.1 types are not supported; if it encounters them,
 // Unmarshal returns a parse error.
-func Unmarshal(b []byte, val interface{}) (rest []byte, err os.Error) {
+func Unmarshal(b []byte, val interface{}) (rest []byte, err error) {
        return UnmarshalWithParams(b, val, "")
 }
 
 // UnmarshalWithParams allows field parameters to be specified for the
 // top-level element. The form of the params is the same as the field tags.
-func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err os.Error) {
+func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err error) {
        v := reflect.ValueOf(val).Elem()
        offset, err := parseField(v, b, 0, parseFieldParameters(params))
        if err != nil {
index 6d1f78b..583d010 100644 (file)
@@ -9,7 +9,6 @@ import (
        "bytes"
        "fmt"
        "io"
-       "os"
        "reflect"
        "time"
 )
@@ -48,7 +47,7 @@ func (f *forkableWriter) Len() (l int) {
        return
 }
 
-func (f *forkableWriter) writeTo(out io.Writer) (n int, err os.Error) {
+func (f *forkableWriter) writeTo(out io.Writer) (n int, err error) {
        n, err = out.Write(f.Bytes())
        if err != nil {
                return
@@ -71,7 +70,7 @@ func (f *forkableWriter) writeTo(out io.Writer) (n int, err os.Error) {
        return
 }
 
-func marshalBase128Int(out *forkableWriter, n int64) (err os.Error) {
+func marshalBase128Int(out *forkableWriter, n int64) (err error) {
        if n == 0 {
                err = out.WriteByte(0)
                return
@@ -97,7 +96,7 @@ func marshalBase128Int(out *forkableWriter, n int64) (err os.Error) {
        return nil
 }
 
-func marshalInt64(out *forkableWriter, i int64) (err os.Error) {
+func marshalInt64(out *forkableWriter, i int64) (err error) {
        n := int64Length(i)
 
        for ; n > 0; n-- {
@@ -126,7 +125,7 @@ func int64Length(i int64) (numBytes int) {
        return
 }
 
-func marshalBigInt(out *forkableWriter, n *big.Int) (err os.Error) {
+func marshalBigInt(out *forkableWriter, n *big.Int) (err error) {
        if n.Sign() < 0 {
                // A negative number has to be converted to two's-complement
                // form. So we'll subtract 1 and invert. If the
@@ -163,7 +162,7 @@ func marshalBigInt(out *forkableWriter, n *big.Int) (err os.Error) {
        return
 }
 
-func marshalLength(out *forkableWriter, i int) (err os.Error) {
+func marshalLength(out *forkableWriter, i int) (err error) {
        n := lengthLength(i)
 
        for ; n > 0; n-- {
@@ -185,7 +184,7 @@ func lengthLength(i int) (numBytes int) {
        return
 }
 
-func marshalTagAndLength(out *forkableWriter, t tagAndLength) (err os.Error) {
+func marshalTagAndLength(out *forkableWriter, t tagAndLength) (err error) {
        b := uint8(t.class) << 6
        if t.isCompound {
                b |= 0x20
@@ -228,7 +227,7 @@ func marshalTagAndLength(out *forkableWriter, t tagAndLength) (err os.Error) {
        return nil
 }
 
-func marshalBitString(out *forkableWriter, b BitString) (err os.Error) {
+func marshalBitString(out *forkableWriter, b BitString) (err error) {
        paddingBits := byte((8 - b.BitLength%8) % 8)
        err = out.WriteByte(paddingBits)
        if err != nil {
@@ -238,7 +237,7 @@ func marshalBitString(out *forkableWriter, b BitString) (err os.Error) {
        return
 }
 
-func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) {
+func marshalObjectIdentifier(out *forkableWriter, oid []int) (err error) {
        if len(oid) < 2 || oid[0] > 6 || oid[1] >= 40 {
                return StructuralError{"invalid object identifier"}
        }
@@ -257,7 +256,7 @@ func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) {
        return
 }
 
-func marshalPrintableString(out *forkableWriter, s string) (err os.Error) {
+func marshalPrintableString(out *forkableWriter, s string) (err error) {
        b := []byte(s)
        for _, c := range b {
                if !isPrintable(c) {
@@ -269,7 +268,7 @@ func marshalPrintableString(out *forkableWriter, s string) (err os.Error) {
        return
 }
 
-func marshalIA5String(out *forkableWriter, s string) (err os.Error) {
+func marshalIA5String(out *forkableWriter, s string) (err error) {
        b := []byte(s)
        for _, c := range b {
                if c > 127 {
@@ -281,7 +280,7 @@ func marshalIA5String(out *forkableWriter, s string) (err os.Error) {
        return
 }
 
-func marshalTwoDigits(out *forkableWriter, v int) (err os.Error) {
+func marshalTwoDigits(out *forkableWriter, v int) (err error) {
        err = out.WriteByte(byte('0' + (v/10)%10))
        if err != nil {
                return
@@ -289,7 +288,7 @@ func marshalTwoDigits(out *forkableWriter, v int) (err os.Error) {
        return out.WriteByte(byte('0' + v%10))
 }
 
-func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
+func marshalUTCTime(out *forkableWriter, t *time.Time) (err error) {
        switch {
        case 1950 <= t.Year && t.Year < 2000:
                err = marshalTwoDigits(out, int(t.Year-1900))
@@ -364,7 +363,7 @@ func stripTagAndLength(in []byte) []byte {
        return in[offset:]
 }
 
-func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameters) (err os.Error) {
+func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameters) (err error) {
        switch value.Type() {
        case timeType:
                return marshalUTCTime(out, value.Interface().(*time.Time))
@@ -452,7 +451,7 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter
        return StructuralError{"unknown Go type"}
 }
 
-func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) (err os.Error) {
+func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) (err error) {
        // If the field is an interface{} then recurse into it.
        if v.Kind() == reflect.Interface && v.Type().NumMethod() == 0 {
                return marshalField(out, v.Elem(), params)
@@ -535,7 +534,7 @@ func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters)
 }
 
 // Marshal returns the ASN.1 encoding of val.
-func Marshal(val interface{}) ([]byte, os.Error) {
+func Marshal(val interface{}) ([]byte, error) {
        var out bytes.Buffer
        v := reflect.ValueOf(val)
        f := newForkableWriter()
index db13d20..c6affbb 100644 (file)
@@ -7,9 +7,9 @@
 package big
 
 import (
+       "errors"
        "fmt"
        "io"
-       "os"
        "rand"
        "strings"
 )
@@ -432,7 +432,7 @@ func (x *Int) Format(s fmt.State, ch rune) {
 // ``0x'' or ``0X'' selects base 16; the ``0'' prefix selects base 8, and a
 // ``0b'' or ``0B'' prefix selects base 2. Otherwise the selected base is 10.
 //
-func (z *Int) scan(r io.RuneScanner, base int) (*Int, int, os.Error) {
+func (z *Int) scan(r io.RuneScanner, base int) (*Int, int, error) {
        // determine sign
        ch, _, err := r.ReadRune()
        if err != nil {
@@ -460,7 +460,7 @@ func (z *Int) scan(r io.RuneScanner, base int) (*Int, int, os.Error) {
 // Scan is a support routine for fmt.Scanner; it sets z to the value of
 // the scanned number. It accepts the formats 'b' (binary), 'o' (octal),
 // 'd' (decimal), 'x' (lowercase hexadecimal), and 'X' (uppercase hexadecimal).
-func (z *Int) Scan(s fmt.ScanState, ch rune) os.Error {
+func (z *Int) Scan(s fmt.ScanState, ch rune) error {
        s.SkipSpace() // skip leading space characters
        base := 0
        switch ch {
@@ -475,7 +475,7 @@ func (z *Int) Scan(s fmt.ScanState, ch rune) os.Error {
        case 's', 'v':
                // let scan determine the base
        default:
-               return os.NewError("Int.Scan: invalid verb")
+               return errors.New("Int.Scan: invalid verb")
        }
        _, _, err := z.scan(s, base)
        return err
@@ -513,7 +513,7 @@ func (z *Int) SetString(s string, base int) (*Int, bool) {
                return nil, false
        }
        _, _, err = r.ReadRune()
-       if err != os.EOF {
+       if err != io.EOF {
                return nil, false
        }
        return z, true // err == os.EOF => scan consumed all of s
@@ -847,7 +847,7 @@ func (z *Int) Not(x *Int) *Int {
 const intGobVersion byte = 1
 
 // GobEncode implements the gob.GobEncoder interface.
-func (z *Int) GobEncode() ([]byte, os.Error) {
+func (z *Int) GobEncode() ([]byte, error) {
        buf := make([]byte, 1+len(z.abs)*_S) // extra byte for version and sign bit
        i := z.abs.bytes(buf) - 1            // i >= 0
        b := intGobVersion << 1              // make space for sign bit
@@ -859,13 +859,13 @@ func (z *Int) GobEncode() ([]byte, os.Error) {
 }
 
 // GobDecode implements the gob.GobDecoder interface.
-func (z *Int) GobDecode(buf []byte) os.Error {
+func (z *Int) GobDecode(buf []byte) error {
        if len(buf) == 0 {
-               return os.NewError("Int.GobDecode: no data")
+               return errors.New("Int.GobDecode: no data")
        }
        b := buf[0]
        if b>>1 != intGobVersion {
-               return os.NewError(fmt.Sprintf("Int.GobDecode: encoding version %d not supported", b>>1))
+               return errors.New(fmt.Sprintf("Int.GobDecode: encoding version %d not supported", b>>1))
        }
        z.neg = b&1 != 0
        z.abs = z.abs.setBytes(buf[1:])
index fa0d7e7..a46f782 100644 (file)
@@ -19,8 +19,8 @@ package big
 // and rationals.
 
 import (
+       "errors"
        "io"
-       "os"
        "rand"
 )
 
@@ -613,10 +613,10 @@ func hexValue(ch rune) Word {
 // ``0x'' or ``0X'' selects base 16; the ``0'' prefix selects base 8, and a
 // ``0b'' or ``0B'' prefix selects base 2. Otherwise the selected base is 10.
 //
-func (z nat) scan(r io.RuneScanner, base int) (nat, int, os.Error) {
+func (z nat) scan(r io.RuneScanner, base int) (nat, int, error) {
        // reject illegal bases
        if base < 0 || base == 1 || MaxBase < base {
-               return z, 0, os.NewError("illegal number base")
+               return z, 0, errors.New("illegal number base")
        }
 
        // one char look-ahead
@@ -644,7 +644,7 @@ func (z nat) scan(r io.RuneScanner, base int) (nat, int, os.Error) {
                                                return z, 0, err
                                        }
                                }
-                       case os.EOF:
+                       case io.EOF:
                                return z.make(0), 10, nil
                        default:
                                return z, 10, err
@@ -676,7 +676,7 @@ func (z nat) scan(r io.RuneScanner, base int) (nat, int, os.Error) {
                }
 
                if ch, _, err = r.ReadRune(); err != nil {
-                       if err != os.EOF {
+                       if err != io.EOF {
                                return z, int(b), err
                        }
                        break
@@ -693,7 +693,7 @@ func (z nat) scan(r io.RuneScanner, base int) (nat, int, os.Error) {
                return z, 10, nil
        case base != 0 || b != 8:
                // there was neither a mantissa digit nor the octal prefix 0
-               return z, int(b), os.NewError("syntax error scanning number")
+               return z, int(b), errors.New("syntax error scanning number")
        }
 
        return z.norm(), int(b), nil
index ab34c6e..041a6c4 100644 (file)
@@ -6,7 +6,7 @@ package big
 
 import (
        "fmt"
-       "os"
+       "io"
        "strings"
        "testing"
 )
@@ -288,7 +288,7 @@ func TestScanBase(t *testing.T) {
                        t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, a.base)
                }
                next, _, err := r.ReadRune()
-               if err == os.EOF {
+               if err == io.EOF {
                        next = 0
                        err = nil
                }
index 1940a05..3a0add3 100644 (file)
@@ -8,8 +8,8 @@ package big
 
 import (
        "encoding/binary"
+       "errors"
        "fmt"
-       "os"
        "strings"
 )
 
@@ -255,16 +255,16 @@ func ratTok(ch rune) bool {
 
 // Scan is a support routine for fmt.Scanner. It accepts the formats
 // 'e', 'E', 'f', 'F', 'g', 'G', and 'v'. All formats are equivalent.
-func (z *Rat) Scan(s fmt.ScanState, ch rune) os.Error {
+func (z *Rat) Scan(s fmt.ScanState, ch rune) error {
        tok, err := s.Token(true, ratTok)
        if err != nil {
                return err
        }
        if strings.IndexRune("efgEFGv", ch) < 0 {
-               return os.NewError("Rat.Scan: invalid verb")
+               return errors.New("Rat.Scan: invalid verb")
        }
        if _, ok := z.SetString(string(tok)); !ok {
-               return os.NewError("Rat.Scan: invalid syntax")
+               return errors.New("Rat.Scan: invalid syntax")
        }
        return nil
 }
@@ -285,7 +285,7 @@ func (z *Rat) SetString(s string) (*Rat, bool) {
                        return nil, false
                }
                s = s[sep+1:]
-               var err os.Error
+               var err error
                if z.b, _, err = z.b.scan(strings.NewReader(s), 10); err != nil {
                        return nil, false
                }
@@ -395,14 +395,14 @@ func (z *Rat) FloatString(prec int) string {
 const ratGobVersion byte = 1
 
 // GobEncode implements the gob.GobEncoder interface.
-func (z *Rat) GobEncode() ([]byte, os.Error) {
+func (z *Rat) GobEncode() ([]byte, error) {
        buf := make([]byte, 1+4+(len(z.a.abs)+len(z.b))*_S) // extra bytes for version and sign bit (1), and numerator length (4)
        i := z.b.bytes(buf)
        j := z.a.abs.bytes(buf[0:i])
        n := i - j
        if int(uint32(n)) != n {
                // this should never happen
-               return nil, os.NewError("Rat.GobEncode: numerator too large")
+               return nil, errors.New("Rat.GobEncode: numerator too large")
        }
        binary.BigEndian.PutUint32(buf[j-4:j], uint32(n))
        j -= 1 + 4
@@ -415,13 +415,13 @@ func (z *Rat) GobEncode() ([]byte, os.Error) {
 }
 
 // GobDecode implements the gob.GobDecoder interface.
-func (z *Rat) GobDecode(buf []byte) os.Error {
+func (z *Rat) GobDecode(buf []byte) error {
        if len(buf) == 0 {
-               return os.NewError("Rat.GobDecode: no data")
+               return errors.New("Rat.GobDecode: no data")
        }
        b := buf[0]
        if b>>1 != ratGobVersion {
-               return os.NewError(fmt.Sprintf("Rat.GobDecode: encoding version %d not supported", b>>1))
+               return errors.New(fmt.Sprintf("Rat.GobDecode: encoding version %d not supported", b>>1))
        }
        const j = 1 + 4
        i := j + binary.BigEndian.Uint32(buf[j-4:j])
index 3a4e0ed..f4ed91b 100644 (file)
@@ -10,7 +10,6 @@ package bufio
 import (
        "bytes"
        "io"
-       "os"
        "strconv"
        "utf8"
 )
@@ -24,20 +23,20 @@ type Error struct {
        ErrorString string
 }
 
-func (err *Error) String() string { return err.ErrorString }
+func (err *Error) Error() string { return err.ErrorString }
 
 var (
-       ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"}
-       ErrInvalidUnreadRune os.Error = &Error{"bufio: invalid use of UnreadRune"}
-       ErrBufferFull        os.Error = &Error{"bufio: buffer full"}
-       ErrNegativeCount     os.Error = &Error{"bufio: negative count"}
-       errInternal          os.Error = &Error{"bufio: internal error"}
+       ErrInvalidUnreadByte error = &Error{"bufio: invalid use of UnreadByte"}
+       ErrInvalidUnreadRune error = &Error{"bufio: invalid use of UnreadRune"}
+       ErrBufferFull        error = &Error{"bufio: buffer full"}
+       ErrNegativeCount     error = &Error{"bufio: negative count"}
+       errInternal          error = &Error{"bufio: internal error"}
 )
 
 // BufSizeError is the error representing an invalid buffer size.
 type BufSizeError int
 
-func (b BufSizeError) String() string {
+func (b BufSizeError) Error() string {
        return "bufio: bad buffer size " + strconv.Itoa(int(b))
 }
 
@@ -48,7 +47,7 @@ type Reader struct {
        buf          []byte
        rd           io.Reader
        r, w         int
-       err          os.Error
+       err          error
        lastByte     int
        lastRuneSize int
 }
@@ -57,7 +56,7 @@ type Reader struct {
 // which must be greater than one.  If the argument io.Reader is already a
 // Reader with large enough size, it returns the underlying Reader.
 // It returns the Reader and any error.
-func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) {
+func NewReaderSize(rd io.Reader, size int) (*Reader, error) {
        if size <= 1 {
                return nil, BufSizeError(size)
        }
@@ -101,7 +100,7 @@ func (b *Reader) fill() {
        }
 }
 
-func (b *Reader) readErr() os.Error {
+func (b *Reader) readErr() error {
        err := b.err
        b.err = nil
        return err
@@ -111,7 +110,7 @@ func (b *Reader) readErr() os.Error {
 // being valid at the next read call. If Peek returns fewer than n bytes, it
 // also returns an error explaining why the read is short. The error is
 // ErrBufferFull if n is larger than b's buffer size.
-func (b *Reader) Peek(n int) ([]byte, os.Error) {
+func (b *Reader) Peek(n int) ([]byte, error) {
        if n < 0 {
                return nil, ErrNegativeCount
        }
@@ -137,7 +136,7 @@ func (b *Reader) Peek(n int) ([]byte, os.Error) {
 // It calls Read at most once on the underlying Reader,
 // hence n may be less than len(p).
 // At EOF, the count will be zero and err will be os.EOF.
-func (b *Reader) Read(p []byte) (n int, err os.Error) {
+func (b *Reader) Read(p []byte) (n int, err error) {
        n = len(p)
        if n == 0 {
                return 0, b.readErr()
@@ -174,7 +173,7 @@ func (b *Reader) Read(p []byte) (n int, err os.Error) {
 
 // ReadByte reads and returns a single byte.
 // If no byte is available, returns an error.
-func (b *Reader) ReadByte() (c byte, err os.Error) {
+func (b *Reader) ReadByte() (c byte, err error) {
        b.lastRuneSize = -1
        for b.w == b.r {
                if b.err != nil {
@@ -189,7 +188,7 @@ func (b *Reader) ReadByte() (c byte, err os.Error) {
 }
 
 // UnreadByte unreads the last byte.  Only the most recently read byte can be unread.
-func (b *Reader) UnreadByte() os.Error {
+func (b *Reader) UnreadByte() error {
        b.lastRuneSize = -1
        if b.r == b.w && b.lastByte >= 0 {
                b.w = 1
@@ -208,7 +207,7 @@ func (b *Reader) UnreadByte() os.Error {
 
 // ReadRune reads a single UTF-8 encoded Unicode character and returns the
 // rune and its size in bytes.
-func (b *Reader) ReadRune() (r rune, size int, err os.Error) {
+func (b *Reader) ReadRune() (r rune, size int, err error) {
        for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil {
                b.fill()
        }
@@ -230,7 +229,7 @@ func (b *Reader) ReadRune() (r rune, size int, err os.Error) {
 // the buffer was not a ReadRune, UnreadRune returns an error.  (In this
 // regard it is stricter than UnreadByte, which will unread the last byte
 // from any read operation.)
-func (b *Reader) UnreadRune() os.Error {
+func (b *Reader) UnreadRune() error {
        if b.lastRuneSize < 0 || b.r == 0 {
                return ErrInvalidUnreadRune
        }
@@ -253,7 +252,7 @@ func (b *Reader) Buffered() int { return b.w - b.r }
 // by the next I/O operation, most clients should use
 // ReadBytes or ReadString instead.
 // ReadSlice returns err != nil if and only if line does not end in delim.
-func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
+func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
        // Look in buffer.
        if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
                line1 := b.buf[b.r : b.r+i+1]
@@ -295,7 +294,7 @@ func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
 // of the line. The returned buffer is only valid until the next call to
 // ReadLine. ReadLine either returns a non-nil line or it returns an error,
 // never both.
-func (b *Reader) ReadLine() (line []byte, isPrefix bool, err os.Error) {
+func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
        line, err = b.ReadSlice('\n')
        if err == ErrBufferFull {
                // Handle the case where "\r\n" straddles the buffer.
@@ -333,7 +332,7 @@ func (b *Reader) ReadLine() (line []byte, isPrefix bool, err os.Error) {
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadBytes returns err != nil if and only if the returned data does not end in
 // delim.
-func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
+func (b *Reader) ReadBytes(delim byte) (line []byte, err error) {
        // Use ReadSlice to look for array,
        // accumulating full buffers.
        var frag []byte
@@ -341,7 +340,7 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
        err = nil
 
        for {
-               var e os.Error
+               var e error
                frag, e = b.ReadSlice(delim)
                if e == nil { // got final fragment
                        break
@@ -380,7 +379,7 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadString returns err != nil if and only if the returned data does not end in
 // delim.
-func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
+func (b *Reader) ReadString(delim byte) (line string, err error) {
        bytes, e := b.ReadBytes(delim)
        return string(bytes), e
 }
@@ -389,7 +388,7 @@ func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
 
 // Writer implements buffering for an io.Writer object.
 type Writer struct {
-       err os.Error
+       err error
        buf []byte
        n   int
        wr  io.Writer
@@ -399,7 +398,7 @@ type Writer struct {
 // which must be greater than zero. If the argument io.Writer is already a
 // Writer with large enough size, it returns the underlying Writer.
 // It returns the Writer and any error.
-func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) {
+func NewWriterSize(wr io.Writer, size int) (*Writer, error) {
        if size <= 0 {
                return nil, BufSizeError(size)
        }
@@ -425,7 +424,7 @@ func NewWriter(wr io.Writer) *Writer {
 }
 
 // Flush writes any buffered data to the underlying io.Writer.
-func (b *Writer) Flush() os.Error {
+func (b *Writer) Flush() error {
        if b.err != nil {
                return b.err
        }
@@ -458,7 +457,7 @@ func (b *Writer) Buffered() int { return b.n }
 // It returns the number of bytes written.
 // If nn < len(p), it also returns an error explaining
 // why the write is short.
-func (b *Writer) Write(p []byte) (nn int, err os.Error) {
+func (b *Writer) Write(p []byte) (nn int, err error) {
        for len(p) > b.Available() && b.err == nil {
                var n int
                if b.Buffered() == 0 {
@@ -483,7 +482,7 @@ func (b *Writer) Write(p []byte) (nn int, err os.Error) {
 }
 
 // WriteByte writes a single byte.
-func (b *Writer) WriteByte(c byte) os.Error {
+func (b *Writer) WriteByte(c byte) error {
        if b.err != nil {
                return b.err
        }
@@ -497,7 +496,7 @@ func (b *Writer) WriteByte(c byte) os.Error {
 
 // WriteRune writes a single Unicode code point, returning
 // the number of bytes written and any error.
-func (b *Writer) WriteRune(r rune) (size int, err os.Error) {
+func (b *Writer) WriteRune(r rune) (size int, err error) {
        if r < utf8.RuneSelf {
                err = b.WriteByte(byte(r))
                if err != nil {
@@ -528,7 +527,7 @@ func (b *Writer) WriteRune(r rune) (size int, err os.Error) {
 // It returns the number of bytes written.
 // If the count is less than len(s), it also returns an error explaining
 // why the write is short.
-func (b *Writer) WriteString(s string) (int, os.Error) {
+func (b *Writer) WriteString(s string) (int, error) {
        nn := 0
        for len(s) > b.Available() && b.err == nil {
                n := copy(b.buf[b.n:], s)
index 4fd5f90..0285dee 100644 (file)
@@ -28,7 +28,7 @@ func newRot13Reader(r io.Reader) *rot13Reader {
        return r13
 }
 
-func (r13 *rot13Reader) Read(p []byte) (int, os.Error) {
+func (r13 *rot13Reader) Read(p []byte) (int, error) {
        n, e := r13.r.Read(p)
        if e != nil {
                return n, e
@@ -50,14 +50,14 @@ func readBytes(buf *Reader) string {
        nb := 0
        for {
                c, e := buf.ReadByte()
-               if e == os.EOF {
+               if e == io.EOF {
                        break
                }
                if e == nil {
                        b[nb] = c
                        nb++
                } else if e != iotest.ErrTimeout {
-                       panic("Data: " + e.String())
+                       panic("Data: " + e.Error())
                }
        }
        return string(b[0:nb])
@@ -95,11 +95,11 @@ func readLines(b *Reader) string {
        s := ""
        for {
                s1, e := b.ReadString('\n')
-               if e == os.EOF {
+               if e == io.EOF {
                        break
                }
                if e != nil && e != iotest.ErrTimeout {
-                       panic("GetLines: " + e.String())
+                       panic("GetLines: " + e.Error())
                }
                s += s1
        }
@@ -113,7 +113,7 @@ func reads(buf *Reader, m int) string {
        for {
                n, e := buf.Read(b[nb : nb+m])
                nb += n
-               if e == os.EOF {
+               if e == io.EOF {
                        break
                }
        }
@@ -179,13 +179,13 @@ type StringReader struct {
        step int
 }
 
-func (r *StringReader) Read(p []byte) (n int, err os.Error) {
+func (r *StringReader) Read(p []byte) (n int, err error) {
        if r.step < len(r.data) {
                s := r.data[r.step]
                n = copy(p, s)
                r.step++
        } else {
-               err = os.EOF
+               err = io.EOF
        }
        return
 }
@@ -197,7 +197,7 @@ func readRuneSegments(t *testing.T, segments []string) {
        for {
                r, _, err := r.ReadRune()
                if err != nil {
-                       if err != os.EOF {
+                       if err != io.EOF {
                                return
                        }
                        break
@@ -235,7 +235,7 @@ func TestUnreadRune(t *testing.T) {
        for {
                r1, _, err := r.ReadRune()
                if err != nil {
-                       if err != os.EOF {
+                       if err != io.EOF {
                                t.Error("unexpected EOF")
                        }
                        break
@@ -328,7 +328,7 @@ func TestUnreadRuneAtEOF(t *testing.T) {
        _, _, err := r.ReadRune()
        if err == nil {
                t.Error("expected error at EOF")
-       } else if err != os.EOF {
+       } else if err != io.EOF {
                t.Error("expected EOF; got", err)
        }
 }
@@ -413,11 +413,11 @@ func TestWriter(t *testing.T) {
 
 type errorWriterTest struct {
        n, m   int
-       err    os.Error
-       expect os.Error
+       err    error
+       expect error
 }
 
-func (w errorWriterTest) Write(p []byte) (int, os.Error) {
+func (w errorWriterTest) Write(p []byte) (int, error) {
        return len(p) * w.n / w.m, w.err
 }
 
@@ -559,7 +559,7 @@ func TestPeek(t *testing.T) {
        if s, err := buf.Peek(0); string(s) != "" || err != nil {
                t.Fatalf("want %q got %q, err=%v", "", string(s), err)
        }
-       if _, err := buf.Peek(1); err != os.EOF {
+       if _, err := buf.Peek(1); err != io.EOF {
                t.Fatalf("want EOF got %v", err)
        }
 }
@@ -583,7 +583,7 @@ type testReader struct {
        stride int
 }
 
-func (t *testReader) Read(buf []byte) (n int, err os.Error) {
+func (t *testReader) Read(buf []byte) (n int, err error) {
        n = t.stride
        if n > len(t.data) {
                n = len(t.data)
@@ -594,7 +594,7 @@ func (t *testReader) Read(buf []byte) (n int, err os.Error) {
        copy(buf, t.data)
        t.data = t.data[n:]
        if len(t.data) == 0 {
-               err = os.EOF
+               err = io.EOF
        }
        return
 }
@@ -614,7 +614,7 @@ func testReadLine(t *testing.T, input []byte) {
                                t.Errorf("ReadLine returned prefix")
                        }
                        if err != nil {
-                               if err != os.EOF {
+                               if err != io.EOF {
                                        t.Fatalf("Got unknown error: %s", err)
                                }
                                break
@@ -679,7 +679,7 @@ func TestReadAfterLines(t *testing.T) {
 func TestReadEmptyBuffer(t *testing.T) {
        l, _ := NewReaderSize(bytes.NewBuffer(nil), 10)
        line, isPrefix, err := l.ReadLine()
-       if err != os.EOF {
+       if err != io.EOF {
                t.Errorf("expected EOF from ReadLine, got '%s' %t %s", line, isPrefix, err)
        }
 }
@@ -693,7 +693,7 @@ func TestLinesAfterRead(t *testing.T) {
        }
 
        line, isPrefix, err := l.ReadLine()
-       if err != os.EOF {
+       if err != io.EOF {
                t.Errorf("expected EOF from ReadLine, got '%s' %t %s", line, isPrefix, err)
        }
 }
@@ -701,7 +701,7 @@ func TestLinesAfterRead(t *testing.T) {
 type readLineResult struct {
        line     []byte
        isPrefix bool
-       err      os.Error
+       err      error
 }
 
 var readLineNewlinesTests = []struct {
@@ -714,27 +714,27 @@ var readLineNewlinesTests = []struct {
                {nil, false, nil},
                {[]byte("b"), true, nil},
                {nil, false, nil},
-               {nil, false, os.EOF},
+               {nil, false, io.EOF},
        }},
        {"hello\r\nworld\r\n", 6, []readLineResult{
                {[]byte("hello"), true, nil},
                {nil, false, nil},
                {[]byte("world"), true, nil},
                {nil, false, nil},
-               {nil, false, os.EOF},
+               {nil, false, io.EOF},
        }},
        {"hello\rworld\r", 6, []readLineResult{
                {[]byte("hello"), true, nil},
                {[]byte("\rworld"), true, nil},
                {[]byte("\r"), false, nil},
-               {nil, false, os.EOF},
+               {nil, false, io.EOF},
        }},
        {"h\ri\r\n\r", 2, []readLineResult{
                {[]byte("h"), true, nil},
                {[]byte("\ri"), true, nil},
                {nil, false, nil},
                {[]byte("\r"), false, nil},
-               {nil, false, os.EOF},
+               {nil, false, io.EOF},
        }},
 }
 
index c2a8c9f..fbfd621 100644 (file)
@@ -7,8 +7,8 @@ package bytes
 // Simple byte buffer for marshaling data.
 
 import (
+       "errors"
        "io"
-       "os"
        "utf8"
 )
 
@@ -94,7 +94,7 @@ func (b *Buffer) grow(n int) int {
 
 // Write appends the contents of p to the buffer.  The return
 // value n is the length of p; err is always nil.
-func (b *Buffer) Write(p []byte) (n int, err os.Error) {
+func (b *Buffer) Write(p []byte) (n int, err error) {
        b.lastRead = opInvalid
        m := b.grow(len(p))
        copy(b.buf[m:], p)
@@ -103,7 +103,7 @@ func (b *Buffer) Write(p []byte) (n int, err os.Error) {
 
 // WriteString appends the contents of s to the buffer.  The return
 // value n is the length of s; err is always nil.
-func (b *Buffer) WriteString(s string) (n int, err os.Error) {
+func (b *Buffer) WriteString(s string) (n int, err error) {
        b.lastRead = opInvalid
        m := b.grow(len(s))
        return copy(b.buf[m:], s), nil
@@ -119,7 +119,7 @@ const MinRead = 512
 // The return value n is the number of bytes read.
 // Any error except os.EOF encountered during the read
 // is also returned.
-func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
+func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
        b.lastRead = opInvalid
        // If buffer is empty, reset to recover space.
        if b.off >= len(b.buf) {
@@ -143,7 +143,7 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
                m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
                b.buf = b.buf[0 : len(b.buf)+m]
                n += int64(m)
-               if e == os.EOF {
+               if e == io.EOF {
                        break
                }
                if e != nil {
@@ -157,7 +157,7 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
 // occurs. The return value n is the number of bytes written; it always
 // fits into an int, but it is int64 to match the io.WriterTo interface.
 // Any error encountered during the write is also returned.
-func (b *Buffer) WriteTo(w io.Writer) (n int64, err os.Error) {
+func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) {
        b.lastRead = opInvalid
        if b.off < len(b.buf) {
                m, e := w.Write(b.buf[b.off:])
@@ -177,7 +177,7 @@ func (b *Buffer) WriteTo(w io.Writer) (n int64, err os.Error) {
 // WriteByte appends the byte c to the buffer.
 // The returned error is always nil, but is included
 // to match bufio.Writer's WriteByte.
-func (b *Buffer) WriteByte(c byte) os.Error {
+func (b *Buffer) WriteByte(c byte) error {
        b.lastRead = opInvalid
        m := b.grow(1)
        b.buf[m] = c
@@ -188,7 +188,7 @@ func (b *Buffer) WriteByte(c byte) os.Error {
 // code point r to the buffer, returning its length and
 // an error, which is always nil but is included
 // to match bufio.Writer's WriteRune.
-func (b *Buffer) WriteRune(r rune) (n int, err os.Error) {
+func (b *Buffer) WriteRune(r rune) (n int, err error) {
        if r < utf8.RuneSelf {
                b.WriteByte(byte(r))
                return 1, nil
@@ -202,12 +202,12 @@ func (b *Buffer) WriteRune(r rune) (n int, err os.Error) {
 // is drained.  The return value n is the number of bytes read.  If the
 // buffer has no data to return, err is os.EOF even if len(p) is zero;
 // otherwise it is nil.
-func (b *Buffer) Read(p []byte) (n int, err os.Error) {
+func (b *Buffer) Read(p []byte) (n int, err error) {
        b.lastRead = opInvalid
        if b.off >= len(b.buf) {
                // Buffer is empty, reset to recover space.
                b.Truncate(0)
-               return 0, os.EOF
+               return 0, io.EOF
        }
        n = copy(p, b.buf[b.off:])
        b.off += n
@@ -237,12 +237,12 @@ func (b *Buffer) Next(n int) []byte {
 
 // ReadByte reads and returns the next byte from the buffer.
 // If no byte is available, it returns error os.EOF.
-func (b *Buffer) ReadByte() (c byte, err os.Error) {
+func (b *Buffer) ReadByte() (c byte, err error) {
        b.lastRead = opInvalid
        if b.off >= len(b.buf) {
                // Buffer is empty, reset to recover space.
                b.Truncate(0)
-               return 0, os.EOF
+               return 0, io.EOF
        }
        c = b.buf[b.off]
        b.off++
@@ -255,12 +255,12 @@ func (b *Buffer) ReadByte() (c byte, err os.Error) {
 // If no bytes are available, the error returned is os.EOF.
 // If the bytes are an erroneous UTF-8 encoding, it
 // consumes one byte and returns U+FFFD, 1.
-func (b *Buffer) ReadRune() (r rune, size int, err os.Error) {
+func (b *Buffer) ReadRune() (r rune, size int, err error) {
        b.lastRead = opInvalid
        if b.off >= len(b.buf) {
                // Buffer is empty, reset to recover space.
                b.Truncate(0)
-               return 0, 0, os.EOF
+               return 0, 0, io.EOF
        }
        b.lastRead = opReadRune
        c := b.buf[b.off]
@@ -278,9 +278,9 @@ func (b *Buffer) ReadRune() (r rune, size int, err os.Error) {
 // not a ReadRune, UnreadRune returns an error.  (In this regard
 // it is stricter than UnreadByte, which will unread the last byte
 // from any read operation.)
-func (b *Buffer) UnreadRune() os.Error {
+func (b *Buffer) UnreadRune() error {
        if b.lastRead != opReadRune {
-               return os.NewError("bytes.Buffer: UnreadRune: previous operation was not ReadRune")
+               return errors.New("bytes.Buffer: UnreadRune: previous operation was not ReadRune")
        }
        b.lastRead = opInvalid
        if b.off > 0 {
@@ -293,9 +293,9 @@ func (b *Buffer) UnreadRune() os.Error {
 // UnreadByte unreads the last byte returned by the most recent
 // read operation.  If write has happened since the last read, UnreadByte
 // returns an error.
-func (b *Buffer) UnreadByte() os.Error {
+func (b *Buffer) UnreadByte() error {
        if b.lastRead != opReadRune && b.lastRead != opRead {
-               return os.NewError("bytes.Buffer: UnreadByte: previous operation was not a read")
+               return errors.New("bytes.Buffer: UnreadByte: previous operation was not a read")
        }
        b.lastRead = opInvalid
        if b.off > 0 {
@@ -310,12 +310,12 @@ func (b *Buffer) UnreadByte() os.Error {
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadBytes returns err != nil if and only if the returned data does not end in
 // delim.
-func (b *Buffer) ReadBytes(delim byte) (line []byte, err os.Error) {
+func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) {
        i := IndexByte(b.buf[b.off:], delim)
        size := i + 1
        if i < 0 {
                size = len(b.buf) - b.off
-               err = os.EOF
+               err = io.EOF
        }
        line = make([]byte, size)
        copy(line, b.buf[b.off:])
@@ -329,7 +329,7 @@ func (b *Buffer) ReadBytes(delim byte) (line []byte, err os.Error) {
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadString returns err != nil if and only if the returned data does not end
 // in delim.
-func (b *Buffer) ReadString(delim byte) (line string, err os.Error) {
+func (b *Buffer) ReadString(delim byte) (line string, err error) {
        bytes, err := b.ReadBytes(delim)
        return string(bytes), err
 }
index ee38e08..c271b48 100644 (file)
@@ -6,7 +6,7 @@ package bytes_test
 
 import (
        . "bytes"
-       "os"
+       "io"
        "rand"
        "testing"
        "utf8"
@@ -344,21 +344,21 @@ var readBytesTests = []struct {
        buffer   string
        delim    byte
        expected []string
-       err      os.Error
+       err      error
 }{
-       {"", 0, []string{""}, os.EOF},
+       {"", 0, []string{""}, io.EOF},
        {"a\x00", 0, []string{"a\x00"}, nil},
        {"abbbaaaba", 'b', []string{"ab", "b", "b", "aaab"}, nil},
        {"hello\x01world", 1, []string{"hello\x01"}, nil},
-       {"foo\nbar", 0, []string{"foo\nbar"}, os.EOF},
+       {"foo\nbar", 0, []string{"foo\nbar"}, io.EOF},
        {"alpha\nbeta\ngamma\n", '\n', []string{"alpha\n", "beta\n", "gamma\n"}, nil},
-       {"alpha\nbeta\ngamma", '\n', []string{"alpha\n", "beta\n", "gamma"}, os.EOF},
+       {"alpha\nbeta\ngamma", '\n', []string{"alpha\n", "beta\n", "gamma"}, io.EOF},
 }
 
 func TestReadBytes(t *testing.T) {
        for _, test := range readBytesTests {
                buf := NewBufferString(test.buffer)
-               var err os.Error
+               var err error
                for _, expected := range test.expected {
                        var bytes []byte
                        bytes, err = buf.ReadBytes(test.delim)
index 50f0ec8..d058c14 100644 (file)
@@ -7,25 +7,24 @@ package bzip2
 import (
        "bufio"
        "io"
-       "os"
 )
 
 // bitReader wraps an io.Reader and provides the ability to read values,
-// bit-by-bit, from it. Its Read* methods don't return the usual os.Error
+// bit-by-bit, from it. Its Read* methods don't return the usual error
 // because the error handling was verbose. Instead, any error is kept and can
 // be checked afterwards.
 type bitReader struct {
        r    byteReader
        n    uint64
        bits uint
-       err  os.Error
+       err  error
 }
 
 // bitReader needs to read bytes from an io.Reader. We attempt to cast the
 // given io.Reader to this interface and, if it doesn't already fit, we wrap in
 // a bufio.Reader.
 type byteReader interface {
-       ReadByte() (byte, os.Error)
+       ReadByte() (byte, error)
 }
 
 func newBitReader(r io.Reader) bitReader {
@@ -42,7 +41,7 @@ func newBitReader(r io.Reader) bitReader {
 func (br *bitReader) ReadBits64(bits uint) (n uint64) {
        for bits > br.bits {
                b, err := br.r.ReadByte()
-               if err == os.EOF {
+               if err == io.EOF {
                        err = io.ErrUnexpectedEOF
                }
                if err != nil {
@@ -83,6 +82,6 @@ func (br *bitReader) ReadBit() bool {
        return n != 0
 }
 
-func (br *bitReader) Error() os.Error {
+func (br *bitReader) Error() error {
        return br.err
 }
index 8b45723..343cca0 100644 (file)
@@ -5,10 +5,7 @@
 // Package bzip2 implements bzip2 decompression.
 package bzip2
 
-import (
-       "io"
-       "os"
-)
+import "io"
 
 // There's no RFC for bzip2. I used the Wikipedia page for reference and a lot
 // of guessing: http://en.wikipedia.org/wiki/Bzip2
@@ -19,7 +16,7 @@ import (
 // syntactically invalid.
 type StructuralError string
 
-func (s StructuralError) String() string {
+func (s StructuralError) Error() string {
        return "bzip2 data invalid: " + string(s)
 }
 
@@ -53,7 +50,7 @@ const bzip2BlockMagic = 0x314159265359
 const bzip2FinalMagic = 0x177245385090
 
 // setup parses the bzip2 header.
-func (bz2 *reader) setup() os.Error {
+func (bz2 *reader) setup() error {
        br := &bz2.br
 
        magic := br.ReadBits(16)
@@ -76,9 +73,9 @@ func (bz2 *reader) setup() os.Error {
        return nil
 }
 
-func (bz2 *reader) Read(buf []byte) (n int, err os.Error) {
+func (bz2 *reader) Read(buf []byte) (n int, err error) {
        if bz2.eof {
-               return 0, os.EOF
+               return 0, io.EOF
        }
 
        if !bz2.setupDone {
@@ -101,7 +98,7 @@ func (bz2 *reader) Read(buf []byte) (n int, err os.Error) {
        return
 }
 
-func (bz2 *reader) read(buf []byte) (n int, err os.Error) {
+func (bz2 *reader) read(buf []byte) (n int, err error) {
        // bzip2 is a block based compressor, except that it has a run-length
        // preprocessing step. The block based nature means that we can
        // preallocate fixed-size buffers and reuse them. However, the RLE
@@ -162,7 +159,7 @@ func (bz2 *reader) read(buf []byte) (n int, err os.Error) {
        if magic == bzip2FinalMagic {
                br.ReadBits64(32) // ignored CRC
                bz2.eof = true
-               return 0, os.EOF
+               return 0, io.EOF
        } else if magic != bzip2BlockMagic {
                return 0, StructuralError("bad magic value found")
        }
@@ -176,7 +173,7 @@ func (bz2 *reader) read(buf []byte) (n int, err os.Error) {
 }
 
 // readBlock reads a bzip2 block. The magic number should already have been consumed.
-func (bz2 *reader) readBlock() (err os.Error) {
+func (bz2 *reader) readBlock() (err error) {
        br := &bz2.br
        br.ReadBits64(32) // skip checksum. TODO: check it if we can figure out what it is.
        randomized := br.ReadBits(1)
index 156eea8..7b227ac 100644 (file)
@@ -9,7 +9,6 @@ import (
        "encoding/hex"
        "io"
        "io/ioutil"
-       "os"
        "testing"
 )
 
@@ -46,7 +45,7 @@ func readerFromHex(s string) io.Reader {
        return bytes.NewBuffer(data)
 }
 
-func decompressHex(s string) (out []byte, err os.Error) {
+func decompressHex(s string) (out []byte, err error) {
        r := NewReader(readerFromHex(s))
        return ioutil.ReadAll(r)
 }
index dc05739..078c1cb 100644 (file)
@@ -4,10 +4,7 @@
 
 package bzip2
 
-import (
-       "os"
-       "sort"
-)
+import "sort"
 
 // A huffmanTree is a binary tree which is navigated, bit-by-bit to reach a
 // symbol.
@@ -63,7 +60,7 @@ func (t huffmanTree) Decode(br *bitReader) (v uint16) {
 
 // newHuffmanTree builds a Huffman tree from a slice containing the code
 // lengths of each symbol. The maximum code length is 32 bits.
-func newHuffmanTree(lengths []uint8) (huffmanTree, os.Error) {
+func newHuffmanTree(lengths []uint8) (huffmanTree, error) {
        // There are many possible trees that assign the same code length to
        // each symbol (consider reflecting a tree down the middle, for
        // example). Since the code length assignments determine the
@@ -176,7 +173,7 @@ func (n huffmanCodes) Swap(i, j int) {
 // buildHuffmanNode takes a slice of sorted huffmanCodes and builds a node in
 // the Huffman tree at the given level. It returns the index of the newly
 // constructed node.
-func buildHuffmanNode(t *huffmanTree, codes []huffmanCode, level uint32) (nodeIndex uint16, err os.Error) {
+func buildHuffmanNode(t *huffmanTree, codes []huffmanCode, level uint32) (nodeIndex uint16, err error) {
        test := uint32(1) << (31 - level)
 
        // We have to search the list of codes to find the divide between the left and right sides.
index b1cee0b..1f659ba 100644 (file)
@@ -7,7 +7,6 @@ package flate
 import (
        "io"
        "math"
-       "os"
 )
 
 const (
@@ -89,7 +88,7 @@ type compressor struct {
        offset         int
        hash           int
        maxInsertIndex int
-       err            os.Error
+       err            error
 }
 
 func (d *compressor) fillDeflate(b []byte) int {
@@ -123,7 +122,7 @@ func (d *compressor) fillDeflate(b []byte) int {
        return n
 }
 
-func (d *compressor) writeBlock(tokens []token, index int, eof bool) os.Error {
+func (d *compressor) writeBlock(tokens []token, index int, eof bool) error {
        if index > 0 || eof {
                var window []byte
                if d.blockStart <= index {
@@ -194,7 +193,7 @@ func (d *compressor) findMatch(pos int, prevHead int, prevLength int, lookahead
        return
 }
 
-func (d *compressor) writeStoredBlock(buf []byte) os.Error {
+func (d *compressor) writeStoredBlock(buf []byte) error {
        if d.w.writeStoredHeader(len(buf), false); d.w.err != nil {
                return d.w.err
        }
@@ -365,7 +364,7 @@ func (d *compressor) store() {
        d.windowEnd = 0
 }
 
-func (d *compressor) write(b []byte) (n int, err os.Error) {
+func (d *compressor) write(b []byte) (n int, err error) {
        n = len(b)
        b = b[d.fill(d, b):]
        for len(b) > 0 {
@@ -375,7 +374,7 @@ func (d *compressor) write(b []byte) (n int, err os.Error) {
        return n, d.err
 }
 
-func (d *compressor) syncFlush() os.Error {
+func (d *compressor) syncFlush() error {
        d.sync = true
        d.step(d)
        if d.err == nil {
@@ -387,7 +386,7 @@ func (d *compressor) syncFlush() os.Error {
        return d.err
 }
 
-func (d *compressor) init(w io.Writer, level int) (err os.Error) {
+func (d *compressor) init(w io.Writer, level int) (err error) {
        d.w = newHuffmanBitWriter(w)
 
        switch {
@@ -409,7 +408,7 @@ func (d *compressor) init(w io.Writer, level int) (err os.Error) {
        return nil
 }
 
-func (d *compressor) close() os.Error {
+func (d *compressor) close() error {
        d.sync = true
        d.step(d)
        if d.err != nil {
@@ -455,7 +454,7 @@ type dictWriter struct {
        enabled bool
 }
 
-func (w *dictWriter) Write(b []byte) (n int, err os.Error) {
+func (w *dictWriter) Write(b []byte) (n int, err error) {
        if w.enabled {
                return w.w.Write(b)
        }
@@ -470,7 +469,7 @@ type Writer struct {
 
 // Write writes data to w, which will eventually write the
 // compressed form of data to its underlying writer.
-func (w *Writer) Write(data []byte) (n int, err os.Error) {
+func (w *Writer) Write(data []byte) (n int, err error) {
        return w.d.write(data)
 }
 
@@ -481,13 +480,13 @@ func (w *Writer) Write(data []byte) (n int, err os.Error) {
 // If the underlying writer returns an error, Flush returns that error.
 //
 // In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH.
-func (w *Writer) Flush() os.Error {
+func (w *Writer) Flush() error {
        // For more about flushing:
        // http://www.bolet.org/~pornin/deflate-flush.html
        return w.d.syncFlush()
 }
 
 // Close flushes and closes the writer.
-func (w *Writer) Close() os.Error {
+func (w *Writer) Close() error {
        return w.d.close()
 }
index 9308236..db2d71d 100644 (file)
@@ -9,7 +9,6 @@ import (
        "fmt"
        "io"
        "io/ioutil"
-       "os"
        "sync"
        "testing"
 )
@@ -102,7 +101,7 @@ func newSyncBuffer() *syncBuffer {
        return &syncBuffer{ready: make(chan bool, 1)}
 }
 
-func (b *syncBuffer) Read(p []byte) (n int, err os.Error) {
+func (b *syncBuffer) Read(p []byte) (n int, err error) {
        for {
                b.mu.RLock()
                n, err = b.buf.Read(p)
@@ -122,7 +121,7 @@ func (b *syncBuffer) signal() {
        }
 }
 
-func (b *syncBuffer) Write(p []byte) (n int, err os.Error) {
+func (b *syncBuffer) Write(p []byte) (n int, err error) {
        n, err = b.buf.Write(p)
        b.signal()
        return
@@ -137,7 +136,7 @@ func (b *syncBuffer) ReadMode() {
        b.signal()
 }
 
-func (b *syncBuffer) Close() os.Error {
+func (b *syncBuffer) Close() error {
        b.closed = true
        b.signal()
        return nil
@@ -204,7 +203,7 @@ func testSync(t *testing.T, level int, input []byte, name string) {
        }
        buf.ReadMode()
        out := make([]byte, 10)
-       if n, err := r.Read(out); n > 0 || err != os.EOF {
+       if n, err := r.Read(out); n > 0 || err != io.EOF {
                t.Errorf("testSync (%d, %d, %s): final Read: %d, %v (hex: %x)", level, len(input), name, n, err, out[0:n])
        }
        if buf.buf.Len() != 0 {
@@ -225,7 +224,7 @@ func testSync(t *testing.T, level int, input []byte, name string) {
        }
 }
 
-func testToFromWithLevel(t *testing.T, level int, input []byte, name string) os.Error {
+func testToFromWithLevel(t *testing.T, level int, input []byte, name string) error {
        buffer := bytes.NewBuffer(nil)
        w := NewWriter(buffer, level)
        w.Write(input)
index 3981df5..efd99c6 100644 (file)
@@ -7,7 +7,6 @@ package flate
 import (
        "io"
        "math"
-       "os"
        "strconv"
 )
 
@@ -83,7 +82,7 @@ type huffmanBitWriter struct {
        literalEncoding *huffmanEncoder
        offsetEncoding  *huffmanEncoder
        codegenEncoding *huffmanEncoder
-       err             os.Error
+       err             error
 }
 
 type WrongValueError struct {
@@ -106,7 +105,7 @@ func newHuffmanBitWriter(w io.Writer) *huffmanBitWriter {
        }
 }
 
-func (err WrongValueError) String() string {
+func (err WrongValueError) Error() string {
        return "huffmanBitWriter: " + err.name + " should belong to [" + strconv.Itoa64(int64(err.from)) + ";" +
                strconv.Itoa64(int64(err.to)) + "] but actual value is " + strconv.Itoa64(int64(err.value))
 }
index 3845f12..3f0c948 100644 (file)
@@ -10,7 +10,6 @@ package flate
 import (
        "bufio"
        "io"
-       "os"
        "strconv"
 )
 
@@ -25,33 +24,33 @@ const (
 // A CorruptInputError reports the presence of corrupt input at a given offset.
 type CorruptInputError int64
 
-func (e CorruptInputError) String() string {
+func (e CorruptInputError) Error() string {
        return "flate: corrupt input before offset " + strconv.Itoa64(int64(e))
 }
 
 // An InternalError reports an error in the flate code itself.
 type InternalError string
 
-func (e InternalError) String() string { return "flate: internal error: " + string(e) }
+func (e InternalError) Error() string { return "flate: internal error: " + string(e) }
 
 // A ReadError reports an error encountered while reading input.
 type ReadError struct {
-       Offset int64    // byte offset where error occurred
-       Error  os.Error // error returned by underlying Read
+       Offset int64 // byte offset where error occurred
+       Err    error // error returned by underlying Read
 }
 
-func (e *ReadError) String() string {
-       return "flate: read error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Error.String()
+func (e *ReadError) Error() string {
+       return "flate: read error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Err.Error()
 }
 
 // A WriteError reports an error encountered while writing output.
 type WriteError struct {
-       Offset int64    // byte offset where error occurred
-       Error  os.Error // error returned by underlying Write
+       Offset int64 // byte offset where error occurred
+       Err    error // error returned by underlying Write
 }
 
-func (e *WriteError) String() string {
-       return "flate: write error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Error.String()
+func (e *WriteError) Error() string {
+       return "flate: write error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Err.Error()
 }
 
 // Huffman decoder is based on
@@ -190,7 +189,7 @@ var fixedHuffmanDecoder = huffmanDecoder{
 // the NewReader will introduce its own buffering.
 type Reader interface {
        io.Reader
-       ReadByte() (c byte, err os.Error)
+       ReadByte() (c byte, err error)
 }
 
 // Decompress state.
@@ -224,7 +223,7 @@ type decompressor struct {
        // and decompression state.
        step     func(*decompressor)
        final    bool
-       err      os.Error
+       err      error
        toRead   []byte
        hl, hd   *huffmanDecoder
        copyLen  int
@@ -237,7 +236,7 @@ func (f *decompressor) nextBlock() {
                        f.flush((*decompressor).nextBlock)
                        return
                }
-               f.err = os.EOF
+               f.err = io.EOF
                return
        }
        for f.nb < 1+2 {
@@ -272,7 +271,7 @@ func (f *decompressor) nextBlock() {
        }
 }
 
-func (f *decompressor) Read(b []byte) (int, os.Error) {
+func (f *decompressor) Read(b []byte) (int, error) {
        for {
                if len(f.toRead) > 0 {
                        n := copy(b, f.toRead)
@@ -287,8 +286,8 @@ func (f *decompressor) Read(b []byte) (int, os.Error) {
        panic("unreachable")
 }
 
-func (f *decompressor) Close() os.Error {
-       if f.err == os.EOF {
+func (f *decompressor) Close() error {
+       if f.err == io.EOF {
                return nil
        }
        return f.err
@@ -299,7 +298,7 @@ func (f *decompressor) Close() os.Error {
 
 var codeOrder = [...]int{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}
 
-func (f *decompressor) readHuffman() os.Error {
+func (f *decompressor) readHuffman() error {
        // HLIT[5], HDIST[5], HCLEN[4].
        for f.nb < 5+5+4 {
                if err := f.moreBits(); err != nil {
@@ -625,10 +624,10 @@ func (f *decompressor) setDict(dict []byte) {
        f.hw = f.hp
 }
 
-func (f *decompressor) moreBits() os.Error {
+func (f *decompressor) moreBits() error {
        c, err := f.r.ReadByte()
        if err != nil {
-               if err == os.EOF {
+               if err == io.EOF {
                        err = io.ErrUnexpectedEOF
                }
                return err
@@ -640,7 +639,7 @@ func (f *decompressor) moreBits() os.Error {
 }
 
 // Read the next Huffman-encoded symbol from f according to h.
-func (f *decompressor) huffSym(h *huffmanDecoder) (int, os.Error) {
+func (f *decompressor) huffSym(h *huffmanDecoder) (int, error) {
        for n := uint(h.min); n <= uint(h.max); n++ {
                lim := h.limit[n]
                if lim == -1 {
index 6ac9293..a23e515 100644 (file)
@@ -9,10 +9,10 @@ package gzip
 import (
        "bufio"
        "compress/flate"
+       "errors"
        "hash"
        "hash/crc32"
        "io"
-       "os"
 )
 
 // BUG(nigeltao): Comments and Names don't properly map UTF-8 character codes outside of
@@ -36,8 +36,8 @@ func makeReader(r io.Reader) flate.Reader {
        return bufio.NewReader(r)
 }
 
-var HeaderError = os.NewError("invalid gzip header")
-var ChecksumError = os.NewError("gzip checksum error")
+var HeaderError = errors.New("invalid gzip header")
+var ChecksumError = errors.New("gzip checksum error")
 
 // The gzip file stores a header giving metadata about the compressed file.
 // That header is exposed as the fields of the Compressor and Decompressor structs.
@@ -71,13 +71,13 @@ type Decompressor struct {
        size         uint32
        flg          byte
        buf          [512]byte
-       err          os.Error
+       err          error
 }
 
 // NewReader creates a new Decompressor reading the given reader.
 // The implementation buffers input and may read more data than necessary from r.
 // It is the caller's responsibility to call Close on the Decompressor when done.
-func NewReader(r io.Reader) (*Decompressor, os.Error) {
+func NewReader(r io.Reader) (*Decompressor, error) {
        z := new(Decompressor)
        z.r = makeReader(r)
        z.digest = crc32.NewIEEE()
@@ -93,8 +93,8 @@ func get4(p []byte) uint32 {
        return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
 }
 
-func (z *Decompressor) readString() (string, os.Error) {
-       var err os.Error
+func (z *Decompressor) readString() (string, error) {
+       var err error
        for i := 0; ; i++ {
                if i >= len(z.buf) {
                        return "", HeaderError
@@ -112,7 +112,7 @@ func (z *Decompressor) readString() (string, os.Error) {
        panic("not reached")
 }
 
-func (z *Decompressor) read2() (uint32, os.Error) {
+func (z *Decompressor) read2() (uint32, error) {
        _, err := io.ReadFull(z.r, z.buf[0:2])
        if err != nil {
                return 0, err
@@ -120,7 +120,7 @@ func (z *Decompressor) read2() (uint32, os.Error) {
        return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil
 }
 
-func (z *Decompressor) readHeader(save bool) os.Error {
+func (z *Decompressor) readHeader(save bool) error {
        _, err := io.ReadFull(z.r, z.buf[0:10])
        if err != nil {
                return err
@@ -186,7 +186,7 @@ func (z *Decompressor) readHeader(save bool) os.Error {
        return nil
 }
 
-func (z *Decompressor) Read(p []byte) (n int, err os.Error) {
+func (z *Decompressor) Read(p []byte) (n int, err error) {
        if z.err != nil {
                return 0, z.err
        }
@@ -197,7 +197,7 @@ func (z *Decompressor) Read(p []byte) (n int, err os.Error) {
        n, err = z.decompressor.Read(p)
        z.digest.Write(p[0:n])
        z.size += uint32(n)
-       if n != 0 || err != os.EOF {
+       if n != 0 || err != io.EOF {
                z.err = err
                return
        }
@@ -227,4 +227,4 @@ func (z *Decompressor) Read(p []byte) (n int, err os.Error) {
 }
 
 // Calling Close does not close the wrapped io.Reader originally passed to NewReader.
-func (z *Decompressor) Close() os.Error { return z.decompressor.Close() }
+func (z *Decompressor) Close() error { return z.decompressor.Close() }
index 1c08c73..771b0b6 100644 (file)
@@ -7,7 +7,6 @@ package gzip
 import (
        "bytes"
        "io"
-       "os"
        "testing"
 )
 
@@ -16,7 +15,7 @@ type gunzipTest struct {
        desc string
        raw  string
        gzip []byte
-       err  os.Error
+       err  error
 }
 
 var gunzipTests = []gunzipTest{
index 8860d10..94b0f1f 100644 (file)
@@ -6,10 +6,10 @@ package gzip
 
 import (
        "compress/flate"
+       "errors"
        "hash"
        "hash/crc32"
        "io"
-       "os"
 )
 
 // These constants are copied from the flate package, so that code that imports
@@ -32,11 +32,11 @@ type Compressor struct {
        size       uint32
        closed     bool
        buf        [10]byte
-       err        os.Error
+       err        error
 }
 
 // NewWriter calls NewWriterLevel with the default compression level.
-func NewWriter(w io.Writer) (*Compressor, os.Error) {
+func NewWriter(w io.Writer) (*Compressor, error) {
        return NewWriterLevel(w, DefaultCompression)
 }
 
@@ -47,7 +47,7 @@ func NewWriter(w io.Writer) (*Compressor, os.Error) {
 // It is the caller's responsibility to call Close on the WriteCloser when done.
 // level is the compression level, which can be DefaultCompression, NoCompression,
 // or any integer value between BestSpeed and BestCompression (inclusive).
-func NewWriterLevel(w io.Writer, level int) (*Compressor, os.Error) {
+func NewWriterLevel(w io.Writer, level int) (*Compressor, error) {
        z := new(Compressor)
        z.OS = 255 // unknown
        z.w = w
@@ -70,9 +70,9 @@ func put4(p []byte, v uint32) {
 }
 
 // writeBytes writes a length-prefixed byte slice to z.w.
-func (z *Compressor) writeBytes(b []byte) os.Error {
+func (z *Compressor) writeBytes(b []byte) error {
        if len(b) > 0xffff {
-               return os.NewError("gzip.Write: Extra data is too large")
+               return errors.New("gzip.Write: Extra data is too large")
        }
        put2(z.buf[0:2], uint16(len(b)))
        _, err := z.w.Write(z.buf[0:2])
@@ -84,12 +84,12 @@ func (z *Compressor) writeBytes(b []byte) os.Error {
 }
 
 // writeString writes a string (in ISO 8859-1 (Latin-1) format) to z.w.
-func (z *Compressor) writeString(s string) os.Error {
+func (z *Compressor) writeString(s string) error {
        // GZIP (RFC 1952) specifies that strings are NUL-terminated ISO 8859-1 (Latin-1).
        // TODO(nigeltao): Convert from UTF-8 to ISO 8859-1 (Latin-1).
        for _, v := range s {
                if v == 0 || v > 0x7f {
-                       return os.NewError("gzip.Write: non-ASCII header string")
+                       return errors.New("gzip.Write: non-ASCII header string")
                }
        }
        _, err := io.WriteString(z.w, s)
@@ -102,7 +102,7 @@ func (z *Compressor) writeString(s string) os.Error {
        return err
 }
 
-func (z *Compressor) Write(p []byte) (int, os.Error) {
+func (z *Compressor) Write(p []byte) (int, error) {
        if z.err != nil {
                return 0, z.err
        }
@@ -162,7 +162,7 @@ func (z *Compressor) Write(p []byte) (int, os.Error) {
 }
 
 // Calling Close does not close the wrapped io.Writer originally passed to NewWriter.
-func (z *Compressor) Close() os.Error {
+func (z *Compressor) Close() error {
        if z.err != nil {
                return z.err
        }
index 21231c8..c787a95 100644 (file)
@@ -16,6 +16,7 @@ package lzw
 
 import (
        "bufio"
+       "errors"
        "fmt"
        "io"
        "os"
@@ -45,9 +46,9 @@ type decoder struct {
        bits     uint32
        nBits    uint
        width    uint
-       read     func(*decoder) (uint16, os.Error) // readLSB or readMSB
-       litWidth int                               // width in bits of literal codes
-       err      os.Error
+       read     func(*decoder) (uint16, error) // readLSB or readMSB
+       litWidth int                            // width in bits of literal codes
+       err      error
 
        // The first 1<<litWidth codes are literal codes.
        // The next two codes mean clear and EOF.
@@ -78,7 +79,7 @@ type decoder struct {
 }
 
 // readLSB returns the next code for "Least Significant Bits first" data.
-func (d *decoder) readLSB() (uint16, os.Error) {
+func (d *decoder) readLSB() (uint16, error) {
        for d.nBits < d.width {
                x, err := d.r.ReadByte()
                if err != nil {
@@ -94,7 +95,7 @@ func (d *decoder) readLSB() (uint16, os.Error) {
 }
 
 // readMSB returns the next code for "Most Significant Bits first" data.
-func (d *decoder) readMSB() (uint16, os.Error) {
+func (d *decoder) readMSB() (uint16, error) {
        for d.nBits < d.width {
                x, err := d.r.ReadByte()
                if err != nil {
@@ -109,7 +110,7 @@ func (d *decoder) readMSB() (uint16, os.Error) {
        return code, nil
 }
 
-func (d *decoder) Read(b []byte) (int, os.Error) {
+func (d *decoder) Read(b []byte) (int, error) {
        for {
                if len(d.toRead) > 0 {
                        n := copy(b, d.toRead)
@@ -132,7 +133,7 @@ func (d *decoder) decode() {
        for {
                code, err := d.read(d)
                if err != nil {
-                       if err == os.EOF {
+                       if err == io.EOF {
                                err = io.ErrUnexpectedEOF
                        }
                        d.err = err
@@ -156,7 +157,7 @@ func (d *decoder) decode() {
                        continue
                case code == d.eof:
                        d.flush()
-                       d.err = os.EOF
+                       d.err = io.EOF
                        return
                case code <= d.hi:
                        c, i := code, len(d.output)-1
@@ -186,7 +187,7 @@ func (d *decoder) decode() {
                                d.prefix[d.hi] = d.last
                        }
                default:
-                       d.err = os.NewError("lzw: invalid code")
+                       d.err = errors.New("lzw: invalid code")
                        return
                }
                d.last, d.hi = code, d.hi+1
@@ -211,7 +212,7 @@ func (d *decoder) flush() {
        d.o = 0
 }
 
-func (d *decoder) Close() os.Error {
+func (d *decoder) Close() error {
        d.err = os.EINVAL // in case any Reads come along
        return nil
 }
@@ -230,7 +231,7 @@ func NewReader(r io.Reader, order Order, litWidth int) io.ReadCloser {
        case MSB:
                d.read = (*decoder).readMSB
        default:
-               d.err = os.NewError("lzw: unknown order")
+               d.err = errors.New("lzw: unknown order")
                return d
        }
        if litWidth < 2 || 8 < litWidth {
index f8042b0..0982157 100644 (file)
@@ -8,7 +8,6 @@ import (
        "bytes"
        "io"
        "io/ioutil"
-       "os"
        "runtime"
        "strconv"
        "strings"
@@ -19,7 +18,7 @@ type lzwTest struct {
        desc       string
        raw        string
        compressed string
-       err        os.Error
+       err        error
 }
 
 var lzwTests = []lzwTest{
index 87143b7..3f380fa 100644 (file)
@@ -6,6 +6,7 @@ package lzw
 
 import (
        "bufio"
+       "errors"
        "fmt"
        "io"
        "os"
@@ -13,20 +14,20 @@ import (
 
 // A writer is a buffered, flushable writer.
 type writer interface {
-       WriteByte(byte) os.Error
-       Flush() os.Error
+       WriteByte(byte) error
+       Flush() error
 }
 
 // An errWriteCloser is an io.WriteCloser that always returns a given error.
 type errWriteCloser struct {
-       err os.Error
+       err error
 }
 
-func (e *errWriteCloser) Write([]byte) (int, os.Error) {
+func (e *errWriteCloser) Write([]byte) (int, error) {
        return 0, e.err
 }
 
-func (e *errWriteCloser) Close() os.Error {
+func (e *errWriteCloser) Close() error {
        return e.err
 }
 
@@ -50,7 +51,7 @@ type encoder struct {
        w writer
        // write, bits, nBits and width are the state for converting a code stream
        // into a byte stream.
-       write func(*encoder, uint32) os.Error
+       write func(*encoder, uint32) error
        bits  uint32
        nBits uint
        width uint
@@ -64,7 +65,7 @@ type encoder struct {
        savedCode uint32
        // err is the first error encountered during writing. Closing the encoder
        // will make any future Write calls return os.EINVAL.
-       err os.Error
+       err error
        // table is the hash table from 20-bit keys to 12-bit values. Each table
        // entry contains key<<12|val and collisions resolve by linear probing.
        // The keys consist of a 12-bit code prefix and an 8-bit byte suffix.
@@ -73,7 +74,7 @@ type encoder struct {
 }
 
 // writeLSB writes the code c for "Least Significant Bits first" data.
-func (e *encoder) writeLSB(c uint32) os.Error {
+func (e *encoder) writeLSB(c uint32) error {
        e.bits |= c << e.nBits
        e.nBits += e.width
        for e.nBits >= 8 {
@@ -87,7 +88,7 @@ func (e *encoder) writeLSB(c uint32) os.Error {
 }
 
 // writeMSB writes the code c for "Most Significant Bits first" data.
-func (e *encoder) writeMSB(c uint32) os.Error {
+func (e *encoder) writeMSB(c uint32) error {
        e.bits |= c << (32 - e.width - e.nBits)
        e.nBits += e.width
        for e.nBits >= 8 {
@@ -102,12 +103,12 @@ func (e *encoder) writeMSB(c uint32) os.Error {
 
 // errOutOfCodes is an internal error that means that the encoder has run out
 // of unused codes and a clear code needs to be sent next.
-var errOutOfCodes = os.NewError("lzw: out of codes")
+var errOutOfCodes = errors.New("lzw: out of codes")
 
 // incHi increments e.hi and checks for both overflow and running out of
 // unused codes. In the latter case, incHi sends a clear code, resets the
 // encoder state and returns errOutOfCodes.
-func (e *encoder) incHi() os.Error {
+func (e *encoder) incHi() error {
        e.hi++
        if e.hi == e.overflow {
                e.width++
@@ -130,7 +131,7 @@ func (e *encoder) incHi() os.Error {
 }
 
 // Write writes a compressed representation of p to e's underlying writer.
-func (e *encoder) Write(p []byte) (int, os.Error) {
+func (e *encoder) Write(p []byte) (int, error) {
        if e.err != nil {
                return 0, e.err
        }
@@ -188,7 +189,7 @@ loop:
 
 // Close closes the encoder, flushing any pending output. It does not close or
 // flush e's underlying writer.
-func (e *encoder) Close() os.Error {
+func (e *encoder) Close() error {
        if e.err != nil {
                if e.err == os.EINVAL {
                        return nil
@@ -230,14 +231,14 @@ func (e *encoder) Close() os.Error {
 // The number of bits to use for literal codes, litWidth, must be in the
 // range [2,8] and is typically 8.
 func NewWriter(w io.Writer, order Order, litWidth int) io.WriteCloser {
-       var write func(*encoder, uint32) os.Error
+       var write func(*encoder, uint32) error
        switch order {
        case LSB:
                write = (*encoder).writeLSB
        case MSB:
                write = (*encoder).writeMSB
        default:
-               return &errWriteCloser{os.NewError("lzw: unknown order")}
+               return &errWriteCloser{errors.New("lzw: unknown order")}
        }
        if litWidth < 2 || 8 < litWidth {
                return &errWriteCloser{fmt.Errorf("lzw: litWidth %d out of range", litWidth)}
index 4c5e522..154cdf8 100644 (file)
@@ -45,7 +45,7 @@ func testFile(t *testing.T, fn string, order Order, litWidth int) {
                var b [4096]byte
                for {
                        n, err0 := raw.Read(b[:])
-                       if err0 != nil && err0 != os.EOF {
+                       if err0 != nil && err0 != io.EOF {
                                t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err0)
                                return
                        }
@@ -58,7 +58,7 @@ func testFile(t *testing.T, fn string, order Order, litWidth int) {
                                t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err1)
                                return
                        }
-                       if err0 == os.EOF {
+                       if err0 == io.EOF {
                                break
                        }
                }
index 78dabdf..50a1e6c 100644 (file)
@@ -26,36 +26,36 @@ package zlib
 import (
        "bufio"
        "compress/flate"
+       "errors"
        "hash"
        "hash/adler32"
        "io"
-       "os"
 )
 
 const zlibDeflate = 8
 
-var ChecksumError = os.NewError("zlib checksum error")
-var HeaderError = os.NewError("invalid zlib header")
-var DictionaryError = os.NewError("invalid zlib dictionary")
+var ChecksumError = errors.New("zlib checksum error")
+var HeaderError = errors.New("invalid zlib header")
+var DictionaryError = errors.New("invalid zlib dictionary")
 
 type reader struct {
        r            flate.Reader
        decompressor io.ReadCloser
        digest       hash.Hash32
-       err          os.Error
+       err          error
        scratch      [4]byte
 }
 
 // NewReader creates a new io.ReadCloser that satisfies reads by decompressing data read from r.
 // The implementation buffers input and may read more data than necessary from r.
 // It is the caller's responsibility to call Close on the ReadCloser when done.
-func NewReader(r io.Reader) (io.ReadCloser, os.Error) {
+func NewReader(r io.Reader) (io.ReadCloser, error) {
        return NewReaderDict(r, nil)
 }
 
 // NewReaderDict is like NewReader but uses a preset dictionary.
 // NewReaderDict ignores the dictionary if the compressed data does not refer to it.
-func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, os.Error) {
+func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error) {
        z := new(reader)
        if fr, ok := r.(flate.Reader); ok {
                z.r = fr
@@ -87,7 +87,7 @@ func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, os.Error) {
        return z, nil
 }
 
-func (z *reader) Read(p []byte) (n int, err os.Error) {
+func (z *reader) Read(p []byte) (n int, err error) {
        if z.err != nil {
                return 0, z.err
        }
@@ -97,7 +97,7 @@ func (z *reader) Read(p []byte) (n int, err os.Error) {
 
        n, err = z.decompressor.Read(p)
        z.digest.Write(p[0:n])
-       if n != 0 || err != os.EOF {
+       if n != 0 || err != io.EOF {
                z.err = err
                return
        }
@@ -117,7 +117,7 @@ func (z *reader) Read(p []byte) (n int, err os.Error) {
 }
 
 // Calling Close does not close the wrapped io.Reader originally passed to NewReader.
-func (z *reader) Close() os.Error {
+func (z *reader) Close() error {
        if z.err != nil {
                return z.err
        }
index 195db44..d8f9f21 100644 (file)
@@ -7,7 +7,6 @@ package zlib
 import (
        "bytes"
        "io"
-       "os"
        "testing"
 )
 
@@ -16,7 +15,7 @@ type zlibTest struct {
        raw        string
        compressed []byte
        dict       []byte
-       err        os.Error
+       err        error
 }
 
 // Compare-to-golden test data was generated by the ZLIB example program at
index 8f86e9c..bbff637 100644 (file)
@@ -6,10 +6,10 @@ package zlib
 
 import (
        "compress/flate"
+       "errors"
        "hash"
        "hash/adler32"
        "io"
-       "os"
 )
 
 // These constants are copied from the flate package, so that code that imports
@@ -27,17 +27,17 @@ type Writer struct {
        w          io.Writer
        compressor *flate.Writer
        digest     hash.Hash32
-       err        os.Error
+       err        error
        scratch    [4]byte
 }
 
 // NewWriter calls NewWriterLevel with the default compression level.
-func NewWriter(w io.Writer) (*Writer, os.Error) {
+func NewWriter(w io.Writer) (*Writer, error) {
        return NewWriterLevel(w, DefaultCompression)
 }
 
 // NewWriterLevel calls NewWriterDict with no dictionary.
-func NewWriterLevel(w io.Writer, level int) (*Writer, os.Error) {
+func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
        return NewWriterDict(w, level, nil)
 }
 
@@ -46,7 +46,7 @@ func NewWriterLevel(w io.Writer, level int) (*Writer, os.Error) {
 // level is the compression level, which can be DefaultCompression, NoCompression,
 // or any integer value between BestSpeed and BestCompression (inclusive).
 // dict is the preset dictionary to compress with, or nil to use no dictionary.
-func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, os.Error) {
+func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error) {
        z := new(Writer)
        // ZLIB has a two-byte header (as documented in RFC 1950).
        // The first four bits is the CINFO (compression info), which is 7 for the default deflate window size.
@@ -66,7 +66,7 @@ func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, os.Error) {
        case 7, 8, 9:
                z.scratch[1] = 3 << 6
        default:
-               return nil, os.NewError("level out of range")
+               return nil, errors.New("level out of range")
        }
        if dict != nil {
                z.scratch[1] |= 1 << 5
@@ -94,7 +94,7 @@ func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, os.Error) {
        return z, nil
 }
 
-func (z *Writer) Write(p []byte) (n int, err os.Error) {
+func (z *Writer) Write(p []byte) (n int, err error) {
        if z.err != nil {
                return 0, z.err
        }
@@ -111,7 +111,7 @@ func (z *Writer) Write(p []byte) (n int, err os.Error) {
 }
 
 // Flush flushes the underlying compressor.
-func (z *Writer) Flush() os.Error {
+func (z *Writer) Flush() error {
        if z.err != nil {
                return z.err
        }
@@ -120,7 +120,7 @@ func (z *Writer) Flush() os.Error {
 }
 
 // Calling Close does not close the wrapped io.Writer originally passed to NewWriter.
-func (z *Writer) Close() os.Error {
+func (z *Writer) Close() error {
        if z.err != nil {
                return z.err
        }
index 7322353..5ad75ec 100644 (file)
@@ -4,10 +4,7 @@
 
 package aes
 
-import (
-       "os"
-       "strconv"
-)
+import "strconv"
 
 // The AES block size in bytes.
 const BlockSize = 16
@@ -20,7 +17,7 @@ type Cipher struct {
 
 type KeySizeError int
 
-func (k KeySizeError) String() string {
+func (k KeySizeError) Error() string {
        return "crypto/aes: invalid key size " + strconv.Itoa(int(k))
 }
 
@@ -28,7 +25,7 @@ func (k KeySizeError) String() string {
 // The key argument should be the AES key,
 // either 16, 24, or 32 bytes to select
 // AES-128, AES-192, or AES-256.
-func NewCipher(key []byte) (*Cipher, os.Error) {
+func NewCipher(key []byte) (*Cipher, error) {
        k := len(key)
        switch k {
        default:
index ed6cea7..fc31160 100644 (file)
@@ -4,10 +4,7 @@
 
 package bcrypt
 
-import (
-       "encoding/base64"
-       "os"
-)
+import "encoding/base64"
 
 const alphabet = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
 
@@ -23,7 +20,7 @@ func base64Encode(src []byte) []byte {
        return dst[:n]
 }
 
-func base64Decode(src []byte) ([]byte, os.Error) {
+func base64Decode(src []byte) ([]byte, error) {
        numOfEquals := 4 - (len(src) % 4)
        for i := 0; i < numOfEquals; i++ {
                src = append(src, '=')
index 1e8ccfa..9740135 100644 (file)
@@ -11,9 +11,9 @@ import (
        "crypto/blowfish"
        "crypto/rand"
        "crypto/subtle"
+       "errors"
        "fmt"
        "io"
-       "os"
        "strconv"
 )
 
@@ -25,30 +25,30 @@ const (
 
 // The error returned from CompareHashAndPassword when a password and hash do
 // not match.
-var MismatchedHashAndPasswordError = os.NewError("crypto/bcrypt: hashedPassword is not the hash of the given password")
+var MismatchedHashAndPasswordError = errors.New("crypto/bcrypt: hashedPassword is not the hash of the given password")
 
 // The error returned from CompareHashAndPassword when a hash is too short to
 // be a bcrypt hash.
-var HashTooShortError = os.NewError("crypto/bcrypt: hashedSecret too short to be a bcrypted password")
+var HashTooShortError = errors.New("crypto/bcrypt: hashedSecret too short to be a bcrypted password")
 
 // The error returned from CompareHashAndPassword when a hash was created with
 // a bcrypt algorithm newer than this implementation.
 type HashVersionTooNewError byte
 
-func (hv HashVersionTooNewError) String() string {
+func (hv HashVersionTooNewError) Error() string {
        return fmt.Sprintf("crypto/bcrypt: bcrypt algorithm version '%c' requested is newer than current version '%c'", byte(hv), majorVersion)
 }
 
 // The error returned from CompareHashAndPassword when a hash starts with something other than '$'
 type InvalidHashPrefixError byte
 
-func (ih InvalidHashPrefixError) String() string {
+func (ih InvalidHashPrefixError) Error() string {
        return fmt.Sprintf("crypto/bcrypt: bcrypt hashes must start with '$', but hashedSecret started with '%c'", byte(ih))
 }
 
 type InvalidCostError int
 
-func (ic InvalidCostError) String() string {
+func (ic InvalidCostError) Error() string {
        return fmt.Sprintf("crypto/bcrypt: cost %d is outside allowed range (%d,%d)", int(ic), int(MinCost), int(MaxCost))
 }
 
@@ -85,7 +85,7 @@ type hashed struct {
 // cost. If the cost given is less than MinCost, the cost will be set to
 // MinCost, instead. Use CompareHashAndPassword, as defined in this package,
 // to compare the returned hashed password with its cleartext version.
-func GenerateFromPassword(password []byte, cost int) ([]byte, os.Error) {
+func GenerateFromPassword(password []byte, cost int) ([]byte, error) {
        p, err := newFromPassword(password, cost)
        if err != nil {
                return nil, err
@@ -96,7 +96,7 @@ func GenerateFromPassword(password []byte, cost int) ([]byte, os.Error) {
 // CompareHashAndPassword compares a bcrypt hashed password with its possible
 // plaintext equivalent. Note: Using bytes.Equal for this job is
 // insecure. Returns nil on success, or an error on failure.
-func CompareHashAndPassword(hashedPassword, password []byte) os.Error {
+func CompareHashAndPassword(hashedPassword, password []byte) error {
        p, err := newFromHash(hashedPassword)
        if err != nil {
                return err
@@ -115,7 +115,7 @@ func CompareHashAndPassword(hashedPassword, password []byte) os.Error {
        return MismatchedHashAndPasswordError
 }
 
-func newFromPassword(password []byte, cost int) (*hashed, os.Error) {
+func newFromPassword(password []byte, cost int) (*hashed, error) {
        if cost < MinCost {
                cost = DefaultCost
        }
@@ -144,7 +144,7 @@ func newFromPassword(password []byte, cost int) (*hashed, os.Error) {
        return p, err
 }
 
-func newFromHash(hashedSecret []byte) (*hashed, os.Error) {
+func newFromHash(hashedSecret []byte) (*hashed, error) {
        if len(hashedSecret) < minHashSize {
                return nil, HashTooShortError
        }
@@ -172,7 +172,7 @@ func newFromHash(hashedSecret []byte) (*hashed, os.Error) {
        return p, nil
 }
 
-func bcrypt(password []byte, cost uint32, salt []byte) ([]byte, os.Error) {
+func bcrypt(password []byte, cost uint32, salt []byte) ([]byte, error) {
        cipherData := make([]byte, len(magicCipherData))
        copy(cipherData, magicCipherData)
 
@@ -193,7 +193,7 @@ func bcrypt(password []byte, cost uint32, salt []byte) ([]byte, os.Error) {
        return hsh, nil
 }
 
-func expensiveBlowfishSetup(key []byte, cost uint32, salt []byte) (*blowfish.Cipher, os.Error) {
+func expensiveBlowfishSetup(key []byte, cost uint32, salt []byte) (*blowfish.Cipher, error) {
 
        csalt, err := base64Decode(salt)
        if err != nil {
@@ -240,7 +240,7 @@ func (p *hashed) Hash() []byte {
        return arr[:n]
 }
 
-func (p *hashed) decodeVersion(sbytes []byte) (int, os.Error) {
+func (p *hashed) decodeVersion(sbytes []byte) (int, error) {
        if sbytes[0] != '$' {
                return -1, InvalidHashPrefixError(sbytes[0])
        }
@@ -257,7 +257,7 @@ func (p *hashed) decodeVersion(sbytes []byte) (int, os.Error) {
 }
 
 // sbytes should begin where decodeVersion left off.
-func (p *hashed) decodeCost(sbytes []byte) (int, os.Error) {
+func (p *hashed) decodeCost(sbytes []byte) (int, error) {
        cost, err := strconv.Atoi(string(sbytes[0:2]))
        if err != nil {
                return -1, err
@@ -274,7 +274,7 @@ func (p *hashed) String() string {
        return fmt.Sprintf("&{hash: %#v, salt: %#v, cost: %d, major: %c, minor: %c}", string(p.hash), p.salt, p.cost, p.major, p.minor)
 }
 
-func checkCost(cost int) os.Error {
+func checkCost(cost int) error {
        if cost < MinCost || cost > MaxCost {
                return InvalidCostError(cost)
        }
index 3efbc1c..a3155c5 100644 (file)
@@ -6,7 +6,6 @@ package bcrypt
 
 import (
        "bytes"
-       "os"
        "testing"
 )
 
@@ -68,7 +67,7 @@ func TestTooLongPasswordsWork(t *testing.T) {
 }
 
 type InvalidHashTest struct {
-       err  os.Error
+       err  error
        hash []byte
 }
 
@@ -81,7 +80,7 @@ var invalidTests = []InvalidHashTest{
 }
 
 func TestInvalidHashErrors(t *testing.T) {
-       check := func(name string, expected, err os.Error) {
+       check := func(name string, expected, err error) {
                if err == nil {
                        t.Errorf("%s: Should have returned an error", name)
                }
index 3439825..a5d56d2 100644 (file)
@@ -8,10 +8,7 @@ package blowfish
 // The code is a port of Bruce Schneier's C implementation.
 // See http://www.schneier.com/blowfish.html.
 
-import (
-       "os"
-       "strconv"
-)
+import "strconv"
 
 // The Blowfish block size in bytes.
 const BlockSize = 8
@@ -24,13 +21,13 @@ type Cipher struct {
 
 type KeySizeError int
 
-func (k KeySizeError) String() string {
+func (k KeySizeError) Error() string {
        return "crypto/blowfish: invalid key size " + strconv.Itoa(int(k))
 }
 
 // NewCipher creates and returns a Cipher.
 // The key argument should be the Blowfish key, 4 to 56 bytes.
-func NewCipher(key []byte) (*Cipher, os.Error) {
+func NewCipher(key []byte) (*Cipher, error) {
        var result Cipher
        k := len(key)
        if k < 4 || k > 56 {
@@ -45,7 +42,7 @@ func NewCipher(key []byte) (*Cipher, os.Error) {
 // schedule. For most purposes, NewCipher, instead of NewSaltedCipher, is
 // sufficient and desirable. For bcrypt compatiblity, the key can be over 56
 // bytes.
-func NewSaltedCipher(key, salt []byte) (*Cipher, os.Error) {
+func NewSaltedCipher(key, salt []byte) (*Cipher, error) {
        var result Cipher
        k := len(key)
        if k < 4 {
index e9d4a24..889a13c 100644 (file)
@@ -6,9 +6,7 @@
 // OpenPGP cipher.
 package cast5
 
-import (
-       "os"
-)
+import "errors"
 
 const BlockSize = 8
 const KeySize = 16
@@ -18,9 +16,9 @@ type Cipher struct {
        rotate  [16]uint8
 }
 
-func NewCipher(key []byte) (c *Cipher, err os.Error) {
+func NewCipher(key []byte) (c *Cipher, err error) {
        if len(key) != KeySize {
-               return nil, os.NewError("CAST5: keys must be 16 bytes")
+               return nil, errors.New("CAST5: keys must be 16 bytes")
        }
 
        c = new(Cipher)
index 97f40b8..9888c98 100644 (file)
@@ -4,10 +4,7 @@
 
 package cipher
 
-import (
-       "os"
-       "io"
-)
+import "io"
 
 // The Stream* objects are so simple that all their members are public. Users
 // can create them themselves.
@@ -19,7 +16,7 @@ type StreamReader struct {
        R io.Reader
 }
 
-func (r StreamReader) Read(dst []byte) (n int, err os.Error) {
+func (r StreamReader) Read(dst []byte) (n int, err error) {
        n, err = r.R.Read(dst)
        r.S.XORKeyStream(dst[:n], dst[:n])
        return
@@ -31,10 +28,10 @@ func (r StreamReader) Read(dst []byte) (n int, err os.Error) {
 type StreamWriter struct {
        S   Stream
        W   io.Writer
-       Err os.Error
+       Err error
 }
 
-func (w StreamWriter) Write(src []byte) (n int, err os.Error) {
+func (w StreamWriter) Write(src []byte) (n int, err error) {
        if w.Err != nil {
                return 0, w.Err
        }
@@ -50,7 +47,7 @@ func (w StreamWriter) Write(src []byte) (n int, err os.Error) {
        return
 }
 
-func (w StreamWriter) Close() os.Error {
+func (w StreamWriter) Close() error {
        // This saves us from either requiring a WriteCloser or having a
        // StreamWriterCloser.
        return w.W.(io.Closer).Close()
index d17a1a7..fc252c8 100644 (file)
@@ -4,17 +4,14 @@
 
 package des
 
-import (
-       "os"
-       "strconv"
-)
+import "strconv"
 
 // The DES block size in bytes.
 const BlockSize = 8
 
 type KeySizeError int
 
-func (k KeySizeError) String() string {
+func (k KeySizeError) Error() string {
        return "crypto/des: invalid key size " + strconv.Itoa(int(k))
 }
 
@@ -24,7 +21,7 @@ type Cipher struct {
 }
 
 // NewCipher creates and returns a new Cipher.
-func NewCipher(key []byte) (*Cipher, os.Error) {
+func NewCipher(key []byte) (*Cipher, error) {
        if len(key) != 8 {
                return nil, KeySizeError(len(key))
        }
@@ -60,7 +57,7 @@ type TripleDESCipher struct {
 }
 
 // NewCipher creates and returns a new Cipher.
-func NewTripleDESCipher(key []byte) (*TripleDESCipher, os.Error) {
+func NewTripleDESCipher(key []byte) (*TripleDESCipher, error) {
        if len(key) != 24 {
                return nil, KeySizeError(len(key))
        }
index a5f96fe..692d62a 100644 (file)
@@ -7,8 +7,8 @@ package dsa
 
 import (
        "big"
+       "errors"
        "io"
-       "os"
 )
 
 // Parameters represents the domain parameters for a key. These parameters can
@@ -31,7 +31,7 @@ type PrivateKey struct {
 
 type invalidPublicKeyError int
 
-func (invalidPublicKeyError) String() string {
+func (invalidPublicKeyError) Error() string {
        return "crypto/dsa: invalid public key"
 }
 
@@ -58,7 +58,7 @@ const numMRTests = 64
 
 // GenerateParameters puts a random, valid set of DSA parameters into params.
 // This function takes many seconds, even on fast machines.
-func GenerateParameters(params *Parameters, rand io.Reader, sizes ParameterSizes) (err os.Error) {
+func GenerateParameters(params *Parameters, rand io.Reader, sizes ParameterSizes) (err error) {
        // This function doesn't follow FIPS 186-3 exactly in that it doesn't
        // use a verification seed to generate the primes. The verification
        // seed doesn't appear to be exported or used by other code and
@@ -79,7 +79,7 @@ func GenerateParameters(params *Parameters, rand io.Reader, sizes ParameterSizes
                L = 3072
                N = 256
        default:
-               return os.NewError("crypto/dsa: invalid ParameterSizes")
+               return errors.New("crypto/dsa: invalid ParameterSizes")
        }
 
        qBytes := make([]byte, N/8)
@@ -156,9 +156,9 @@ GeneratePrimes:
 
 // GenerateKey generates a public&private key pair. The Parameters of the
 // PrivateKey must already be valid (see GenerateParameters).
-func GenerateKey(priv *PrivateKey, rand io.Reader) os.Error {
+func GenerateKey(priv *PrivateKey, rand io.Reader) error {
        if priv.P == nil || priv.Q == nil || priv.G == nil {
-               return os.NewError("crypto/dsa: parameters not set up before generating key")
+               return errors.New("crypto/dsa: parameters not set up before generating key")
        }
 
        x := new(big.Int)
@@ -185,7 +185,7 @@ func GenerateKey(priv *PrivateKey, rand io.Reader) os.Error {
 // larger message) using the private key, priv. It returns the signature as a
 // pair of integers. The security of the private key depends on the entropy of
 // rand.
-func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err os.Error) {
+func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
        // FIPS 186-3, section 4.6
 
        n := priv.Q.BitLen()
index 7bce1bc..b7f235b 100644 (file)
@@ -16,7 +16,6 @@ import (
        "big"
        "crypto/elliptic"
        "io"
-       "os"
 )
 
 // PublicKey represents an ECDSA public key.
@@ -35,7 +34,7 @@ var one = new(big.Int).SetInt64(1)
 
 // randFieldElement returns a random element of the field underlying the given
 // curve using the procedure given in [NSA] A.2.1.
-func randFieldElement(c *elliptic.Curve, rand io.Reader) (k *big.Int, err os.Error) {
+func randFieldElement(c *elliptic.Curve, rand io.Reader) (k *big.Int, err error) {
        b := make([]byte, c.BitSize/8+8)
        _, err = io.ReadFull(rand, b)
        if err != nil {
@@ -50,7 +49,7 @@ func randFieldElement(c *elliptic.Curve, rand io.Reader) (k *big.Int, err os.Err
 }
 
 // GenerateKey generates a public&private key pair.
-func GenerateKey(c *elliptic.Curve, rand io.Reader) (priv *PrivateKey, err os.Error) {
+func GenerateKey(c *elliptic.Curve, rand io.Reader) (priv *PrivateKey, err error) {
        k, err := randFieldElement(c, rand)
        if err != nil {
                return
@@ -86,7 +85,7 @@ func hashToInt(hash []byte, c *elliptic.Curve) *big.Int {
 // larger message) using the private key, priv. It returns the signature as a
 // pair of integers. The security of the private key depends on the entropy of
 // rand.
-func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err os.Error) {
+func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
        // See [NSA] 3.4.1
        c := priv.PublicKey.Curve
 
index 41835f1..3c3327f 100644 (file)
@@ -16,7 +16,6 @@ package elliptic
 import (
        "big"
        "io"
-       "os"
        "sync"
 )
 
@@ -249,7 +248,7 @@ var mask = []byte{0xff, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f}
 
 // GenerateKey returns a public/private key pair. The private key is generated
 // using the given reader, which must return random data.
-func (curve *Curve) GenerateKey(rand io.Reader) (priv []byte, x, y *big.Int, err os.Error) {
+func (curve *Curve) GenerateKey(rand io.Reader) (priv []byte, x, y *big.Int, err error) {
        byteLen := (curve.BitSize + 7) >> 3
        priv = make([]byte, byteLen)
 
index 04ec86e..6a17bbd 100644 (file)
@@ -13,7 +13,6 @@ import (
        "crypto/sha1"
        "crypto/sha256"
        "hash"
-       "os"
 )
 
 // FIPS 198:
@@ -60,7 +59,7 @@ func (h *hmac) Sum() []byte {
        return h.outer.Sum()
 }
 
-func (h *hmac) Write(p []byte) (n int, err os.Error) {
+func (h *hmac) Write(p []byte) (n int, err error) {
        return h.inner.Write(p)
 }
 
index 848d955..f21cc51 100644 (file)
@@ -8,7 +8,6 @@ package md4
 import (
        "crypto"
        "hash"
-       "os"
 )
 
 func init() {
@@ -52,7 +51,7 @@ func New() hash.Hash {
 
 func (d *digest) Size() int { return Size }
 
-func (d *digest) Write(p []byte) (nn int, err os.Error) {
+func (d *digest) Write(p []byte) (nn int, err error) {
        nn = len(p)
        d.len += uint64(nn)
        if d.nx > 0 {
index 378faa6..20f3a1b 100644 (file)
@@ -8,7 +8,6 @@ package md5
 import (
        "crypto"
        "hash"
-       "os"
 )
 
 func init() {
@@ -52,7 +51,7 @@ func New() hash.Hash {
 
 func (d *digest) Size() int { return Size }
 
-func (d *digest) Write(p []byte) (nn int, err os.Error) {
+func (d *digest) Write(p []byte) (nn int, err error) {
        nn = len(p)
        d.len += uint64(nn)
        if d.nx > 0 {
index 7ea7a1e..f697fa1 100644 (file)
@@ -14,7 +14,6 @@ import (
        _ "crypto/sha1"
        "crypto/x509"
        "crypto/x509/pkix"
-       "os"
        "time"
 )
 
@@ -106,7 +105,7 @@ type Response struct {
 // ParseError results from an invalid OCSP response.
 type ParseError string
 
-func (p ParseError) String() string {
+func (p ParseError) Error() string {
        return string(p)
 }
 
@@ -114,7 +113,7 @@ func (p ParseError) String() string {
 // responses for a single certificate and only those using RSA signatures.
 // Non-RSA responses will result in an x509.UnsupportedAlgorithmError.
 // Signature errors or parse failures will result in a ParseError.
-func ParseResponse(bytes []byte) (*Response, os.Error) {
+func ParseResponse(bytes []byte) (*Response, error) {
        var resp responseASN1
        rest, err := asn1.Unmarshal(bytes, &resp)
        if err != nil {
index 9c4180d..707bdf3 100644 (file)
@@ -9,10 +9,9 @@ package armor
 import (
        "bufio"
        "bytes"
-       "crypto/openpgp/error"
+       error_ "crypto/openpgp/error"
        "encoding/base64"
        "io"
-       "os"
 )
 
 // A Block represents an OpenPGP armored structure.
@@ -36,7 +35,7 @@ type Block struct {
        oReader openpgpReader
 }
 
-var ArmorCorrupt os.Error = error.StructuralError("armor invalid")
+var ArmorCorrupt error = error_.StructuralError("armor invalid")
 
 const crc24Init = 0xb704ce
 const crc24Poly = 0x1864cfb
@@ -69,9 +68,9 @@ type lineReader struct {
        crc uint32
 }
 
-func (l *lineReader) Read(p []byte) (n int, err os.Error) {
+func (l *lineReader) Read(p []byte) (n int, err error) {
        if l.eof {
-               return 0, os.EOF
+               return 0, io.EOF
        }
 
        if len(l.buf) > 0 {
@@ -101,7 +100,7 @@ func (l *lineReader) Read(p []byte) (n int, err os.Error) {
                        uint32(expectedBytes[2])
 
                line, _, err = l.in.ReadLine()
-               if err != nil && err != os.EOF {
+               if err != nil && err != io.EOF {
                        return
                }
                if !bytes.HasPrefix(line, armorEnd) {
@@ -109,7 +108,7 @@ func (l *lineReader) Read(p []byte) (n int, err os.Error) {
                }
 
                l.eof = true
-               return 0, os.EOF
+               return 0, io.EOF
        }
 
        if len(line) > 64 {
@@