- amend based on review comments

Author: pjebs

src/strconv/atoc.go

@@ -1,4 +1,4 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2020 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.
 
@@ -33,8 +33,9 @@ func parseComplexComponent(s, orig string, bitSize int) (float64, error) {
 // When bitSize=64, the result still has type complex128, but it will be
 // convertible to complex64 without changing its value.
 //
-// The number represented by s may or may not be parenthesized and have the format (N+Ni) where N is
-// a floating-point number. There must not be spaces between the real and imaginary components.
+// The number represented by s may or may not be parenthesized and have the format
+// (N+Ni) where N is a floating-point number. There must not be spaces between the real
+// and imaginary components.
 //
 // ParseComplex accepts decimal and hexadecimal floating-point number syntax.
 // If s is well-formed and near a valid floating-point number,
@@ -56,23 +57,21 @@ func parseComplexComponent(s, orig string, bitSize int) (float64, error) {
 // ParseComplex recognizes the strings "NaN", "+Inf", and "-Inf" as their
 // respective special floating point values for each component. It ignores case when matching.
 func ParseComplex(s string, bitSize int) (complex128, error) {
-
-	orig := s
-
 	if len(s) == 0 {
-		return 0, syntaxError(fnParseComplex, orig)
+		return 0, syntaxError(fnParseComplex, s)
 	}
+	orig := s
 
-	lastChar := s[len(s)-1 : len(s)]
+	endCh := s[len(s)-1]
 
 	// Remove brackets
-	if len(s) > 1 && s[0:1] == "(" && lastChar == ")" {
+	if len(s) > 1 && s[0] == '(' && endCh == ')' {
 		s = s[1 : len(s)-1]
-		lastChar = s[len(s)-1 : len(s)]
+		endCh = s[len(s)-1]
 	}
 
 	// Is last character an i?
-	if lastChar != "i" {
+	if endCh != 'i' {
 		// The last character is not an i so there is only a real component.
 		real, err := parseComplexComponent(s, orig, bitSize)
 		if err != nil {
@@ -85,17 +84,15 @@ func ParseComplex(s string, bitSize int) (complex128, error) {
 	s = s[0 : len(s)-1]
 
 	// Count how many ± exist.
-	pos := []int{}
-
-	for idx, rune := range s {
-		if rune == '+' || rune == '-' {
-			pos = append(pos, idx)
+	signPos := []int{}
+	for i, ch := range s {
+		if ch == '+' || ch == '-' {
+			signPos = append(signPos, i)
 		}
 	}
 
-	if len(pos) == 0 {
+	if len(signPos) == 0 {
 		// There is only an imaginary component
-
 		if s == "" {
 			return complex(0, 1), nil
 		}
@@ -105,26 +102,26 @@ func ParseComplex(s string, bitSize int) (complex128, error) {
 			return 0, err
 		}
 		return complex(0, imag), nil
-
-	} else if len(pos) > 4 {
+	} else if len(signPos) > 4 {
 		// Too many ± exists for a valid complex number
 		return 0, syntaxError(fnParseComplex, orig)
 	}
 
-	/* From here onwards, it is either a complex number with both a real and imaginary component OR a pure imaginary number in exponential form. */
+	// From here onwards, it is either a complex number with both a real and imaginary component
+	// XOR a pure imaginary number in exponential form.
 
-	// Loop through pos from middle of slice, outwards
-	mid := (len(pos) - 1) >> 1
-	for j := 0; j < len(pos); j++ {
+	// Loop through signPos from middle of slice, outwards
+	mid := (len(signPos) - 1) >> 1
+	for j := 0; j < len(signPos); j++ {
 		var idx int
 		if j%2 == 0 {
 			idx = mid - j/2
 		} else {
 			idx = mid + (j/2 + 1)
 		}
 
-		left := s[0:pos[idx]]
-		right := s[pos[idx]:]
+		left := s[0:signPos[idx]]
+		right := s[signPos[idx]:]
 
 		if left == "" {
 			left = left + "0"
@@ -144,7 +141,6 @@ func ParseComplex(s string, bitSize int) (complex128, error) {
 		if err != nil {
 			continue
 		}
-
 		return complex(real, imag), nil
 	}