code review 5294074: src/pkg/[n-z]*: gofix -r error

src/pkg/strconv/quote.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.
 
 package strconv
 
 import (
         "bytes"
-        "os"
         "strings"
         "unicode"
         "utf8"
 )
 
 const lowerhex = "0123456789abcdef"
 
 func quoteWith(s string, quote byte, ASCIIonly bool) string {
         var buf bytes.Buffer
         buf.WriteByte(quote)
@@ skipping 130 matching lines @@
 //      1) value, the decoded Unicode code point or byte value;
 //      2) multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation;
 //      3) tail, the remainder of the string after the character; and
 //      4) an error that will be nil if the character is syntactically valid.
 //
 // The second argument, quote, specifies the type of literal being parsed
 // and therefore which escaped quote character is permitted.
 // If set to a single quote, it permits the sequence \' and disallows unescaped '.
 // If set to a double quote, it permits \" and disallows unescaped ".
 // If set to zero, it does not permit either escape and allows both quote characters to appear unescaped.
-func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err os.Error) {
+func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error) {
         // easy cases
         switch c := s[0]; {
         case c == quote && (quote == '\'' || quote == '"'):
                 err = ErrSyntax
                 return
         case c >= utf8.RuneSelf:
                 r, size := utf8.DecodeRuneInString(s)
                 return r, true, s[size:], nil
         case c != '\\':
                 return rune(s[0]), false, s[1:], nil
@@ skipping 90 matching lines @@
         }
         tail = s
         return
 }
 
 // Unquote interprets s as a single-quoted, double-quoted,
 // or backquoted Go string literal, returning the string value
 // that s quotes.  (If s is single-quoted, it would be a Go
 // character literal; Unquote returns the corresponding
 // one-character string.)
-func Unquote(s string) (t string, err os.Error) {
+func Unquote(s string) (t string, err error) {
         n := len(s)
         if n < 2 {
                 return "", ErrSyntax
         }
         quote := s[0]
         if quote != s[n-1] {
                 return "", ErrSyntax
         }
         s = s[1 : n-1]
 
@@ skipping 35 matching lines @@
                 } else {
                         buf.WriteString(string(c))
                 }
                 if quote == '\'' && len(s) != 0 {
                         // single-quoted must be single character
                         return "", ErrSyntax
                 }
         }
         return buf.String(), nil
 }