This reverts https://golang.org/cl/65930.
Fixes #22148
Change-Id: Ie0712621ed89c43bef94417fc32de9af77607760
Reviewed-on: https://go-review.googlesource.com/68430
Reviewed-by: Ian Lance Taylor <iant@golang.org>
features = append(features, f)
continue
}
- comma := strings.IndexByte(f, ',')
+ comma := strings.Index(f, ",")
for cname := range cmap {
f2 := fmt.Sprintf("%s (%s)%s", f[:comma], cname, f[comma:])
features = append(features, f2)
line = strings.TrimSpace(line[8:])
var key, val string
- spaceIndex := strings.IndexByte(line, ' ')
+ spaceIndex := strings.Index(line, " ")
tabIndex := strings.Index(line, "\t")
if spaceIndex == -1 && tabIndex == -1 {
continue
}
- c1 := strings.IndexByte(line, ':')
+ c1 := strings.Index(line, ":")
if c1 < 0 {
continue
}
- c2 := strings.IndexByte(line[c1+1:], ':')
+ c2 := strings.Index(line[c1+1:], ":")
if c2 < 0 {
continue
}
if strings.HasPrefix(n.Name, "orig_") || strings.HasPrefix(n.Name, "_") {
continue
}
- i := strings.IndexByte(n.Name, '_')
+ i := strings.Index(n.Name, "_")
if i < 0 {
continue
}
continue
}
s := strings.TrimSpace(c.Text[i+len("+godefs map"):])
- i = strings.IndexByte(s, ' ')
+ i = strings.Index(s, " ")
if i < 0 {
fmt.Fprintf(os.Stderr, "invalid +godefs map comment: %s\n", c.Text)
continue
for key, val := range knownFormats {
// key must be "typename format", and format starts with a '%'
// (formats containing '*' alone are not collected in this table)
- i := strings.IndexByte(key, '%')
+ i := strings.Index(key, "%")
if i < 0 || !oneFormat(key[i:]) {
log.Fatalf("incorrect knownFormats key: %q", key)
}
// _ in phase name also matches space
phase := name[4:]
flag := "debug" // default flag is debug
- if i := strings.IndexByte(phase, '/'); i >= 0 {
+ if i := strings.Index(phase, "/"); i >= 0 {
flag = phase[i+1:]
phase = phase[:i]
}
if strings.Count(s, "=") != 1 {
log.Fatal("-importmap argument must be of the form source=actual")
}
- i := strings.IndexByte(s, '=')
+ i := strings.Index(s, "=")
source, actual := s[:i], s[i+1:]
if source == "" || actual == "" {
log.Fatal("-importmap argument must be of the form source=actual; source and actual must be non-empty")
}
var verb, args string
- if i := strings.IndexByte(line, ' '); i < 0 {
+ if i := strings.Index(line, " "); i < 0 {
verb = line
} else {
verb, args = line[:i], strings.TrimSpace(line[i+1:])
}
var before, after string
- if i := strings.IndexByte(args, '='); i >= 0 {
+ if i := strings.Index(args, "="); i >= 0 {
before, after = args[:i], args[i+1:]
}
switch verb {
fallthrough // because of //go:cgo_unsafe_args
default:
verb := text
- if i := strings.IndexByte(text, ' '); i >= 0 {
+ if i := strings.Index(text, " "); i >= 0 {
verb = verb[:i]
}
prag := pragmaValue(verb)
s += fmt.Sprintf("entry to %s:", lv.fn.funcname())
} else if sym, ok := v.Aux.(*obj.LSym); ok {
fn := sym.Name
- if pos := strings.IndexByte(fn, '.'); pos >= 0 {
+ if pos := strings.Index(fn, "."); pos >= 0 {
fn = fn[pos+1:]
}
s += fmt.Sprintf("call to %s:", fn)
}
// compound sexpr
var argname string
- colon := strings.IndexByte(arg, ':')
- openparen := strings.IndexByte(arg, '(')
+ colon := strings.Index(arg, ":")
+ openparen := strings.Index(arg, "(")
if colon >= 0 && openparen >= 0 && colon < openparen {
// rule-specified name
argname = arg[:colon]
}
// Split up input.
var prefix string
- colon := strings.IndexByte(m, ':')
+ colon := strings.Index(m, ":")
if colon >= 0 && isVariable(m[:colon]) {
prefix = m[:colon+1]
m = m[colon+1:]
return
}
// Split up input.
- colon := strings.IndexByte(m, ':')
+ colon := strings.Index(m, ":")
if colon >= 0 && isVariable(m[:colon]) {
cnt[m[:colon]]++
m = m[colon+1:]
}
func stripAt(s string) (string, int) {
- if i := strings.IndexByte(s, '@'); i >= 0 {
+ if i := strings.Index(s, "@"); i >= 0 {
return s[:i] + s[i+1:], i
}
return s, -1
// so OS X 10.6 is uname version 10 and OS X 10.8 is uname version 12.
if gohostos == "darwin" {
rel := run("", CheckExit, "uname", "-r")
- if i := strings.IndexByte(rel, '.'); i >= 0 {
+ if i := strings.Index(rel, "."); i >= 0 {
rel = rel[:i]
}
osx, _ := strconv.Atoi(rel)
// slash+1: if there's no slash, the value is -1 and start is 0; otherwise
// start is the byte after the slash.
for start := slash + 1; start < len(arg); start = period + 1 {
- period = strings.IndexByte(arg[start:], '.')
+ period = strings.Index(arg[start:], ".")
symbol := ""
if period < 0 {
period = len(arg)
}
func parseName(s string) (ptr bool, pkg, nam string) {
- i := strings.IndexByte(s, '.')
+ i := strings.Index(s, ".")
if i < 0 {
panic("parseName: invalid name " + s)
}
if strings.HasPrefix(t, "[") || strings.HasPrefix(t, "map[") {
// Lazy: assume there are no nested [] in the array
// length or map key type.
- if i := strings.IndexByte(t, ']'); i >= 0 {
+ if i := strings.Index(t, "]"); i >= 0 {
typeof[n] = t[i+1:]
}
}
key, value = "int", "rune"
} else if strings.HasPrefix(t, "[") {
key = "int"
- if i := strings.IndexByte(t, ']'); i >= 0 {
+ if i := strings.Index(t, "]"); i >= 0 {
value = t[i+1:]
}
} else if strings.HasPrefix(t, "map[") {
- if i := strings.IndexByte(t, ']'); i >= 0 {
+ if i := strings.Index(t, "]"); i >= 0 {
key, value = t[4:i], t[i+1:]
}
}
}
for _, e := range tg.env {
if strings.HasPrefix(e, "GOROOT=") || strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") {
- val := e[strings.IndexByte(e, '=')+1:]
+ val := e[strings.Index(e, "=")+1:]
if strings.HasPrefix(val, "testdata") || strings.HasPrefix(val, "./testdata") {
tg.t.Fatalf("internal testsuite error: call to parallel with testdata in environment (%s)", e)
}
// Name returns the command's name: the first word in the usage line.
func (c *Command) Name() string {
name := c.UsageLine
- i := strings.IndexByte(name, ' ')
+ i := strings.Index(name, " ")
if i >= 0 {
name = name[:i]
}
name := arg[1:]
// If there's already a prefix such as "test.", drop it for now.
name = strings.TrimPrefix(name, cmd+".")
- equals := strings.IndexByte(name, '=')
+ equals := strings.Index(name, "=")
if equals >= 0 {
value = name[equals+1:]
name = name[:equals]
return err
}
vers := runtime.Version()
- if i := strings.IndexByte(vers, ' '); i >= 0 {
+ if i := strings.Index(vers, " "); i >= 0 {
vers = vers[:i]
}
if err := vcs.tagSync(root, selectTag(vers, tags)); err != nil {
//
// This handles custom import paths like "name.tld/pkg/foo" or just "name.tld".
func repoRootForImportDynamic(importPath string, security web.SecurityMode) (*repoRoot, error) {
- slash := strings.IndexByte(importPath, '/')
+ slash := strings.Index(importPath, "/")
if slash < 0 {
slash = len(importPath)
}
func testPatterns(t *testing.T, name, tests string, fn func(string, string) bool) {
var patterns []string
for _, line := range strings.Split(tests, "\n") {
- if i := strings.IndexByte(line, '#'); i >= 0 {
+ if i := strings.Index(line, "#"); i >= 0 {
line = line[:i]
}
f := strings.Fields(line)
// their own code to $GOROOT instead of using $GOPATH, but we assume that
// code will start with a domain name (dot in the first element).
func isStandardImportPath(path string) bool {
- i := strings.IndexByte(path, '/')
+ i := strings.Index(path, "/")
if i < 0 {
i = len(path)
}
var strdata []*sym.Symbol
func addstrdata1(ctxt *Link, arg string) {
- eq := strings.IndexByte(arg, '=')
+ eq := strings.Index(arg, "=")
dot := strings.LastIndex(arg[:eq+1], ".")
if eq < 0 || dot < 0 {
Exitf("-X flag requires argument of the form importpath.name=value")
}
for i, m := range methodsigs {
name := string(m)
- name = name[:strings.IndexByte(name, '(')]
+ name = name[:strings.Index(name, "(")]
if !strings.HasSuffix(methods[i].ifn().Name, name) {
panic(fmt.Sprintf("%q relocation for %q does not match method %q", s.Name, methods[i].ifn().Name, name))
}
local = expandpkg(local, pkg)
q = ""
- if i := strings.IndexByte(remote, '#'); i >= 0 {
+ if i := strings.Index(remote, "#"); i >= 0 {
remote, q = remote[:i], remote[i+1:]
}
s = ctxt.Syms.Lookup(local, 0)
}
var verb, args string
- if i := strings.IndexByte(line, ' '); i < 0 {
+ if i := strings.Index(line, " "); i < 0 {
verb = line
} else {
verb, args = line[:i], strings.TrimSpace(line[i+1:])
}
var before, after string
- if i := strings.IndexByte(args, '='); i >= 0 {
+ if i := strings.Index(args, "="); i >= 0 {
before, after = args[:i], args[i+1:]
}
switch verb {
// Determine whether the match we're holding
// is the first or second argument.
- if strings.Index(line, expr) > strings.IndexByte(line, ',') {
+ if strings.Index(line, expr) > strings.Index(line, ",") {
kind = dst
} else {
kind = src
start := s.nbytes
s.scanNum()
if s.nbytes == len(s.format) || s.nbytes == start || s.format[s.nbytes] != ']' {
- end := strings.IndexByte(s.format, ']')
+ end := strings.Index(s.format, "]")
if end < 0 {
end = len(s.format)
}
// by containing a field named XMLName; see issue 18256.
continue
}
- if i := strings.IndexByte(val, ','); i >= 0 {
+ if i := strings.Index(val, ","); i >= 0 {
if key == "xml" {
// Use a separate namespace for XML attributes.
for _, opt := range strings.Split(val[i:], ",") {
return nil, errors.New("x509: no DEK-Info header in block")
}
- idx := strings.IndexByte(dek, ',')
+ idx := strings.Index(dek, ",")
if idx == -1 {
return nil, errors.New("x509: malformed DEK-Info header")
}
}
if strings.HasPrefix(ln, sn) {
// extract hex value from parentheses.
- id.serialNumber = ln[strings.IndexByte(ln, '(')+1 : len(ln)-1]
+ id.serialNumber = ln[strings.Index(ln, "(")+1 : len(ln)-1]
continue
}
if strings.TrimSpace(ln) == "X509v3 Subject Key Identifier:" {
pathend = 0
}
- if i := strings.IndexByte(s.Name[pathend:], '.'); i != -1 {
+ if i := strings.Index(s.Name[pathend:], "."); i != -1 {
return s.Name[:pathend+i]
}
return ""
if pathend < 0 {
pathend = 0
}
- l := strings.IndexByte(s.Name[pathend:], '.')
+ l := strings.Index(s.Name[pathend:], ".")
r := strings.LastIndexByte(s.Name[pathend:], '.')
if l == -1 || r == -1 || l == r {
return ""
// parseTag splits a struct field's json tag into its name and
// comma-separated options.
func parseTag(tag string) (string, tagOptions) {
- if idx := strings.IndexByte(tag, ','); idx != -1 {
+ if idx := strings.Index(tag, ","); idx != -1 {
return tag[:idx], tagOptions(tag[idx+1:])
}
return tag, tagOptions("")
s := string(o)
for s != "" {
var next string
- i := strings.IndexByte(s, ',')
+ i := strings.Index(s, ",")
if i >= 0 {
s, next = s[:i], s[i+1:]
}
// Split the tag from the xml namespace if necessary.
tag := f.Tag.Get("xml")
- if i := strings.IndexByte(tag, ' '); i >= 0 {
+ if i := strings.Index(tag, " "); i >= 0 {
finfo.xmlns, tag = tag[:i], tag[i+1:]
}
if !ok {
return
}
- i := strings.IndexByte(s, ':')
+ i := strings.Index(s, ":")
if i < 0 {
name.Local = s
} else {
// Split at colon.
line = strings.TrimSpace(line[4:])
- i := strings.IndexByte(line, ':')
+ i := strings.Index(line, ":")
if i < 0 {
return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
}
}
return false
}
- if i := strings.IndexByte(name, ','); i >= 0 {
+ if i := strings.Index(name, ","); i >= 0 {
// comma-separated list
ok1 := ctxt.match(name[:i], allTags)
ok2 := ctxt.match(name[i+1:], allTags)
//
// An exception: if GOOS=android, then files with GOOS=linux are also matched.
func (ctxt *Context) goodOSArchFile(name string, allTags map[string]bool) bool {
- if dot := strings.IndexByte(name, '.'); dot != -1 {
+ if dot := strings.Index(name, "."); dot != -1 {
name = name[:dot]
}
// systems, such as android, to arrive without breaking existing code with
// innocuous source code in "android.go". The easiest fix: cut everything
// in the name before the initial _.
- i := strings.IndexByte(name, '_')
+ i := strings.Index(name, "_")
if i < 0 {
return true
}
* Check for vertical "line of stars" and correct prefix accordingly.
*/
lineOfStars := false
- if i := strings.IndexByte(prefix, '*'); i >= 0 {
+ if i := strings.Index(prefix, "*"); i >= 0 {
// Line of stars present.
if i > 0 && prefix[i-1] == ' ' {
i-- // remove trailing blank from prefix so stars remain aligned
// https://www.ietf.org/rfc/rfc4627.txt
mimeType = strings.ToLower(mimeType)
// discard parameters
- if i := strings.IndexByte(mimeType, ';'); i >= 0 {
+ if i := strings.Index(mimeType, ";"); i >= 0 {
mimeType = mimeType[:i]
}
mimeType = strings.TrimSpace(mimeType)
// len(s) > 0
// parse fraction a/b, if any
- if sep := strings.IndexByte(s, '/'); sep >= 0 {
+ if sep := strings.Index(s, "/"); sep >= 0 {
if _, ok := z.a.SetString(s[:sep], 0); !ok {
return nil, false
}
}
cur := start + len("=?")
- i := strings.IndexByte(header[cur:], '?')
+ i := strings.Index(header[cur:], "?")
if i == -1 {
break
}
// FormatMediaType returns the empty string.
func FormatMediaType(t string, param map[string]string) string {
var b bytes.Buffer
- if slash := strings.IndexByte(t, '/'); slash == -1 {
+ if slash := strings.Index(t, "/"); slash == -1 {
if !isToken(t) {
return ""
}
// The returned map, params, maps from the lowercase
// attribute to the attribute value with its case preserved.
func ParseMediaType(v string) (mediatype string, params map[string]string, err error) {
- i := strings.IndexByte(v, ';')
+ i := strings.Index(v, ";")
if i == -1 {
i = len(v)
}
}
pmap := params
- if idx := strings.IndexByte(key, '*'); idx != -1 {
+ if idx := strings.Index(key, "*"); idx != -1 {
baseName := key[:idx]
if continuation == nil {
continuation = make(map[string]map[string]string)
func envMap(env []string) map[string]string {
m := make(map[string]string)
for _, kv := range env {
- if idx := strings.IndexByte(kv, '='); idx != -1 {
+ if idx := strings.Index(kv, "="); idx != -1 {
m[kv[:idx]] = kv[idx+1:]
}
}
continue
}
parts[0] = strings.TrimSpace(parts[0])
- j := strings.IndexByte(parts[0], '=')
+ j := strings.Index(parts[0], "=")
if j < 0 {
continue
}
}
attr, val := parts[i], ""
- if j := strings.IndexByte(attr, '='); j >= 0 {
+ if j := strings.Index(attr, "="); j >= 0 {
attr, val = attr[:j], attr[j+1:]
}
lowerAttr := strings.ToLower(attr)
continue
}
name, val := parts[i], ""
- if j := strings.IndexByte(name, '='); j >= 0 {
+ if j := strings.Index(name, "="); j >= 0 {
name, val = name[:j], name[j+1:]
}
if !isCookieNameValid(name) {
if ra == "" {
continue
}
- i := strings.IndexByte(ra, '-')
+ i := strings.Index(ra, "-")
if i < 0 {
return nil, errors.New("invalid range")
}
if !strings.HasPrefix(vers, "HTTP/") {
return 0, 0, false
}
- dot := strings.IndexByte(vers, '.')
+ dot := strings.Index(vers, ".")
if dot < 0 {
return 0, 0, false
}
// parseRequestLine parses "GET /foo HTTP/1.1" into its three parts.
func parseRequestLine(line string) (method, requestURI, proto string, ok bool) {
- s1 := strings.IndexByte(line, ' ')
- s2 := strings.IndexByte(line[s1+1:], ' ')
+ s1 := strings.Index(line, " ")
+ s2 := strings.Index(line[s1+1:], " ")
if s1 < 0 || s2 < 0 {
return
}
}
var query string
- if i := strings.IndexByte(url, '?'); i != -1 {
+ if i := strings.Index(url, "?"); i != -1 {
url, query = url[:i], url[i:]
}
}
loop:
for i, name := range names {
- if strings.IndexByte(name, '.') == len(name)-1 { // "localhost" not "localhost."
+ if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost."
for j := range names {
if j == i {
continue
// RFC 3986, ยง3.3:
// In addition, a URI reference (Section 4.1) may be a relative-path reference,
// in which case the first path segment cannot contain a colon (":") character.
- colon := strings.IndexByte(rest, ':')
- slash := strings.IndexByte(rest, '/')
+ colon := strings.Index(rest, ":")
+ slash := strings.Index(rest, "/")
if colon >= 0 && (slash < 0 || colon < slash) {
// First path segment has colon. Not allowed in relative URL.
return nil, errors.New("first path segment in URL cannot contain colon")
continue
}
value := ""
- if i := strings.IndexByte(key, '='); i >= 0 {
+ if i := strings.Index(key, "="); i >= 0 {
key, value = key[:i], key[i+1:]
}
key, err1 := QueryUnescape(key)
for _, pair := range origEnv {
// Environment variables on Windows can begin with =
// http://blogs.msdn.com/b/oldnewthing/archive/2010/05/06/10008132.aspx
- i := strings.IndexByte(pair[1:], '=') + 1
+ i := strings.Index(pair[1:], "=") + 1
if err := Setenv(pair[:i], pair[i+1:]); err != nil {
t.Errorf("Setenv(%q, %q) failed during reset: %v", pair[:i], pair[i+1:], err)
}
out := make([]string, 0, len(env))
saw := map[string]int{} // key => index into out
for _, kv := range env {
- eq := strings.IndexByte(kv, '=')
+ eq := strings.Index(kv, "=")
if eq < 0 {
out = append(out, kv)
continue
}
want := runBinHostname(t)
if hostname != want {
- i := strings.IndexByte(hostname, '.')
+ i := strings.Index(hostname, ".")
if i < 0 || hostname[0:i] != want {
t.Errorf("Hostname() = %q, want %q", hostname, want)
}
// say: "It is expected to be a comma separated list of
// personal data where the first item is the full name of the
// user."
- if i := strings.IndexByte(u.Name, ','); i >= 0 {
+ if i := strings.Index(u.Name, ","); i >= 0 {
u.Name = u.Name[:i]
}
return u
// say: "It is expected to be a comma separated list of
// personal data where the first item is the full name of the
// user."
- if i := strings.IndexByte(u.Name, ','); i >= 0 {
+ if i := strings.Index(u.Name, ","); i >= 0 {
u.Name = u.Name[:i]
}
return u, nil
out[n] = -1
out[n+1] = -1
} else {
- k := strings.IndexByte(pair, '-')
+ k := strings.Index(pair, "-")
if k < 0 {
t.Fatalf("%s:%d: invalid pair %s", file, lineno, pair)
}
continue Reading
}
case ':':
- i := strings.IndexByte(flag[1:], ':')
+ i := strings.Index(flag[1:], ":")
if i < 0 {
t.Logf("skip: %s", line)
continue Reading
func (re *Regexp) expand(dst []byte, template string, bsrc []byte, src string, match []int) []byte {
for len(template) > 0 {
- i := strings.IndexByte(template, '$')
+ i := strings.Index(template, "$")
if i < 0 {
break
}
fprintStack(&buf, stk)
samples += count
for i, name := range need {
- if semi := strings.IndexByte(name, ';'); semi > -1 {
+ if semi := strings.Index(name, ";"); semi > -1 {
kv := strings.SplitN(name[semi+1:], "=", 2)
if len(kv) != 2 || !contains(labels[kv[0]], kv[1]) {
continue
}
func parseScript(line string, scripts map[string][]Script) {
- comment := strings.IndexByte(line, '#')
+ comment := strings.Index(line, "#")
if comment >= 0 {
line = line[0:comment]
}