code review 4128049: fmt.Scan: scan binary-exponent floating format, 2.4p-3

src/pkg/fmt/scan.go

 // Copyright 2010 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 fmt
 
 import (
         "bytes"
         "io"
         "os"
@@ skipping 441 matching lines @@
 }
 
 // Numerical elements
 const (
         binaryDigits      = "01"
         octalDigits       = "01234567"
         decimalDigits     = "0123456789"
         hexadecimalDigits = "0123456789aAbBcCdDeEfF"
         sign              = "+-"
         period            = "."
-        exponent          = "eE"
+        exponent          = "eEp"
 )
 
 // getBase returns the numeric base represented by the verb and its digit string.
 func (s *ss) getBase(verb int) (base int, digits string) {
         s.okVerb(verb, "bdoUxXv", "integer") // sets s.err
         base = 10
         digits = decimalDigits
         switch verb {
         case 'b':
                 base = 2
@@ skipping 137 matching lines @@
                 s.error(complexError)
         }
         if parens && !s.accept(")") {
                 s.error(complexError)
         }
         return real, imagSign + imag
 }
 
 // convertFloat converts the string to a float64value.
 func (s *ss) convertFloat(str string, n int) float64 {
+        if p := strings.Index(str, "p"); p >= 0 {
+                // Atof doesn't handle power-of-2 exponents,
+                // but they're easy to evaluate.
+                f, err := strconv.AtofN(str[:p], n)
+                if err != nil {
+                        s.error(err)

[rsc, 2011/02/02 20:20:51]

In this error and the next one, fill in the 
whole string instead of the half that got
passed to the strconv routine:

if e, ok := err.(*strconv.NumError); ok {
    e.Num = str
}
s.error(err)

+                }
+                n, err := strconv.Atoi64(str[p+1:])

[rsc, 2011/02/02 20:20:51]

Use Atoi and then below call math.Ldexp.

+                if err != nil {
+                        s.error(err)
+                }
+                for n >= 32 {
+                        f *= 1 << 32
+                        n -= 32
+                }
+                for n > 0 {
+                        f *= 2
+                        n--
+                }
+                for n <= -32 {
+                        f /= 1 << 32
+                        n += 32
+                }
+                for n < 0 {
+                        f /= 2
+                        n++
+                }
+                return f
+        }
         f, err := strconv.AtofN(str, n)
         if err != nil {
                 s.error(err)
         }
         return f
 }
 
 // convertComplex converts the next token to a complex128 value.
 // The atof argument is a type-specific reader for the underlying type.
 // If we're reading complex64, atof will parse float32s and convert them
@@ skipping 110 matching lines @@
                 }
                 s.buf.WriteByte(b)
         }
         if s.buf.Len() == 0 {
                 s.errorString("Scan: no hex data for %x string")
                 return ""
         }
         return s.buf.String()
 }
 
-const floatVerbs = "eEfFgGv"
+const floatVerbs = "beEfFgGv"
 
 // scanOne scans a single value, deriving the scanner from the type of the argument.
 func (s *ss) scanOne(verb int, field interface{}) {
         s.buf.Reset()
         var err os.Error
         // If the parameter has its own Scan method, use that.
         if v, ok := field.(Scanner); ok {
                 err = v.Scan(s, verb)
                 if err != nil {
                         s.error(err)
@@ skipping 211 matching lines @@
                 field := a[numProcessed]
 
                 s.scanOne(c, field)
                 numProcessed++
         }
         if numProcessed < len(a) {
                 s.errorString("too many operands")
         }
         return
 }