obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

5 files changed, 332 insertions, 0 deletions

diff --git a/libgo/go/syslog/syslog.go b/libgo/go/syslog/syslog.go
new file mode 100644
index 000000000..711d5ddc7
--- /dev/null
+++ b/libgo/go/syslog/syslog.go
@@ -0,0 +1,150 @@
+// 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.
+
+// The syslog package provides a simple interface to
+// the system log service. It can send messages to the
+// syslog daemon using UNIX domain sockets, UDP, or
+// TCP connections.
+package syslog
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"os"
+)
+
+type Priority int
+
+const (
+	// From /usr/include/sys/syslog.h.
+	// These are the same on Linux, BSD, and OS X.
+	LOG_EMERG Priority = iota
+	LOG_ALERT
+	LOG_CRIT
+	LOG_ERR
+	LOG_WARNING
+	LOG_NOTICE
+	LOG_INFO
+	LOG_DEBUG
+)
+
+// A Writer is a connection to a syslog server.
+type Writer struct {
+	priority Priority
+	prefix   string
+	conn     serverConn
+}
+
+type serverConn interface {
+	writeBytes(p Priority, prefix string, b []byte) (int, os.Error)
+	writeString(p Priority, prefix string, s string) (int, os.Error)
+	close() os.Error
+}
+
+type netConn struct {
+	conn net.Conn
+}
+
+// New establishes a new connection to the system log daemon.
+// Each write to the returned writer sends a log message with
+// the given priority and prefix.
+func New(priority Priority, prefix string) (w *Writer, err os.Error) {
+	return Dial("", "", priority, prefix)
+}
+
+// Dial establishes a connection to a log daemon by connecting
+// to address raddr on the network net.
+// Each write to the returned writer sends a log message with
+// the given priority and prefix.
+func Dial(network, raddr string, priority Priority, prefix string) (w *Writer, err os.Error) {
+	if prefix == "" {
+		prefix = os.Args[0]
+	}
+	var conn serverConn
+	if network == "" {
+		conn, err = unixSyslog()
+	} else {
+		var c net.Conn
+		c, err = net.Dial(network, "", raddr)
+		conn = netConn{c}
+	}
+	return &Writer{priority, prefix, conn}, err
+}
+
+// Write sends a log message to the syslog daemon.
+func (w *Writer) Write(b []byte) (int, os.Error) {
+	if w.priority > LOG_DEBUG || w.priority < LOG_EMERG {
+		return 0, os.EINVAL
+	}
+	return w.conn.writeBytes(w.priority, w.prefix, b)
+}
+
+func (w *Writer) writeString(p Priority, s string) (int, os.Error) {
+	return w.conn.writeString(p, w.prefix, s)
+}
+
+func (w *Writer) Close() os.Error { return w.conn.close() }
+
+// Emerg logs a message using the LOG_EMERG priority.
+func (w *Writer) Emerg(m string) (err os.Error) {
+	_, err = w.writeString(LOG_EMERG, m)
+	return err
+}
+// Crit logs a message using the LOG_CRIT priority.
+func (w *Writer) Crit(m string) (err os.Error) {
+	_, err = w.writeString(LOG_CRIT, m)
+	return err
+}
+// ERR logs a message using the LOG_ERR priority.
+func (w *Writer) Err(m string) (err os.Error) {
+	_, err = w.writeString(LOG_ERR, m)
+	return err
+}
+
+// Warning logs a message using the LOG_WARNING priority.
+func (w *Writer) Warning(m string) (err os.Error) {
+	_, err = w.writeString(LOG_WARNING, m)
+	return err
+}
+
+// Notice logs a message using the LOG_NOTICE priority.
+func (w *Writer) Notice(m string) (err os.Error) {
+	_, err = w.writeString(LOG_NOTICE, m)
+	return err
+}
+// Info logs a message using the LOG_INFO priority.
+func (w *Writer) Info(m string) (err os.Error) {
+	_, err = w.writeString(LOG_INFO, m)
+	return err
+}
+// Debug logs a message using the LOG_DEBUG priority.
+func (w *Writer) Debug(m string) (err os.Error) {
+	_, err = w.writeString(LOG_DEBUG, m)
+	return err
+}
+
+func (n netConn) writeBytes(p Priority, prefix string, b []byte) (int, os.Error) {
+	return fmt.Fprintf(n.conn, "<%d>%s: %s\n", p, prefix, b)
+}
+
+func (n netConn) writeString(p Priority, prefix string, s string) (int, os.Error) {
+	return fmt.Fprintf(n.conn, "<%d>%s: %s\n", p, prefix, s)
+}
+
+func (n netConn) close() os.Error {
+	return n.conn.Close()
+}
+
+// NewLogger provides an object that implements the full log.Logger interface,
+// but sends messages to Syslog instead; flag is passed as is to Logger;
+// priority will be used for all messages sent using this interface.
+// All messages are logged with priority p.
+func NewLogger(p Priority, flag int) *log.Logger {
+	s, err := New(p, "")
+	if err != nil {
+		return nil
+	}
+	return log.New(s, "", flag)
+}
diff --git a/libgo/go/syslog/syslog_c.c b/libgo/go/syslog/syslog_c.c
new file mode 100644
index 000000000..f49b9ffcb
--- /dev/null
+++ b/libgo/go/syslog/syslog_c.c
@@ -0,0 +1,19 @@
+/* syslog_c.c -- call syslog for Go.
+
+   Copyright 2011 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.  */
+
+#include <syslog.h>
+
+/* We need to use a C function to call the syslog function, because we
+   can't represent a C varargs function in Go.  */
+
+void syslog_c(int, const char*)
+  asm ("libgo_syslog.syslog.syslog_c");
+
+void
+syslog_c (int priority, const char *msg)
+{
+  syslog (priority, "%s", msg);
+}
diff --git a/libgo/go/syslog/syslog_solaris.go b/libgo/go/syslog/syslog_solaris.go
new file mode 100644
index 000000000..044351dbf
--- /dev/null
+++ b/libgo/go/syslog/syslog_solaris.go
@@ -0,0 +1,37 @@
+// Copyright 2011 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.
+
+// gccgo specific implementation of syslog for Solaris.  Solaris uses
+// STREAMS to communicate with syslogd.  That is enough of a pain that
+// we just call the libc function.
+
+package syslog
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+)
+
+func unixSyslog() (conn serverConn, err os.Error) {
+	return libcConn(0), nil
+}
+
+type libcConn int
+
+func syslog_c(int, *byte)
+
+func (libcConn) writeBytes(p Priority, prefix string, b []byte) (int, os.Error) {
+	syslog_c(int(p), syscall.StringBytePtr(fmt.Sprintf("%s: %s", prefix, b)))
+	return len(b), nil
+}
+
+func (libcConn) writeString(p Priority, prefix string, s string) (int, os.Error) {
+	syslog_c(int(p), syscall.StringBytePtr(fmt.Sprintf("%s: %s", prefix, s)))
+	return len(s), nil
+}
+
+func (libcConn) close() os.Error {
+	return nil
+}
diff --git a/libgo/go/syslog/syslog_test.go b/libgo/go/syslog/syslog_test.go
new file mode 100644
index 000000000..063ab71b4
--- /dev/null
+++ b/libgo/go/syslog/syslog_test.go
@@ -0,0 +1,95 @@
+// 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 syslog
+
+import (
+	"io"
+	"log"
+	"net"
+	"testing"
+)
+
+var serverAddr string
+
+func runSyslog(c net.PacketConn, done chan<- string) {
+	var buf [4096]byte
+	var rcvd string = ""
+	for {
+		n, _, err := c.ReadFrom(buf[0:])
+		if err != nil || n == 0 {
+			break
+		}
+		rcvd += string(buf[0:n])
+	}
+	done <- rcvd
+}
+
+func startServer(done chan<- string) {
+	c, e := net.ListenPacket("udp", "127.0.0.1:0")
+	if e != nil {
+		log.Exitf("net.ListenPacket failed udp :0 %v", e)
+	}
+	serverAddr = c.LocalAddr().String()
+	c.SetReadTimeout(100e6) // 100ms
+	go runSyslog(c, done)
+}
+
+func TestNew(t *testing.T) {
+	s, err := New(LOG_INFO, "")
+	if err != nil {
+		t.Fatalf("New() failed: %s", err)
+	}
+	// Don't send any messages.
+	s.Close()
+}
+
+func TestNewLogger(t *testing.T) {
+	f := NewLogger(LOG_INFO, 0)
+	if f == nil {
+		t.Error("NewLogger() failed")
+	}
+}
+
+func TestDial(t *testing.T) {
+	l, err := Dial("", "", LOG_ERR, "syslog_test")
+	if err != nil {
+		t.Fatalf("Dial() failed: %s", err)
+	}
+	l.Close()
+}
+
+func TestUDPDial(t *testing.T) {
+	done := make(chan string)
+	startServer(done)
+	l, err := Dial("udp", serverAddr, LOG_INFO, "syslog_test")
+	if err != nil {
+		t.Fatalf("syslog.Dial() failed: %s", err)
+	}
+	msg := "udp test"
+	l.Info(msg)
+	expected := "<6>syslog_test: udp test\n"
+	rcvd := <-done
+	if rcvd != expected {
+		t.Fatalf("s.Info() = '%q', but wanted '%q'", rcvd, expected)
+	}
+}
+
+func TestWrite(t *testing.T) {
+	done := make(chan string)
+	startServer(done)
+	l, err := Dial("udp", serverAddr, LOG_ERR, "syslog_test")
+	if err != nil {
+		t.Fatalf("syslog.Dial() failed: %s", err)
+	}
+	msg := "write test"
+	_, err = io.WriteString(l, msg)
+	if err != nil {
+		t.Fatalf("WriteString() failed: %s", err)
+	}
+	expected := "<3>syslog_test: write test\n"
+	rcvd := <-done
+	if rcvd != expected {
+		t.Fatalf("s.Info() = '%q', but wanted '%q'", rcvd, expected)
+	}
+}
diff --git a/libgo/go/syslog/syslog_unix.go b/libgo/go/syslog/syslog_unix.go
new file mode 100644
index 000000000..b4daf88ee
--- /dev/null
+++ b/libgo/go/syslog/syslog_unix.go
@@ -0,0 +1,31 @@
+// 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 syslog
+
+import (
+	"net"
+	"os"
+)
+
+// unixSyslog opens a connection to the syslog daemon running on the
+// local machine using a Unix domain socket.
+
+func unixSyslog() (conn serverConn, err os.Error) {
+	logTypes := []string{"unixgram", "unix"}
+	logPaths := []string{"/dev/log", "/var/run/syslog"}
+	var raddr string
+	for _, network := range logTypes {
+		for _, path := range logPaths {
+			raddr = path
+			conn, err := net.Dial(network, "", raddr)
+			if err != nil {
+				continue
+			} else {
+				return netConn{conn}, nil
+			}
+		}
+	}
+	return nil, os.ErrorString("Unix syslog delivery error")
+}