code review 12485044: undo CL 12486043 / ab644299d124

src/pkg/go/build/build.go

 // Copyright 2011 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 build
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 859 matching lines @@
                 // Line is
                 //      #cgo [GOOS/GOARCH...] LDFLAGS: stuff
                 //
                 line = strings.TrimSpace(line)
                 if len(line) < 5 || line[:4] != "#cgo" || (line[4] != ' ' && line[4] != '\t') {
                         continue
                 }
 
                 // 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)
                 }
                 line, argstr := line[:i], line[i+1:]
 
                 // Parse GOOS/GOARCH stuff.
                 f := strings.Fields(line)
                 if len(f) < 1 {
                         return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
                 }
@@ skipping 124 matching lines @@
 //      ctxt.Compiler
 //      !ctxt.Compiler
 //      tag (if tag is listed in ctxt.BuildTags or ctxt.ReleaseTags)
 //      !tag (if tag is not listed in ctxt.BuildTags or ctxt.ReleaseTags)
 //      a comma-separated list of any of these
 //
 func (ctxt *Context) match(name string) bool {
         if name == "" {
                 return false
         }
-        if i := strings.IndexByte(name, ','); i >= 0 {
+        if i := strings.Index(name, ","); i >= 0 {
                 // comma-separated list
                 return ctxt.match(name[:i]) && ctxt.match(name[i+1:])
         }
         if strings.HasPrefix(name, "!!") { // bad syntax, reject always
                 return false
         }
         if strings.HasPrefix(name, "!") { // negation
                 return len(name) > 1 && !ctxt.match(name[1:])
         }
 
@@ skipping 33 matching lines @@
 // The recognized name formats are:
 //
 //     name_$(GOOS).*
 //     name_$(GOARCH).*
 //     name_$(GOOS)_$(GOARCH).*
 //     name_$(GOOS)_test.*
 //     name_$(GOARCH)_test.*
 //     name_$(GOOS)_$(GOARCH)_test.*
 //
 func (ctxt *Context) goodOSArchFile(name string) bool {
-        if dot := strings.IndexByte(name, '.'); dot != -1 {
+        if dot := strings.Index(name, "."); dot != -1 {
                 name = name[:dot]
         }
         l := strings.Split(name, "_")
         if n := len(l); n > 0 && l[n-1] == "test" {
                 l = l[:n-1]
         }
         n := len(l)
         if n >= 2 && knownOS[l[n-2]] && knownArch[l[n-1]] {
                 return l[n-2] == ctxt.GOOS && l[n-1] == ctxt.GOARCH
         }
@@ skipping 34 matching lines @@
         switch goarch {
         case "386":
                 return "8", nil
         case "amd64":
                 return "6", nil
         case "arm":
                 return "5", nil
         }
         return "", errors.New("unsupported GOARCH " + goarch)
 }