Move readColonFile to separate file

Plan9 operating system stores users and groups information in
/adm/users file. This file is similar in strucuture to unix
based /etc/passwd and /etc/group. Since readColonFile resides in
lookup_unix.go file, extracting it makes it possible to reuse the
functionality across all os targets that can can utilize the function.

Author: Mantelijo

src/os/user/lookup_unix.go

@@ -9,7 +9,6 @@
 package user
 
 import (
-	"bufio"
 	"bytes"
 	"errors"
 	"io"
@@ -27,80 +26,6 @@ func init() {
 	groupImplemented = false
 }
 
-// lineFunc returns a value, an error, or (nil, nil) to skip the row.
-type lineFunc func(line []byte) (v interface{}, err error)
-
-// readColonFile parses r as an /etc/group or /etc/passwd style file, running
-// fn for each row. readColonFile returns a value, an error, or (nil, nil) if
-// the end of the file is reached without a match.
-//
-// readCols is the minimum number of colon-separated fields that will be passed
-// to fn; in a long line additional fields may be silently discarded.
-func readColonFile(r io.Reader, fn lineFunc, readCols int) (v interface{}, err error) {
-	rd := bufio.NewReader(r)
-
-	// Read the file line-by-line.
-	for {
-		var isPrefix bool
-		var wholeLine []byte
-
-		// Read the next line. We do so in chunks (as much as reader's
-		// buffer is able to keep), check if we read enough columns
-		// already on each step and store final result in wholeLine.
-		for {
-			var line []byte
-			line, isPrefix, err = rd.ReadLine()
-
-			if err != nil {
-				// We should return (nil, nil) if EOF is reached
-				// without a match.
-				if err == io.EOF {
-					err = nil
-				}
-				return nil, err
-			}
-
-			// Simple common case: line is short enough to fit in a
-			// single reader's buffer.
-			if !isPrefix && len(wholeLine) == 0 {
-				wholeLine = line
-				break
-			}
-
-			wholeLine = append(wholeLine, line...)
-
-			// Check if we read the whole line (or enough columns)
-			// already.
-			if !isPrefix || bytes.Count(wholeLine, []byte{':'}) >= readCols {
-				break
-			}
-		}
-
-		// There's no spec for /etc/passwd or /etc/group, but we try to follow
-		// the same rules as the glibc parser, which allows comments and blank
-		// space at the beginning of a line.
-		wholeLine = bytes.TrimSpace(wholeLine)
-		if len(wholeLine) == 0 || wholeLine[0] == '#' {
-			continue
-		}
-		v, err = fn(wholeLine)
-		if v != nil || err != nil {
-			return
-		}
-
-		// If necessary, skip the rest of the line
-		for ; isPrefix; _, isPrefix, err = rd.ReadLine() {
-			if err != nil {
-				// We should return (nil, nil) if EOF is reached without a match.
-				if err == io.EOF {
-					err = nil
-				}
-				return nil, err
-			}
-		}
-	}
-}
-
 func matchGroupIndexValue(value string, idx int) lineFunc {
 	var leadColon string
 	if idx > 0 {

src/os/user/read_colon_file.go

@@ -0,0 +1,86 @@
+//go:build !windows
+// +build !windows
+
+package user
+
+import (
+	"bufio"
+	"bytes"
+	"io"
+)
+
+// lineFunc returns a value, an error, or (nil, nil) to skip the row.
+type lineFunc func(line []byte) (v interface{}, err error)
+
+// readColonFile parses r as an /etc/group or /etc/passwd style file, running
+// fn for each row. readColonFile returns a value, an error, or (nil, nil) if
+// the end of the file is reached without a match.
+//
+// readCols is the minimum number of colon-separated fields that will be passed
+// to fn; in a long line additional fields may be silently discarded.
+//
+// readColonFile can also be used to read /adm/users on plan9.
+func readColonFile(r io.Reader, fn lineFunc, readCols int) (v interface{}, err error) {
+	rd := bufio.NewReader(r)
+
+	// Read the file line-by-line.
+	for {
+		var isPrefix bool
+		var wholeLine []byte
+
+		// Read the next line. We do so in chunks (as much as reader's
+		// buffer is able to keep), check if we read enough columns
+		// already on each step and store final result in wholeLine.
+		for {
+			var line []byte
+			line, isPrefix, err = rd.ReadLine()
+
+			if err != nil {
+				// We should return (nil, nil) if EOF is reached
+				// without a match.
+				if err == io.EOF {
+					err = nil
+				}
+				return nil, err
+			}
+
+			// Simple common case: line is short enough to fit in a
+			// single reader's buffer.
+			if !isPrefix && len(wholeLine) == 0 {
+				wholeLine = line
+				break
+			}
+
+			wholeLine = append(wholeLine, line...)
+
+			// Check if we read the whole line (or enough columns)
+			// already.
+			if !isPrefix || bytes.Count(wholeLine, []byte{':'}) >= readCols {
+				break
+			}
+		}
+
+		// There's no spec for /etc/passwd or /etc/group, but we try to follow
+		// the same rules as the glibc parser, which allows comments and blank
+		// space at the beginning of a line.
+		wholeLine = bytes.TrimSpace(wholeLine)
+		if len(wholeLine) == 0 || wholeLine[0] == '#' {
+			continue
+		}
+		v, err = fn(wholeLine)
+		if v != nil || err != nil {
+			return
+		}
+
+		// If necessary, skip the rest of the line
+		for ; isPrefix; _, isPrefix, err = rd.ReadLine() {
+			if err != nil {
+				// We should return (nil, nil) if EOF is reached without a match.
+				if err == io.EOF {
+					err = nil
+				}
+				return nil, err
+			}
+		}
+	}
+}