replyc chan int;
}
-type binOp (a, b int) int;
+type binOp func(a, b int) int;
-func run(op *binOp, req *request) {
+func run(op binOp, req *request) {
reply := op(req.a, req.b);
req.replyc <- reply;
}
-func server(op *binOp, service chan *request) {
+func server(op binOp, service chan *request) {
for {
req := <-service;
go run(op, req); // don't wait for it
}
}
-func startServer(op *binOp) chan *request {
+func startServer(op binOp) chan *request {
req := make(chan *request);
go server(op, req);
return req;
replyc chan int;
}
-type binOp (a, b int) int;
+type binOp func(a, b int) int;
-func run(op *binOp, req *request) {
+func run(op binOp, req *request) {
reply := op(req.a, req.b);
req.replyc <- reply;
}
-func server(op *binOp, service chan *request, quit chan bool) {
+func server(op binOp, service chan *request, quit chan bool) {
for {
select {
case req := <-service:
}
}
-func startServer(op *binOp) (service chan *request, quit chan bool) {
+func startServer(op binOp) (service chan *request, quit chan bool) {
service = make(chan *request);
quit = make(chan bool);
go server(op, service, quit);
# Run any commands given in sources, like
# // gotest: $GC foo.go
-# to build any test-only dependencies.
+# to build any test-only dependencies.
sed -n 's/^\/\/ gotest: //p' $gofiles | sh
for i in $gofiles
echo 'import "testing"'
# test array
echo
- echo 'var tests = []testing.Test {' # TODO(rsc): *&
+ echo 'var tests = []testing.Test {'
for ofile in $ofiles
do
# test functions are named TestFoo
else
for i in $tests
do
- echo ' testing.Test{ "'$i'", &'$i' },'
+ echo ' testing.Test{ "'$i'", '$i' },'
done
fi
done
type readMaker struct {
name string;
- fn *([]byte) io.Read;
+ fn func([]byte) io.Read;
}
var readMakers = []readMaker {
readMaker{ "full", func(p []byte) io.Read { return newByteReader(p) } },
type bufReader struct {
name string;
- fn *(*BufRead) string;
+ fn func(*BufRead) string;
}
var bufreaders = []bufReader {
bufReader{ "1", func(b *BufRead) string { return reads(b, 1) } },
bufReader{ "4", func(b *BufRead) string { return reads(b, 4) } },
bufReader{ "5", func(b *BufRead) string { return reads(b, 5) } },
bufReader{ "7", func(b *BufRead) string { return reads(b, 7) } },
- bufReader{ "bytes", &readBytes },
- bufReader{ "lines", &readLines },
+ bufReader{ "bytes", readBytes },
+ bufReader{ "lines", readLines },
}
var bufsizes = []int {
type writeMaker struct {
name string;
- fn *()writeBuffer;
+ fn func()writeBuffer;
}
func TestBufWrite(t *testing.T) {
var data [8192]byte;
var writers = []writeMaker {
- writeMaker{ "full", &newByteWriter },
- writeMaker{ "half", &newHalfByteWriter },
+ writeMaker{ "full", newByteWriter },
+ writeMaker{ "half", newHalfByteWriter },
};
for i := 0; i < len(data); i++ {
)
// Serve a new connection.
-func serveConnection(fd net.Conn, raddr string, f *(*Conn, *Request)) {
+func serveConnection(fd net.Conn, raddr string, f func(*Conn, *Request)) {
c, err := NewConn(fd);
if err != nil {
return
}
// Web server: already listening on l, call f for each request.
-func Serve(l net.Listener, f *(*Conn, *Request)) *os.Error {
+func Serve(l net.Listener, f func(*Conn, *Request)) *os.Error {
// TODO: Make this unnecessary
s, e := os.Getenv("GOMAXPROCS");
if n, ok := strconv.Atoi(s); n < 3 {
}
// Web server: listen on address, call f for each request.
-func ListenAndServe(addr string, f *(*Conn, *Request)) *os.Error {
+func ListenAndServe(addr string, f func(*Conn, *Request)) *os.Error {
l, e := net.Listen("tcp", addr);
if e != nil {
return e
// TODO(rsc): Pick out obvious non-DNS names to avoid
// sending stupid requests to the server?
- once.Do(&_LoadConfig);
+ once.Do(_LoadConfig);
if cfg == nil {
err = DNS_MissingConfig;
return;
// packing sequence.
// Map of constructors for each RR wire type.
-var rr_mk = map[int]*()DNS_RR {
+var rr_mk = map[int] func()DNS_RR {
DNS_TypeCNAME: func() DNS_RR { return new(DNS_RR_CNAME) },
DNS_TypeHINFO: func() DNS_RR { return new(DNS_RR_HINFO) },
DNS_TypeMB: func() DNS_RR { return new(DNS_RR_MB) },
func NewFD(fd int64) (f *FD, err *os.Error) {
if pollserver == nil {
- once.Do(&_StartServer);
+ once.Do(_StartServer);
}
if err = _SetNonblock(fd); err != nil {
return nil, err
}
}
- var cvt *(addr []byte, port int) (sa *syscall.Sockaddr, err *os.Error);
+ var cvt func(addr []byte, port int) (sa *syscall.Sockaddr, err *os.Error);
var family int64;
if vers == 4 {
- cvt = &IPv4ToSockaddr;
+ cvt = IPv4ToSockaddr;
family = syscall.AF_INET
} else {
- cvt = &IPv6ToSockaddr;
+ cvt = IPv6ToSockaddr;
family = syscall.AF_INET6
}
}
func LookupPort(netw, name string) (port int, ok bool) {
- once.Do(&_ReadServices);
+ once.Do(_ReadServices);
switch netw {
case "tcp4", "tcp6":
}
type _Request struct {
- f *();
+ f func();
reply chan *_Job
}
var service = make(chan _Request)
-var jobmap = make(map[*()]*_Job)
+var jobmap = make(map[func()]*_Job)
// Moderate access to the jobmap.
// Even if accesses were thread-safe (they should be but are not)
}
}
-func Do(f *()) {
+func Do(f func()) {
// Look for job in map (avoids channel communication).
// If not there, ask map server to make one.
// TODO: Uncomment use of jobmap[f] once
func TestOnce(t *testing.T) {
ncall = 0;
- once.Do(&call);
+ once.Do(call);
if ncall != 1 {
- t.Fatalf("once.Do(&call) didn't call(): ncall=%d", ncall);
+ t.Fatalf("once.Do(call) didn't call(): ncall=%d", ncall);
}
- once.Do(&call);
+ once.Do(call);
if ncall != 1 {
- t.Fatalf("second once.Do(&call) did call(): ncall=%d", ncall);
+ t.Fatalf("second once.Do(call) did call(): ncall=%d", ncall);
}
- once.Do(&call);
+ once.Do(call);
if ncall != 1 {
- t.Fatalf("third once.Do(&call) did call(): ncall=%d", ncall);
+ t.Fatalf("third once.Do(call) did call(): ncall=%d", ncall);
}
}
func newValueAddr(typ Type, addr Addr) Value
-type creatorFn *(typ Type, addr Addr) Value
+type creatorFn func(typ Type, addr Addr) Value
// -- Missing
}
var creator = map[int] creatorFn {
- MissingKind : &missingCreator,
- IntKind : &intCreator,
- Int8Kind : &int8Creator,
- Int16Kind : &int16Creator,
- Int32Kind : &int32Creator,
- Int64Kind : &int64Creator,
- UintKind : &uintCreator,
- Uint8Kind : &uint8Creator,
- Uint16Kind : &uint16Creator,
- Uint32Kind : &uint32Creator,
- Uint64Kind : &uint64Creator,
- UintptrKind : &uintptrCreator,
- FloatKind : &floatCreator,
- Float32Kind : &float32Creator,
- Float64Kind : &float64Creator,
- Float80Kind : &float80Creator,
- StringKind : &stringCreator,
- BoolKind : &boolCreator,
- PtrKind : &ptrCreator,
- ArrayKind : &arrayCreator,
- MapKind : &mapCreator,
- ChanKind : &chanCreator,
- StructKind : &structCreator,
- InterfaceKind : &interfaceCreator,
- FuncKind : &funcCreator,
+ MissingKind : missingCreator,
+ IntKind : intCreator,
+ Int8Kind : int8Creator,
+ Int16Kind : int16Creator,
+ Int32Kind : int32Creator,
+ Int64Kind : int64Creator,
+ UintKind : uintCreator,
+ Uint8Kind : uint8Creator,
+ Uint16Kind : uint16Creator,
+ Uint32Kind : uint32Creator,
+ Uint64Kind : uint64Creator,
+ UintptrKind : uintptrCreator,
+ FloatKind : floatCreator,
+ Float32Kind : float32Creator,
+ Float64Kind : float64Creator,
+ Float80Kind : float80Creator,
+ StringKind : stringCreator,
+ BoolKind : boolCreator,
+ PtrKind : ptrCreator,
+ ArrayKind : arrayCreator,
+ MapKind : mapCreator,
+ ChanKind : chanCreator,
+ StructKind : structCreator,
+ InterfaceKind : interfaceCreator,
+ FuncKind : funcCreator,
}
var typecache = make(map[string] Type);
type Test struct {
Name string;
- F *(*T);
+ F func(*T);
}
func tRunner(t *T, test *Test) {
}
func LookupTimezone(sec int64) (zone string, offset int, err *os.Error) {
- once.Do(&_SetupZone);
+ once.Do(_SetupZone);
if zoneerr != nil || len(zones) == 0 {
return "GMT", 0, zoneerr
}
+++ /dev/null
-// 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.
-
-// ! $G $D/$F.go
-
-package main
-
-//should be f *func but compiler accepts it
-func iterate(f func(int)) {
-}
-
-func main() {
-}
package bug0
-var V0 *() int;
-var V1 *() (a int);
-var V2 *() (a, b int);
+var V0 func() int;
+var V1 func() (a int);
+var V2 func() (a, b int);
package main
-type T ()
+type T func()
type I interface {
f, g ();
+++ /dev/null
-// 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.
-
-// errchk $G $D/$F.go
-
-package main
-
-type T struct {
- v (); // ERROR "field type"
-}
--- /dev/null
+// errchk $G $D/$F.go
+
+// 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 main
+
+var notmain func()
+
+func main() {
+ var x = &main; // ERROR "address of function"
+ main = notmain; // ERROR "assign to function"
+}
--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out
+
+// 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 main
+
+func caller(f func(int, int) int, a, b int, c chan int) {
+ c <- f(a,b)
+}
+
+func gocall(f func(int, int) int, a, b int) int {
+ c := make(chan int);
+ go caller(f, a, b, c);
+ return <-c;
+}
+
+func call(f func(int, int) int, a, b int) int {
+ return f(a, b)
+}
+
+func call1(f func(int, int) int, a, b int) int {
+ return call(f, a, b)
+}
+
+var f func(int, int) int
+
+func add(x, y int) int {
+ return x + y
+}
+
+func fn() (func(int, int) int) {
+ return f
+}
+
+var fc func(int, int, chan int)
+
+func addc(x, y int, c chan int) {
+ c <- x+y
+}
+
+func fnc() (func(int, int, chan int)) {
+ return fc
+}
+
+func three(x int) {
+ if x != 3 {
+ panic("wrong val", x)
+ }
+}
+
+var notmain func()
+
+func main() {
+ three(call(add, 1, 2));
+ three(call1(add, 1, 2));
+ f = add;
+ three(call(f, 1, 2));
+ three(call1(f, 1, 2));
+ three(call(fn(), 1, 2));
+ three(call1(fn(), 1, 2));
+ three(call(func(a,b int) int {return a+b}, 1, 2));
+ three(call1(func(a,b int) int {return a+b}, 1, 2));
+
+ fc = addc;
+ c := make(chan int);
+ go addc(1, 2, c);
+ three(<-c);
+ go fc(1, 2, c);
+ three(<-c);
+ go fnc()(1, 2, c);
+ three(<-c);
+ go func(a, b int, c chan int){c <- a+b}(1, 2, c);
+ three(<-c);
+}
+
int
BUG: should compile
-=========== bugs/bug121.go
-BUG: compilation succeeds incorrectly
-
=========== bugs/bug122.go
BUG: compilation succeeds incorrectly
3 11
4 0
-=========== fixedbugs/bug029.go
-fixedbugs/bug029.go:6: f is not a type
-fixedbugs/bug029.go:6: syntax error near func
-fixedbugs/bug029.go:6: syntax error near int
-
=========== fixedbugs/bug035.go
fixedbugs/bug035.go:6: variable i redeclared in this block
previous declaration at fixedbugs/bug035.go:5
pc: xxx
+=========== fixedbugs/bug121.go
+fixedbugs/bug121.go:9: syntax error near T
+fixedbugs/bug121.go:20: incomplete type I
+fixedbugs/bug121.go:20: illegal types for operand: AS
+ I
+ *S
+
=========== fixedbugs/bug133.go
fixedbugs/bug133.dir/bug2.go:11: undefined DOT i on bug0.T
fixedbugs/bug133.dir/bug2.go:11: illegal types for operand: RETURN
type C struct
{
a int;
- x *(p *C)int;
+ x func(p *C)int;
}
func g(p *C)int;
c = new(C);
c.a = 6;
- c.x = &g;
+ c.x = g;
v = g(c);
if v != 6 { panic(v); }
+++ /dev/null
-// 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.
-
-// errchk $G $D/$F.go
-
-package main
-
-func main()
-{
- f := new(()); // ERROR "new"
- g := new((x int, f float) string); // ERROR "new"
- h := new(*()); // ok
- i := new(string); // ok
- j := new(map[int]int); // ok
- k := new(chan int); // ok
-}