code review 3423043: fmt: add %U format for standard Unicode representation ...

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 370 matching lines @@
 }
 
 // typeError indicates that the type of the operand did not match the format
 func (s *ss) typeError(field interface{}, expected string) {
         s.errorString("expected field of type pointer to " + expected + "; found " + reflect.Typeof(field).String())
 }
 
 var complexError = os.ErrorString("syntax error scanning complex number")
 var boolError = os.ErrorString("syntax error scanning boolean")
 
-// accepts checks the next rune in the input.  If it's a byte (sic) in the string, it puts it in the
-// buffer and returns true. Otherwise it return false.
-func (s *ss) accept(ok string) bool {
+// consume reads the next rune in the input and reports whether it is in the ok string.
+// If accept is true, it puts the character into the input token.
+func (s *ss) consume(ok string, accept bool) bool {
         if s.wid >= s.maxWid {
                 return false
         }
         rune := s.getRune()
         if rune == EOF {
                 return false
         }
         for i := 0; i < len(ok); i++ {
                 if int(ok[i]) == rune {
-                        s.buf.WriteRune(rune)
-                        s.wid++
+                        if accept {
+                                s.buf.WriteRune(rune)
+                                s.wid++
+                        }
                         return true
                 }
         }
-        if rune != EOF {
+        if rune != EOF && accept {
                 s.UngetRune()
         }
         return false
 }
 
+// accept checks the next rune in the input.  If it's a byte (sic) in the string, it puts it in the
+// buffer and returns true. Otherwise it return false.
+func (s *ss) accept(ok string) bool {
+        return s.consume(ok, true)
+}
+
 // okVerb verifies that the verb is present in the list, setting s.err appropriately if not.
 func (s *ss) okVerb(verb int, okVerbs, typ string) bool {
         for _, v := range okVerbs {
                 if v == verb {
                         return true
                 }
         }
         s.errorString("bad verb %" + string(verb) + " for " + typ)
         return false
 }
@@ skipping 29 matching lines @@
         octalDigits       = "01234567"
         decimalDigits     = "0123456789"
         hexadecimalDigits = "0123456789aAbBcCdDeEfF"
         sign              = "+-"
         period            = "."
         exponent          = "eE"
 )
 
 // 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, "bdoxXv", "integer") // sets s.err
+        s.okVerb(verb, "bdoUxXv", "integer") // sets s.err
         base = 10
         digits = decimalDigits
         switch verb {
         case 'b':
                 base = 2
                 digits = binaryDigits
         case 'o':
                 base = 8
                 digits = octalDigits
-        case 'x', 'X':
+        case 'x', 'X', 'U':
                 base = 16
                 digits = hexadecimalDigits
         }
         return
 }
 
 // scanNumber returns the numerical string with specified digits starting here.
 func (s *ss) scanNumber(digits string) string {
         if !s.accept(digits) {
                 s.errorString("expected integer")
@@ skipping 15 matching lines @@
 }
 
 // scanInt returns the value of the integer represented by the next
 // token, checking for overflow.  Any error is stored in s.err.
 func (s *ss) scanInt(verb int, bitSize int) int64 {
         if verb == 'c' {
                 return s.scanRune(bitSize)
         }
         base, digits := s.getBase(verb)
         s.skipSpace(false)
-        s.accept(sign) // If there's a sign, it will be left in the token buffer.
+        if verb == 'U' {
+                if !s.consume("U", false) || !s.consume("+", false) {
+                        s.errorString("bad unicode format ")
+                }
+        } else {
+                s.accept(sign) // If there's a sign, it will be left in the token buffer.
+        }
         tok := s.scanNumber(digits)
         i, err := strconv.Btoi64(tok, base)
         if err != nil {
                 s.error(err)
         }
         n := uint(bitSize)
         x := (i << (64 - n)) >> (64 - n)
         if x != i {
                 s.errorString("integer overflow on token " + tok)
         }
         return i
 }
 
 // scanUint returns the value of the unsigned integer represented
 // by the next token, checking for overflow.  Any error is stored in s.err.
 func (s *ss) scanUint(verb int, bitSize int) uint64 {
         if verb == 'c' {
                 return uint64(s.scanRune(bitSize))
         }
         base, digits := s.getBase(verb)
         s.skipSpace(false)
+        if verb == 'U' {
+                if !s.consume("U", false) || !s.consume("+", false) {
+                        s.errorString("bad unicode format ")
+                }
+        }
         tok := s.scanNumber(digits)
         i, err := strconv.Btoui64(tok, base)
         if err != nil {
                 s.error(err)
         }
         n := uint(bitSize)
         x := (i << (64 - n)) >> (64 - n)
         if x != i {
                 s.errorString("unsigned integer overflow on token " + tok)
         }
@@ skipping 423 matching lines @@
                 field := a[numProcessed]
 
                 s.scanOne(c, field)
                 numProcessed++
         }
         if numProcessed < len(a) {
                 s.errorString("too many operands")
         }
         return
 }