Add Go frontend, libgo library, and Go testsuite.

gcc/:
	* gcc.c (default_compilers): Add entry for ".go".
	* common.opt: Add -static-libgo as a driver option.
	* doc/install.texi (Configuration): Mention libgo as an option for
	--enable-shared.  Mention go as an option for --enable-languages.
	* doc/invoke.texi (Overall Options): Mention .go as a file name
	suffix.  Mention go as a -x option.
	* doc/frontends.texi (G++ and GCC): Mention Go as a supported
	language.
	* doc/sourcebuild.texi (Top Level): Mention libgo.
	* doc/standards.texi (Standards): Add section on Go language.
	Move references for other languages into their own section.
	* doc/contrib.texi (Contributors): Mention that I contributed the
	Go frontend.
gcc/testsuite/:
	* lib/go.exp: New file.
	* lib/go-dg.exp: New file.
	* lib/go-torture.exp: New file.
	* lib/target-supports.exp (check_compile): Match // Go.

From-SVN: r167407

2 files changed, 250 insertions, 0 deletions

diff --git a/libgo/go/encoding/hex/hex.go b/libgo/go/encoding/hex/hex.go
new file mode 100644
index 0000000..292d917e
--- /dev/null
+++ b/libgo/go/encoding/hex/hex.go
@@ -0,0 +1,101 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This package implements hexadecimal encoding and decoding.
+package hex
+
+import (
+	"os"
+	"strconv"
+)
+
+const hextable = "0123456789abcdef"
+
+// EncodedLen returns the length of an encoding of n source bytes.
+func EncodedLen(n int) int { return n * 2 }
+
+// Encode encodes src into EncodedLen(len(src))
+// bytes of dst.  As a convenience, it returns the number
+// of bytes written to dst, but this value is always EncodedLen(len(src)).
+// Encode implements hexadecimal encoding.
+func Encode(dst, src []byte) int {
+	for i, v := range src {
+		dst[i*2] = hextable[v>>4]
+		dst[i*2+1] = hextable[v&0x0f]
+	}
+
+	return len(src) * 2
+}
+
+// OddLengthInputError results from decoding an odd length slice.
+type OddLengthInputError struct{}
+
+func (OddLengthInputError) String() string { return "odd length hex string" }
+
+// InvalidHexCharError results from finding an invalid character in a hex string.
+type InvalidHexCharError byte
+
+func (e InvalidHexCharError) String() string {
+	return "invalid hex char: " + strconv.Itoa(int(e))
+}
+
+
+func DecodedLen(x int) int { return x / 2 }
+
+// Decode decodes src into DecodedLen(len(src)) bytes, returning the actual
+// number of bytes written to dst.
+//
+// If Decode encounters invalid input, it returns an OddLengthInputError or an
+// InvalidHexCharError.
+func Decode(dst, src []byte) (int, os.Error) {
+	if len(src)%2 == 1 {
+		return 0, OddLengthInputError{}
+	}
+
+	for i := 0; i < len(src)/2; i++ {
+		a, ok := fromHexChar(src[i*2])
+		if !ok {
+			return 0, InvalidHexCharError(src[i*2])
+		}
+		b, ok := fromHexChar(src[i*2+1])
+		if !ok {
+			return 0, InvalidHexCharError(src[i*2+1])
+		}
+		dst[i] = (a << 4) | b
+	}
+
+	return len(src) / 2, nil
+}
+
+// fromHexChar converts a hex character into its value and a success flag.
+func fromHexChar(c byte) (byte, bool) {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	}
+
+	return 0, false
+}
+
+// EncodeToString returns the hexadecimal encoding of src.
+func EncodeToString(src []byte) string {
+	dst := make([]byte, EncodedLen(len(src)))
+	Encode(dst, src)
+	return string(dst)
+}
+
+// DecodeString returns the bytes represented by the hexadecimal string s.
+func DecodeString(s string) ([]byte, os.Error) {
+	src := []byte(s)
+	dst := make([]byte, DecodedLen(len(src)))
+	_, err := Decode(dst, src)
+	if err != nil {
+		return nil, err
+	}
+	return dst, nil
+}
diff --git a/libgo/go/encoding/hex/hex_test.go b/libgo/go/encoding/hex/hex_test.go
new file mode 100644
index 0000000..a14c9d4
--- /dev/null
+++ b/libgo/go/encoding/hex/hex_test.go
@@ -0,0 +1,149 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package hex
+
+import (
+	"bytes"
+	"testing"
+)
+
+type encodeTest struct {
+	in, out []byte
+}
+
+var encodeTests = []encodeTest{
+	{[]byte{}, []byte{}},
+	{[]byte{0x01}, []byte{'0', '1'}},
+	{[]byte{0xff}, []byte{'f', 'f'}},
+	{[]byte{0xff, 00}, []byte{'f', 'f', '0', '0'}},
+	{[]byte{0}, []byte{'0', '0'}},
+	{[]byte{1}, []byte{'0', '1'}},
+	{[]byte{2}, []byte{'0', '2'}},
+	{[]byte{3}, []byte{'0', '3'}},
+	{[]byte{4}, []byte{'0', '4'}},
+	{[]byte{5}, []byte{'0', '5'}},
+	{[]byte{6}, []byte{'0', '6'}},
+	{[]byte{7}, []byte{'0', '7'}},
+	{[]byte{8}, []byte{'0', '8'}},
+	{[]byte{9}, []byte{'0', '9'}},
+	{[]byte{10}, []byte{'0', 'a'}},
+	{[]byte{11}, []byte{'0', 'b'}},
+	{[]byte{12}, []byte{'0', 'c'}},
+	{[]byte{13}, []byte{'0', 'd'}},
+	{[]byte{14}, []byte{'0', 'e'}},
+	{[]byte{15}, []byte{'0', 'f'}},
+}
+
+func TestEncode(t *testing.T) {
+	for i, test := range encodeTests {
+		dst := make([]byte, EncodedLen(len(test.in)))
+		n := Encode(dst, test.in)
+		if n != len(dst) {
+			t.Errorf("#%d: bad return value: got: %d want: %d", i, n, len(dst))
+		}
+		if bytes.Compare(dst, test.out) != 0 {
+			t.Errorf("#%d: got: %#v want: %#v", i, dst, test.out)
+		}
+	}
+}
+
+type decodeTest struct {
+	in, out []byte
+	ok      bool
+}
+
+var decodeTests = []decodeTest{
+	{[]byte{}, []byte{}, true},
+	{[]byte{'0'}, []byte{}, false},
+	{[]byte{'0', 'g'}, []byte{}, false},
+	{[]byte{'0', '\x01'}, []byte{}, false},
+	{[]byte{'0', '0'}, []byte{0}, true},
+	{[]byte{'0', '1'}, []byte{1}, true},
+	{[]byte{'0', '2'}, []byte{2}, true},
+	{[]byte{'0', '3'}, []byte{3}, true},
+	{[]byte{'0', '4'}, []byte{4}, true},
+	{[]byte{'0', '5'}, []byte{5}, true},
+	{[]byte{'0', '6'}, []byte{6}, true},
+	{[]byte{'0', '7'}, []byte{7}, true},
+	{[]byte{'0', '8'}, []byte{8}, true},
+	{[]byte{'0', '9'}, []byte{9}, true},
+	{[]byte{'0', 'a'}, []byte{10}, true},
+	{[]byte{'0', 'b'}, []byte{11}, true},
+	{[]byte{'0', 'c'}, []byte{12}, true},
+	{[]byte{'0', 'd'}, []byte{13}, true},
+	{[]byte{'0', 'e'}, []byte{14}, true},
+	{[]byte{'0', 'f'}, []byte{15}, true},
+	{[]byte{'0', 'A'}, []byte{10}, true},
+	{[]byte{'0', 'B'}, []byte{11}, true},
+	{[]byte{'0', 'C'}, []byte{12}, true},
+	{[]byte{'0', 'D'}, []byte{13}, true},
+	{[]byte{'0', 'E'}, []byte{14}, true},
+	{[]byte{'0', 'F'}, []byte{15}, true},
+}
+
+func TestDecode(t *testing.T) {
+	for i, test := range decodeTests {
+		dst := make([]byte, DecodedLen(len(test.in)))
+		n, err := Decode(dst, test.in)
+		if err == nil && n != len(dst) {
+			t.Errorf("#%d: bad return value: got:%d want:%d", i, n, len(dst))
+		}
+		if test.ok != (err == nil) {
+			t.Errorf("#%d: unexpected err value: %s", i, err)
+		}
+		if err == nil && bytes.Compare(dst, test.out) != 0 {
+			t.Errorf("#%d: got: %#v want: %#v", i, dst, test.out)
+		}
+	}
+}
+
+type encodeStringTest struct {
+	in  []byte
+	out string
+}
+
+var encodeStringTests = []encodeStringTest{
+	{[]byte{}, ""},
+	{[]byte{0}, "00"},
+	{[]byte{0, 1}, "0001"},
+	{[]byte{0, 1, 255}, "0001ff"},
+}
+
+func TestEncodeToString(t *testing.T) {
+	for i, test := range encodeStringTests {
+		s := EncodeToString(test.in)
+		if s != test.out {
+			t.Errorf("#%d got:%s want:%s", i, s, test.out)
+		}
+	}
+}
+
+type decodeStringTest struct {
+	in  string
+	out []byte
+	ok  bool
+}
+
+var decodeStringTests = []decodeStringTest{
+	{"", []byte{}, true},
+	{"0", []byte{}, false},
+	{"00", []byte{0}, true},
+	{"0\x01", []byte{}, false},
+	{"0g", []byte{}, false},
+	{"00ff00", []byte{0, 255, 0}, true},
+	{"0000ff", []byte{0, 0, 255}, true},
+}
+
+func TestDecodeString(t *testing.T) {
+	for i, test := range decodeStringTests {
+		dst, err := DecodeString(test.in)
+		if test.ok != (err == nil) {
+			t.Errorf("#%d: unexpected err value: %s", i, err)
+		}
+		if err == nil && bytes.Compare(dst, test.out) != 0 {
+			t.Errorf("#%d: got: %#v want: #%v", i, dst, test.out)
+		}
+	}
+}