code review 5447069: use new strconv API

src/pkg/text/template/parse/node.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.
 
 // Parse nodes.
 
 package parse
 
 import (
         "bytes"
@@ skipping 249 matching lines @@
                 // fmt.Sscan can parse the pair, so let it do the work.
                 if _, err := fmt.Sscan(text, &n.Complex128); err != nil {
                         return nil, err
                 }
                 n.IsComplex = true
                 n.simplifyComplex()
                 return n, nil
         }
         // Imaginary constants can only be complex unless they are zero.
         if len(text) > 0 && text[len(text)-1] == 'i' {
-                f, err := strconv.Atof64(text[:len(text)-1])
+                f, err := strconv.ParseFloat(text[:len(text)-1], 64)
                 if err == nil {
                         n.IsComplex = true
                         n.Complex128 = complex(0, f)
                         n.simplifyComplex()
                         return n, nil
                 }
         }
         // Do integer test first so we get 0x123 etc.
-        u, err := strconv.Btoui64(text, 0) // will fail for -0; fixed below.
+        u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.
         if err == nil {
                 n.IsUint = true
                 n.Uint64 = u
         }
-        i, err := strconv.Btoi64(text, 0)
+        i, err := strconv.ParseInt(text, 0, 64)
         if err == nil {
                 n.IsInt = true
                 n.Int64 = i
                 if i == 0 {
                         n.IsUint = true // in case of -0.
                         n.Uint64 = u
                 }
         }
         // If an integer extraction succeeded, promote the float.
         if n.IsInt {
                 n.IsFloat = true
                 n.Float64 = float64(n.Int64)
         } else if n.IsUint {
                 n.IsFloat = true
                 n.Float64 = float64(n.Uint64)
         } else {
-                f, err := strconv.Atof64(text)
+                f, err := strconv.ParseFloat(text, 64)
                 if err == nil {
                         n.IsFloat = true
                         n.Float64 = f
                         // If a floating-point extraction succeeded, extract the int if needed.
                         if !n.IsInt && float64(int64(f)) == f {
                                 n.IsInt = true
                                 n.Int64 = int64(f)
                         }
                         if !n.IsUint && float64(uint64(f)) == f {
                                 n.IsUint = true
@@ skipping 142 matching lines @@
 func newTemplate(line int, name string, pipe *PipeNode) *TemplateNode {
         return &TemplateNode{NodeType: NodeTemplate, Line: line, Name: name, Pipe: pipe}
 }
 
 func (t *TemplateNode) String() string {
         if t.Pipe == nil {
                 return fmt.Sprintf("{{template %q}}", t.Name)
         }
         return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
 }