1 // Copyright 2010 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
18 // runeUnreader is the interface to something that can unread runes.
19 // If the object provided to Scan does not satisfy this interface,
20 // a local buffer will be used to back up the input, but its contents
21 // will be lost when Scan returns.
22 type runeUnreader
interface {
26 // ScanState represents the scanner state passed to custom scanners.
27 // Scanners may do rune-at-a-time scanning or ask the ScanState
28 // to discover the next space-delimited token.
29 type ScanState
interface {
30 // ReadRune reads the next rune (Unicode code point) from the input.
31 // If invoked during Scanln, Fscanln, or Sscanln, ReadRune() will
32 // return EOF after returning the first '\n' or when reading beyond
33 // the specified width.
34 ReadRune() (r rune
, size
int, err error
)
35 // UnreadRune causes the next call to ReadRune to return the same rune.
37 // SkipSpace skips space in the input. Newlines are treated as space
38 // unless the scan operation is Scanln, Fscanln or Sscanln, in which case
39 // a newline is treated as EOF.
41 // Token skips space in the input if skipSpace is true, then returns the
42 // run of Unicode code points c satisfying f(c). If f is nil,
43 // !unicode.IsSpace(c) is used; that is, the token will hold non-space
44 // characters. Newlines are treated as space unless the scan operation
45 // is Scanln, Fscanln or Sscanln, in which case a newline is treated as
46 // EOF. The returned slice points to shared data that may be overwritten
47 // by the next call to Token, a call to a Scan function using the ScanState
48 // as input, or when the calling Scan method returns.
49 Token(skipSpace
bool, f
func(rune
) bool) (token
[]byte, err error
)
50 // Width returns the value of the width option and whether it has been set.
51 // The unit is Unicode code points.
52 Width() (wid
int, ok
bool)
53 // Because ReadRune is implemented by the interface, Read should never be
54 // called by the scanning routines and a valid implementation of
55 // ScanState may choose always to return an error from Read.
56 Read(buf
[]byte) (n
int, err error
)
59 // Scanner is implemented by any value that has a Scan method, which scans
60 // the input for the representation of a value and stores the result in the
61 // receiver, which must be a pointer to be useful. The Scan method is called
62 // for any argument to Scan, Scanf, or Scanln that implements it.
63 type Scanner
interface {
64 Scan(state ScanState
, verb rune
) error
67 // Scan scans text read from standard input, storing successive
68 // space-separated values into successive arguments. Newlines count
69 // as space. It returns the number of items successfully scanned.
70 // If that is less than the number of arguments, err will report why.
71 func Scan(a
...interface{}) (n
int, err error
) {
72 return Fscan(os
.Stdin
, a
...)
75 // Scanln is similar to Scan, but stops scanning at a newline and
76 // after the final item there must be a newline or EOF.
77 func Scanln(a
...interface{}) (n
int, err error
) {
78 return Fscanln(os
.Stdin
, a
...)
81 // Scanf scans text read from standard input, storing successive
82 // space-separated values into successive arguments as determined by
83 // the format. It returns the number of items successfully scanned.
84 func Scanf(format
string, a
...interface{}) (n
int, err error
) {
85 return Fscanf(os
.Stdin
, format
, a
...)
88 type stringReader
string
90 func (r
*stringReader
) Read(b
[]byte) (n
int, err error
) {
99 // Sscan scans the argument string, storing successive space-separated
100 // values into successive arguments. Newlines count as space. It
101 // returns the number of items successfully scanned. If that is less
102 // than the number of arguments, err will report why.
103 func Sscan(str
string, a
...interface{}) (n
int, err error
) {
104 return Fscan((*stringReader
)(&str
), a
...)
107 // Sscanln is similar to Sscan, but stops scanning at a newline and
108 // after the final item there must be a newline or EOF.
109 func Sscanln(str
string, a
...interface{}) (n
int, err error
) {
110 return Fscanln((*stringReader
)(&str
), a
...)
113 // Sscanf scans the argument string, storing successive space-separated
114 // values into successive arguments as determined by the format. It
115 // returns the number of items successfully parsed.
116 func Sscanf(str
string, format
string, a
...interface{}) (n
int, err error
) {
117 return Fscanf((*stringReader
)(&str
), format
, a
...)
120 // Fscan scans text read from r, storing successive space-separated
121 // values into successive arguments. Newlines count as space. It
122 // returns the number of items successfully scanned. If that is less
123 // than the number of arguments, err will report why.
124 func Fscan(r io
.Reader
, a
...interface{}) (n
int, err error
) {
125 s
, old
:= newScanState(r
, true, false)
131 // Fscanln is similar to Fscan, but stops scanning at a newline and
132 // after the final item there must be a newline or EOF.
133 func Fscanln(r io
.Reader
, a
...interface{}) (n
int, err error
) {
134 s
, old
:= newScanState(r
, false, true)
140 // Fscanf scans text read from r, storing successive space-separated
141 // values into successive arguments as determined by the format. It
142 // returns the number of items successfully parsed.
143 func Fscanf(r io
.Reader
, format
string, a
...interface{}) (n
int, err error
) {
144 s
, old
:= newScanState(r
, false, false)
145 n
, err
= s
.doScanf(format
, a
)
150 // scanError represents an error generated by the scanning software.
151 // It's used as a unique signature to identify such errors when recovering.
152 type scanError
struct {
158 // ss is the internal implementation of ScanState.
160 rr io
.RuneReader
// where to read input
161 buf buffer
// token accumulator
162 peekRune rune
// one-rune lookahead
163 prevRune rune
// last rune returned by ReadRune
164 count
int // runes consumed so far.
165 atEOF
bool // already read EOF
169 // ssave holds the parts of ss that need to be
170 // saved and restored on recursive scans.
172 validSave
bool // is or was a part of an actual ss.
173 nlIsEnd
bool // whether newline terminates scan
174 nlIsSpace
bool // whether newline counts as white space
175 argLimit
int // max value of ss.count for this arg; argLimit <= limit
176 limit
int // max value of ss.count.
177 maxWid
int // width of this arg.
180 // The Read method is only in ScanState so that ScanState
181 // satisfies io.Reader. It will never be called when used as
182 // intended, so there is no need to make it actually work.
183 func (s
*ss
) Read(buf
[]byte) (n
int, err error
) {
184 return 0, errors
.New("ScanState's Read should not be called. Use ReadRune")
187 func (s
*ss
) ReadRune() (r rune
, size
int, err error
) {
191 size
= utf8
.RuneLen(r
)
196 if s
.atEOF || s
.nlIsEnd
&& s
.prevRune
== '\n' || s
.count
>= s
.argLimit
{
201 r
, size
, err
= s
.rr
.ReadRune()
205 } else if err
== io
.EOF
{
211 func (s
*ss
) Width() (wid
int, ok
bool) {
212 if s
.maxWid
== hugeWid
{
215 return s
.maxWid
, true
218 // The public method returns an error; this private one panics.
219 // If getRune reaches EOF, the return value is EOF (-1).
220 func (s
*ss
) getRune() (r rune
) {
221 r
, _
, err
:= s
.ReadRune()
231 // mustReadRune turns io.EOF into a panic(io.ErrUnexpectedEOF).
232 // It is called in cases such as string scanning where an EOF is a
234 func (s
*ss
) mustReadRune() (r rune
) {
237 s
.error(io
.ErrUnexpectedEOF
)
242 func (s
*ss
) UnreadRune() error
{
243 if u
, ok
:= s
.rr
.(runeUnreader
); ok
{
246 s
.peekRune
= s
.prevRune
253 func (s
*ss
) error(err error
) {
254 panic(scanError
{err
})
257 func (s
*ss
) errorString(err
string) {
258 panic(scanError
{errors
.New(err
)})
261 func (s
*ss
) Token(skipSpace
bool, f
func(rune
) bool) (tok
[]byte, err error
) {
263 if e
:= recover(); e
!= nil {
264 if se
, ok
:= e
.(scanError
); ok
{
275 tok
= s
.token(skipSpace
, f
)
279 // space is a copy of the unicode.White_Space ranges,
280 // to avoid depending on package unicode.
281 var space
= [][2]uint16{
294 func isSpace(r rune
) bool {
299 for _
, rng
:= range space
{
310 // notSpace is the default scanning function used in Token.
311 func notSpace(r rune
) bool {
315 // SkipSpace provides Scan methods the ability to skip space and newline
316 // characters in keeping with the current scanning mode set by format strings
318 func (s
*ss
) SkipSpace() {
322 // readRune is a structure to enable reading UTF-8 encoded code points
323 // from an io.Reader. It is used if the Reader given to the scanner does
324 // not already implement io.RuneReader.
325 type readRune
struct {
327 buf
[utf8
.UTFMax
]byte // used only inside ReadRune
328 pending
int // number of bytes in pendBuf; only >0 for bad UTF-8
329 pendBuf
[utf8
.UTFMax
]byte // bytes left over
332 // readByte returns the next byte from the input, which may be
333 // left over from a previous read if the UTF-8 was ill-formed.
334 func (r
*readRune
) readByte() (b
byte, err error
) {
337 copy(r
.pendBuf
[0:], r
.pendBuf
[1:])
341 n
, err
:= io
.ReadFull(r
.reader
, r
.pendBuf
[0:1])
345 return r
.pendBuf
[0], err
348 // unread saves the bytes for the next read.
349 func (r
*readRune
) unread(buf
[]byte) {
350 copy(r
.pendBuf
[r
.pending
:], buf
)
351 r
.pending
+= len(buf
)
354 // ReadRune returns the next UTF-8 encoded code point from the
355 // io.Reader inside r.
356 func (r
*readRune
) ReadRune() (rr rune
, size
int, err error
) {
357 r
.buf
[0], err
= r
.readByte()
361 if r
.buf
[0] < utf8
.RuneSelf
{ // fast check for common ASCII case
366 for n
= 1; !utf8
.FullRune(r
.buf
[0:n
]); n
++ {
367 r
.buf
[n
], err
= r
.readByte()
376 rr
, size
= utf8
.DecodeRune(r
.buf
[0:n
])
377 if size
< n
{ // an error
378 r
.unread(r
.buf
[size
:n
])
383 var ssFree
= sync
.Pool
{
384 New
: func() interface{} { return new(ss
) },
387 // newScanState allocates a new ss struct or grab a cached one.
388 func newScanState(r io
.Reader
, nlIsSpace
, nlIsEnd
bool) (s
*ss
, old ssave
) {
389 // If the reader is a *ss, then we've got a recursive
390 // call to Scan, so re-use the scan state.
395 s
.nlIsEnd
= nlIsEnd || s
.nlIsEnd
396 s
.nlIsSpace
= nlIsSpace
400 s
= ssFree
.Get().(*ss
)
401 if rr
, ok
:= r
.(io
.RuneReader
); ok
{
404 s
.rr
= &readRune
{reader
: r
}
406 s
.nlIsSpace
= nlIsSpace
419 // free saves used ss structs in ssFree; avoid an allocation per invocation.
420 func (s
*ss
) free(old ssave
) {
421 // If it was used recursively, just restore the old state.
426 // Don't hold on to ss structs with large buffers.
427 if cap(s
.buf
) > 1024 {
435 // skipSpace skips spaces and maybe newlines.
436 func (s
*ss
) skipSpace(stopAtNewline
bool) {
442 if r
== '\r' && s
.peek("\n") {
452 s
.errorString("unexpected newline")
462 // token returns the next space-delimited string from the input. It
463 // skips white space. For Scanln, it stops at newlines. For Scan,
464 // newlines are treated as spaces.
465 func (s
*ss
) token(skipSpace
bool, f
func(rune
) bool) []byte {
469 // read until white space or newline
484 var complexError
= errors
.New("syntax error scanning complex number")
485 var boolError
= errors
.New("syntax error scanning boolean")
487 func indexRune(s
string, r rune
) int {
488 for i
, c
:= range s
{
496 // consume reads the next rune in the input and reports whether it is in the ok string.
497 // If accept is true, it puts the character into the input token.
498 func (s
*ss
) consume(ok
string, accept
bool) bool {
503 if indexRune(ok
, r
) >= 0 {
509 if r
!= eof
&& accept
{
515 // peek reports whether the next character is in the ok string, without consuming it.
516 func (s
*ss
) peek(ok
string) bool {
521 return indexRune(ok
, r
) >= 0
524 func (s
*ss
) notEOF() {
525 // Guarantee there is data to be read.
526 if r
:= s
.getRune(); r
== eof
{
532 // accept checks the next rune in the input. If it's a byte (sic) in the string, it puts it in the
533 // buffer and returns true. Otherwise it return false.
534 func (s
*ss
) accept(ok
string) bool {
535 return s
.consume(ok
, true)
538 // okVerb verifies that the verb is present in the list, setting s.err appropriately if not.
539 func (s
*ss
) okVerb(verb rune
, okVerbs
, typ
string) bool {
540 for _
, v
:= range okVerbs
{
545 s
.errorString("bad verb %" + string(verb
) + " for " + typ
)
549 // scanBool returns the value of the boolean represented by the next token.
550 func (s
*ss
) scanBool(verb rune
) bool {
553 if !s
.okVerb(verb
, "tv", "boolean") {
556 // Syntax-checking a boolean is annoying. We're not fastidious about case.
563 if s
.accept("rR") && (!s
.accept("uU") ||
!s
.accept("eE")) {
568 if s
.accept("aA") && (!s
.accept("lL") ||
!s
.accept("sS") ||
!s
.accept("eE")) {
576 // Numerical elements
579 octalDigits
= "01234567"
580 decimalDigits
= "0123456789"
581 hexadecimalDigits
= "0123456789aAbBcCdDeEfF"
587 // getBase returns the numeric base represented by the verb and its digit string.
588 func (s
*ss
) getBase(verb rune
) (base
int, digits
string) {
589 s
.okVerb(verb
, "bdoUxXv", "integer") // sets s.err
591 digits
= decimalDigits
595 digits
= binaryDigits
601 digits
= hexadecimalDigits
606 // scanNumber returns the numerical string with specified digits starting here.
607 func (s
*ss
) scanNumber(digits
string, haveDigits
bool) string {
610 if !s
.accept(digits
) {
611 s
.errorString("expected integer")
614 for s
.accept(digits
) {
619 // scanRune returns the next rune value in the input.
620 func (s
*ss
) scanRune(bitSize
int) int64 {
622 r
:= int64(s
.getRune())
624 x
:= (r
<< (64 - n
)) >> (64 - n
)
626 s
.errorString("overflow on character value " + string(r
))
631 // scanBasePrefix reports whether the integer begins with a 0 or 0x,
632 // and returns the base, digit string, and whether a zero was found.
633 // It is called only if the verb is %v.
634 func (s
*ss
) scanBasePrefix() (base
int, digits
string, found
bool) {
636 return 10, decimalDigits
, false
639 found
= true // We've put a digit into the token buffer.
640 // Special cases for '0' && '0x'
641 base
, digits
= 8, octalDigits
643 s
.consume("xX", false)
644 base
, digits
= 16, hexadecimalDigits
649 // scanInt returns the value of the integer represented by the next
650 // token, checking for overflow. Any error is stored in s.err.
651 func (s
*ss
) scanInt(verb rune
, bitSize
int) int64 {
653 return s
.scanRune(bitSize
)
657 base
, digits
:= s
.getBase(verb
)
660 if !s
.consume("U", false) ||
!s
.consume("+", false) {
661 s
.errorString("bad unicode format ")
664 s
.accept(sign
) // If there's a sign, it will be left in the token buffer.
666 base
, digits
, haveDigits
= s
.scanBasePrefix()
669 tok
:= s
.scanNumber(digits
, haveDigits
)
670 i
, err
:= strconv
.ParseInt(tok
, base
, 64)
675 x
:= (i
<< (64 - n
)) >> (64 - n
)
677 s
.errorString("integer overflow on token " + tok
)
682 // scanUint returns the value of the unsigned integer represented
683 // by the next token, checking for overflow. Any error is stored in s.err.
684 func (s
*ss
) scanUint(verb rune
, bitSize
int) uint64 {
686 return uint64(s
.scanRune(bitSize
))
690 base
, digits
:= s
.getBase(verb
)
693 if !s
.consume("U", false) ||
!s
.consume("+", false) {
694 s
.errorString("bad unicode format ")
696 } else if verb
== 'v' {
697 base
, digits
, haveDigits
= s
.scanBasePrefix()
699 tok
:= s
.scanNumber(digits
, haveDigits
)
700 i
, err
:= strconv
.ParseUint(tok
, base
, 64)
705 x
:= (i
<< (64 - n
)) >> (64 - n
)
707 s
.errorString("unsigned integer overflow on token " + tok
)
712 // floatToken returns the floating-point number starting here, no longer than swid
713 // if the width is specified. It's not rigorous about syntax because it doesn't check that
714 // we have at least some digits, but Atof will do that.
715 func (s
*ss
) floatToken() string {
718 if s
.accept("nN") && s
.accept("aA") && s
.accept("nN") {
724 if s
.accept("iI") && s
.accept("nN") && s
.accept("fF") {
728 for s
.accept(decimalDigits
) {
731 if s
.accept(period
) {
733 for s
.accept(decimalDigits
) {
737 if s
.accept(exponent
) {
741 for s
.accept(decimalDigits
) {
747 // complexTokens returns the real and imaginary parts of the complex number starting here.
748 // The number might be parenthesized and has the format (N+Ni) where N is a floating-point
749 // number and there are no spaces within.
750 func (s
*ss
) complexTokens() (real
, imag
string) {
751 // TODO: accept N and Ni independently?
752 parens
:= s
.accept("(")
753 real
= s
.floatToken()
755 // Must now have a sign.
757 s
.error(complexError
)
759 // Sign is now in buffer
760 imagSign
:= string(s
.buf
)
761 imag
= s
.floatToken()
763 s
.error(complexError
)
765 if parens
&& !s
.accept(")") {
766 s
.error(complexError
)
768 return real
, imagSign
+ imag
771 // convertFloat converts the string to a float64value.
772 func (s
*ss
) convertFloat(str
string, n
int) float64 {
773 if p
:= indexRune(str
, 'p'); p
>= 0 {
774 // Atof doesn't handle power-of-2 exponents,
775 // but they're easy to evaluate.
776 f
, err
:= strconv
.ParseFloat(str
[:p
], n
)
778 // Put full string into error.
779 if e
, ok
:= err
.(*strconv
.NumError
); ok
{
784 m
, err
:= strconv
.Atoi(str
[p
+1:])
786 // Put full string into error.
787 if e
, ok
:= err
.(*strconv
.NumError
); ok
{
792 return math
.Ldexp(f
, m
)
794 f
, err
:= strconv
.ParseFloat(str
, n
)
801 // convertComplex converts the next token to a complex128 value.
802 // The atof argument is a type-specific reader for the underlying type.
803 // If we're reading complex64, atof will parse float32s and convert them
804 // to float64's to avoid reproducing this code for each complex type.
805 func (s
*ss
) scanComplex(verb rune
, n
int) complex128
{
806 if !s
.okVerb(verb
, floatVerbs
, "complex") {
811 sreal
, simag
:= s
.complexTokens()
812 real
:= s
.convertFloat(sreal
, n
/2)
813 imag
:= s
.convertFloat(simag
, n
/2)
814 return complex(real
, imag
)
817 // convertString returns the string represented by the next input characters.
818 // The format of the input is determined by the verb.
819 func (s
*ss
) convertString(verb rune
) (str
string) {
820 if !s
.okVerb(verb
, "svqx", "string") {
827 str
= s
.quotedString()
831 str
= string(s
.token(true, notSpace
)) // %s and %v just return the next word
836 // quotedString returns the double- or back-quoted string represented by the next input characters.
837 func (s
*ss
) quotedString() string {
842 // Back-quoted: Anything goes until EOF or back quote.
844 r
:= s
.mustReadRune()
852 // Double-quoted: Include the quotes and let strconv.Unquote do the backslash escapes.
853 s
.buf
.WriteRune(quote
)
855 r
:= s
.mustReadRune()
858 // In a legal backslash escape, no matter how long, only the character
859 // immediately after the escape can itself be a backslash or quote.
860 // Thus we only need to protect the first character after the backslash.
861 s
.buf
.WriteRune(s
.mustReadRune())
866 result
, err
:= strconv
.Unquote(string(s
.buf
))
872 s
.errorString("expected quoted string")
877 // hexDigit returns the value of the hexadecimal digit
878 func (s
*ss
) hexDigit(d rune
) int {
881 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
883 case 'a', 'b', 'c', 'd', 'e', 'f':
884 return 10 + digit
- 'a'
885 case 'A', 'B', 'C', 'D', 'E', 'F':
886 return 10 + digit
- 'A'
888 s
.errorString("illegal hex digit")
892 // hexByte returns the next hex-encoded (two-character) byte from the input.
893 // There must be either two hexadecimal digits or a space character in the input.
894 func (s
*ss
) hexByte() (b
byte, ok
bool) {
903 rune2
:= s
.mustReadRune()
904 return byte(s
.hexDigit(rune1
)<<4 | s
.hexDigit(rune2
)), true
907 // hexString returns the space-delimited hexpair-encoded string.
908 func (s
*ss
) hexString() string {
918 s
.errorString("no hex data for %x string")
924 const floatVerbs
= "beEfFgGv"
926 const hugeWid
= 1 << 30
928 // scanOne scans a single value, deriving the scanner from the type of the argument.
929 func (s
*ss
) scanOne(verb rune
, arg
interface{}) {
932 // If the parameter has its own Scan method, use that.
933 if v
, ok
:= arg
.(Scanner
); ok
{
934 err
= v
.Scan(s
, verb
)
937 err
= io
.ErrUnexpectedEOF
944 switch v
:= arg
.(type) {
946 *v
= s
.scanBool(verb
)
948 *v
= complex64(s
.scanComplex(verb
, 64))
950 *v
= s
.scanComplex(verb
, 128)
952 *v
= int(s
.scanInt(verb
, intBits
))
954 *v
= int8(s
.scanInt(verb
, 8))
956 *v
= int16(s
.scanInt(verb
, 16))
958 *v
= int32(s
.scanInt(verb
, 32))
960 *v
= s
.scanInt(verb
, 64)
962 *v
= uint(s
.scanUint(verb
, intBits
))
964 *v
= uint8(s
.scanUint(verb
, 8))
966 *v
= uint16(s
.scanUint(verb
, 16))
968 *v
= uint32(s
.scanUint(verb
, 32))
970 *v
= s
.scanUint(verb
, 64)
972 *v
= uintptr(s
.scanUint(verb
, uintptrBits
))
973 // Floats are tricky because you want to scan in the precision of the result, not
974 // scan in high precision and convert, in order to preserve the correct error condition.
976 if s
.okVerb(verb
, floatVerbs
, "float32") {
979 *v
= float32(s
.convertFloat(s
.floatToken(), 32))
982 if s
.okVerb(verb
, floatVerbs
, "float64") {
985 *v
= s
.convertFloat(s
.floatToken(), 64)
988 *v
= s
.convertString(verb
)
990 // We scan to string and convert so we get a copy of the data.
991 // If we scanned to bytes, the slice would point at the buffer.
992 *v
= []byte(s
.convertString(verb
))
994 val
:= reflect
.ValueOf(v
)
996 if ptr
.Kind() != reflect
.Ptr
{
997 s
.errorString("type not a pointer: " + val
.Type().String())
1000 switch v
:= ptr
.Elem(); v
.Kind() {
1002 v
.SetBool(s
.scanBool(verb
))
1003 case reflect
.Int
, reflect
.Int8
, reflect
.Int16
, reflect
.Int32
, reflect
.Int64
:
1004 v
.SetInt(s
.scanInt(verb
, v
.Type().Bits()))
1005 case reflect
.Uint
, reflect
.Uint8
, reflect
.Uint16
, reflect
.Uint32
, reflect
.Uint64
, reflect
.Uintptr
:
1006 v
.SetUint(s
.scanUint(verb
, v
.Type().Bits()))
1007 case reflect
.String
:
1008 v
.SetString(s
.convertString(verb
))
1010 // For now, can only handle (renamed) []byte.
1012 if typ
.Elem().Kind() != reflect
.Uint8
{
1013 s
.errorString("can't scan type: " + val
.Type().String())
1015 str
:= s
.convertString(verb
)
1016 v
.Set(reflect
.MakeSlice(typ
, len(str
), len(str
)))
1017 for i
:= 0; i
< len(str
); i
++ {
1018 v
.Index(i
).SetUint(uint64(str
[i
]))
1020 case reflect
.Float32
, reflect
.Float64
:
1023 v
.SetFloat(s
.convertFloat(s
.floatToken(), v
.Type().Bits()))
1024 case reflect
.Complex64
, reflect
.Complex128
:
1025 v
.SetComplex(s
.scanComplex(verb
, v
.Type().Bits()))
1027 s
.errorString("can't scan type: " + val
.Type().String())
1032 // errorHandler turns local panics into error returns.
1033 func errorHandler(errp
*error
) {
1034 if e
:= recover(); e
!= nil {
1035 if se
, ok
:= e
.(scanError
); ok
{ // catch local error
1037 } else if eof
, ok
:= e
.(error
); ok
&& eof
== io
.EOF
{ // out of input
1045 // doScan does the real work for scanning without a format string.
1046 func (s
*ss
) doScan(a
[]interface{}) (numProcessed
int, err error
) {
1047 defer errorHandler(&err
)
1048 for _
, arg
:= range a
{
1052 // Check for newline if required.
1056 if r
== '\n' || r
== eof
{
1060 s
.errorString("expected newline")
1068 // advance determines whether the next characters in the input match
1069 // those of the format. It returns the number of bytes (sic) consumed
1070 // in the format. Newlines included, all runs of space characters in
1071 // either input or format behave as a single space. This routine also
1072 // handles the %% case. If the return value is zero, either format
1073 // starts with a % (with no following %) or the input is empty.
1074 // If it is negative, the input did not match the string.
1075 func (s
*ss
) advance(format
string) (i
int) {
1076 for i
< len(format
) {
1077 fmtc
, w
:= utf8
.DecodeRuneInString(format
[i
:])
1079 // %% acts like a real percent
1080 nextc
, _
:= utf8
.DecodeRuneInString(format
[i
+w
:]) // will not match % if string is empty
1084 i
+= w
// skip the first %
1087 for isSpace(fmtc
) && i
< len(format
) {
1090 fmtc
, w
= utf8
.DecodeRuneInString(format
[i
:])
1093 // There was space in the format, so there should be space (EOF)
1095 inputc
:= s
.getRune()
1096 if inputc
== eof || inputc
== '\n' {
1097 // If we've reached a newline, stop now; don't read ahead.
1100 if !isSpace(inputc
) {
1101 // Space in format but not in input: error
1102 s
.errorString("expected space in input to match format")
1107 inputc
:= s
.mustReadRune()
1117 // doScanf does the real work when scanning with a format string.
1118 // At the moment, it handles only pointers to basic types.
1119 func (s
*ss
) doScanf(format
string, a
[]interface{}) (numProcessed
int, err error
) {
1120 defer errorHandler(&err
)
1121 end
:= len(format
) - 1
1122 // We process one item per non-trivial format
1123 for i
:= 0; i
<= end
; {
1124 w
:= s
.advance(format
[i
:])
1129 // Either we failed to advance, we have a percent character, or we ran out of input.
1130 if format
[i
] != '%' {
1131 // Can't advance format. Why not?
1133 s
.errorString("input does not match format")
1135 // Otherwise at EOF; "too many operands" error handled below
1138 i
++ // % is one byte
1140 // do we have 20 (width)?
1142 s
.maxWid
, widPresent
, i
= parsenum(format
, i
, end
)
1146 s
.argLimit
= s
.limit
1147 if f
:= s
.count
+ s
.maxWid
; f
< s
.argLimit
{
1151 c
, w
:= utf8
.DecodeRuneInString(format
[i
:])
1154 if numProcessed
>= len(a
) { // out of operands
1155 s
.errorString("too few operands for format %" + format
[i
-w
:])
1158 arg
:= a
[numProcessed
]
1162 s
.argLimit
= s
.limit
1164 if numProcessed
< len(a
) {
1165 s
.errorString("too many operands")