}
return
}
- for i, ch := range []byte(s) {
- b[i] = ch
- }
+ copy(b, s)
if len(s) < len(b) {
b[len(s)] = 0
}
full = make([][]byte, 16)
} else if nfull >= len(full) {
newfull := make([][]byte, len(full)*2)
- for i := 0; i < len(full); i++ {
- newfull[i] = full[i]
- }
+ copy(newfull, full)
full = newfull
}
func (r *StringReader) Read(p []byte) (n int, err os.Error) {
if r.step < len(r.data) {
s := r.data[r.step]
- for i := 0; i < len(s); i++ {
- p[i] = s[i]
- }
- n = len(s)
+ n = copy(p, s)
r.step++
} else {
err = os.EOF
"utf8"
)
-// Copy from string to byte array at offset doff. Assume there's room.
-func copyString(dst []byte, doff int, str string) {
- for soff := 0; soff < len(str); soff++ {
- dst[doff] = str[soff]
- doff++
- }
-}
-
// A Buffer is a variable-sized buffer of bytes with Read and Write methods.
// The zero value for Buffer is an empty buffer ready to use.
type Buffer struct {
// value n is the length of s; err is always nil.
func (b *Buffer) WriteString(s string) (n int, err os.Error) {
m := b.grow(len(s))
- copyString(b.buf, m, s)
- return len(s), nil
+ return copy(b.buf[m:], s), nil
}
// MinRead is the minimum slice size passed to a Read call by
// initial contents. It is intended to prepare a buffer to read an existing
// string.
func NewBufferString(s string) *Buffer {
- buf := make([]byte, len(s))
- copyString(buf, 0, s)
- return &Buffer{buf: buf}
+ return &Buffer{buf: []byte(s)}
}
buf.Truncate(0)
check(t, "TestBasicOperations (3)", &buf, "")
- n, err := buf.Write(Bytes(data[0:1]))
+ n, err := buf.Write([]byte(data[0:1]))
if n != 1 {
t.Errorf("wrote 1 byte, but n == %d", n)
}
buf.WriteByte(data[1])
check(t, "TestBasicOperations (5)", &buf, "ab")
- n, err = buf.Write(Bytes(data[2:26]))
+ n, err = buf.Write([]byte(data[2:26]))
if n != 24 {
t.Errorf("wrote 25 bytes, but n == %d", n)
}
// Grow the buffer.
maxbytes = maxbytes*2 + utf8.UTFMax
nb := make([]byte, maxbytes)
- for i, c := range b[0:nbytes] {
- nb[i] = c
- }
+ copy(nb, b[0:nbytes])
b = nb
}
nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes])
{"x ☺ ", "x ☺"},
}
-// Bytes returns a new slice containing the bytes in s.
-// Borrowed from strings to avoid dependency.
-func Bytes(s string) []byte {
- b := make([]byte, len(s))
- for i := 0; i < len(s); i++ {
- b[i] = s[i]
- }
- return b
-}
-
// Execute f on each test case. funcName should be the name of f; it's used
// in failure reports.
func runStringTests(t *testing.T, f func([]byte) []byte, funcName string, testCases []StringTest) {
for _, tc := range testCases {
- actual := string(f(Bytes(tc.in)))
+ actual := string(f([]byte(tc.in)))
if actual != tc.out {
t.Errorf("%s(%q) = %q; want %q", funcName, tc.in, actual, tc.out)
}
// 1. Grow. This triggers two reallocations in Map.
maxRune := func(rune int) int { return unicode.MaxRune }
- m := Map(maxRune, Bytes(a))
+ m := Map(maxRune, []byte(a))
expect := tenRunes(unicode.MaxRune)
if string(m) != expect {
t.Errorf("growing: expected %q got %q", expect, m)
// 2. Shrink
minRune := func(rune int) int { return 'a' }
- m = Map(minRune, Bytes(tenRunes(unicode.MaxRune)))
+ m = Map(minRune, []byte(tenRunes(unicode.MaxRune)))
expect = a
if string(m) != expect {
t.Errorf("shrinking: expected %q got %q", expect, m)
}
// 3. Rot13
- m = Map(rot13, Bytes("a to zed"))
+ m = Map(rot13, []byte("a to zed"))
expect = "n gb mrq"
if string(m) != expect {
t.Errorf("rot13: expected %q got %q", expect, m)
}
// 4. Rot13^2
- m = Map(rot13, Map(rot13, Bytes("a to zed")))
+ m = Map(rot13, Map(rot13, []byte("a to zed")))
expect = "a to zed"
if string(m) != expect {
t.Errorf("rot13: expected %q got %q", expect, m)
}
return -1
}
- m = Map(dropNotLatin, Bytes("Hello, 세계"))
+ m = Map(dropNotLatin, []byte("Hello, 세계"))
expect = "Hello"
if string(m) != expect {
t.Errorf("drop: expected %q got %q", expect, m)
func TestAdd(t *testing.T) {
for _, test := range addtests {
b := make([]byte, len(test.s), test.cap)
- for i := 0; i < len(test.s); i++ {
- b[i] = test.s[i]
- }
+ copy(b, test.s)
b = Add(b, []byte(test.t))
if string(b) != test.s+test.t {
t.Errorf("Add(%q,%q) = %q", test.s, test.t, string(b))
x := new(cbcCipher)
x.c = c
x.blockSize = n
- x.iv = copy(iv)
+ x.iv = dup(iv)
x.tmp = make([]byte, n)
return x
}
x.c = c
x.blockSize = s / 8
x.cipherSize = b
- x.iv = copy(iv)
+ x.iv = dup(iv)
x.tmp = make([]byte, b)
return x
}
return true
}
-func copy(p []byte) []byte {
+func dup(p []byte) []byte {
q := make([]byte, len(p))
- for i, b := range p {
- q[i] = b
- }
+ copy(q, p)
return q
}
func newCTRStream(c Cipher, ctr []byte) *ctrStream {
x := new(ctrStream)
x.c = c
- x.ctr = copy(ctr)
+ x.ctr = dup(ctr)
x.out = make([]byte, len(ctr))
return x
}
cmac.Write(buf) // 0
cmac.Write(iv)
sum := cmac.Sum()
- ctrIV = copy(sum)
- tag = copy(sum[0:tagBytes])
+ ctrIV = dup(sum)
+ tag = dup(sum[0:tagBytes])
cmac.Reset()
buf[n-1] = 1
finishEAX(x.tag, x.cr.cmac)
if !same(x.tag, x.cr.tag) {
e := new(EAXTagError)
- e.Computed = copy(x.tag)
- e.Read = copy(x.cr.tag)
+ e.Computed = dup(x.tag)
+ e.Read = dup(x.cr.tag)
return e
}
return nil
// Save it for next time.
if i < n {
p = p[i:n]
- for j, v := range p {
- x.buf[j] = v
- }
+ copy(x.buf, p)
x.crypt = x.buf[0:len(p)]
n = i
}
if len(x.plain) == 0 {
x.plain = x.buf[0:0]
} else if cap(x.plain) < cap(x.buf) {
- // plain and buf share same data,
- // but buf is before plain, so forward loop is correct
- for i := 0; i < len(x.plain); i++ {
- x.buf[i] = x.plain[i]
- }
+ copy(x.buf, x.plain)
x.plain = x.buf[0:len(x.plain)]
}
}
if n != c.BlockSize() {
panic(fmt.Sprintln("crypto/block: newOFBStream: invalid iv size", n, "!=", c.BlockSize()))
}
- x.iv = copy(iv)
+ x.iv = dup(iv)
return x
}
n := _Block(d, p)
p = p[n:]
if len(p) > 0 {
- for i, x := range p {
- d.x[i] = x
- }
- d.nx = len(p)
+ d.nx = copy(d.x[:], p)
}
return
}
n := _Block(d, p)
p = p[n:]
if len(p) > 0 {
- for i, x := range p {
- d.x[i] = x
- }
- d.nx = len(p)
+ d.nx = copy(d.x[:], p)
}
return
}
n := _Block(d, p)
p = p[n:]
if len(p) > 0 {
- for i, x := range p {
- d.x[i] = x
- }
- d.nx = len(p)
+ d.nx = copy(d.x[:], p)
}
return
}
n := _Block(d, p)
p = p[n:]
if len(p) > 0 {
- for i, x := range p {
- d.x[i] = x
- }
- d.nx = len(p)
+ d.nx = copy(d.x[:], p)
}
return
}
n := _Block(d, p)
p = p[n:]
if len(p) > 0 {
- for i, x := range p {
- d.x[i] = x
- }
- d.nx = len(p)
+ d.nx = copy(d.x[:], p)
}
return
}
n := _Block(d, p)
p = p[n:]
if len(p) > 0 {
- for i, x := range p {
- d.x[i] = x
- }
- d.nx = len(p)
+ d.nx = copy(d.x[:], p)
}
return
}
func appendString(in []string, v string) (out []string) {
if cap(in)-len(in) < 1 {
out = make([]string, len(in)+1, len(in)*2+1)
- for i, v := range in {
- out[i] = v
- }
+ copy(out, in)
} else {
out = in[0 : len(in)+1]
}
n := len(t.Field)
if n >= cap(t.Field) {
fld := make([]*StructField, n, n*2)
- for i, f := range t.Field {
- fld[i] = f
- }
+ copy(fld, t.Field)
t.Field = fld
}
t.Field = t.Field[0 : n+1]
n := len(t.Val)
if n >= cap(t.Val) {
val := make([]*EnumValue, n, n*2)
- for i, f := range t.Val {
- val[i] = f
- }
+ copy(val, t.Val)
t.Val = val
}
t.Val = t.Val[0 : n+1]
n := len(t.ParamType)
if n >= cap(t.ParamType) {
param := make([]Type, n, n*2)
- for i, t := range t.ParamType {
- param[i] = t
- }
+ copy(param, t.ParamType)
t.ParamType = param
}
t.ParamType = t.ParamType[0 : n+1]
if n >= cap(f.Sections) {
m := (n + 1) * 2
new := make([]*Section, n, m)
- for i, sh := range f.Sections {
- new[i] = sh
- }
+ copy(new, f.Sections)
f.Sections = new
}
f.Sections = f.Sections[0 : n+1]
println(n, len(b)*2)
}
a := make([]uint16, n/2)
- for i := range b {
- a[i] = b[i]
- }
+ copy(a, b)
n, err = av.AudioStream(a)
}
}
// Gather argument and out types to initialize frame variables
vts := make([]Type, nin+nout)
- for i, t := range lt.In {
- vts[i] = t
- }
- for i, t := range lt.Out {
- vts[i+nin] = t
- }
+ copy(vts, lt.In)
+ copy(vts[nin:], lt.Out)
// Compile
lf := l.asFunc()
n := len(b.instrs)
if n >= cap(b.instrs) {
a := make(code, n, n*2)
- for i := range b.instrs {
- a[i] = b.instrs[i]
- }
+ copy(a, b.instrs)
b.instrs = a
}
b.instrs = b.instrs[0 : n+1]
func (b *codeBuf) get() code {
// Freeze this buffer into an array of exactly the right size
a := make(code, len(b.instrs))
- for i := range b.instrs {
- a[i] = b.instrs[i]
- }
+ copy(a, b.instrs)
return code(a)
}
// Combine methods
allMethods := make([]IMethod, nMethods)
- for i, m := range methods {
- allMethods[i] = m
- }
+ copy(allMethods, methods)
n := len(methods)
for _, e := range embeds {
for _, m := range e.methods {
// The system call *did* update r.hdr.ndesc.
if r.hdr.ndesc > 0 {
m.rdesc = make([]int32, r.hdr.ndesc)
- for i := range m.rdesc {
- m.rdesc[i] = r.desc[i]
- }
+ copy(m.rdesc, r.desc)
}
return m, nil
func (m *msg) wstring(s string) {
b := m.grow(len(s))
- for i := range b {
- b[i] = s[i]
- }
+ copy(b, s)
}
// Parsing of RPC header and arguments.
n := len(rpcMethod)
if n >= cap(rpcMethod) {
a := make([]method, n, (n+4)*2)
- for i := range a {
- a[i] = rpcMethod[i]
- }
+ copy(a, rpcMethod)
rpcMethod = a
}
rpcMethod = rpcMethod[0 : n+1]
m = 4
}
posted := make([]Event, n+1, m)
- for i, p := range p.posted {
- posted[i] = p
- }
+ copy(posted, p.posted)
posted[n] = ev
p.posted = posted
}
func copyCommentList(list []*ast.Comment) []*ast.Comment {
- copy := make([]*ast.Comment, len(list))
- for i, c := range list {
- copy[i] = c
- }
- return copy
+ nlist := make([]*ast.Comment, len(list))
+ copy(nlist, list)
+ return nlist
}
}
msg[off] = byte(len(s))
off++
- for i := 0; i < len(s); i++ {
- msg[off+i] = s[i]
- }
- off += len(s)
+ off += copy(msg[off:], s)
}
}
}
count--
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names))
- for i := 0; i < len(names); i++ {
- nnames[i] = names[i]
- }
+ copy(nnames, names)
names = nnames
}
names = names[0 : len(names)+1]
count--
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names))
- for i := 0; i < len(names); i++ {
- nnames[i] = names[i]
- }
+ copy(nnames, names)
names = nnames
}
names = names[0 : len(names)+1]
count--
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names))
- for i := 0; i < len(names); i++ {
- nnames[i] = names[i]
- }
+ copy(nnames, names)
names = nnames
}
names = names[0 : len(names)+1]
count--
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names))
- for i := 0; i < len(names); i++ {
- nnames[i] = names[i]
- }
+ copy(nnames, names)
names = nnames
}
names = names[0 : len(names)+1]
}
if len(r) == cap(r) {
nr := make([]string, len(r), 2*len(r))
- for k := 0; k < len(r); k++ {
- nr[k] = r[k]
- }
+ copy(nr, r)
r = nr
}
r = r[0 : len(r)+1]
count--
if len(fi) == cap(fi) {
nfi := make([]FileInfo, len(fi), 2*len(fi))
- for i := 0; i < len(fi); i++ {
- nfi[i] = fi[i]
- }
+ copy(nfi, fi)
fi = nfi
}
fi = fi[0 : len(fi)+1]
func (r *StringReader) Read(p []byte) (n int, err os.Error) {
if r.step < len(r.data) {
s := r.data[r.step]
- for i := 0; i < len(s); i++ {
- p[i] = s[i]
- }
- n = len(s)
+ n = copy(p, s)
r.step++
} else {
err = os.EOF
} else {
j += Index(s[start:], old)
}
- w += copyString(t[w:], s[start:j])
- w += copyString(t[w:], new)
+ w += copy(t[w:], s[start:j])
+ w += copy(t[w:], new)
start = j + len(old)
}
- w += copyString(t[w:], s[start:])
+ w += copy(t[w:], s[start:])
return string(t[0:w])
}
-
-func copyString(dst []byte, src string) int {
- n := len(dst)
- if n > len(src) {
- n = len(src)
- }
- for i := 0; i < n; i++ {
- dst[i] = src[i]
- }
- return n
-}
// containing the text of s.
func StringByteSlice(s string) []byte {
a := make([]byte, len(s)+1)
- for i := 0; i < len(s); i++ {
- a[i] = s[i]
- }
+ copy(a, s)
return a
}
}
if i == cap(s) {
ns := make([]string, 2*cap(s))
- for j := range s {
- ns[j] = s[j]
- }
+ copy(ns, s)
s = ns
}
s = s[0 : i+1]
n := len(cclass.ranges)
if n >= cap(cclass.ranges) {
nr := make([]int, n, 2*n)
- for i, j := range nr {
- nr[i] = j
- }
+ copy(nr, cclass.ranges)
cclass.ranges = nr
}
cclass.ranges = cclass.ranges[0 : n+2]
i.setIndex(len(re.inst))
if n >= cap(re.inst) {
ni := make([]instr, n, 2*n)
- for i, j := range re.inst {
- ni[i] = j
- }
+ copy(ni, re.inst)
re.inst = ni
}
re.inst = re.inst[0 : n+1]
s, ok := scripts[name]
if !ok || len(s) == cap(s) {
ns := make([]Script, len(s), len(s)+100)
- for i, sc := range s {
- ns[i] = sc
- }
+ copy(ns, s)
s = ns
}
s = s[0 : len(s)+1]
n := len(attr)
if n >= cap(attr) {
nattr := make([]Attr, n, 2*cap(attr))
- for i, a := range attr {
- nattr[i] = a
- }
+ copy(nattr, attr)
attr = nattr
}
attr = attr[0 : n+1]