code review 4602054: sort: change IntArray etc. to IntSlice for better name ...

src/pkg/syscall/exec_unix.go

 // Copyright 2009 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.
 
 // Fork, exec, wait, etc.
 
 package syscall
 
 import (
         "sync"
@@ skipping 44 matching lines @@
 // 4) Open.    Can block.  Use O_CLOEXEC if available (Linux).
 //             Otherwise, live with the race.
 // 5) Dup.     Does not block.  Use the ForkLock.
 //             On Linux, could use fcntl F_DUPFD_CLOEXEC
 //             instead of the ForkLock, but only for dup(fd, -1).
 
 var ForkLock sync.RWMutex
 
 // Convert array of string to array
 // of NUL-terminated byte pointer.
-func StringArrayPtr(ss []string) []*byte {
+func StringSlicePtr(ss []string) []*byte {
         bb := make([]*byte, len(ss)+1)
         for i := 0; i < len(ss); i++ {
                 bb[i] = StringBytePtr(ss[i])
         }
         bb[len(ss)] = nil
         return bb
 }
 
 func CloseOnExec(fd int) { fcntl(fd, F_SETFD, FD_CLOEXEC) }
 
@@ skipping 210 matching lines @@
 
         if attr == nil {
                 attr = &zeroAttributes
         }
 
         p[0] = -1
         p[1] = -1
 
         // Convert args to C form.
         argv0p := StringBytePtr(argv0)
-        argvp := StringArrayPtr(argv)
-        envvp := StringArrayPtr(attr.Env)
+        argvp := StringSlicePtr(argv)
+        envvp := StringSlicePtr(attr.Env)
 
         if OS == "freebsd" && len(argv[0]) > len(argv0) {
                 argvp[0] = argv0p
         }
 
         var chroot *byte
         if attr.Chroot != "" {
                 chroot = StringBytePtr(attr.Chroot)
         }
         var dir *byte
@@ skipping 63 matching lines @@
 // StartProcess wraps ForkExec for package os.
 func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid, handle int, err int) {
         pid, err = forkExec(argv0, argv, attr)
         return pid, 0, err
 }
 
 // Ordinary exec.
 func Exec(argv0 string, argv []string, envv []string) (err int) {
         _, _, err1 := RawSyscall(SYS_EXECVE,
                 uintptr(unsafe.Pointer(StringBytePtr(argv0))),
-                uintptr(unsafe.Pointer(&StringArrayPtr(argv)[0])),
-                uintptr(unsafe.Pointer(&StringArrayPtr(envv)[0])))
+                uintptr(unsafe.Pointer(&StringSlicePtr(argv)[0])),
+                uintptr(unsafe.Pointer(&StringSlicePtr(envv)[0])))
         return int(err1)
 }