}
c := Digit(0);
- z := new(Natural, n + 1);
+ z := make(Natural, n + 1);
i := 0;
for i < m {
t := c + x[i] + y[i];
}
c := Digit(0);
- z := new(Natural, n);
+ z := make(Natural, n);
i := 0;
for i < m {
t := c + x[i] - y[i];
n := len(x);
m := len(y);
- z := new(Natural, n + m);
+ z := make(Natural, n + m);
for j := 0; j < m; j++ {
d := y[j];
if d != 0 {
func Unpack(x Natural) []Digit2 {
n := len(x);
- z := new([]Digit2, n*2 + 1); // add space for extra digit (used by DivMod)
+ z := make([]Digit2, n*2 + 1); // add space for extra digit (used by DivMod)
for i := 0; i < n; i++ {
t := x[i];
z[i*2] = Digit2(t & M2);
func Pack(x []Digit2) Natural {
n := (len(x) + 1) / 2;
- z := new(Natural, n);
+ z := make(Natural, n);
if len(x) & 1 == 1 {
// handle odd len(x)
n--;
func (x Natural) Shl(s uint) Natural {
n := uint(len(x));
m := n + s/W;
- z := new(Natural, m+1);
+ z := make(Natural, m+1);
z[m] = Shl(z[m-n : m], x, s%W);
if m > n { // check for underflow
m = 0;
}
- z := new(Natural, m);
+ z := make(Natural, m);
Shr(z, x[n-m : n], s%W);
return y.And(x);
}
- z := new(Natural, m);
+ z := make(Natural, m);
for i := 0; i < m; i++ {
z[i] = x[i] & y[i];
}
return y.Or(x);
}
- z := new(Natural, n);
+ z := make(Natural, n);
for i := 0; i < m; i++ {
z[i] = x[i] | y[i];
}
return y.Xor(x);
}
- z := new(Natural, n);
+ z := make(Natural, n);
for i := 0; i < m; i++ {
z[i] = x[i] ^ y[i];
}
// allocate buffer for conversion
assert(2 <= base && base <= 16);
n := (x.Log2() + 1) / Log2(Digit(base)) + 1; // +1: round up
- s := new([]byte, n);
+ s := make([]byte, n);
// don't destroy x
- t := new(Natural, len(x));
+ t := make(Natural, len(x));
Copy(t, x);
// convert
func MulAdd1(x Natural, d, c Digit) Natural {
assert(IsSmall(d-1) && IsSmall(c));
n := len(x);
- z := new(Natural, n + 1);
+ z := make(Natural, n + 1);
for i := 0; i < n; i++ {
t := c + x[i]*d;
if size <= 0 {
return nil, BadBufSize
}
- b = new(*BufRead);
- b.buf = new([]byte, size);
+ b = new(BufRead);
+ b.buf = make([]byte, size);
b.rd = rd;
return b, nil
}
}
// Read bytes out of buffer.
- buf := new([]byte, b.Buffered());
+ buf := make([]byte, b.Buffered());
var n int;
n, e = b.Read(buf);
if e != nil {
// Grow list if needed.
if full == nil {
- full = new([][]byte, 16);
+ full = make([][]byte, 16);
} else if nfull >= len(full) {
- newfull := new([][]byte, len(full)*2);
+ newfull := make([][]byte, len(full)*2);
// BUG slice assignment
for i := 0; i < len(full); i++ {
newfull[i] = full[i];
n += len(frag);
// Copy full pieces and fragment in.
- buf := new([]byte, n);
+ buf := make([]byte, n);
n = 0;
for i := 0; i < nfull; i++ {
CopySlice(buf[n:n+len(full[i])], full[i]);
if size <= 0 {
return nil, BadBufSize
}
- b = new(*BufWrite);
- b.buf = new([]byte, size);
+ b = new(BufWrite);
+ b.buf = make([]byte, size);
b.wr = wr;
return b, nil
}
)
func StringToBytes(s string) []byte {
- b := new([]byte, len(s));
+ b := make([]byte, len(s));
for i := 0; i < len(s); i++ {
b[i] = s[i]
}
}
func NewByteReader(p []byte) io.Read {
- b := new(*ByteReader);
+ b := new(ByteReader);
b.p = p;
return b
}
}
func NewHalfByteReader(p []byte) io.Read {
- b := new(*HalfByteReader);
+ b := new(HalfByteReader);
b.p = p;
return b
}
}
func NewRot13Reader(r io.Read) *Rot13Reader {
- r13 := new(*Rot13Reader);
+ r13 := new(Rot13Reader);
r13.r = r;
return r13
}
}
func NewByteWriter() WriteBuffer {
- return new(*ByteWriter)
+ return new(ByteWriter)
}
func (w *ByteWriter) Write(p []byte) (int, *os.Error) {
if w.p == nil {
- w.p = new([]byte, len(p)+100)
+ w.p = make([]byte, len(p)+100)
} else if w.n + len(p) >= len(w.p) {
- newp := new([]byte, len(w.p)*2 + len(p));
+ newp := make([]byte, len(w.p)*2 + len(p));
Copy(newp[0:w.n], w.p[0:w.n]);
w.p = newp
}
}
func NewHalfByteWriter() WriteBuffer {
- w := new(*HalfByteWriter);
+ w := new(HalfByteWriter);
w.bw = NewByteWriter();
return w
}
if initial_len > n {
n = initial_len
}
- a = new([]Element, n);
+ a = make([]Element, n);
} else {
// nil out entries
for j := len(a) - 1; j >= 0; j-- {
export func New(len int) *Array {
- return new(*Array).Init(len)
+ return new(Array).Init(len)
}
// grow array by doubling its capacity
if n == cap(a) {
- b := new([]Element, 2*n);
+ b := make([]Element, 2*n);
for j := n-1; j >= 0; j-- {
b[j] = a[j];
}
export func NewIntArray(len int) *IntArray {
- return new(*IntArray).Init(len)
+ return new(IntArray).Init(len)
}
}
func New() *Flags {
- f := new(*Flags);
+ f := new(Flags);
f.first_arg = 1; // 0 is the program name, 1 is first arg
- f.actual = new(map[string] *Flag);
- f.formal = new(map[string] *Flag);
+ f.actual = make(map[string] *Flag);
+ f.formal = make(map[string] *Flag);
return f;
}
}
func Add(name string, value Value, usage string) *Flag {
- f := new(*Flag);
+ f := new(Flag);
f.name = name;
f.usage = usage;
f.value = value;
}
export func New() *Fmt {
- f := new(*Fmt);
+ f := new(Fmt);
f.init();
return f;
}
if w > NByte {
w = NByte;
}
- buf := new([]byte, w);
+ buf := make([]byte, w);
for i := 0; i < w; i++ {
buf[i] = padchar;
}
}
func Printer() *P {
- p := new(*P);
+ p := new(P);
p.fmt = fmt.New();
return p;
}
if newn < n {
newn = n + AllocSize
}
- b := new([]byte, newn);
+ b := make([]byte, newn);
for i := 0; i < p.n; i++ {
b[i] = p.buf[i];
}
}
func (d *Digest) Sum() []byte {
- p := new([]byte, 4);
+ p := make([]byte, 4);
s := d.Sum32();
p[0] = byte(s>>24);
p[1] = byte(s>>16);
export type Table []uint32
export func MakeTable(poly uint32) Table {
- t := new(Table, 256);
+ t := make(Table, 256);
for i := 0; i < 256; i++ {
crc := uint32(i);
for j := 0; j < 8; j++ {
}
func (d *Digest) Sum() []byte {
- p := new([]byte, 4);
+ p := make([]byte, 4);
s := d.Sum32();
p[0] = byte(s>>24);
p[1] = byte(s>>16);
}
export func NewDigest() *Digest {
- d := new(*Digest);
+ d := new(Digest);
d.s[0] = A;
d.s[1] = B;
d.s[2] = C;
panicln("oops");
}
- p := new([]byte, 16);
+ p := make([]byte, 16);
j := 0;
for i := 0; i < 4; i++ {
s := d.s[i];
}
export func NewDigest() *Digest {
- d := new(*Digest);
+ d := new(Digest);
d.h[0] = H0;
d.h[1] = H1;
d.h[2] = H2;
panicln("oops");
}
- p := new([]byte, 20);
+ p := make([]byte, 20);
j := 0;
for i := 0; i < 5; i++ {
s := d.h[i];
// Create new connection from rwc.
export func NewConn(rwc io.ReadWriteClose) (c *Conn, err *os.Error) {
- c = new(*Conn);
+ c = new(Conn);
c.rwc = rwc;
if c.br, err = bufio.NewBufRead(rwc); err != nil {
return nil, err
// Read and parse a request from b.
export func ReadRequest(b *bufio.BufRead) (req *Request, err *os.Error) {
- req = new(*Request);
+ req = new(Request);
// First line: GET /index.html HTTP/1.0
var s string;
// Subsequent lines: Key: value.
nheader := 0;
- req.header = new(map[string] string);
+ req.header = make(map[string] string);
for {
var key, value string;
if key, value, err = ReadKeyValue(b); err != nil {
return s, nil
}
- t := new([]byte, len(s)-2*n);
+ t := make([]byte, len(s)-2*n);
j := 0;
for i := 0; i < len(s); {
if s[i] == '%' {
if rawurl == "" {
return nil, BadURL
}
- url = new(*URL);
+ url = new(URL);
url.raw = rawurl;
// Split off possible leading "http:", "mailto:", etc.
plen := len(p);
if len(b.buf) == 0 {
b.cap = plen + 1024;
- b.buf = new([]byte, b.cap);
+ b.buf = make([]byte, b.cap);
b.len = 0;
}
if b.len + len(p) > b.cap {
b.cap = 2*(b.cap + plen);
- nb := new([]byte, b.cap);
+ nb := make([]byte, b.cap);
bytecopy(nb, 0, b.buf, 0, b.len);
b.buf = nb;
}
export func NewByteBufferFromArray(buf []byte) *ByteBuffer {
- b := new(*ByteBuffer);
+ b := new(ByteBuffer);
b.buf = buf;
b.off = 0;
b.len = len(buf);
}
export func WriteString(w Write, s string) (n int, err *os.Error) {
- b := new([]byte, len(s)+1);
+ b := make([]byte, len(s)+1);
if !syscall.StringToBytes(b, s) {
return -1, os.EINVAL
}
// Copies n bytes (or until EOF is reached) from src to dst.
// Returns the number of bytes copied and the error, if any.
export func Copyn(src Read, dst Write, n int64) (written int64, err *os.Error) {
- buf := new([]byte, 32*1024);
+ buf := make([]byte, 32*1024);
for written < n {
l := len(buf);
if d := n - written; d < int64(l) {
// Copies from src to dst until EOF is reached.
// Returns the number of bytes copied and the error, if any.
export func Copy(src Read, dst Write) (written int64, err *os.Error) {
- buf := new([]byte, 32*1024);
+ buf := make([]byte, 32*1024);
for {
nr, er := src.Read(buf);
if nr > 0 {
// Could fill with syscall.StringToBytes but it adds an unnecessary \000
// so the length would be wrong.
export func StringBytes(s string) []byte {
- b := new([]byte, len(s));
+ b := make([]byte, len(s));
for i := 0; i < len(s); i++ {
b[i] = s[i];
}
}
func (b *JsonBuilder) Map() {
- b.Put(&Map{new(map[string]Json), Null{}})
+ b.Put(&Map{make(map[string]Json), Null{}})
}
func (b *JsonBuilder) Elem(i int) Builder {
- bb := new(*JsonBuilder);
+ bb := new(JsonBuilder);
bb.a = b.Get().(*Array).a;
bb.i = i;
for i >= bb.a.Len() {
}
func (b *JsonBuilder) Key(k string) Builder {
- bb := new(*JsonBuilder);
+ bb := new(JsonBuilder);
bb.m = b.Get().(*Map).m;
bb.k = k;
bb.m[k] = null;
export func StringToJson(s string) (json Json, ok bool, errtok string) {
var errindx int;
var j Json;
- b := new(*JsonBuilder);
+ b := new(JsonBuilder);
b.ptr = &j;
ok, errindx, errtok = Parse(s, b);
if !ok {
}
export func TestJsonMap(t *testing.T) {
- values := new(map[string]Json);
+ values := make(map[string]Json);
mapstr := "{";
for i := 0; i < len(jsontests); i++ {
val, ok, errtok := StringToJson(jsontests[i]);
if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
return
}
- b := new([]byte, len(s));
+ b := make([]byte, len(s));
w := 0;
for r := 1; r < len(s)-1; {
switch {
}
export func Quote(s string) string {
- chr := new([]byte, utf8.UTFMax);
+ chr := make([]byte, utf8.UTFMax);
chr0 := chr[0:1];
- b := new(*io.ByteBuffer);
+ b := new(io.ByteBuffer);
chr[0] = '"';
b.Write(chr0);
for i := 0; i < len(s); i++ {
}
export func Parse(s string, build Builder) (ok bool, errindx int, errtok string) {
- lex := new(*Lexer);
+ lex := new(Lexer);
lex.s = s;
lex.Next();
if ParseValue(lex, build) {
req := io.StringBytes("GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n");
n, errno := fd.Write(req);
- buf := new([]byte, 1000);
+ buf := make([]byte, 1000);
n, errno = io.Readn(fd, buf);
if n < 1000 {
if len(name) >= 256 {
return nil, DNS_NameTooLong
}
- out := new(*DNS_Msg);
+ out := new(DNS_Msg);
out.id = 0x1234;
out.question = []DNS_Question{
DNS_Question{ name, DNS_TypeA, DNS_ClassINET }
// TODO(rsc): set up timeout or call ReadTimeout.
// right now net does not support that.
- buf := new([]byte, 2000); // More than enough.
+ buf := make([]byte, 2000); // More than enough.
n, err = c.Read(buf);
if err != nil {
// TODO(rsc): only continue if timed out
continue
}
buf = buf[0:n];
- in := new(*DNS_Msg);
+ in := new(DNS_Msg);
if !in.Unpack(buf) || in.id != out.id {
continue
}
// On return, if err == nil, addrs != nil.
// TODO(rsc): Maybe return [][]byte (==[]IPAddr) instead?
func Answer(name string, dns *DNS_Msg) (addrs []string, err *os.Error) {
- addrs = new([]string, 0, len(dns.answer));
+ addrs = make([]string, 0, len(dns.answer));
if dns.rcode == DNS_RcodeNameError && dns.authoritative {
return nil, DNS_NameNotFound // authoritative "no such host"
if file == nil {
return nil
}
- conf := new(*DNS_Config);
- conf.servers = new([]string, 3)[0:0]; // small, but the standard limit
- conf.search = new([]string, 0);
+ conf := new(DNS_Config);
+ conf.servers = make([]string, 3)[0:0]; // small, but the standard limit
+ conf.search = make([]string, 0);
conf.ndots = 1;
conf.timeout = 1;
conf.attempts = 1;
case "domain": // set search path to just this domain
if len(f) > 1 {
- conf.search = new([]string, 1);
+ conf.search = make([]string, 1);
conf.search[0] = f[1];
} else {
- conf.search = new([]string, 0)
+ conf.search = make([]string, 0)
}
case "search": // set search path to given servers
- conf.search = new([]string, len(f) - 1);
+ conf.search = make([]string, len(f) - 1);
for i := 0; i < len(conf.search); i++ {
conf.search[i] = f[i+1];
}
// Map of constructors for each RR wire type.
var rr_mk = map[int]*()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) },
- DNS_TypeMG: func() DNS_RR { return new(*DNS_RR_MG) },
- DNS_TypeMINFO: func() DNS_RR { return new(*DNS_RR_MINFO) },
- DNS_TypeMR: func() DNS_RR { return new(*DNS_RR_MR) },
- DNS_TypeMX: func() DNS_RR { return new(*DNS_RR_MX) },
- DNS_TypeNS: func() DNS_RR { return new(*DNS_RR_NS) },
- DNS_TypePTR: func() DNS_RR { return new(*DNS_RR_PTR) },
- DNS_TypeSOA: func() DNS_RR { return new(*DNS_RR_SOA) },
- DNS_TypeTXT: func() DNS_RR { return new(*DNS_RR_TXT) },
- DNS_TypeA: func() DNS_RR { return new(*DNS_RR_A) },
+ 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) },
+ DNS_TypeMG: func() DNS_RR { return new(DNS_RR_MG) },
+ DNS_TypeMINFO: func() DNS_RR { return new(DNS_RR_MINFO) },
+ DNS_TypeMR: func() DNS_RR { return new(DNS_RR_MR) },
+ DNS_TypeMX: func() DNS_RR { return new(DNS_RR_MX) },
+ DNS_TypeNS: func() DNS_RR { return new(DNS_RR_NS) },
+ DNS_TypePTR: func() DNS_RR { return new(DNS_RR_PTR) },
+ DNS_TypeSOA: func() DNS_RR { return new(DNS_RR_SOA) },
+ DNS_TypeTXT: func() DNS_RR { return new(DNS_RR_TXT) },
+ DNS_TypeA: func() DNS_RR { return new(DNS_RR_A) },
}
// Pack a domain name s into msg[off:].
}
n := int(msg[off]);
off++;
- b := new([]byte, n);
+ b := make([]byte, n);
for i := 0; i < n; i++ {
b[i] = msg[off+i];
}
// Could work harder to calculate message size,
// but this is far more than we need and not
// big enough to hurt the allocator.
- msg = new([]byte, 2000);
+ msg = make([]byte, 2000);
// Pack it in: header and then the pieces.
off := 0;
dns.rcode = int(dh.bits & 0xF);
// Arrays.
- dns.question = new([]DNS_Question, dh.qdcount);
- dns.answer = new([]DNS_RR, dh.ancount);
- dns.ns = new([]DNS_RR, dh.nscount);
- dns.extra = new([]DNS_RR, dh.arcount);
+ dns.question = make([]DNS_Question, dh.qdcount);
+ dns.answer = make([]DNS_RR, dh.ancount);
+ dns.ns = make([]DNS_RR, dh.nscount);
+ dns.extra = make([]DNS_RR, dh.arcount);
for i := 0; i < len(dns.question); i++ {
off, ok = UnpackStruct(&dns.question[i], msg, off);
func (s *PollServer) Run();
func NewPollServer() (s *PollServer, err *os.Error) {
- s = new(*PollServer);
- s.cr = new(chan *FD, 1);
- s.cw = new(chan *FD, 1);
+ s = new(PollServer);
+ s.cr = make(chan *FD, 1);
+ s.cw = make(chan *FD, 1);
if s.pr, s.pw, err = os.Pipe(); err != nil {
return nil, err
}
s.poll.Close();
goto Error
}
- s.pending = new(map[int64] *FD);
+ s.pending = make(map[int64] *FD);
go s.Run();
return s, nil
}
if err = SetNonblock(fd); err != nil {
return nil, err
}
- f = new(*FD);
+ f = new(FD);
f.fd = fd;
f.osfd = os.NewFD(fd);
- f.cr = new(chan *FD, 1);
- f.cw = new(chan *FD, 1);
+ f.cr = make(chan *FD, 1);
+ f.cw = make(chan *FD, 1);
return f, nil
}
}
export func NewPollster() (p *Pollster, err *os.Error) {
- p = new(*Pollster);
+ p = new(Pollster);
var e int64;
if p.kq, e = syscall.kqueue(); e != 0 {
return nil, os.ErrnoToError(e)
}
export func NewPollster() (p *Pollster, err *os.Error) {
- p = new(*Pollster);
+ p = new(Pollster);
var e int64;
// The arg to epoll_create is a hint to the kernel
if p.epfd, e = syscall.epoll_create(16); e != 0 {
return nil, os.ErrnoToError(e)
}
- p.events = new(map[int64] uint32);
+ p.events = make(map[int64] uint32);
return p, nil
}
// Make the 4 bytes into an IPv4 address (in IPv6 form)
func MakeIPv4(a, b, c, d byte) []byte {
- p := new([]byte, IPv6len);
+ p := make([]byte, IPv6len);
for i := 0; i < 10; i++ {
p[i] = 0
}
IPv4allsys = MakeIPv4(0xe0, 0x00, 0x00, 0x01);
IPv4allrouter = MakeIPv4(0xe0, 0x00, 0x00, 0x02);
IPv4prefix = MakeIPv4(0, 0, 0, 0);
- IPallbits = new([]byte, IPv6len);
+ IPallbits = make([]byte, IPv6len);
for i := 0; i < IPv6len; i++ {
IPallbits[i] = 0xff
}
- IPnoaddr = new([]byte, IPv6len); // zeroed
+ IPnoaddr = make([]byte, IPv6len); // zeroed
}
// Is p all zeros?
if n != len(mask) {
return nil
}
- out := new([]byte, n);
+ out := make([]byte, n);
for i := 0; i < n; i++ {
out[i] = ip[i] & mask[i];
}
// * The last 32 bits can be in IPv4 form.
// Thus, ::ffff:1.2.3.4 is the IPv4 address 1.2.3.4.
func ParseIPv6(s string) []byte {
- p := new([]byte, 16);
+ p := make([]byte, 16);
ellipsis := -1; // position of ellipsis in p
i := 0; // index in string s
}
func NewConnTCP(fd *FD, raddr string) *ConnTCP {
- c := new(*ConnTCP);
+ c := new(ConnTCP);
c.fd = fd;
c.raddr = raddr;
c.SetNoDelay(true);
}
func NewConnUDP(fd *FD, raddr string) *ConnUDP {
- c := new(*ConnUDP);
+ c := new(ConnUDP);
c.fd = fd;
c.raddr = raddr;
return c
syscall.close(fd.fd);
return nil, os.ErrnoToError(e1)
}
- l = new(*ListenerTCP);
+ l = new(ListenerTCP);
l.fd = fd;
return l, nil
}
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
- sa := new(*syscall.SockaddrInet4);
+ sa := new(syscall.SockaddrInet4);
sa.len = syscall.SizeofSockaddrInet4;
sa.family = syscall.AF_INET;
sa.port[0] = byte(port>>8);
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
- sa := new(*syscall.SockaddrInet6);
+ sa := new(syscall.SockaddrInet6);
sa.len = syscall.SizeofSockaddrInet6;
sa.family = syscall.AF_INET6;
sa.port[0] = byte(port>>8);
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
- sa := new(*syscall.SockaddrInet4);
+ sa := new(syscall.SockaddrInet4);
sa.family = syscall.AF_INET;
sa.port[0] = byte(port>>8);
sa.port[1] = byte(port);
p = IPv6zero;
}
- sa := new(*syscall.SockaddrInet6);
+ sa := new(syscall.SockaddrInet6);
sa.family = syscall.AF_INET6;
sa.port[0] = byte(port>>8);
sa.port[1] = byte(port);
if err != nil {
return nil
}
- return &File{fd, new([]byte, 1024)[0:0]};
+ return &File{fd, make([]byte, 1024)[0:0]};
}
package func ByteIndex(s string, c byte) int {
// Split s at any bytes in t.
package func SplitAtBytes(s string, t string) []string {
- a := new([]string, 1+CountAnyByte(s, t));
+ a := make([]string, 1+CountAnyByte(s, t));
n := 0;
last := 0;
for i := 0; i < len(s); i++ {
var services map[string] map[string] int
func ReadServices() {
- services = new(map[string] map[string] int);
+ services = make(map[string] map[string] int);
file := Open("/etc/services");
for line, ok := file.ReadLine(); ok; line, ok = file.ReadLine() {
// "http 80/tcp www www-http # World Wide Web HTTP"
netw := portnet[j+1:len(portnet)]; // "tcp"
m, ok1 := services[netw];
if !ok1 {
- m = new(map[string] int);
+ m = make(map[string] int);
services[netw] = m;
}
for i := 0; i < len(f); i++ {
if err != nil {
break;
}
- echodone := new(chan int);
+ echodone := make(chan int);
go Echo(fd, echodone);
<-echodone; // make sure Echo stops
l.Close();
func DoTest(t *testing.T, network, listenaddr, dialaddr string) {
t.Logf("Test %s %s %s\n", network, listenaddr, dialaddr);
- listening := new(chan int);
- done := new(chan int);
+ listening := make(chan int);
+ done := make(chan int);
go Serve(t, network, listenaddr, listening, done);
<-listening; // wait for server to start
Connect(t, network, dialaddr);
}
// TODO: Would like to use chan Request but 6g rejects it.
-var service = new(chan *Request)
-var jobmap = new(map[*()]*Job)
+var service = make(chan *Request)
+var jobmap = make(map[*()]*Job)
// Moderate access to the jobmap.
// Even if accesses were thread-safe (they should be but are not)
req := <-service;
job, present := jobmap[req.f];
if !present {
- job = new(*Job);
- job.doit = new(chan bool, 1);
+ job = new(Job);
+ job.doit = make(chan bool, 1);
job.doit <- true;
jobmap[req.f] = job
}
var present bool;
// job, present = jobmap[f]
if !present {
- c := new(chan *Job);
+ c := make(chan *Job);
req := Request{f, c};
service <- &req;
job = <-c
s string
}
-var ErrorTab = new(map[int64] *Error);
+var ErrorTab = make(map[int64] *Error);
export func NewError(s string) *Error {
return &Error{s}
if fd == nil {
return 0, EINVAL
}
- b := new([]byte, len(s)+1);
+ b := make([]byte, len(s)+1);
if !syscall.StringToBytes(b, s) {
return 0, EINVAL
}
export func
perm(n int) []int
{
- m := new([]int, n);
+ m := make([]int, n);
for i:=0; i<n; i++ {
m[i] = i;
}
}
{
type C chan *T; // TODO: should not be necessary
- var tmp = new(*C);
+ var tmp = new(C);
value := reflect.NewValue(tmp);
assert(reflect.ValueToString(value), "*reflect.C·all_test(@)");
}
return len(t.field)
}
-var NilInterface = NewInterfaceTypeStruct("nil", "", new([]Field, 0));
+var NilInterface = NewInterfaceTypeStruct("nil", "", make([]Field, 0));
// -- Func
Lock(); // not necessary because of init ordering but be safe.
- types = new(map[string] Type);
- typestring = new(map[string] string);
- basicstub = new(map[string] *StubType);
+ types = make(map[string] Type);
+ typestring = make(map[string] string);
+ basicstub = make(map[string] *StubType);
// Basics go into types table
types[MissingString] = Missing;
// Parse array of fields for struct, interface, and func arguments
func (p *Parser) Fields(sep, term string) []Field {
- a := new([]Field, 10);
+ a := make([]Field, 10);
nf := 0;
for p.token != "" && p.token != term {
if nf == len(a) {
- a1 := new([]Field, 2*nf);
+ a1 := make([]Field, 2*nf);
for i := 0; i < nf; i++ {
a1[i] = a[i];
}
// A single type packaged as a field for a function return
func (p *Parser) OneField() []Field {
- a := new([]Field, 1);
+ a := make([]Field, 1);
a[0].name = "";
a[0].typ = p.Type("");
return a;
// If the typestring is empty, it represents (the type of) a nil interface value
return NilInterface
}
- p := new(*Parser);
+ p := new(Parser);
p.str = typestring;
p.Next();
return p.Type(name).Get();
func ArrayCreator(typ Type, addr Addr) Value {
arraytype := typ.(ArrayType);
if arraytype.Open() {
- v := new(*OpenArrayValueStruct);
+ v := new(OpenArrayValueStruct);
v.kind = ArrayKind;
v.addr = addr;
v.typ = typ;
v.array = addr.(*RuntimeArray);
return v;
}
- v := new(*FixedArrayValueStruct);
+ v := new(FixedArrayValueStruct);
v.kind = ArrayKind;
v.addr = addr;
v.typ = typ;
func StructCreator(typ Type, addr Addr) Value {
t := typ.(StructType);
nfield := t.Len();
- v := &StructValueStruct{ Common{StructKind, typ, addr}, new([]Value, nfield) };
+ v := &StructValueStruct{ Common{StructKind, typ, addr}, make([]Value, nfield) };
for i := 0; i < nfield; i++ {
name, ftype, str, offset := t.Field(i);
addr_uint := uintptr(addr) + uintptr(offset);
FuncKind : &FuncCreator,
}
-var typecache = new(map[string] *Type);
+var typecache = make(map[string] *Type);
func NewValueAddr(typ Type, addr Addr) Value {
c, ok := creator[typ.Kind()];
if size == 0 {
size = 1;
}
- data := new([]uint8, size);
+ data := make([]uint8, size);
return NewValueAddr(typ, Addr(&data[0]));
}
return nil
}
- array := new(*RuntimeArray);
+ array := new(RuntimeArray);
size := typ.Elem().Size() * cap;
if size == 0 {
size = 1;
}
- data := new([]uint8, size);
+ data := make([]uint8, size);
array.data = Addr(&data[0]);
array.len = uint32(len);
array.cap = uint32(cap);
p, ok := typecache[typestring];
if !ok {
typ := ParseTypeString("", typestring);
- p = new(*Type);
+ p = new(Type);
*p = typ;
typecache[typestring] = p;
}
// Content of interface is a value; need a permanent copy to take its address
// so we can modify the contents. Values contain pointers to 'values'.
- ap := new(*uint64);
+ ap := new(uint64);
*ap = value;
return NewValueAddr(*p, ap.(Addr));
}
if re == nil {
return
}
- strs := new([]string, len(match)/2);
+ strs := make([]string, len(match)/2);
for i := 0; i < len(match); i++ {
strs[i/2] = str[match[i] : match[i+1]]
}
func (char *Char) Print() { print("char ", string(char.char)) }
func NewChar(char int) *Char {
- c := new(*Char);
+ c := new(Char);
c.char = char;
return c;
}
}
func NewCharClass() *CharClass {
- c := new(*CharClass);
+ c := new(CharClass);
c.ranges = array.NewIntArray(0);
return c;
}
}
func NewParser(re *RE) *Parser {
- parser := new(*Parser);
+ parser := new(Parser);
parser.re = re;
parser.nextc(); // load p.ch
return parser;
p.re.Error(ErrUnmatchedRbkt);
case '^':
p.nextc();
- start = p.re.Add(new(*Bot));
+ start = p.re.Add(new(Bot));
return start, start;
case '$':
p.nextc();
- start = p.re.Add(new(*Eot));
+ start = p.re.Add(new(Eot));
return start, start;
case '.':
p.nextc();
- start = p.re.Add(new(*Any));
+ start = p.re.Add(new(Any));
return start, start;
case '[':
p.nextc();
}
p.nlpar--;
p.nextc();
- bra := new(*Bra);
+ bra := new(Bra);
p.re.Add(bra);
- ebra := new(*Ebra);
+ ebra := new(Ebra);
p.re.Add(ebra);
bra.n = nbra;
ebra.n = nbra;
switch p.c() {
case '*':
// (start,end)*:
- alt := new(*Alt);
+ alt := new(Alt);
p.re.Add(alt);
end.SetNext(alt); // after end, do alt
alt.left = start; // alternate brach: return to start
end = alt;
case '+':
// (start,end)+:
- alt := new(*Alt);
+ alt := new(Alt);
p.re.Add(alt);
end.SetNext(alt); // after end, do alt
alt.left = start; // alternate brach: return to start
end = alt; // start is unchanged; end is alt
case '?':
// (start,end)?:
- alt := new(*Alt);
+ alt := new(Alt);
p.re.Add(alt);
- nop := new(*Nop);
+ nop := new(Nop);
p.re.Add(nop);
alt.left = start; // alternate branch is start
alt.next = nop; // follow on to nop
switch {
case nstart == NULL: // end of this concatenation
if start == NULL { // this is the empty string
- nop := p.re.Add(new(*Nop));
+ nop := p.re.Add(new(Nop));
return nop, nop;
}
return;
case '|':
p.nextc();
nstart, nend := p.Concatenation();
- alt := new(*Alt);
+ alt := new(Alt);
p.re.Add(alt);
alt.left = start;
alt.next = nstart;
- nop := new(*Nop);
+ nop := new(Nop);
p.re.Add(nop);
end.SetNext(nop);
nend.SetNext(nop);
func (re *RE) DoParse() {
parser := NewParser(re);
- start := new(*Start);
+ start := new(Start);
re.Add(start);
s, e := parser.Regexp();
start.next = s;
re.start = start;
- e.SetNext(re.Add(new(*End)));
+ e.SetNext(re.Add(new(End)));
if debug {
re.Dump();
func Compiler(str string, ch chan *RE) {
- re := new(*RE);
+ re := new(RE);
re.expr = str;
re.inst = array.New(0);
re.ch = ch;
// Compile in separate goroutine; wait for result
export func Compile(str string) (regexp Regexp, error *os.Error) {
- ch := new(chan *RE);
+ ch := make(chan *RE);
go Compiler(str, ch);
re := <-ch;
return re, re.error
}
}
if l == cap(s) {
- s1 := new([]State, 2*l)[0:l];
+ s1 := make([]State, 2*l)[0:l];
for i := 0; i < l; i++ {
s1[i] = s[i];
}
func (re *RE) DoExecute(str string, pos int) []int {
var s [2][]State; // TODO: use a vector when State values (not ptrs) can be vector elements
- s[0] = new([]State, 10)[0:0];
- s[1] = new([]State, 10)[0:0];
+ s[0] = make([]State, 10)[0:0];
+ s[1] = make([]State, 10)[0:0];
in, out := 0, 1;
var final State;
found := false;
for pos <= len(str) {
if !found {
// prime the pump if we haven't seen a match yet
- match := new([]int, 2*(re.nbra+1));
+ match := make([]int, 2*(re.nbra+1));
for i := 0; i < len(match); i++ {
match[i] = -1; // no match seen; catches cases like "a(b)?c" on "ac"
}
case ALT:
s[in] = AddState(s[in], state.inst.(*Alt).left, state.match);
// give other branch a copy of this match vector
- s1 := new([]int, 2*(re.nbra+1));
+ s1 := make([]int, 2*(re.nbra+1));
for i := 0; i < len(s1); i++ {
s1[i] = state.match[i]
}
if r == nil {
return nil
}
- a := new([]string, len(r)/2);
+ a := make([]string, len(r)/2);
for i := 0; i < len(r); i += 2 {
a[i/2] = s[r[i] : r[i+1]]
}
}
export func TestSortLargeRandom(t *testing.T) {
- data := new([]int, 1000000);
+ data := make([]int, 1000000);
for i := 0; i < len(data); i++ {
data[i] = rand.rand() % 100;
}
}
// digits
- b := new(*Decimal);
+ b := new(Decimal);
sawdot := false;
sawdigits := false;
for ; i < len(s); i++ {
n += -a.dp;
}
- buf := new([]byte, n);
+ buf := make([]byte, n);
w := 0;
switch {
case a.nd == 0:
}
package func NewDecimal(i uint64) *Decimal {
- a := new(*Decimal);
+ a := new(Decimal);
a.Assign(i);
return a;
}
// %e: -d.ddddde±dd
func FmtE(neg bool, d *Decimal, prec int) string {
- buf := new([]byte, 3+Max(prec, 0)+30); // "-0." + prec digits + exp
+ buf := make([]byte, 3+Max(prec, 0)+30); // "-0." + prec digits + exp
w := 0; // write index
// sign
// %f: -ddddddd.ddddd
func FmtF(neg bool, d *Decimal, prec int) string {
- buf := new([]byte, 1+Max(d.dp, 1)+1+Max(prec, 0));
+ buf := make([]byte, 1+Max(d.dp, 1)+1+Max(prec, 0));
w := 0;
// sign
// Split string into array of UTF-8 sequences (still strings)
export func explode(s string) []string {
- a := new([]string, utf8.RuneCountInString(s, 0, len(s)));
+ a := make([]string, utf8.RuneCountInString(s, 0, len(s)));
j := 0;
var size, rune int;
for i := 0; i < len(a); i++ {
c := sep[0];
start := 0;
n := count(s, sep)+1;
- a := new([]string, n);
+ a := make([]string, n);
na := 0;
for i := 0; i+len(sep) <= len(s); i++ {
if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
n += len(a[i])
}
- b := new([]byte, n);
+ b := make([]byte, n);
bp := 0;
for i := 0; i < len(a); i++ {
s := a[i];
}
export func TestSemaphore(t *testing.T) {
- s := new(*int32);
+ s := new(int32);
*s = 1;
- c := new(chan bool);
+ c := make(chan bool);
for i := 0; i < 10; i++ {
go HammerSemaphore(s, c);
}
}
export func TestMutex(t *testing.T) {
- m := new(*Mutex);
- c := new(chan bool);
+ m := new(Mutex);
+ c := make(chan bool);
for i := 0; i < 10; i++ {
go HammerMutex(m, c);
}
func (b *ByteArray) Init(initial_size int) {
- b.a = new([]byte, initial_size)[0 : 0];
+ b.a = make([]byte, initial_size)[0 : 0];
}
if m > n2 {
n2 = m;
}
- b := new([]byte, n2);
+ b := make([]byte, n2);
for i := 0; i < n; i++ {
b[i] = a[i];
}
export func New(writer io.Write, cellwidth, padding int, padchar byte, align_left, filter_html bool) *Writer {
- return new(*Writer).Init(writer, cellwidth, padding, padchar, align_left, filter_html)
+ return new(Writer).Init(writer, cellwidth, padding, padchar, align_left, filter_html)
}
func (b *Buffer) Init(n int) {
- b.a = new([]byte, n)[0 : 0];
+ b.a = make([]byte, n)[0 : 0];
}
if chatty {
println("=== RUN ", tests[i].name);
}
- t := new(*T);
- t.ch = new(chan *T);
+ t := new(T);
+ t.ch = make(chan *T);
go TRunner(t, &tests[i]);
<-t.ch;
if t.failed {
if ns <= 0 {
return nil
}
- c := new(chan int64);
+ c := make(chan int64);
go Ticker(ns, c);
return c;
}
)
export func SecondsToUTC(sec int64) *Time {
- t := new(*Time);
+ t := new(Time);
// Split into time and day.
day := sec/SecondsPerDay;
// Just enough of strftime to implement the date formats below.
// Not exported.
func Format(t *Time, fmt string) string {
- buf := new([]byte, 128);
+ buf := make([]byte, 128);
bp := 0;
for i := 0; i < len(fmt); i++ {
// Now we can build up a useful data structure.
// First the zone information.
// utcoff[4] isdst[1] nameindex[1]
- zone := new([]Zone, n[NZone]);
+ zone := make([]Zone, n[NZone]);
for i := 0; i < len(zone); i++ {
var ok bool;
var n uint32;
}
// Now the transition time info.
- zt = new([]Zonetime, n[NTime]);
+ zt = make([]Zonetime, n[NTime]);
for i := 0; i < len(zt); i++ {
var ok bool;
var n uint32;
if e != nil {
return nil, e
}
- p = new([]byte, max+1)[0:0];
+ p = make([]byte, max+1)[0:0];
n := 0;
for len(p) < max {
nn, e := fd.Read(p[n:cap(p)]);
make smoketest
) || exit $?
-(xcd ../usr/gri/gosrc
-make clean
-time make
-# make test
-) || exit $?
+# (xcd ../usr/gri/gosrc
+# make clean
+# time make
+# # make test
+# ) || exit $?
(xcd ../test
./run
type T chan uint64;
func M(f uint64) (in, out T) {
- in = new(T, 100);
- out = new(T, 100);
+ in = make(T, 100);
+ out = make(T, 100);
go func(in, out T, f uint64) {
for {
out <- f * <-in;
1250, 1280, 1296, 1350, 1440, 1458, 1500, 1536, 1600 };
x := uint64(1);
- ins := new([]T, n);
- outs := new([]T, n);
- xs := new([]uint64, n);
+ ins := make([]T, n);
+ outs := make([]T, n);
+ xs := make([]uint64, n);
for i := 0; i < n; i++ {
ins[i], outs[i] = M(F[i]);
xs[i] = x;
}
var t = T{1.5, 123, "hello", 255}
-var mt = new(map[int]T)
-var ma = new(map[int][]int)
+var mt = make(map[int]T)
+var ma = make(map[int][]int)
func maptest() {
mt[0] = t;
}
}
-var mt1 = new(map[T]int)
-var ma1 = new(map[[]int] int)
+var mt1 = make(map[T]int)
+var ma1 = make(map[[]int] int)
func maptest2() {
mt1[t] = 123;
}
}
-var ct = new(chan T)
-var ca = new(chan []int)
+var ct = make(chan T)
+var ca = make(chan []int)
func send() {
ct <- t;
if !SameArray(a, a1) {
println("interface <-> []int", a, a1);
}
- pa := new(*[]int);
+ pa := new([]int);
*pa = a;
i = pa;
a1 = *i.(*[]int);
func (s *S) h() {} // here we can't write (s *S) T either
func main() {
- var i I = new(*S);
+ var i I = new(S);
}
package main
func main() {
- a := new([]int, 10, 20, 30, 40); // should allow at most 2 sizes
+ a := make([]int, 10, 20, 30, 40); // should allow at most 2 sizes
}
func main() {
s := S{0};
var i I = &s;
- c := new(chan int);
+ c := make(chan int);
go i.send(c);
sys.exit(<-c);
}
const N = 10
func AsynchFifo() {
- ch := new(chan int, N);
+ ch := make(chan int, N);
for i := 0; i < N; i++ {
ch <- i
}
// thread together a daisy chain to read the elements in sequence
func SynchFifo() {
- ch := new(chan int);
- in := new(chan int);
+ ch := make(chan int);
+ in := make(chan int);
start := in;
for i := 0; i < N; i++ {
- out := new(chan int);
+ out := make(chan int);
go Chain(ch, i, in, out);
in = out;
}
sys.exit(1);
}
}
- leftmost := new(chan int);
+ leftmost := make(chan int);
right := leftmost;
left := leftmost;
for i := 0; i < n; i++ {
- right = new(chan int);
+ right = make(chan int);
go f(left, right);
left = right;
}
var ok bool;
for buffer := 0; buffer < 2; buffer++ {
- c32 := new(chan int32, buffer);
- c64 := new(chan int64, buffer);
- cb := new(chan bool, buffer);
- cs := new(chan string, buffer);
+ c32 := make(chan int32, buffer);
+ c64 := make(chan int64, buffer);
+ cb := make(chan bool, buffer);
+ cs := make(chan string, buffer);
i32, ok = <-c32;
if ok { panic("blocked i32sender") }
func mkdch() *dch {
c := chnameserial % len(chnames);
chnameserial++;
- d := new(*dch);
- d.req = new(chan int);
- d.dat = new(chan item);
+ d := new(dch);
+ d.req = make(chan int);
+ d.dat = make(chan item);
d.nam = c;
return d;
}
func mkdch2() *dch2 {
- d2 := new(*dch2);
+ d2 := new(dch2);
d2[0] = mkdch();
d2[1] = mkdch();
return d2;
seqno++;
in.req <- seqno;
- release := new(chan int);
+ release := make(chan int);
go dosplit(in, out, release);
dat := <-in.dat;
out[0].dat <- dat;
}
func split(in *dch, out *dch2){
- release := new(chan int);
+ release := make(chan int);
go dosplit(in, out, release);
release <- 0;
}
func getn(in []*dch, n int) []item {
// BUG n:=len(in);
if n != 2 { panic("bad n in getn") };
- req := new(*[2] chan int);
- dat := new(*[2] chan item);
- out := new([]item, 2);
+ req := new([2] chan int);
+ dat := new([2] chan item);
+ out := make([]item, 2);
var i int;
var it item;
for i=0; i<n; i++ {
func i2tor(u, v int64) *rat{
g := gcd(u,v);
- r := new(*rat);
+ r := new(rat);
if v > 0 {
r.num = u/g;
r.den = v/g;
func mul(u, v *rat) *rat{
g1 := gcd(u.num,v.den);
g2 := gcd(u.den,v.num);
- r := new(*rat);
+ r := new(rat);
r.num =(u.num/g1)*(v.num/g2);
r.den = (u.den/g2)*(v.den/g1);
return r;
check(Ones, one, 5, "Ones");
check(Add(Ones, Ones), itor(2), 0, "Add Ones Ones"); // 1 1 1 1 1
check(Add(Ones, Twos), itor(3), 0, "Add Ones Twos"); // 3 3 3 3 3
- a := new([] *rat, N);
+ a := make([] *rat, N);
d := Diff(Ones);
// BUG: want array initializer
for i:=0; i < N; i++ {
func mkdch() *dch {
c := chnameserial % len(chnames);
chnameserial++;
- d := new(*dch);
- d.req = new(chan int);
- d.dat = new(chan item);
+ d := new(dch);
+ d.req = make(chan int);
+ d.dat = make(chan item);
d.nam = c;
return d;
}
func mkdch2() *dch2 {
- d2 := new(*dch2);
+ d2 := new(dch2);
d2[0] = mkdch();
d2[1] = mkdch();
return d2;
seqno++;
in.req <- seqno;
- release := new(chan int);
+ release := make(chan int);
go dosplit(in, out, release);
dat := <-in.dat;
out[0].dat <- dat;
}
func split(in *dch, out *dch2){
- release := new(chan int);
+ release := make(chan int);
go dosplit(in, out, release);
release <- 0;
}
func getn(in []*dch, n int) []item {
// BUG n:=len(in);
if n != 2 { panic("bad n in getn") };
- req := new([] chan int, 2);
- dat := new([] chan item, 2);
- out := new([]item, 2);
+ req := make([] chan int, 2);
+ dat := make([] chan item, 2);
+ out := make([]item, 2);
var i int;
var it item;
for i=0; i<n; i++ {
func i2tor(u, v int64) *rat{
g := gcd(u,v);
- r := new(*rat);
+ r := new(rat);
if v > 0 {
r.num = u/g;
r.den = v/g;
func mul(u, v *rat) *rat{
g1 := gcd(u.num,v.den);
g2 := gcd(u.den,v.num);
- r := new(*rat);
+ r := new(rat);
r.num =(u.num/g1)*(v.num/g2);
r.den = (u.den/g2)*(v.den/g1);
return r;
check(Ones, one, 5, "Ones");
check(Add(Ones, Ones), itor(2), 0, "Add Ones Ones"); // 1 1 1 1 1
check(Add(Ones, Twos), itor(3), 0, "Add Ones Twos"); // 3 3 3 3 3
- a := new([]*rat, N);
+ a := make([]*rat, N);
d := Diff(Ones);
// BUG: want array initializer
for i:=0; i < N; i++ {
}
func main() {
- a := new(chan uint, 1);
- b := new(chan uint, 1);
+ a := make(chan uint, 1);
+ b := make(chan uint, 1);
if v := Send(a, b); v != 2 {
panicln("Send returned", v, "!= 2");
}
// The prime sieve: Daisy-chain Filter processes together.
func Sieve(primes chan<- int) {
- ch := new(chan int); // Create a new channel.
+ ch := make(chan int); // Create a new channel.
go Generate(ch); // Start Generate() as a subprocess.
for {
prime := <-ch;
primes <- prime;
- ch1 := new(chan int);
+ ch1 := make(chan int);
go Filter(ch, ch1, prime);
ch = ch1
}
}
func main() {
- primes := new(chan int);
+ primes := make(chan int);
go Sieve(primes);
a := []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
for i := 0; i < len(a); i++ {
type R struct { num int }
func itor(a int) *R {
- r := new(*R);
+ r := new(R);
r.num = a;
return r;
}
at := []*T{&t, &t, &t};
if len(at) != 3 { panic("at") }
- c := new(chan int);
+ c := make(chan int);
ac := []chan int{c, c, c};
if len(ac) != 3 { panic("ac") }
}
func main() {
- var t *T = new(*T);
+ var t *T = new(T);
t.x = 1;
t.y = 2;
r10 := t.m(1, 3.0);
func main() {
type I struct { val int; }; // BUG: can't be local; works if global
- v := new(*Vector);
- v.Insert(0, new(*I));
+ v := new(Vector);
+ v.Insert(0, new(I));
}
/*
check: main_sigs_I: not defined
}
func New() *Vector {
- v := new(*Vector);
+ v := new(Vector);
v.nelem = 0;
- v.elem = new([]Element, 10);
+ v.elem = make([]Element, 10);
return v;
}
func main() {
type I struct { val int; };
- i0 := new(*I); i0.val = 0;
- i1 := new(*I); i1.val = 11;
- i2 := new(*I); i2.val = 222;
- i3 := new(*I); i3.val = 3333;
- i4 := new(*I); i4.val = 44444;
+ i0 := new(I); i0.val = 0;
+ i1 := new(I); i1.val = 11;
+ i2 := new(I); i2.val = 222;
+ i3 := new(I); i3.val = 3333;
+ i4 := new(I); i4.val = 44444;
v := New();
print("hi\n");
v.Insert(i4);
func main() {
var z [3]byte;
- z := new(*[3]byte); // BUG redeclaration
+ z := new([3]byte); // BUG redeclaration
}
func main() {
var ta []*T;
- ta = *new(*[1]*T); // TODO: the first * shouldn't be necessary
+ ta = *new([1]*T); // TODO: the first * shouldn't be necessary
ta[0] = nil;
}
/*
}
func main() {
- v := new(*Vector);
- v.elem = new([]Element, 10);
- t := new(*TStruct);
+ v := new(Vector);
+ v.elem = make([]Element, 10);
+ t := new(TStruct);
t.name = "hi";
v.elem[0] = t;
- s := new(*TStruct);
+ s := new(TStruct);
s.name = "foo";
s.fields = v;
if s.field(0).name != "hi" {
var m map[string] *Box;
func main() {
- m := new(map[string] *Box);
+ m := make(map[string] *Box);
s := "foo";
var x *Box = nil;
m[s] = x;
}
func main() {
- m := new(map[string] []string);
+ m := make(map[string] []string);
as := new([2]string);
as[0] = "0";
as[1] = "1";
- m["0"] = as;
+ m["0"] = *as;
a := m["0"];
a[0] = "x";
package main
func main() {
- m := new(map[int]int);
+ m := make(map[int]int);
m[0] = 0;
m[0]++;
if m[0] != 1 {
var c chan int
func main() {
- c = new(chan int);
+ c = make(chan int);
go func() { print("ok\n"); c <- 0 } ();
<-c
}
package main
func main(){
- c := new(chan int);
+ c := make(chan int);
ok := false;
i := 0;
i, ok = <-c; // works
- ca := new(*[2]chan int);
+ ca := new([2]chan int);
i, ok = <-(ca[0]); // fails: c.go:11: bad shape across assignment - cr=1 cl=2
}
type T struct { m map[int]int }
func main() {
- t := new(*T);
- t.m = new(map[int]int);
+ t := new(T);
+ t.m = make(map[int]int);
var x int;
var ok bool;
x, ok = t.m[0]; //bug075.go:11: bad shape across assignment - cr=1 cl=2
var arith Service
func main() {
- c := new(chan string);
- a := new(*Service);
+ c := make(chan string);
+ a := new(Service);
go a.Serve(1234);
}
// if you take it out (and the 0s below)
// then the bug goes away.
func NewI(i int) I {
- return new(*S)
+ return new(S)
}
// Uses interface method.
if string(b1) != "hello" {
panic("bad convert 1")
}
- var b2 = new([]byte, 5);
+ var b2 = make([]byte, 5);
for i := 0; i < 5; i++ { b2[i] = b1[i] }
if string(b2) != "hello" {
panic("bad convert 2")
}
func main() {
- s := new(*Stucky);
+ s := new(Stucky);
i := s.Me();
j := i.Me();
j.Me();
r9, s9 := f9(1);
assertequal(r9, 9, "r9");
assertequal(int(s9), 9, "s9");
- var t *T = new(*T);
+ var t *T = new(T);
t.x = 1;
t.y = 2;
r10 := t.m10(1, 3.0);
bugs/bug087.go:8: illegal combination of literals LEN 9
BUG: fails incorrectly
-=========== bugs/bug098.go
-bugs/bug098.go:10: illegal types for operand: AS
- *M
- **M
-BUG should compile
-
=========== bugs/bug105.go
bugs/bug105.go:8: P: undefined
bugs/bug105.go:8: illegal types for operand: RETURN
func (m *HashMap) Initialize (initial_log2_capacity uint32) {
m.log2_capacity_ = initial_log2_capacity;
- m.map_ = new(*[1024] Entry);
+ m.map_ = new([1024] Entry);
m.Clear();
}
func MakeNumber (x uint32) *Number {
- var n *Number = new(*Number);
+ var n *Number = new(Number);
n.x = x;
return n;
}
//print "HashMap - gri 2/8/2008\n";
- var hmap *HashMap = new(*HashMap);
+ var hmap *HashMap = new(HashMap);
hmap.Initialize(0);
var x1 *Number = MakeNumber(1001);
func NewMatrix(n, m int) *Matrix {
assert(0 <= n && 0 <= m);
- a := new(*Matrix);
+ a := new(Matrix);
a.n = n;
a.m = m;
- a.a = new([]*Big.Rational, n*m);
+ a.a = make([]*Big.Rational, n*m);
return a;
}
}
func main() {
- re := new(*Regexp);
+ re := new(Regexp);
print("call addinst\n");
- var x Inst = AddInst(new(*Start)); // ERROR "illegal|incompatible"
+ var x Inst = AddInst(new(Start)); // ERROR "illegal|incompatible"
print("return from addinst\n");
}
func
testpdpd()
{
- a := new([]int, 10, 100);
+ a := make([]int, 10, 100);
if len(a) != 10 && cap(a) != 100 {
panic("len and cap from new: ", len(a), " ", cap(a), "\n");
}
func
testpdpf1()
{
- a := new(*[40]int);
+ a := new([40]int);
setpd(*a);
res(sumpd(*a), 0, 40);
func
testpdfault()
{
- a := new([]int, 100);
+ a := make([]int, 100);
print("good\n");
for i:=0; i<100; i++ {
func
init()
{
- nc = new(*Chan);
+ nc = new(Chan);
}
func
mkchan(c,n int) []*Chan
{
- ca := new([]*Chan, n);
+ ca := make([]*Chan, n);
for i:=0; i<n; i++ {
cval = cval+100;
- ch := new(*Chan);
- ch.sc = new(chan int, c);
+ ch := new(Chan);
+ ch.sc = make(chan int, c);
ch.rc = ch.sc;
ch.sv = cval;
ch.rv = cval;
var s *S;
// allocate
- s = new(*S);
- s.Subp = new(*Subp);
- s.Sub.SubSubp = new(*SubSubp);
- s.Subp.SubpSubp = new(*SubpSubp);
+ s = new(S);
+ s.Subp = new(Subp);
+ s.Sub.SubSubp = new(SubSubp);
+ s.Subp.SubpSubp = new(SubpSubp);
// explicit assignment
s.a = 1;
var i2 I2;
var g *S;
- s := new(*S);
+ s := new(S);
s.a = 5;
s.b = 6;
func
main()
{
- p := new(*Print);
- b := new(*Bio);
- f := new(*File);
+ p := new(Print);
+ b := new(Bio);
+ f := new(File);
p.whoami = 1;
p.put = b;
var v int;
var c *C;
- c = new(*C);
+ c = new(C);
c.a = 6;
c.x = &g;
func
init()
{
- p = new([]byte, size);
- m = new(map[int]byte);
+ p = make([]byte, size);
+ m = make(map[int]byte);
for k:=0; k<size; k++ {
v := f(k);
a[k] = v;
func (list *List)
Insert(i Item)
{
- item := new(*ListItem);
+ item := new(ListItem);
item.item = i;
item.next = list.head;
list.head = item;
func
main()
{
- list := new(*List);
+ list := new(List);
list.Init();
for i := 0; i < 10; i = i + 1 {
- integer := new(*Integer);
+ integer := new(Integer);
integer.Init(i);
list.Insert(integer);
}
{
var slist, retval *Slist;
- slist = new(*Slist);
+ slist = new(Slist);
slist.list.car = nil;
slist.list.cdr = nil;
slist.isatom = false;
if token == ')' || token == EOF { // empty cdr
break;
}
- slist.list.cdr = new(*Slist);
+ slist.list.cdr = new(Slist);
slist = slist.list.cdr;
}
return retval;
var h, length int;
var slist, tail *Slist;
- slist = new(*Slist);
+ slist = new(Slist);
if token == '0' {
slist.atom.integer = i;
slist.isstring = false;
r9, s9 = f9(1);
assertequal(r9, 9, "r9");
assertequal(int(s9), 9, "s9");
- var t *T = new(*T);
+ var t *T = new(T);
t.x = 1;
t.y = 2;
r10 := t.m10(1, 3.0);
if s2 != 35 { panic(s2); }
- b := new(*[100]int);
+ b := new([100]int);
for i:=0; i<100; i=i+1 {
b[i] = i;
}
if !!!a { panic(6); }
var x *s;
- x = new(*s);
+ x = new(s);
x.a = true;
x.b = false;
}
/* create string with byte array pointer */
- z2 := new(*[3]byte);
+ z2 := new([3]byte);
z2[0] = 'a';
z2[1] = 'b';
z2[2] = 'c';
func main() {
flag.Parse();
- b = new([]*byte, 10000);
+ b = make([]*byte, 10000);
if flag.NArg() > 0 {
AllocAndFree(atoi(flag.Arg(0)), atoi(flag.Arg(1)));
return;
}
}
- mib := new(map[int] bool);
- mii := new(map[int] int);
- mfi := new(map[float] int);
- mif := new(map[int] float);
- msi := new(map[string] int);
- mis := new(map[int] string);
- mss := new(map[string] string);
- mspa := new(map[string] []string);
+ mib := make(map[int] bool);
+ mii := make(map[int] int);
+ mfi := make(map[float] int);
+ mif := make(map[int] float);
+ msi := make(map[string] int);
+ mis := make(map[int] string);
+ mss := make(map[string] string);
+ mspa := make(map[string] []string);
// BUG need an interface map both ways too
type T struct {
i int64; // can't use string here; struct values are only compared at the top level
f float;
};
- mipT := new(map[int] *T);
- mpTi := new(map[*T] int);
- mit := new(map[int] T);
- mti := new(map[T] int);
+ mipT := make(map[int] *T);
+ mpTi := make(map[*T] int);
+ mit := make(map[int] T);
+ mti := make(map[T] int);
type M map[int] int;
- mipM := new(map[int] M);
+ mipM := make(map[int] M);
const count = 1000;
var apT [2*count]*T;
s10 := strconv.itoa(i*10);
f := float(i);
t := T{int64(i),f};
- apT[i] = new(*T);
+ apT[i] = new(T);
apT[i].i = int64(i);
apT[i].f = f;
- apT[2*i] = new(*T); // need twice as many entries as we use, for the nonexistence check
+ apT[2*i] = new(T); // need twice as many entries as we use, for the nonexistence check
apT[2*i].i = int64(i);
apT[2*i].f = f;
- // BUG m := M{i, i+1};
- m := new(M); m[i] = i+1;
+ m := M{i: i+1};
mib[i] = (i != 0);
mii[i] = 10*i;
mfi[float(i)] = 10*i;
msi[s] = i;
mss[s] = s10;
mss[s] = s10;
- as := new([]string, arraylen);
+ as := make([]string, arraylen);
as[0] = s10;
as[1] = s10;
mspa[s] = as;
if len(mpTi) != count {
fmt.printf("len(mpTi) = %d\n", len(mpTi));
}
+ if len(mti) != count {
+ fmt.printf("len(mti) = %d\n", len(mti));
+ }
if len(mipM) != count {
fmt.printf("len(mipM) = %d\n", len(mipM));
}
if(mpTi[apT[i]] != i) {
fmt.printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]]);
}
+ if(mti[t] != i) {
+ fmt.printf("mti[%s] = %s\n", s, mti[t]);
+ }
if (mipM[i][i] != i + 1) {
fmt.printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i]);
}
{
f := new(()); // ERROR "new"
g := new((x int, f float) string); // ERROR "new"
- h := new(*()); // ok
+ h := new(()); // ok
}
c = nil;
t = nil;
i = nil;
- ta = new([]IN, 1);
+ ta = make([]IN, 1);
ta[0] = nil;
}
func add1(x *Number) *Number {
- e := new(*Number);
+ e := new(Number);
e.next = x;
return e;
}
// The prime sieve: Daisy-chain Filter processes together.
func Sieve() {
- ch := new(chan int); // Create a new channel.
+ ch := make(chan int); // Create a new channel.
go Generate(ch); // Start Generate() as a subprocess.
for {
prime := <-ch;
print(prime, "\n");
- ch1 := new(chan int);
+ ch1 := make(chan int);
go Filter(ch, ch1, prime);
ch = ch1
}
}
func control_structs() {
- var p *Point = new(*Point).Initialize(2, 3);
+ var p *Point = new(Point).Initialize(2, 3);
i := p.Distance();
var f float = 0.3;
for {}
// encoded as bytes: 'a' 'b' 'c' e6 97 a5 e6 9c ac e8 aa 9e
const L = 12;
if L != l { panic("wrong length constructing array") }
- a := new(*[L]byte);
+ a := new([L]byte);
a[0] = 'a';
a[1] = 'b';
a[2] = 'c';
func test1() {
var a [1000] *S;
for i := 0; i < len(a); i++ {
- a[i] = new(*S).Init(i);
+ a[i] = new(S).Init(i);
}
v := array.New(0);