| // Copyright 2014 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 runtime |
| |
| import ( |
| "unsafe" |
| ) |
| |
| func concatstrings(a []string) string { |
| idx := 0 |
| l := 0 |
| count := 0 |
| for i, x := range a { |
| n := len(x) |
| if n == 0 { |
| continue |
| } |
| if l+n < l { |
| gothrow("string concatenation too long") |
| } |
| l += n |
| count++ |
| idx = i |
| } |
| if count == 0 { |
| return "" |
| } |
| if count == 1 { |
| return a[idx] |
| } |
| s, b := rawstring(l) |
| l = 0 |
| for _, x := range a { |
| copy(b[l:], x) |
| l += len(x) |
| } |
| return s |
| } |
| |
| //go:nosplit |
| func concatstring2(a [2]string) string { |
| return concatstrings(a[:]) |
| } |
| |
| //go:nosplit |
| func concatstring3(a [3]string) string { |
| return concatstrings(a[:]) |
| } |
| |
| //go:nosplit |
| func concatstring4(a [4]string) string { |
| return concatstrings(a[:]) |
| } |
| |
| //go:nosplit |
| func concatstring5(a [5]string) string { |
| return concatstrings(a[:]) |
| } |
| |
| func slicebytetostring(b []byte) string { |
| if raceenabled && len(b) > 0 { |
| racereadrangepc(unsafe.Pointer(&b[0]), |
| uintptr(len(b)), |
| getcallerpc(unsafe.Pointer(&b)), |
| funcPC(slicebytetostring)) |
| } |
| s, c := rawstring(len(b)) |
| copy(c, b) |
| return s |
| } |
| |
| func slicebytetostringtmp(b []byte) string { |
| // Return a "string" referring to the actual []byte bytes. |
| // This is only for use by internal compiler optimizations |
| // that know that the string form will be discarded before |
| // the calling goroutine could possibly modify the original |
| // slice or synchronize with another goroutine. |
| // Today, the only such case is a m[string(k)] lookup where |
| // m is a string-keyed map and k is a []byte. |
| |
| if raceenabled && len(b) > 0 { |
| racereadrangepc(unsafe.Pointer(&b[0]), |
| uintptr(len(b)), |
| getcallerpc(unsafe.Pointer(&b)), |
| funcPC(slicebytetostringtmp)) |
| } |
| return *(*string)(unsafe.Pointer(&b)) |
| } |
| |
| func stringtoslicebyte(s string) []byte { |
| b := rawbyteslice(len(s)) |
| copy(b, s) |
| return b |
| } |
| |
| func stringtoslicerune(s string) []rune { |
| // two passes. |
| // unlike slicerunetostring, no race because strings are immutable. |
| n := 0 |
| t := s |
| for len(s) > 0 { |
| _, k := charntorune(s) |
| s = s[k:] |
| n++ |
| } |
| a := rawruneslice(n) |
| n = 0 |
| for len(t) > 0 { |
| r, k := charntorune(t) |
| t = t[k:] |
| a[n] = r |
| n++ |
| } |
| return a |
| } |
| |
| func slicerunetostring(a []rune) string { |
| if raceenabled && len(a) > 0 { |
| racereadrangepc(unsafe.Pointer(&a[0]), |
| uintptr(len(a))*unsafe.Sizeof(a[0]), |
| getcallerpc(unsafe.Pointer(&a)), |
| funcPC(slicerunetostring)) |
| } |
| var dum [4]byte |
| size1 := 0 |
| for _, r := range a { |
| size1 += runetochar(dum[:], r) |
| } |
| s, b := rawstring(size1 + 3) |
| size2 := 0 |
| for _, r := range a { |
| // check for race |
| if size2 >= size1 { |
| break |
| } |
| size2 += runetochar(b[size2:], r) |
| } |
| return s[:size2] |
| } |
| |
| type stringStruct struct { |
| str unsafe.Pointer |
| len int |
| } |
| |
| func intstring(v int64) string { |
| s, b := rawstring(4) |
| n := runetochar(b, rune(v)) |
| return s[:n] |
| } |
| |
| // stringiter returns the index of the next |
| // rune after the rune that starts at s[k]. |
| func stringiter(s string, k int) int { |
| if k >= len(s) { |
| // 0 is end of iteration |
| return 0 |
| } |
| |
| c := s[k] |
| if c < runeself { |
| return k + 1 |
| } |
| |
| // multi-char rune |
| _, n := charntorune(s[k:]) |
| return k + n |
| } |
| |
| // stringiter2 returns the rune that starts at s[k] |
| // and the index where the next rune starts. |
| func stringiter2(s string, k int) (int, rune) { |
| if k >= len(s) { |
| // 0 is end of iteration |
| return 0, 0 |
| } |
| |
| c := s[k] |
| if c < runeself { |
| return k + 1, rune(c) |
| } |
| |
| // multi-char rune |
| r, n := charntorune(s[k:]) |
| return k + n, r |
| } |
| |
| // rawstring allocates storage for a new string. The returned |
| // string and byte slice both refer to the same storage. |
| // The storage is not zeroed. Callers should use |
| // b to set the string contents and then drop b. |
| func rawstring(size int) (s string, b []byte) { |
| p := mallocgc(uintptr(size), nil, flagNoScan|flagNoZero) |
| |
| (*stringStruct)(unsafe.Pointer(&s)).str = p |
| (*stringStruct)(unsafe.Pointer(&s)).len = size |
| |
| (*slice)(unsafe.Pointer(&b)).array = (*uint8)(p) |
| (*slice)(unsafe.Pointer(&b)).len = uint(size) |
| (*slice)(unsafe.Pointer(&b)).cap = uint(size) |
| |
| for { |
| ms := maxstring |
| if uintptr(size) <= uintptr(ms) || casuintptr((*uintptr)(unsafe.Pointer(&maxstring)), uintptr(ms), uintptr(size)) { |
| return |
| } |
| } |
| } |
| |
| // rawbyteslice allocates a new byte slice. The byte slice is not zeroed. |
| func rawbyteslice(size int) (b []byte) { |
| cap := goroundupsize(uintptr(size)) |
| p := mallocgc(cap, nil, flagNoScan|flagNoZero) |
| if cap != uintptr(size) { |
| memclr(add(p, uintptr(size)), cap-uintptr(size)) |
| } |
| |
| (*slice)(unsafe.Pointer(&b)).array = (*uint8)(p) |
| (*slice)(unsafe.Pointer(&b)).len = uint(size) |
| (*slice)(unsafe.Pointer(&b)).cap = uint(cap) |
| return |
| } |
| |
| // rawruneslice allocates a new rune slice. The rune slice is not zeroed. |
| func rawruneslice(size int) (b []rune) { |
| if uintptr(size) > maxmem/4 { |
| gothrow("out of memory") |
| } |
| mem := goroundupsize(uintptr(size) * 4) |
| p := mallocgc(mem, nil, flagNoScan|flagNoZero) |
| if mem != uintptr(size)*4 { |
| memclr(add(p, uintptr(size)*4), mem-uintptr(size)*4) |
| } |
| |
| (*slice)(unsafe.Pointer(&b)).array = (*uint8)(p) |
| (*slice)(unsafe.Pointer(&b)).len = uint(size) |
| (*slice)(unsafe.Pointer(&b)).cap = uint(mem / 4) |
| return |
| } |
| |
| // used by cmd/cgo |
| func gobytes(p *byte, n int) []byte { |
| if n == 0 { |
| return make([]byte, 0) |
| } |
| x := make([]byte, n) |
| memmove(unsafe.Pointer(&x[0]), unsafe.Pointer(p), uintptr(n)) |
| return x |
| } |
| |
| func gostringsize(n int) string { |
| s, _ := rawstring(n) |
| return s |
| } |
| |
| //go:noescape |
| func findnull(*byte) int |
| |
| func gostring(p *byte) string { |
| l := findnull(p) |
| if l == 0 { |
| return "" |
| } |
| s, b := rawstring(l) |
| memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l)) |
| return s |
| } |
| |
| func gostringn(p *byte, l int) string { |
| if l == 0 { |
| return "" |
| } |
| s, b := rawstring(l) |
| memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l)) |
| return s |
| } |
| |
| func index(s, t string) int { |
| if len(t) == 0 { |
| return 0 |
| } |
| for i := 0; i < len(s); i++ { |
| if s[i] == t[0] && hasprefix(s[i:], t) { |
| return i |
| } |
| } |
| return -1 |
| } |
| |
| func contains(s, t string) bool { |
| return index(s, t) >= 0 |
| } |
| |
| func hasprefix(s, t string) bool { |
| return len(s) >= len(t) && s[:len(t)] == t |
| } |