| // 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" |
| "sync" |
| "unicode/utf8" |
| ) |
| |
| // 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 appropriately |
| // for the operation being performed; see the package documentation |
| // for more information. |
| 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 appropriately for the operation being |
| // performed; see the package documentation for more information. |
| // 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 ...any) (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 ...any) (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. |
| // If that is less than the number of arguments, err will report why. |
| // Newlines in the input must match newlines in the format. |
| // The one exception: the verb %c always scans the next rune in the |
| // input, even if it is a space (or tab etc.) or newline. |
| func Scanf(format string, a ...any) (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 ...any) (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 ...any) (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. |
| // Newlines in the input must match newlines in the format. |
| func Sscanf(str string, format string, a ...any) (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 ...any) (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 ...any) (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. |
| // Newlines in the input must match newlines in the format. |
| func Fscanf(r io.Reader, format string, a ...any) (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 { |
| rs io.RuneScanner // where to read input |
| buf buffer // token accumulator |
| 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 |
| argLimit int // max value of ss.count for this arg; argLimit <= limit |
| limit int // max value of ss.count. |
| maxWid int // width of this arg. |
| } |
| |
| // 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.atEOF || s.count >= s.argLimit { |
| err = io.EOF |
| return |
| } |
| |
| r, size, err = s.rs.ReadRune() |
| if err == nil { |
| s.count++ |
| if s.nlIsEnd && r == '\n' { |
| s.atEOF = true |
| } |
| } 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 { |
| s.rs.UnreadRune() |
| s.atEOF = false |
| 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}, |
| {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) |
| } |
| |
| // 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.RuneScanner. |
| 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 |
| peekRune rune // if >=0 next rune; when <0 is ^(previous Rune) |
| } |
| |
| // 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[:1]) |
| if n != 1 { |
| return 0, err |
| } |
| return r.pendBuf[0], err |
| } |
| |
| // 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) { |
| if r.peekRune >= 0 { |
| rr = r.peekRune |
| r.peekRune = ^r.peekRune |
| size = utf8.RuneLen(rr) |
| return |
| } |
| r.buf[0], err = r.readByte() |
| if err != nil { |
| return |
| } |
| if r.buf[0] < utf8.RuneSelf { // fast check for common ASCII case |
| rr = rune(r.buf[0]) |
| size = 1 // Known to be 1. |
| // Flip the bits of the rune so it's available to UnreadRune. |
| r.peekRune = ^rr |
| return |
| } |
| var n int |
| for n = 1; !utf8.FullRune(r.buf[: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[:n]) |
| if size < n { // an error, save the bytes for the next read |
| copy(r.pendBuf[r.pending:], r.buf[size:n]) |
| r.pending += n - size |
| } |
| // Flip the bits of the rune so it's available to UnreadRune. |
| r.peekRune = ^rr |
| return |
| } |
| |
| func (r *readRune) UnreadRune() error { |
| if r.peekRune >= 0 { |
| return errors.New("fmt: scanning called UnreadRune with no rune available") |
| } |
| // Reverse bit flip of previously read rune to obtain valid >=0 state. |
| r.peekRune = ^r.peekRune |
| return nil |
| } |
| |
| var ssFree = sync.Pool{ |
| New: func() any { 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) { |
| s = ssFree.Get().(*ss) |
| if rs, ok := r.(io.RuneScanner); ok { |
| s.rs = rs |
| } else { |
| s.rs = &readRune{reader: r, peekRune: -1} |
| } |
| s.nlIsSpace = nlIsSpace |
| s.nlIsEnd = nlIsEnd |
| s.atEOF = false |
| s.limit = hugeWid |
| s.argLimit = 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.rs = nil |
| ssFree.Put(s) |
| } |
| |
| // 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() { |
| for { |
| r := s.getRune() |
| if r == eof { |
| return |
| } |
| if r == '\r' && s.peek("\n") { |
| continue |
| } |
| if r == '\n' { |
| 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() |
| } |
| // 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 |
| } |
| |
| var errComplex = errors.New("syntax error scanning complex number") |
| var errBool = 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() |
| 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(errBool) |
| } |
| return true |
| case 'f', 'F': |
| if s.accept("aA") && (!s.accept("lL") || !s.accept("sS") || !s.accept("eE")) { |
| s.error(errBool) |
| } |
| return false |
| } |
| return false |
| } |
| |
| // Numerical elements |
| const ( |
| binaryDigits = "01" |
| octalDigits = "01234567" |
| decimalDigits = "0123456789" |
| hexadecimalDigits = "0123456789aAbBcCdDeEfF" |
| sign = "+-" |
| period = "." |
| exponent = "eEpP" |
| ) |
| |
| // 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 := s.getRune() |
| n := uint(bitSize) |
| x := (int64(r) << (64 - n)) >> (64 - n) |
| if x != int64(r) { |
| s.errorString("overflow on character value " + string(r)) |
| } |
| return int64(r) |
| } |
| |
| // scanBasePrefix reports whether the integer begins with a base prefix |
| // 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, zeroFound bool) { |
| if !s.peek("0") { |
| return 0, decimalDigits + "_", false |
| } |
| s.accept("0") |
| // Special cases for 0, 0b, 0o, 0x. |
| switch { |
| case s.peek("bB"): |
| s.consume("bB", true) |
| return 0, binaryDigits + "_", true |
| case s.peek("oO"): |
| s.consume("oO", true) |
| return 0, octalDigits + "_", true |
| case s.peek("xX"): |
| s.consume("xX", true) |
| return 0, hexadecimalDigits + "_", true |
| default: |
| return 0, octalDigits + "_", true |
| } |
| } |
| |
| // 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() |
| 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() |
| 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 := decimalDigits + "_" |
| exp := exponent |
| if s.accept("0") && s.accept("xX") { |
| digits = hexadecimalDigits + "_" |
| exp = "pP" |
| } |
| // digits? |
| for s.accept(digits) { |
| } |
| // decimal point? |
| if s.accept(period) { |
| // fraction? |
| for s.accept(digits) { |
| } |
| } |
| // exponent? |
| if s.accept(exp) { |
| // 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(errComplex) |
| } |
| // Sign is now in buffer |
| imagSign := string(s.buf) |
| imag = s.floatToken() |
| if !s.accept("i") { |
| s.error(errComplex) |
| } |
| if parens && !s.accept(")") { |
| s.error(errComplex) |
| } |
| return real, imagSign + imag |
| } |
| |
| func hasX(s string) bool { |
| for i := 0; i < len(s); i++ { |
| if s[i] == 'x' || s[i] == 'X' { |
| return true |
| } |
| } |
| return false |
| } |
| |
| // convertFloat converts the string to a float64value. |
| func (s *ss) convertFloat(str string, n int) float64 { |
| // strconv.ParseFloat will handle "+0x1.fp+2", |
| // but we have to implement our non-standard |
| // decimal+binary exponent mix (1.2p4) ourselves. |
| if p := indexRune(str, 'p'); p >= 0 && !hasX(str) { |
| // 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) |
| } |
| m, 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, m) |
| } |
| f, err := strconv.ParseFloat(str, n) |
| if err != nil { |
| s.error(err) |
| } |
| return f |
| } |
| |
| // scanComplex 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() |
| 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, "svqxX", "string") { |
| return "" |
| } |
| s.SkipSpace() |
| s.notEOF() |
| switch verb { |
| case 'q': |
| str = s.quotedString() |
| case 'x', '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.writeByte('"') |
| 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. |
| s.buf.writeRune(s.mustReadRune()) |
| } 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 hexDigit(d rune) (int, bool) { |
| digit := int(d) |
| switch digit { |
| case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': |
| return digit - '0', true |
| case 'a', 'b', 'c', 'd', 'e', 'f': |
| return 10 + digit - 'a', true |
| case 'A', 'B', 'C', 'D', 'E', 'F': |
| return 10 + digit - 'A', true |
| } |
| return -1, false |
| } |
| |
| // hexByte returns the next hex-encoded (two-character) byte from the input. |
| // It returns ok==false if the next bytes in the input do not encode a hex byte. |
| // If the first byte is hex and the second is not, processing stops. |
| func (s *ss) hexByte() (b byte, ok bool) { |
| rune1 := s.getRune() |
| if rune1 == eof { |
| return |
| } |
| value1, ok := hexDigit(rune1) |
| if !ok { |
| s.UnreadRune() |
| return |
| } |
| value2, ok := hexDigit(s.mustReadRune()) |
| if !ok { |
| s.errorString("illegal hex digit") |
| return |
| } |
| return byte(value1<<4 | value2), 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("no hex data for %x string") |
| return "" |
| } |
| return string(s.buf) |
| } |
| |
| const ( |
| floatVerbs = "beEfFgGv" |
| |
| hugeWid = 1 << 30 |
| |
| intBits = 32 << (^uint(0) >> 63) |
| uintptrBits = 32 << (^uintptr(0) >> 63) |
| ) |
| |
| // scanPercent scans a literal percent character. |
| func (s *ss) scanPercent() { |
| s.SkipSpace() |
| s.notEOF() |
| if !s.accept("%") { |
| s.errorString("missing literal %") |
| } |
| } |
| |
| // scanOne scans a single value, deriving the scanner from the type of the argument. |
| func (s *ss) scanOne(verb rune, arg any) { |
| s.buf = s.buf[:0] |
| var err error |
| // If the parameter has its own Scan method, use that. |
| if v, ok := arg.(Scanner); ok { |
| err = v.Scan(s, verb) |
| if err != nil { |
| if err == io.EOF { |
| err = io.ErrUnexpectedEOF |
| } |
| s.error(err) |
| } |
| return |
| } |
| |
| switch v := arg.(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() |
| s.notEOF() |
| *v = float32(s.convertFloat(s.floatToken(), 32)) |
| } |
| case *float64: |
| if s.okVerb(verb, floatVerbs, "float64") { |
| s.SkipSpace() |
| 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.Pointer { |
| s.errorString("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("can't scan 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() |
| 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("can't scan 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 []any) (numProcessed int, err error) { |
| defer errorHandler(&err) |
| for _, arg := range a { |
| s.scanOne('v', arg) |
| numProcessed++ |
| } |
| // Check for newline (or EOF) if required (Scanln etc.). |
| if s.nlIsEnd { |
| for { |
| r := s.getRune() |
| if r == '\n' || r == eof { |
| break |
| } |
| if !isSpace(r) { |
| s.errorString("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. All runs of space characters in either input or |
| // format behave as a single space. Newlines are special, though: |
| // newlines in the format must match those in the input and vice versa. |
| // 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:]) |
| |
| // Space processing. |
| // In the rest of this comment "space" means spaces other than newline. |
| // Newline in the format matches input of zero or more spaces and then newline or end-of-input. |
| // Spaces in the format before the newline are collapsed into the newline. |
| // Spaces in the format after the newline match zero or more spaces after the corresponding input newline. |
| // Other spaces in the format match input of one or more spaces or end-of-input. |
| if isSpace(fmtc) { |
| newlines := 0 |
| trailingSpace := false |
| for isSpace(fmtc) && i < len(format) { |
| if fmtc == '\n' { |
| newlines++ |
| trailingSpace = false |
| } else { |
| trailingSpace = true |
| } |
| i += w |
| fmtc, w = utf8.DecodeRuneInString(format[i:]) |
| } |
| for j := 0; j < newlines; j++ { |
| inputc := s.getRune() |
| for isSpace(inputc) && inputc != '\n' { |
| inputc = s.getRune() |
| } |
| if inputc != '\n' && inputc != eof { |
| s.errorString("newline in format does not match input") |
| } |
| } |
| if trailingSpace { |
| inputc := s.getRune() |
| if newlines == 0 { |
| // If the trailing space stood alone (did not follow a newline), |
| // it must find at least one space to consume. |
| if !isSpace(inputc) && inputc != eof { |
| s.errorString("expected space in input to match format") |
| } |
| if inputc == '\n' { |
| s.errorString("newline in input does not match format") |
| } |
| } |
| for isSpace(inputc) && inputc != '\n' { |
| inputc = s.getRune() |
| } |
| if inputc != eof { |
| s.UnreadRune() |
| } |
| } |
| continue |
| } |
| |
| // Verbs. |
| if fmtc == '%' { |
| // % at end of string is an error. |
| if i+w == len(format) { |
| s.errorString("missing verb: % at end of format string") |
| } |
| // %% 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 % |
| } |
| |
| // Literals. |
| 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 []any) (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 |
| } |
| |
| c, w := utf8.DecodeRuneInString(format[i:]) |
| i += w |
| |
| if c != 'c' { |
| s.SkipSpace() |
| } |
| if c == '%' { |
| s.scanPercent() |
| continue // Do not consume an argument. |
| } |
| s.argLimit = s.limit |
| if f := s.count + s.maxWid; f < s.argLimit { |
| s.argLimit = f |
| } |
| |
| if numProcessed >= len(a) { // out of operands |
| s.errorString("too few operands for format '%" + format[i-w:] + "'") |
| break |
| } |
| arg := a[numProcessed] |
| |
| s.scanOne(c, arg) |
| numProcessed++ |
| s.argLimit = s.limit |
| } |
| if numProcessed < len(a) { |
| s.errorString("too many operands") |
| } |
| return |
| } |