1170 lines
30 KiB
Go
1170 lines
30 KiB
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 (
|
|
"errors"
|
|
"io"
|
|
"math"
|
|
"os"
|
|
"reflect"
|
|
"strconv"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// runeUnreader is the interface to something that can unread runes.
|
|
// If the object provided to Scan does not satisfy this interface,
|
|
// a local buffer will be used to back up the input, but its contents
|
|
// will be lost when Scan returns.
|
|
type runeUnreader interface {
|
|
UnreadRune() error
|
|
}
|
|
|
|
// ScanState represents the scanner state passed to custom scanners.
|
|
// Scanners may do rune-at-a-time scanning or ask the ScanState
|
|
// to discover the next space-delimited token.
|
|
type ScanState interface {
|
|
// ReadRune reads the next rune (Unicode code point) from the input.
|
|
// If invoked during Scanln, Fscanln, or Sscanln, ReadRune() will
|
|
// return EOF after returning the first '\n' or when reading beyond
|
|
// the specified width.
|
|
ReadRune() (r rune, size int, err error)
|
|
// UnreadRune causes the next call to ReadRune to return the same rune.
|
|
UnreadRune() error
|
|
// SkipSpace skips space in the input. Newlines are treated as space
|
|
// unless the scan operation is Scanln, Fscanln or Sscanln, in which case
|
|
// a newline is treated as EOF.
|
|
SkipSpace()
|
|
// Token skips space in the input if skipSpace is true, then returns the
|
|
// run of Unicode code points c satisfying f(c). If f is nil,
|
|
// !unicode.IsSpace(c) is used; that is, the token will hold non-space
|
|
// characters. Newlines are treated as space unless the scan operation
|
|
// is Scanln, Fscanln or Sscanln, in which case a newline is treated as
|
|
// EOF. The returned slice points to shared data that may be overwritten
|
|
// by the next call to Token, a call to a Scan function using the ScanState
|
|
// as input, or when the calling Scan method returns.
|
|
Token(skipSpace bool, f func(rune) bool) (token []byte, err error)
|
|
// Width returns the value of the width option and whether it has been set.
|
|
// The unit is Unicode code points.
|
|
Width() (wid int, ok bool)
|
|
// Because ReadRune is implemented by the interface, Read should never be
|
|
// called by the scanning routines and a valid implementation of
|
|
// ScanState may choose always to return an error from Read.
|
|
Read(buf []byte) (n int, err error)
|
|
}
|
|
|
|
// Scanner is implemented by any value that has a Scan method, which scans
|
|
// the input for the representation of a value and stores the result in the
|
|
// receiver, which must be a pointer to be useful. The Scan method is called
|
|
// for any argument to Scan, Scanf, or Scanln that implements it.
|
|
type Scanner interface {
|
|
Scan(state ScanState, verb rune) error
|
|
}
|
|
|
|
// Scan scans text read from standard input, storing successive
|
|
// space-separated values into successive arguments. Newlines count
|
|
// as space. It returns the number of items successfully scanned.
|
|
// If that is less than the number of arguments, err will report why.
|
|
func Scan(a ...interface{}) (n int, err error) {
|
|
return Fscan(os.Stdin, a...)
|
|
}
|
|
|
|
// Scanln is similar to Scan, but stops scanning at a newline and
|
|
// after the final item there must be a newline or EOF.
|
|
func Scanln(a ...interface{}) (n int, err error) {
|
|
return Fscanln(os.Stdin, a...)
|
|
}
|
|
|
|
// Scanf scans text read from standard input, storing successive
|
|
// space-separated values into successive arguments as determined by
|
|
// the format. It returns the number of items successfully scanned.
|
|
func Scanf(format string, a ...interface{}) (n int, err error) {
|
|
return Fscanf(os.Stdin, format, a...)
|
|
}
|
|
|
|
type stringReader string
|
|
|
|
func (r *stringReader) Read(b []byte) (n int, err error) {
|
|
n = copy(b, *r)
|
|
*r = (*r)[n:]
|
|
if n == 0 {
|
|
err = io.EOF
|
|
}
|
|
return
|
|
}
|
|
|
|
// Sscan scans the argument string, storing successive space-separated
|
|
// values into successive arguments. Newlines count as space. It
|
|
// returns the number of items successfully scanned. If that is less
|
|
// than the number of arguments, err will report why.
|
|
func Sscan(str string, a ...interface{}) (n int, err error) {
|
|
return Fscan((*stringReader)(&str), a...)
|
|
}
|
|
|
|
// Sscanln is similar to Sscan, but stops scanning at a newline and
|
|
// after the final item there must be a newline or EOF.
|
|
func Sscanln(str string, a ...interface{}) (n int, err error) {
|
|
return Fscanln((*stringReader)(&str), a...)
|
|
}
|
|
|
|
// Sscanf scans the argument string, storing successive space-separated
|
|
// values into successive arguments as determined by the format. It
|
|
// returns the number of items successfully parsed.
|
|
func Sscanf(str string, format string, a ...interface{}) (n int, err error) {
|
|
return Fscanf((*stringReader)(&str), format, a...)
|
|
}
|
|
|
|
// Fscan scans text read from r, storing successive space-separated
|
|
// values into successive arguments. Newlines count as space. It
|
|
// returns the number of items successfully scanned. If that is less
|
|
// than the number of arguments, err will report why.
|
|
func Fscan(r io.Reader, a ...interface{}) (n int, err error) {
|
|
s, old := newScanState(r, true, false)
|
|
n, err = s.doScan(a)
|
|
s.free(old)
|
|
return
|
|
}
|
|
|
|
// Fscanln is similar to Fscan, but stops scanning at a newline and
|
|
// after the final item there must be a newline or EOF.
|
|
func Fscanln(r io.Reader, a ...interface{}) (n int, err error) {
|
|
s, old := newScanState(r, false, true)
|
|
n, err = s.doScan(a)
|
|
s.free(old)
|
|
return
|
|
}
|
|
|
|
// Fscanf scans text read from r, storing successive space-separated
|
|
// values into successive arguments as determined by the format. It
|
|
// returns the number of items successfully parsed.
|
|
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error) {
|
|
s, old := newScanState(r, false, false)
|
|
n, err = s.doScanf(format, a)
|
|
s.free(old)
|
|
return
|
|
}
|
|
|
|
// scanError represents an error generated by the scanning software.
|
|
// It's used as a unique signature to identify such errors when recovering.
|
|
type scanError struct {
|
|
err error
|
|
}
|
|
|
|
const eof = -1
|
|
|
|
// ss is the internal implementation of ScanState.
|
|
type ss struct {
|
|
rr io.RuneReader // where to read input
|
|
buf buffer // token accumulator
|
|
peekRune rune // one-rune lookahead
|
|
prevRune rune // last rune returned by ReadRune
|
|
count int // runes consumed so far.
|
|
atEOF bool // already read EOF
|
|
ssave
|
|
}
|
|
|
|
// ssave holds the parts of ss that need to be
|
|
// saved and restored on recursive scans.
|
|
type ssave struct {
|
|
validSave bool // is or was a part of an actual ss.
|
|
nlIsEnd bool // whether newline terminates scan
|
|
nlIsSpace bool // whether newline counts as white space
|
|
fieldLimit int // max value of ss.count for this field; fieldLimit <= limit
|
|
limit int // max value of ss.count.
|
|
maxWid int // width of this field.
|
|
}
|
|
|
|
// The Read method is only in ScanState so that ScanState
|
|
// satisfies io.Reader. It will never be called when used as
|
|
// intended, so there is no need to make it actually work.
|
|
func (s *ss) Read(buf []byte) (n int, err error) {
|
|
return 0, errors.New("ScanState's Read should not be called. Use ReadRune")
|
|
}
|
|
|
|
func (s *ss) ReadRune() (r rune, size int, err error) {
|
|
if s.peekRune >= 0 {
|
|
s.count++
|
|
r = s.peekRune
|
|
size = utf8.RuneLen(r)
|
|
s.prevRune = r
|
|
s.peekRune = -1
|
|
return
|
|
}
|
|
if s.atEOF || s.nlIsEnd && s.prevRune == '\n' || s.count >= s.fieldLimit {
|
|
err = io.EOF
|
|
return
|
|
}
|
|
|
|
r, size, err = s.rr.ReadRune()
|
|
if err == nil {
|
|
s.count++
|
|
s.prevRune = r
|
|
} else if err == io.EOF {
|
|
s.atEOF = true
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *ss) Width() (wid int, ok bool) {
|
|
if s.maxWid == hugeWid {
|
|
return 0, false
|
|
}
|
|
return s.maxWid, true
|
|
}
|
|
|
|
// The public method returns an error; this private one panics.
|
|
// If getRune reaches EOF, the return value is EOF (-1).
|
|
func (s *ss) getRune() (r rune) {
|
|
r, _, err := s.ReadRune()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
return eof
|
|
}
|
|
s.error(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// mustReadRune turns io.EOF into a panic(io.ErrUnexpectedEOF).
|
|
// It is called in cases such as string scanning where an EOF is a
|
|
// syntax error.
|
|
func (s *ss) mustReadRune() (r rune) {
|
|
r = s.getRune()
|
|
if r == eof {
|
|
s.error(io.ErrUnexpectedEOF)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *ss) UnreadRune() error {
|
|
if u, ok := s.rr.(runeUnreader); ok {
|
|
u.UnreadRune()
|
|
} else {
|
|
s.peekRune = s.prevRune
|
|
}
|
|
s.prevRune = -1
|
|
s.count--
|
|
return nil
|
|
}
|
|
|
|
func (s *ss) error(err error) {
|
|
panic(scanError{err})
|
|
}
|
|
|
|
func (s *ss) errorString(err string) {
|
|
panic(scanError{errors.New(err)})
|
|
}
|
|
|
|
func (s *ss) Token(skipSpace bool, f func(rune) bool) (tok []byte, err error) {
|
|
defer func() {
|
|
if e := recover(); e != nil {
|
|
if se, ok := e.(scanError); ok {
|
|
err = se.err
|
|
} else {
|
|
panic(e)
|
|
}
|
|
}
|
|
}()
|
|
if f == nil {
|
|
f = notSpace
|
|
}
|
|
s.buf = s.buf[:0]
|
|
tok = s.token(skipSpace, f)
|
|
return
|
|
}
|
|
|
|
// space is a copy of the unicode.White_Space ranges,
|
|
// to avoid depending on package unicode.
|
|
var space = [][2]uint16{
|
|
{0x0009, 0x000d},
|
|
{0x0020, 0x0020},
|
|
{0x0085, 0x0085},
|
|
{0x00a0, 0x00a0},
|
|
{0x1680, 0x1680},
|
|
{0x180e, 0x180e},
|
|
{0x2000, 0x200a},
|
|
{0x2028, 0x2029},
|
|
{0x202f, 0x202f},
|
|
{0x205f, 0x205f},
|
|
{0x3000, 0x3000},
|
|
}
|
|
|
|
func isSpace(r rune) bool {
|
|
if r >= 1<<16 {
|
|
return false
|
|
}
|
|
rx := uint16(r)
|
|
for _, rng := range space {
|
|
if rx < rng[0] {
|
|
return false
|
|
}
|
|
if rx <= rng[1] {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// notSpace is the default scanning function used in Token.
|
|
func notSpace(r rune) bool {
|
|
return !isSpace(r)
|
|
}
|
|
|
|
// SkipSpace provides Scan methods the ability to skip space and newline
|
|
// characters in keeping with the current scanning mode set by format strings
|
|
// and Scan/Scanln.
|
|
func (s *ss) SkipSpace() {
|
|
s.skipSpace(false)
|
|
}
|
|
|
|
// readRune is a structure to enable reading UTF-8 encoded code points
|
|
// from an io.Reader. It is used if the Reader given to the scanner does
|
|
// not already implement io.RuneReader.
|
|
type readRune struct {
|
|
reader io.Reader
|
|
buf [utf8.UTFMax]byte // used only inside ReadRune
|
|
pending int // number of bytes in pendBuf; only >0 for bad UTF-8
|
|
pendBuf [utf8.UTFMax]byte // bytes left over
|
|
}
|
|
|
|
// readByte returns the next byte from the input, which may be
|
|
// left over from a previous read if the UTF-8 was ill-formed.
|
|
func (r *readRune) readByte() (b byte, err error) {
|
|
if r.pending > 0 {
|
|
b = r.pendBuf[0]
|
|
copy(r.pendBuf[0:], r.pendBuf[1:])
|
|
r.pending--
|
|
return
|
|
}
|
|
n, err := io.ReadFull(r.reader, r.pendBuf[0:1])
|
|
if n != 1 {
|
|
return 0, err
|
|
}
|
|
return r.pendBuf[0], err
|
|
}
|
|
|
|
// unread saves the bytes for the next read.
|
|
func (r *readRune) unread(buf []byte) {
|
|
copy(r.pendBuf[r.pending:], buf)
|
|
r.pending += len(buf)
|
|
}
|
|
|
|
// ReadRune returns the next UTF-8 encoded code point from the
|
|
// io.Reader inside r.
|
|
func (r *readRune) ReadRune() (rr rune, size int, err error) {
|
|
r.buf[0], err = r.readByte()
|
|
if err != nil {
|
|
return 0, 0, err
|
|
}
|
|
if r.buf[0] < utf8.RuneSelf { // fast check for common ASCII case
|
|
rr = rune(r.buf[0])
|
|
return
|
|
}
|
|
var n int
|
|
for n = 1; !utf8.FullRune(r.buf[0:n]); n++ {
|
|
r.buf[n], err = r.readByte()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
err = nil
|
|
break
|
|
}
|
|
return
|
|
}
|
|
}
|
|
rr, size = utf8.DecodeRune(r.buf[0:n])
|
|
if size < n { // an error
|
|
r.unread(r.buf[size:n])
|
|
}
|
|
return
|
|
}
|
|
|
|
var ssFree = newCache(func() interface{} { return new(ss) })
|
|
|
|
// newScanState allocates a new ss struct or grab a cached one.
|
|
func newScanState(r io.Reader, nlIsSpace, nlIsEnd bool) (s *ss, old ssave) {
|
|
// If the reader is a *ss, then we've got a recursive
|
|
// call to Scan, so re-use the scan state.
|
|
s, ok := r.(*ss)
|
|
if ok {
|
|
old = s.ssave
|
|
s.limit = s.fieldLimit
|
|
s.nlIsEnd = nlIsEnd || s.nlIsEnd
|
|
s.nlIsSpace = nlIsSpace
|
|
return
|
|
}
|
|
|
|
s = ssFree.get().(*ss)
|
|
if rr, ok := r.(io.RuneReader); ok {
|
|
s.rr = rr
|
|
} else {
|
|
s.rr = &readRune{reader: r}
|
|
}
|
|
s.nlIsSpace = nlIsSpace
|
|
s.nlIsEnd = nlIsEnd
|
|
s.prevRune = -1
|
|
s.peekRune = -1
|
|
s.atEOF = false
|
|
s.limit = hugeWid
|
|
s.fieldLimit = hugeWid
|
|
s.maxWid = hugeWid
|
|
s.validSave = true
|
|
s.count = 0
|
|
return
|
|
}
|
|
|
|
// free saves used ss structs in ssFree; avoid an allocation per invocation.
|
|
func (s *ss) free(old ssave) {
|
|
// If it was used recursively, just restore the old state.
|
|
if old.validSave {
|
|
s.ssave = old
|
|
return
|
|
}
|
|
// Don't hold on to ss structs with large buffers.
|
|
if cap(s.buf) > 1024 {
|
|
return
|
|
}
|
|
s.buf = s.buf[:0]
|
|
s.rr = nil
|
|
ssFree.put(s)
|
|
}
|
|
|
|
// skipSpace skips spaces and maybe newlines.
|
|
func (s *ss) skipSpace(stopAtNewline bool) {
|
|
for {
|
|
r := s.getRune()
|
|
if r == eof {
|
|
return
|
|
}
|
|
if r == '\n' {
|
|
if stopAtNewline {
|
|
break
|
|
}
|
|
if s.nlIsSpace {
|
|
continue
|
|
}
|
|
s.errorString("unexpected newline")
|
|
return
|
|
}
|
|
if !isSpace(r) {
|
|
s.UnreadRune()
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// token returns the next space-delimited string from the input. It
|
|
// skips white space. For Scanln, it stops at newlines. For Scan,
|
|
// newlines are treated as spaces.
|
|
func (s *ss) token(skipSpace bool, f func(rune) bool) []byte {
|
|
if skipSpace {
|
|
s.skipSpace(false)
|
|
}
|
|
// read until white space or newline
|
|
for {
|
|
r := s.getRune()
|
|
if r == eof {
|
|
break
|
|
}
|
|
if !f(r) {
|
|
s.UnreadRune()
|
|
break
|
|
}
|
|
s.buf.WriteRune(r)
|
|
}
|
|
return s.buf
|
|
}
|
|
|
|
// 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 = errors.New("syntax error scanning complex number")
|
|
var boolError = errors.New("syntax error scanning boolean")
|
|
|
|
func indexRune(s string, r rune) int {
|
|
for i, c := range s {
|
|
if c == r {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// 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 {
|
|
r := s.getRune()
|
|
if r == eof {
|
|
return false
|
|
}
|
|
if indexRune(ok, r) >= 0 {
|
|
if accept {
|
|
s.buf.WriteRune(r)
|
|
}
|
|
return true
|
|
}
|
|
if r != eof && accept {
|
|
s.UnreadRune()
|
|
}
|
|
return false
|
|
}
|
|
|
|
// peek reports whether the next character is in the ok string, without consuming it.
|
|
func (s *ss) peek(ok string) bool {
|
|
r := s.getRune()
|
|
if r != eof {
|
|
s.UnreadRune()
|
|
}
|
|
return indexRune(ok, r) >= 0
|
|
}
|
|
|
|
func (s *ss) notEOF() {
|
|
// Guarantee there is data to be read.
|
|
if r := s.getRune(); r == eof {
|
|
panic(io.EOF)
|
|
}
|
|
s.UnreadRune()
|
|
}
|
|
|
|
// 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 rune, okVerbs, typ string) bool {
|
|
for _, v := range okVerbs {
|
|
if v == verb {
|
|
return true
|
|
}
|
|
}
|
|
s.errorString("bad verb %" + string(verb) + " for " + typ)
|
|
return false
|
|
}
|
|
|
|
// scanBool returns the value of the boolean represented by the next token.
|
|
func (s *ss) scanBool(verb rune) bool {
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
if !s.okVerb(verb, "tv", "boolean") {
|
|
return false
|
|
}
|
|
// Syntax-checking a boolean is annoying. We're not fastidious about case.
|
|
switch s.getRune() {
|
|
case '0':
|
|
return false
|
|
case '1':
|
|
return true
|
|
case 't', 'T':
|
|
if s.accept("rR") && (!s.accept("uU") || !s.accept("eE")) {
|
|
s.error(boolError)
|
|
}
|
|
return true
|
|
case 'f', 'F':
|
|
if s.accept("aA") && (!s.accept("lL") || !s.accept("sS") || !s.accept("eE")) {
|
|
s.error(boolError)
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Numerical elements
|
|
const (
|
|
binaryDigits = "01"
|
|
octalDigits = "01234567"
|
|
decimalDigits = "0123456789"
|
|
hexadecimalDigits = "0123456789aAbBcCdDeEfF"
|
|
sign = "+-"
|
|
period = "."
|
|
exponent = "eEp"
|
|
)
|
|
|
|
// getBase returns the numeric base represented by the verb and its digit string.
|
|
func (s *ss) getBase(verb rune) (base int, digits string) {
|
|
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', 'U':
|
|
base = 16
|
|
digits = hexadecimalDigits
|
|
}
|
|
return
|
|
}
|
|
|
|
// scanNumber returns the numerical string with specified digits starting here.
|
|
func (s *ss) scanNumber(digits string, haveDigits bool) string {
|
|
if !haveDigits {
|
|
s.notEOF()
|
|
if !s.accept(digits) {
|
|
s.errorString("expected integer")
|
|
}
|
|
}
|
|
for s.accept(digits) {
|
|
}
|
|
return string(s.buf)
|
|
}
|
|
|
|
// scanRune returns the next rune value in the input.
|
|
func (s *ss) scanRune(bitSize int) int64 {
|
|
s.notEOF()
|
|
r := int64(s.getRune())
|
|
n := uint(bitSize)
|
|
x := (r << (64 - n)) >> (64 - n)
|
|
if x != r {
|
|
s.errorString("overflow on character value " + string(r))
|
|
}
|
|
return r
|
|
}
|
|
|
|
// scanBasePrefix reports whether the integer begins with a 0 or 0x,
|
|
// and returns the base, digit string, and whether a zero was found.
|
|
// It is called only if the verb is %v.
|
|
func (s *ss) scanBasePrefix() (base int, digits string, found bool) {
|
|
if !s.peek("0") {
|
|
return 10, decimalDigits, false
|
|
}
|
|
s.accept("0")
|
|
found = true // We've put a digit into the token buffer.
|
|
// Special cases for '0' && '0x'
|
|
base, digits = 8, octalDigits
|
|
if s.peek("xX") {
|
|
s.consume("xX", false)
|
|
base, digits = 16, hexadecimalDigits
|
|
}
|
|
return
|
|
}
|
|
|
|
// 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 rune, bitSize int) int64 {
|
|
if verb == 'c' {
|
|
return s.scanRune(bitSize)
|
|
}
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
base, digits := s.getBase(verb)
|
|
haveDigits := false
|
|
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.
|
|
if verb == 'v' {
|
|
base, digits, haveDigits = s.scanBasePrefix()
|
|
}
|
|
}
|
|
tok := s.scanNumber(digits, haveDigits)
|
|
i, err := strconv.ParseInt(tok, base, 64)
|
|
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 rune, bitSize int) uint64 {
|
|
if verb == 'c' {
|
|
return uint64(s.scanRune(bitSize))
|
|
}
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
base, digits := s.getBase(verb)
|
|
haveDigits := false
|
|
if verb == 'U' {
|
|
if !s.consume("U", false) || !s.consume("+", false) {
|
|
s.errorString("bad unicode format ")
|
|
}
|
|
} else if verb == 'v' {
|
|
base, digits, haveDigits = s.scanBasePrefix()
|
|
}
|
|
tok := s.scanNumber(digits, haveDigits)
|
|
i, err := strconv.ParseUint(tok, base, 64)
|
|
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)
|
|
}
|
|
return i
|
|
}
|
|
|
|
// floatToken returns the floating-point number starting here, no longer than swid
|
|
// if the width is specified. It's not rigorous about syntax because it doesn't check that
|
|
// we have at least some digits, but Atof will do that.
|
|
func (s *ss) floatToken() string {
|
|
s.buf = s.buf[:0]
|
|
// NaN?
|
|
if s.accept("nN") && s.accept("aA") && s.accept("nN") {
|
|
return string(s.buf)
|
|
}
|
|
// leading sign?
|
|
s.accept(sign)
|
|
// Inf?
|
|
if s.accept("iI") && s.accept("nN") && s.accept("fF") {
|
|
return string(s.buf)
|
|
}
|
|
// digits?
|
|
for s.accept(decimalDigits) {
|
|
}
|
|
// decimal point?
|
|
if s.accept(period) {
|
|
// fraction?
|
|
for s.accept(decimalDigits) {
|
|
}
|
|
}
|
|
// exponent?
|
|
if s.accept(exponent) {
|
|
// leading sign?
|
|
s.accept(sign)
|
|
// digits?
|
|
for s.accept(decimalDigits) {
|
|
}
|
|
}
|
|
return string(s.buf)
|
|
}
|
|
|
|
// complexTokens returns the real and imaginary parts of the complex number starting here.
|
|
// The number might be parenthesized and has the format (N+Ni) where N is a floating-point
|
|
// number and there are no spaces within.
|
|
func (s *ss) complexTokens() (real, imag string) {
|
|
// TODO: accept N and Ni independently?
|
|
parens := s.accept("(")
|
|
real = s.floatToken()
|
|
s.buf = s.buf[:0]
|
|
// Must now have a sign.
|
|
if !s.accept("+-") {
|
|
s.error(complexError)
|
|
}
|
|
// Sign is now in buffer
|
|
imagSign := string(s.buf)
|
|
imag = s.floatToken()
|
|
if !s.accept("i") {
|
|
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 := indexRune(str, 'p'); p >= 0 {
|
|
// Atof doesn't handle power-of-2 exponents,
|
|
// but they're easy to evaluate.
|
|
f, err := strconv.ParseFloat(str[:p], n)
|
|
if err != nil {
|
|
// Put full string into error.
|
|
if e, ok := err.(*strconv.NumError); ok {
|
|
e.Num = str
|
|
}
|
|
s.error(err)
|
|
}
|
|
n, err := strconv.Atoi(str[p+1:])
|
|
if err != nil {
|
|
// Put full string into error.
|
|
if e, ok := err.(*strconv.NumError); ok {
|
|
e.Num = str
|
|
}
|
|
s.error(err)
|
|
}
|
|
return math.Ldexp(f, n)
|
|
}
|
|
f, err := strconv.ParseFloat(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
|
|
// to float64's to avoid reproducing this code for each complex type.
|
|
func (s *ss) scanComplex(verb rune, n int) complex128 {
|
|
if !s.okVerb(verb, floatVerbs, "complex") {
|
|
return 0
|
|
}
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
sreal, simag := s.complexTokens()
|
|
real := s.convertFloat(sreal, n/2)
|
|
imag := s.convertFloat(simag, n/2)
|
|
return complex(real, imag)
|
|
}
|
|
|
|
// convertString returns the string represented by the next input characters.
|
|
// The format of the input is determined by the verb.
|
|
func (s *ss) convertString(verb rune) (str string) {
|
|
if !s.okVerb(verb, "svqx", "string") {
|
|
return ""
|
|
}
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
switch verb {
|
|
case 'q':
|
|
str = s.quotedString()
|
|
case 'x':
|
|
str = s.hexString()
|
|
default:
|
|
str = string(s.token(true, notSpace)) // %s and %v just return the next word
|
|
}
|
|
return
|
|
}
|
|
|
|
// quotedString returns the double- or back-quoted string represented by the next input characters.
|
|
func (s *ss) quotedString() string {
|
|
s.notEOF()
|
|
quote := s.getRune()
|
|
switch quote {
|
|
case '`':
|
|
// Back-quoted: Anything goes until EOF or back quote.
|
|
for {
|
|
r := s.mustReadRune()
|
|
if r == quote {
|
|
break
|
|
}
|
|
s.buf.WriteRune(r)
|
|
}
|
|
return string(s.buf)
|
|
case '"':
|
|
// Double-quoted: Include the quotes and let strconv.Unquote do the backslash escapes.
|
|
s.buf.WriteRune(quote)
|
|
for {
|
|
r := s.mustReadRune()
|
|
s.buf.WriteRune(r)
|
|
if r == '\\' {
|
|
// In a legal backslash escape, no matter how long, only the character
|
|
// immediately after the escape can itself be a backslash or quote.
|
|
// Thus we only need to protect the first character after the backslash.
|
|
r := s.mustReadRune()
|
|
s.buf.WriteRune(r)
|
|
} else if r == '"' {
|
|
break
|
|
}
|
|
}
|
|
result, err := strconv.Unquote(string(s.buf))
|
|
if err != nil {
|
|
s.error(err)
|
|
}
|
|
return result
|
|
default:
|
|
s.errorString("expected quoted string")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// hexDigit returns the value of the hexadecimal digit
|
|
func (s *ss) hexDigit(d rune) int {
|
|
digit := int(d)
|
|
switch digit {
|
|
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
|
return digit - '0'
|
|
case 'a', 'b', 'c', 'd', 'e', 'f':
|
|
return 10 + digit - 'a'
|
|
case 'A', 'B', 'C', 'D', 'E', 'F':
|
|
return 10 + digit - 'A'
|
|
}
|
|
s.errorString("Scan: illegal hex digit")
|
|
return 0
|
|
}
|
|
|
|
// hexByte returns the next hex-encoded (two-character) byte from the input.
|
|
// There must be either two hexadecimal digits or a space character in the input.
|
|
func (s *ss) hexByte() (b byte, ok bool) {
|
|
rune1 := s.getRune()
|
|
if rune1 == eof {
|
|
return
|
|
}
|
|
if isSpace(rune1) {
|
|
s.UnreadRune()
|
|
return
|
|
}
|
|
rune2 := s.mustReadRune()
|
|
return byte(s.hexDigit(rune1)<<4 | s.hexDigit(rune2)), true
|
|
}
|
|
|
|
// hexString returns the space-delimited hexpair-encoded string.
|
|
func (s *ss) hexString() string {
|
|
s.notEOF()
|
|
for {
|
|
b, ok := s.hexByte()
|
|
if !ok {
|
|
break
|
|
}
|
|
s.buf.WriteByte(b)
|
|
}
|
|
if len(s.buf) == 0 {
|
|
s.errorString("Scan: no hex data for %x string")
|
|
return ""
|
|
}
|
|
return string(s.buf)
|
|
}
|
|
|
|
const floatVerbs = "beEfFgGv"
|
|
|
|
const hugeWid = 1 << 30
|
|
|
|
// scanOne scans a single value, deriving the scanner from the type of the argument.
|
|
func (s *ss) scanOne(verb rune, field interface{}) {
|
|
s.buf = s.buf[:0]
|
|
var err 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 {
|
|
if err == io.EOF {
|
|
err = io.ErrUnexpectedEOF
|
|
}
|
|
s.error(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
switch v := field.(type) {
|
|
case *bool:
|
|
*v = s.scanBool(verb)
|
|
case *complex64:
|
|
*v = complex64(s.scanComplex(verb, 64))
|
|
case *complex128:
|
|
*v = s.scanComplex(verb, 128)
|
|
case *int:
|
|
*v = int(s.scanInt(verb, intBits))
|
|
case *int8:
|
|
*v = int8(s.scanInt(verb, 8))
|
|
case *int16:
|
|
*v = int16(s.scanInt(verb, 16))
|
|
case *int32:
|
|
*v = int32(s.scanInt(verb, 32))
|
|
case *int64:
|
|
*v = s.scanInt(verb, 64)
|
|
case *uint:
|
|
*v = uint(s.scanUint(verb, intBits))
|
|
case *uint8:
|
|
*v = uint8(s.scanUint(verb, 8))
|
|
case *uint16:
|
|
*v = uint16(s.scanUint(verb, 16))
|
|
case *uint32:
|
|
*v = uint32(s.scanUint(verb, 32))
|
|
case *uint64:
|
|
*v = s.scanUint(verb, 64)
|
|
case *uintptr:
|
|
*v = uintptr(s.scanUint(verb, uintptrBits))
|
|
// Floats are tricky because you want to scan in the precision of the result, not
|
|
// scan in high precision and convert, in order to preserve the correct error condition.
|
|
case *float32:
|
|
if s.okVerb(verb, floatVerbs, "float32") {
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
*v = float32(s.convertFloat(s.floatToken(), 32))
|
|
}
|
|
case *float64:
|
|
if s.okVerb(verb, floatVerbs, "float64") {
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
*v = s.convertFloat(s.floatToken(), 64)
|
|
}
|
|
case *string:
|
|
*v = s.convertString(verb)
|
|
case *[]byte:
|
|
// We scan to string and convert so we get a copy of the data.
|
|
// If we scanned to bytes, the slice would point at the buffer.
|
|
*v = []byte(s.convertString(verb))
|
|
default:
|
|
val := reflect.ValueOf(v)
|
|
ptr := val
|
|
if ptr.Kind() != reflect.Ptr {
|
|
s.errorString("Scan: type not a pointer: " + val.Type().String())
|
|
return
|
|
}
|
|
switch v := ptr.Elem(); v.Kind() {
|
|
case reflect.Bool:
|
|
v.SetBool(s.scanBool(verb))
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
v.SetInt(s.scanInt(verb, v.Type().Bits()))
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
v.SetUint(s.scanUint(verb, v.Type().Bits()))
|
|
case reflect.String:
|
|
v.SetString(s.convertString(verb))
|
|
case reflect.Slice:
|
|
// For now, can only handle (renamed) []byte.
|
|
typ := v.Type()
|
|
if typ.Elem().Kind() != reflect.Uint8 {
|
|
s.errorString("Scan: can't handle type: " + val.Type().String())
|
|
}
|
|
str := s.convertString(verb)
|
|
v.Set(reflect.MakeSlice(typ, len(str), len(str)))
|
|
for i := 0; i < len(str); i++ {
|
|
v.Index(i).SetUint(uint64(str[i]))
|
|
}
|
|
case reflect.Float32, reflect.Float64:
|
|
s.skipSpace(false)
|
|
s.notEOF()
|
|
v.SetFloat(s.convertFloat(s.floatToken(), v.Type().Bits()))
|
|
case reflect.Complex64, reflect.Complex128:
|
|
v.SetComplex(s.scanComplex(verb, v.Type().Bits()))
|
|
default:
|
|
s.errorString("Scan: can't handle type: " + val.Type().String())
|
|
}
|
|
}
|
|
}
|
|
|
|
// errorHandler turns local panics into error returns.
|
|
func errorHandler(errp *error) {
|
|
if e := recover(); e != nil {
|
|
if se, ok := e.(scanError); ok { // catch local error
|
|
*errp = se.err
|
|
} else if eof, ok := e.(error); ok && eof == io.EOF { // out of input
|
|
*errp = eof
|
|
} else {
|
|
panic(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
// doScan does the real work for scanning without a format string.
|
|
func (s *ss) doScan(a []interface{}) (numProcessed int, err error) {
|
|
defer errorHandler(&err)
|
|
for _, field := range a {
|
|
s.scanOne('v', field)
|
|
numProcessed++
|
|
}
|
|
// Check for newline if required.
|
|
if !s.nlIsSpace {
|
|
for {
|
|
r := s.getRune()
|
|
if r == '\n' || r == eof {
|
|
break
|
|
}
|
|
if !isSpace(r) {
|
|
s.errorString("Scan: expected newline")
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// advance determines whether the next characters in the input match
|
|
// those of the format. It returns the number of bytes (sic) consumed
|
|
// in the format. Newlines included, all runs of space characters in
|
|
// either input or format behave as a single space. This routine also
|
|
// handles the %% case. If the return value is zero, either format
|
|
// starts with a % (with no following %) or the input is empty.
|
|
// If it is negative, the input did not match the string.
|
|
func (s *ss) advance(format string) (i int) {
|
|
for i < len(format) {
|
|
fmtc, w := utf8.DecodeRuneInString(format[i:])
|
|
if fmtc == '%' {
|
|
// %% acts like a real percent
|
|
nextc, _ := utf8.DecodeRuneInString(format[i+w:]) // will not match % if string is empty
|
|
if nextc != '%' {
|
|
return
|
|
}
|
|
i += w // skip the first %
|
|
}
|
|
sawSpace := false
|
|
for isSpace(fmtc) && i < len(format) {
|
|
sawSpace = true
|
|
i += w
|
|
fmtc, w = utf8.DecodeRuneInString(format[i:])
|
|
}
|
|
if sawSpace {
|
|
// There was space in the format, so there should be space (EOF)
|
|
// in the input.
|
|
inputc := s.getRune()
|
|
if inputc == eof || inputc == '\n' {
|
|
// If we've reached a newline, stop now; don't read ahead.
|
|
return
|
|
}
|
|
if !isSpace(inputc) {
|
|
// Space in format but not in input: error
|
|
s.errorString("expected space in input to match format")
|
|
}
|
|
s.skipSpace(true)
|
|
continue
|
|
}
|
|
inputc := s.mustReadRune()
|
|
if fmtc != inputc {
|
|
s.UnreadRune()
|
|
return -1
|
|
}
|
|
i += w
|
|
}
|
|
return
|
|
}
|
|
|
|
// doScanf does the real work when scanning with a format string.
|
|
// At the moment, it handles only pointers to basic types.
|
|
func (s *ss) doScanf(format string, a []interface{}) (numProcessed int, err error) {
|
|
defer errorHandler(&err)
|
|
end := len(format) - 1
|
|
// We process one item per non-trivial format
|
|
for i := 0; i <= end; {
|
|
w := s.advance(format[i:])
|
|
if w > 0 {
|
|
i += w
|
|
continue
|
|
}
|
|
// Either we failed to advance, we have a percent character, or we ran out of input.
|
|
if format[i] != '%' {
|
|
// Can't advance format. Why not?
|
|
if w < 0 {
|
|
s.errorString("input does not match format")
|
|
}
|
|
// Otherwise at EOF; "too many operands" error handled below
|
|
break
|
|
}
|
|
i++ // % is one byte
|
|
|
|
// do we have 20 (width)?
|
|
var widPresent bool
|
|
s.maxWid, widPresent, i = parsenum(format, i, end)
|
|
if !widPresent {
|
|
s.maxWid = hugeWid
|
|
}
|
|
s.fieldLimit = s.limit
|
|
if f := s.count + s.maxWid; f < s.fieldLimit {
|
|
s.fieldLimit = f
|
|
}
|
|
|
|
c, w := utf8.DecodeRuneInString(format[i:])
|
|
i += w
|
|
|
|
if numProcessed >= len(a) { // out of operands
|
|
s.errorString("too few operands for format %" + format[i-w:])
|
|
break
|
|
}
|
|
field := a[numProcessed]
|
|
|
|
s.scanOne(c, field)
|
|
numProcessed++
|
|
s.fieldLimit = s.limit
|
|
}
|
|
if numProcessed < len(a) {
|
|
s.errorString("too many operands")
|
|
}
|
|
return
|
|
}
|