Source file src/pkg/fmt/scan.go
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. 4 5 package fmt 6 7 import ( 8 "errors" 9 "io" 10 "math" 11 "os" 12 "reflect" 13 "strconv" 14 "unicode/utf8" 15 ) 16 17 // runeUnreader is the interface to something that can unread runes. 18 // If the object provided to Scan does not satisfy this interface, 19 // a local buffer will be used to back up the input, but its contents 20 // will be lost when Scan returns. 21 type runeUnreader interface { 22 UnreadRune() error 23 } 24 25 // ScanState represents the scanner state passed to custom scanners. 26 // Scanners may do rune-at-a-time scanning or ask the ScanState 27 // to discover the next space-delimited token. 28 type ScanState interface { 29 // ReadRune reads the next rune (Unicode code point) from the input. 30 // If invoked during Scanln, Fscanln, or Sscanln, ReadRune() will 31 // return EOF after returning the first '\n' or when reading beyond 32 // the specified width. 33 ReadRune() (r rune, size int, err error) 34 // UnreadRune causes the next call to ReadRune to return the same rune. 35 UnreadRune() error 36 // SkipSpace skips space in the input. Newlines are treated as space 37 // unless the scan operation is Scanln, Fscanln or Sscanln, in which case 38 // a newline is treated as EOF. 39 SkipSpace() 40 // Token skips space in the input if skipSpace is true, then returns the 41 // run of Unicode code points c satisfying f(c). If f is nil, 42 // !unicode.IsSpace(c) is used; that is, the token will hold non-space 43 // characters. Newlines are treated as space unless the scan operation 44 // is Scanln, Fscanln or Sscanln, in which case a newline is treated as 45 // EOF. The returned slice points to shared data that may be overwritten 46 // by the next call to Token, a call to a Scan function using the ScanState 47 // as input, or when the calling Scan method returns. 48 Token(skipSpace bool, f func(rune) bool) (token []byte, err error) 49 // Width returns the value of the width option and whether it has been set. 50 // The unit is Unicode code points. 51 Width() (wid int, ok bool) 52 // Because ReadRune is implemented by the interface, Read should never be 53 // called by the scanning routines and a valid implementation of 54 // ScanState may choose always to return an error from Read. 55 Read(buf []byte) (n int, err error) 56 } 57 58 // Scanner is implemented by any value that has a Scan method, which scans 59 // the input for the representation of a value and stores the result in the 60 // receiver, which must be a pointer to be useful. The Scan method is called 61 // for any argument to Scan, Scanf, or Scanln that implements it. 62 type Scanner interface { 63 Scan(state ScanState, verb rune) error 64 } 65 66 // Scan scans text read from standard input, storing successive 67 // space-separated values into successive arguments. Newlines count 68 // as space. It returns the number of items successfully scanned. 69 // If that is less than the number of arguments, err will report why. 70 func Scan(a ...interface{}) (n int, err error) { 71 return Fscan(os.Stdin, a...) 72 } 73 74 // Scanln is similar to Scan, but stops scanning at a newline and 75 // after the final item there must be a newline or EOF. 76 func Scanln(a ...interface{}) (n int, err error) { 77 return Fscanln(os.Stdin, a...) 78 } 79 80 // Scanf scans text read from standard input, storing successive 81 // space-separated values into successive arguments as determined by 82 // the format. It returns the number of items successfully scanned. 83 func Scanf(format string, a ...interface{}) (n int, err error) { 84 return Fscanf(os.Stdin, format, a...) 85 } 86 87 type stringReader string 88 89 func (r *stringReader) Read(b []byte) (n int, err error) { 90 n = copy(b, *r) 91 *r = (*r)[n:] 92 if n == 0 { 93 err = io.EOF 94 } 95 return 96 } 97 98 // Sscan scans the argument string, storing successive space-separated 99 // values into successive arguments. Newlines count as space. It 100 // returns the number of items successfully scanned. If that is less 101 // than the number of arguments, err will report why. 102 func Sscan(str string, a ...interface{}) (n int, err error) { 103 return Fscan((*stringReader)(&str), a...) 104 } 105 106 // Sscanln is similar to Sscan, but stops scanning at a newline and 107 // after the final item there must be a newline or EOF. 108 func Sscanln(str string, a ...interface{}) (n int, err error) { 109 return Fscanln((*stringReader)(&str), a...) 110 } 111 112 // Sscanf scans the argument string, storing successive space-separated 113 // values into successive arguments as determined by the format. It 114 // returns the number of items successfully parsed. 115 func Sscanf(str string, format string, a ...interface{}) (n int, err error) { 116 return Fscanf((*stringReader)(&str), format, a...) 117 } 118 119 // Fscan scans text read from r, storing successive space-separated 120 // values into successive arguments. Newlines count as space. It 121 // returns the number of items successfully scanned. If that is less 122 // than the number of arguments, err will report why. 123 func Fscan(r io.Reader, a ...interface{}) (n int, err error) { 124 s, old := newScanState(r, true, false) 125 n, err = s.doScan(a) 126 s.free(old) 127 return 128 } 129 130 // Fscanln is similar to Fscan, but stops scanning at a newline and 131 // after the final item there must be a newline or EOF. 132 func Fscanln(r io.Reader, a ...interface{}) (n int, err error) { 133 s, old := newScanState(r, false, true) 134 n, err = s.doScan(a) 135 s.free(old) 136 return 137 } 138 139 // Fscanf scans text read from r, storing successive space-separated 140 // values into successive arguments as determined by the format. It 141 // returns the number of items successfully parsed. 142 func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error) { 143 s, old := newScanState(r, false, false) 144 n, err = s.doScanf(format, a) 145 s.free(old) 146 return 147 } 148 149 // scanError represents an error generated by the scanning software. 150 // It's used as a unique signature to identify such errors when recovering. 151 type scanError struct { 152 err error 153 } 154 155 const eof = -1 156 157 // ss is the internal implementation of ScanState. 158 type ss struct { 159 rr io.RuneReader // where to read input 160 buf buffer // token accumulator 161 peekRune rune // one-rune lookahead 162 prevRune rune // last rune returned by ReadRune 163 count int // runes consumed so far. 164 atEOF bool // already read EOF 165 ssave 166 } 167 168 // ssave holds the parts of ss that need to be 169 // saved and restored on recursive scans. 170 type ssave struct { 171 validSave bool // is or was a part of an actual ss. 172 nlIsEnd bool // whether newline terminates scan 173 nlIsSpace bool // whether newline counts as white space 174 fieldLimit int // max value of ss.count for this field; fieldLimit <= limit 175 limit int // max value of ss.count. 176 maxWid int // width of this field. 177 } 178 179 // The Read method is only in ScanState so that ScanState 180 // satisfies io.Reader. It will never be called when used as 181 // intended, so there is no need to make it actually work. 182 func (s *ss) Read(buf []byte) (n int, err error) { 183 return 0, errors.New("ScanState's Read should not be called. Use ReadRune") 184 } 185 186 func (s *ss) ReadRune() (r rune, size int, err error) { 187 if s.peekRune >= 0 { 188 s.count++ 189 r = s.peekRune 190 size = utf8.RuneLen(r) 191 s.prevRune = r 192 s.peekRune = -1 193 return 194 } 195 if s.atEOF || s.nlIsEnd && s.prevRune == '\n' || s.count >= s.fieldLimit { 196 err = io.EOF 197 return 198 } 199 200 r, size, err = s.rr.ReadRune() 201 if err == nil { 202 s.count++ 203 s.prevRune = r 204 } else if err == io.EOF { 205 s.atEOF = true 206 } 207 return 208 } 209 210 func (s *ss) Width() (wid int, ok bool) { 211 if s.maxWid == hugeWid { 212 return 0, false 213 } 214 return s.maxWid, true 215 } 216 217 // The public method returns an error; this private one panics. 218 // If getRune reaches EOF, the return value is EOF (-1). 219 func (s *ss) getRune() (r rune) { 220 r, _, err := s.ReadRune() 221 if err != nil { 222 if err == io.EOF { 223 return eof 224 } 225 s.error(err) 226 } 227 return 228 } 229 230 // mustReadRune turns io.EOF into a panic(io.ErrUnexpectedEOF). 231 // It is called in cases such as string scanning where an EOF is a 232 // syntax error. 233 func (s *ss) mustReadRune() (r rune) { 234 r = s.getRune() 235 if r == eof { 236 s.error(io.ErrUnexpectedEOF) 237 } 238 return 239 } 240 241 func (s *ss) UnreadRune() error { 242 if u, ok := s.rr.(runeUnreader); ok { 243 u.UnreadRune() 244 } else { 245 s.peekRune = s.prevRune 246 } 247 s.prevRune = -1 248 s.count-- 249 return nil 250 } 251 252 func (s *ss) error(err error) { 253 panic(scanError{err}) 254 } 255 256 func (s *ss) errorString(err string) { 257 panic(scanError{errors.New(err)}) 258 } 259 260 func (s *ss) Token(skipSpace bool, f func(rune) bool) (tok []byte, err error) { 261 defer func() { 262 if e := recover(); e != nil { 263 if se, ok := e.(scanError); ok { 264 err = se.err 265 } else { 266 panic(e) 267 } 268 } 269 }() 270 if f == nil { 271 f = notSpace 272 } 273 s.buf = s.buf[:0] 274 tok = s.token(skipSpace, f) 275 return 276 } 277 278 // space is a copy of the unicode.White_Space ranges, 279 // to avoid depending on package unicode. 280 var space = [][2]uint16{ 281 {0x0009, 0x000d}, 282 {0x0020, 0x0020}, 283 {0x0085, 0x0085}, 284 {0x00a0, 0x00a0}, 285 {0x1680, 0x1680}, 286 {0x180e, 0x180e}, 287 {0x2000, 0x200a}, 288 {0x2028, 0x2029}, 289 {0x202f, 0x202f}, 290 {0x205f, 0x205f}, 291 {0x3000, 0x3000}, 292 } 293 294 func isSpace(r rune) bool { 295 if r >= 1<<16 { 296 return false 297 } 298 rx := uint16(r) 299 for _, rng := range space { 300 if rx < rng[0] { 301 return false 302 } 303 if rx <= rng[1] { 304 return true 305 } 306 } 307 return false 308 } 309 310 // notSpace is the default scanning function used in Token. 311 func notSpace(r rune) bool { 312 return !isSpace(r) 313 } 314 315 // skipSpace provides Scan() methods the ability to skip space and newline characters 316 // in keeping with the current scanning mode set by format strings and Scan()/Scanln(). 317 func (s *ss) SkipSpace() { 318 s.skipSpace(false) 319 } 320 321 // readRune is a structure to enable reading UTF-8 encoded code points 322 // from an io.Reader. It is used if the Reader given to the scanner does 323 // not already implement io.RuneReader. 324 type readRune struct { 325 reader io.Reader 326 buf [utf8.UTFMax]byte // used only inside ReadRune 327 pending int // number of bytes in pendBuf; only >0 for bad UTF-8 328 pendBuf [utf8.UTFMax]byte // bytes left over 329 } 330 331 // readByte returns the next byte from the input, which may be 332 // left over from a previous read if the UTF-8 was ill-formed. 333 func (r *readRune) readByte() (b byte, err error) { 334 if r.pending > 0 { 335 b = r.pendBuf[0] 336 copy(r.pendBuf[0:], r.pendBuf[1:]) 337 r.pending-- 338 return 339 } 340 _, err = r.reader.Read(r.pendBuf[0:1]) 341 return r.pendBuf[0], err 342 } 343 344 // unread saves the bytes for the next read. 345 func (r *readRune) unread(buf []byte) { 346 copy(r.pendBuf[r.pending:], buf) 347 r.pending += len(buf) 348 } 349 350 // ReadRune returns the next UTF-8 encoded code point from the 351 // io.Reader inside r. 352 func (r *readRune) ReadRune() (rr rune, size int, err error) { 353 r.buf[0], err = r.readByte() 354 if err != nil { 355 return 0, 0, err 356 } 357 if r.buf[0] < utf8.RuneSelf { // fast check for common ASCII case 358 rr = rune(r.buf[0]) 359 return 360 } 361 var n int 362 for n = 1; !utf8.FullRune(r.buf[0:n]); n++ { 363 r.buf[n], err = r.readByte() 364 if err != nil { 365 if err == io.EOF { 366 err = nil 367 break 368 } 369 return 370 } 371 } 372 rr, size = utf8.DecodeRune(r.buf[0:n]) 373 if size < n { // an error 374 r.unread(r.buf[size:n]) 375 } 376 return 377 } 378 379 var ssFree = newCache(func() interface{} { return new(ss) }) 380 381 // Allocate a new ss struct or grab a cached one. 382 func newScanState(r io.Reader, nlIsSpace, nlIsEnd bool) (s *ss, old ssave) { 383 // If the reader is a *ss, then we've got a recursive 384 // call to Scan, so re-use the scan state. 385 s, ok := r.(*ss) 386 if ok { 387 old = s.ssave 388 s.limit = s.fieldLimit 389 s.nlIsEnd = nlIsEnd || s.nlIsEnd 390 s.nlIsSpace = nlIsSpace 391 return 392 } 393 394 s = ssFree.get().(*ss) 395 if rr, ok := r.(io.RuneReader); ok { 396 s.rr = rr 397 } else { 398 s.rr = &readRune{reader: r} 399 } 400 s.nlIsSpace = nlIsSpace 401 s.nlIsEnd = nlIsEnd 402 s.prevRune = -1 403 s.peekRune = -1 404 s.atEOF = false 405 s.limit = hugeWid 406 s.fieldLimit = hugeWid 407 s.maxWid = hugeWid 408 s.validSave = true 409 s.count = 0 410 return 411 } 412 413 // Save used ss structs in ssFree; avoid an allocation per invocation. 414 func (s *ss) free(old ssave) { 415 // If it was used recursively, just restore the old state. 416 if old.validSave { 417 s.ssave = old 418 return 419 } 420 // Don't hold on to ss structs with large buffers. 421 if cap(s.buf) > 1024 { 422 return 423 } 424 s.buf = s.buf[:0] 425 s.rr = nil 426 ssFree.put(s) 427 } 428 429 // skipSpace skips spaces and maybe newlines. 430 func (s *ss) skipSpace(stopAtNewline bool) { 431 for { 432 r := s.getRune() 433 if r == eof { 434 return 435 } 436 if r == '\n' { 437 if stopAtNewline { 438 break 439 } 440 if s.nlIsSpace { 441 continue 442 } 443 s.errorString("unexpected newline") 444 return 445 } 446 if !isSpace(r) { 447 s.UnreadRune() 448 break 449 } 450 } 451 } 452 453 // token returns the next space-delimited string from the input. It 454 // skips white space. For Scanln, it stops at newlines. For Scan, 455 // newlines are treated as spaces. 456 func (s *ss) token(skipSpace bool, f func(rune) bool) []byte { 457 if skipSpace { 458 s.skipSpace(false) 459 } 460 // read until white space or newline 461 for { 462 r := s.getRune() 463 if r == eof { 464 break 465 } 466 if !f(r) { 467 s.UnreadRune() 468 break 469 } 470 s.buf.WriteRune(r) 471 } 472 return s.buf 473 } 474 475 // typeError indicates that the type of the operand did not match the format 476 func (s *ss) typeError(field interface{}, expected string) { 477 s.errorString("expected field of type pointer to " + expected + "; found " + reflect.TypeOf(field).String()) 478 } 479 480 var complexError = errors.New("syntax error scanning complex number") 481 var boolError = errors.New("syntax error scanning boolean") 482 483 func indexRune(s string, r rune) int { 484 for i, c := range s { 485 if c == r { 486 return i 487 } 488 } 489 return -1 490 } 491 492 // consume reads the next rune in the input and reports whether it is in the ok string. 493 // If accept is true, it puts the character into the input token. 494 func (s *ss) consume(ok string, accept bool) bool { 495 r := s.getRune() 496 if r == eof { 497 return false 498 } 499 if indexRune(ok, r) >= 0 { 500 if accept { 501 s.buf.WriteRune(r) 502 } 503 return true 504 } 505 if r != eof && accept { 506 s.UnreadRune() 507 } 508 return false 509 } 510 511 // peek reports whether the next character is in the ok string, without consuming it. 512 func (s *ss) peek(ok string) bool { 513 r := s.getRune() 514 if r != eof { 515 s.UnreadRune() 516 } 517 return indexRune(ok, r) >= 0 518 } 519 520 func (s *ss) notEOF() { 521 // Guarantee there is data to be read. 522 if r := s.getRune(); r == eof { 523 panic(io.EOF) 524 } 525 s.UnreadRune() 526 } 527 528 // accept checks the next rune in the input. If it's a byte (sic) in the string, it puts it in the 529 // buffer and returns true. Otherwise it return false. 530 func (s *ss) accept(ok string) bool { 531 return s.consume(ok, true) 532 } 533 534 // okVerb verifies that the verb is present in the list, setting s.err appropriately if not. 535 func (s *ss) okVerb(verb rune, okVerbs, typ string) bool { 536 for _, v := range okVerbs { 537 if v == verb { 538 return true 539 } 540 } 541 s.errorString("bad verb %" + string(verb) + " for " + typ) 542 return false 543 } 544 545 // scanBool returns the value of the boolean represented by the next token. 546 func (s *ss) scanBool(verb rune) bool { 547 s.skipSpace(false) 548 s.notEOF() 549 if !s.okVerb(verb, "tv", "boolean") { 550 return false 551 } 552 // Syntax-checking a boolean is annoying. We're not fastidious about case. 553 switch s.getRune() { 554 case '0': 555 return false 556 case '1': 557 return true 558 case 't', 'T': 559 if s.accept("rR") && (!s.accept("uU") || !s.accept("eE")) { 560 s.error(boolError) 561 } 562 return true 563 case 'f', 'F': 564 if s.accept("aA") && (!s.accept("lL") || !s.accept("sS") || !s.accept("eE")) { 565 s.error(boolError) 566 } 567 return false 568 } 569 return false 570 } 571 572 // Numerical elements 573 const ( 574 binaryDigits = "01" 575 octalDigits = "01234567" 576 decimalDigits = "0123456789" 577 hexadecimalDigits = "0123456789aAbBcCdDeEfF" 578 sign = "+-" 579 period = "." 580 exponent = "eEp" 581 ) 582 583 // getBase returns the numeric base represented by the verb and its digit string. 584 func (s *ss) getBase(verb rune) (base int, digits string) { 585 s.okVerb(verb, "bdoUxXv", "integer") // sets s.err 586 base = 10 587 digits = decimalDigits 588 switch verb { 589 case 'b': 590 base = 2 591 digits = binaryDigits 592 case 'o': 593 base = 8 594 digits = octalDigits 595 case 'x', 'X', 'U': 596 base = 16 597 digits = hexadecimalDigits 598 } 599 return 600 } 601 602 // scanNumber returns the numerical string with specified digits starting here. 603 func (s *ss) scanNumber(digits string, haveDigits bool) string { 604 if !haveDigits { 605 s.notEOF() 606 if !s.accept(digits) { 607 s.errorString("expected integer") 608 } 609 } 610 for s.accept(digits) { 611 } 612 return string(s.buf) 613 } 614 615 // scanRune returns the next rune value in the input. 616 func (s *ss) scanRune(bitSize int) int64 { 617 s.notEOF() 618 r := int64(s.getRune()) 619 n := uint(bitSize) 620 x := (r << (64 - n)) >> (64 - n) 621 if x != r { 622 s.errorString("overflow on character value " + string(r)) 623 } 624 return r 625 } 626 627 // scanBasePrefix reports whether the integer begins with a 0 or 0x, 628 // and returns the base, digit string, and whether a zero was found. 629 // It is called only if the verb is %v. 630 func (s *ss) scanBasePrefix() (base int, digits string, found bool) { 631 if !s.peek("0") { 632 return 10, decimalDigits, false 633 } 634 s.accept("0") 635 found = true // We've put a digit into the token buffer. 636 // Special cases for '0' && '0x' 637 base, digits = 8, octalDigits 638 if s.peek("xX") { 639 s.consume("xX", false) 640 base, digits = 16, hexadecimalDigits 641 } 642 return 643 } 644 645 // scanInt returns the value of the integer represented by the next 646 // token, checking for overflow. Any error is stored in s.err. 647 func (s *ss) scanInt(verb rune, bitSize int) int64 { 648 if verb == 'c' { 649 return s.scanRune(bitSize) 650 } 651 s.skipSpace(false) 652 s.notEOF() 653 base, digits := s.getBase(verb) 654 haveDigits := false 655 if verb == 'U' { 656 if !s.consume("U", false) || !s.consume("+", false) { 657 s.errorString("bad unicode format ") 658 } 659 } else { 660 s.accept(sign) // If there's a sign, it will be left in the token buffer. 661 if verb == 'v' { 662 base, digits, haveDigits = s.scanBasePrefix() 663 } 664 } 665 tok := s.scanNumber(digits, haveDigits) 666 i, err := strconv.ParseInt(tok, base, 64) 667 if err != nil { 668 s.error(err) 669 } 670 n := uint(bitSize) 671 x := (i << (64 - n)) >> (64 - n) 672 if x != i { 673 s.errorString("integer overflow on token " + tok) 674 } 675 return i 676 } 677 678 // scanUint returns the value of the unsigned integer represented 679 // by the next token, checking for overflow. Any error is stored in s.err. 680 func (s *ss) scanUint(verb rune, bitSize int) uint64 { 681 if verb == 'c' { 682 return uint64(s.scanRune(bitSize)) 683 } 684 s.skipSpace(false) 685 s.notEOF() 686 base, digits := s.getBase(verb) 687 haveDigits := false 688 if verb == 'U' { 689 if !s.consume("U", false) || !s.consume("+", false) { 690 s.errorString("bad unicode format ") 691 } 692 } else if verb == 'v' { 693 base, digits, haveDigits = s.scanBasePrefix() 694 } 695 tok := s.scanNumber(digits, haveDigits) 696 i, err := strconv.ParseUint(tok, base, 64) 697 if err != nil { 698 s.error(err) 699 } 700 n := uint(bitSize) 701 x := (i << (64 - n)) >> (64 - n) 702 if x != i { 703 s.errorString("unsigned integer overflow on token " + tok) 704 } 705 return i 706 } 707 708 // floatToken returns the floating-point number starting here, no longer than swid 709 // if the width is specified. It's not rigorous about syntax because it doesn't check that 710 // we have at least some digits, but Atof will do that. 711 func (s *ss) floatToken() string { 712 s.buf = s.buf[:0] 713 // NaN? 714 if s.accept("nN") && s.accept("aA") && s.accept("nN") { 715 return string(s.buf) 716 } 717 // leading sign? 718 s.accept(sign) 719 // Inf? 720 if s.accept("iI") && s.accept("nN") && s.accept("fF") { 721 return string(s.buf) 722 } 723 // digits? 724 for s.accept(decimalDigits) { 725 } 726 // decimal point? 727 if s.accept(period) { 728 // fraction? 729 for s.accept(decimalDigits) { 730 } 731 } 732 // exponent? 733 if s.accept(exponent) { 734 // leading sign? 735 s.accept(sign) 736 // digits? 737 for s.accept(decimalDigits) { 738 } 739 } 740 return string(s.buf) 741 } 742 743 // complexTokens returns the real and imaginary parts of the complex number starting here. 744 // The number might be parenthesized and has the format (N+Ni) where N is a floating-point 745 // number and there are no spaces within. 746 func (s *ss) complexTokens() (real, imag string) { 747 // TODO: accept N and Ni independently? 748 parens := s.accept("(") 749 real = s.floatToken() 750 s.buf = s.buf[:0] 751 // Must now have a sign. 752 if !s.accept("+-") { 753 s.error(complexError) 754 } 755 // Sign is now in buffer 756 imagSign := string(s.buf) 757 imag = s.floatToken() 758 if !s.accept("i") { 759 s.error(complexError) 760 } 761 if parens && !s.accept(")") { 762 s.error(complexError) 763 } 764 return real, imagSign + imag 765 } 766 767 // convertFloat converts the string to a float64value. 768 func (s *ss) convertFloat(str string, n int) float64 { 769 if p := indexRune(str, 'p'); p >= 0 { 770 // Atof doesn't handle power-of-2 exponents, 771 // but they're easy to evaluate. 772 f, err := strconv.ParseFloat(str[:p], n) 773 if err != nil { 774 // Put full string into error. 775 if e, ok := err.(*strconv.NumError); ok { 776 e.Num = str 777 } 778 s.error(err) 779 } 780 n, err := strconv.Atoi(str[p+1:]) 781 if err != nil { 782 // Put full string into error. 783 if e, ok := err.(*strconv.NumError); ok { 784 e.Num = str 785 } 786 s.error(err) 787 } 788 return math.Ldexp(f, n) 789 } 790 f, err := strconv.ParseFloat(str, n) 791 if err != nil { 792 s.error(err) 793 } 794 return f 795 } 796 797 // convertComplex converts the next token to a complex128 value. 798 // The atof argument is a type-specific reader for the underlying type. 799 // If we're reading complex64, atof will parse float32s and convert them 800 // to float64's to avoid reproducing this code for each complex type. 801 func (s *ss) scanComplex(verb rune, n int) complex128 { 802 if !s.okVerb(verb, floatVerbs, "complex") { 803 return 0 804 } 805 s.skipSpace(false) 806 s.notEOF() 807 sreal, simag := s.complexTokens() 808 real := s.convertFloat(sreal, n/2) 809 imag := s.convertFloat(simag, n/2) 810 return complex(real, imag) 811 } 812 813 // convertString returns the string represented by the next input characters. 814 // The format of the input is determined by the verb. 815 func (s *ss) convertString(verb rune) (str string) { 816 if !s.okVerb(verb, "svqx", "string") { 817 return "" 818 } 819 s.skipSpace(false) 820 s.notEOF() 821 switch verb { 822 case 'q': 823 str = s.quotedString() 824 case 'x': 825 str = s.hexString() 826 default: 827 str = string(s.token(true, notSpace)) // %s and %v just return the next word 828 } 829 return 830 } 831 832 // quotedString returns the double- or back-quoted string represented by the next input characters. 833 func (s *ss) quotedString() string { 834 s.notEOF() 835 quote := s.getRune() 836 switch quote { 837 case '`': 838 // Back-quoted: Anything goes until EOF or back quote. 839 for { 840 r := s.mustReadRune() 841 if r == quote { 842 break 843 } 844 s.buf.WriteRune(r) 845 } 846 return string(s.buf) 847 case '"': 848 // Double-quoted: Include the quotes and let strconv.Unquote do the backslash escapes. 849 s.buf.WriteRune(quote) 850 for { 851 r := s.mustReadRune() 852 s.buf.WriteRune(r) 853 if r == '\\' { 854 // In a legal backslash escape, no matter how long, only the character 855 // immediately after the escape can itself be a backslash or quote. 856 // Thus we only need to protect the first character after the backslash. 857 r := s.mustReadRune() 858 s.buf.WriteRune(r) 859 } else if r == '"' { 860 break 861 } 862 } 863 result, err := strconv.Unquote(string(s.buf)) 864 if err != nil { 865 s.error(err) 866 } 867 return result 868 default: 869 s.errorString("expected quoted string") 870 } 871 return "" 872 } 873 874 // hexDigit returns the value of the hexadecimal digit 875 func (s *ss) hexDigit(d rune) int { 876 digit := int(d) 877 switch digit { 878 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': 879 return digit - '0' 880 case 'a', 'b', 'c', 'd', 'e', 'f': 881 return 10 + digit - 'a' 882 case 'A', 'B', 'C', 'D', 'E', 'F': 883 return 10 + digit - 'A' 884 } 885 s.errorString("Scan: illegal hex digit") 886 return 0 887 } 888 889 // hexByte returns the next hex-encoded (two-character) byte from the input. 890 // There must be either two hexadecimal digits or a space character in the input. 891 func (s *ss) hexByte() (b byte, ok bool) { 892 rune1 := s.getRune() 893 if rune1 == eof { 894 return 895 } 896 if isSpace(rune1) { 897 s.UnreadRune() 898 return 899 } 900 rune2 := s.mustReadRune() 901 return byte(s.hexDigit(rune1)<<4 | s.hexDigit(rune2)), true 902 } 903 904 // hexString returns the space-delimited hexpair-encoded string. 905 func (s *ss) hexString() string { 906 s.notEOF() 907 for { 908 b, ok := s.hexByte() 909 if !ok { 910 break 911 } 912 s.buf.WriteByte(b) 913 } 914 if len(s.buf) == 0 { 915 s.errorString("Scan: no hex data for %x string") 916 return "" 917 } 918 return string(s.buf) 919 } 920 921 const floatVerbs = "beEfFgGv" 922 923 const hugeWid = 1 << 30 924 925 // scanOne scans a single value, deriving the scanner from the type of the argument. 926 func (s *ss) scanOne(verb rune, field interface{}) { 927 s.buf = s.buf[:0] 928 var err error 929 // If the parameter has its own Scan method, use that. 930 if v, ok := field.(Scanner); ok { 931 err = v.Scan(s, verb) 932 if err != nil { 933 if err == io.EOF { 934 err = io.ErrUnexpectedEOF 935 } 936 s.error(err) 937 } 938 return 939 } 940 941 switch v := field.(type) { 942 case *bool: 943 *v = s.scanBool(verb) 944 case *complex64: 945 *v = complex64(s.scanComplex(verb, 64)) 946 case *complex128: 947 *v = s.scanComplex(verb, 128) 948 case *int: 949 *v = int(s.scanInt(verb, intBits)) 950 case *int8: 951 *v = int8(s.scanInt(verb, 8)) 952 case *int16: 953 *v = int16(s.scanInt(verb, 16)) 954 case *int32: 955 *v = int32(s.scanInt(verb, 32)) 956 case *int64: 957 *v = s.scanInt(verb, 64) 958 case *uint: 959 *v = uint(s.scanUint(verb, intBits)) 960 case *uint8: 961 *v = uint8(s.scanUint(verb, 8)) 962 case *uint16: 963 *v = uint16(s.scanUint(verb, 16)) 964 case *uint32: 965 *v = uint32(s.scanUint(verb, 32)) 966 case *uint64: 967 *v = s.scanUint(verb, 64) 968 case *uintptr: 969 *v = uintptr(s.scanUint(verb, uintptrBits)) 970 // Floats are tricky because you want to scan in the precision of the result, not 971 // scan in high precision and convert, in order to preserve the correct error condition. 972 case *float32: 973 if s.okVerb(verb, floatVerbs, "float32") { 974 s.skipSpace(false) 975 s.notEOF() 976 *v = float32(s.convertFloat(s.floatToken(), 32)) 977 } 978 case *float64: 979 if s.okVerb(verb, floatVerbs, "float64") { 980 s.skipSpace(false) 981 s.notEOF() 982 *v = s.convertFloat(s.floatToken(), 64) 983 } 984 case *string: 985 *v = s.convertString(verb) 986 case *[]byte: 987 // We scan to string and convert so we get a copy of the data. 988 // If we scanned to bytes, the slice would point at the buffer. 989 *v = []byte(s.convertString(verb)) 990 default: 991 val := reflect.ValueOf(v) 992 ptr := val 993 if ptr.Kind() != reflect.Ptr { 994 s.errorString("Scan: type not a pointer: " + val.Type().String()) 995 return 996 } 997 switch v := ptr.Elem(); v.Kind() { 998 case reflect.Bool: 999 v.SetBool(s.scanBool(verb)) 1000 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1001 v.SetInt(s.scanInt(verb, v.Type().Bits())) 1002 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1003 v.SetUint(s.scanUint(verb, v.Type().Bits())) 1004 case reflect.String: 1005 v.SetString(s.convertString(verb)) 1006 case reflect.Slice: 1007 // For now, can only handle (renamed) []byte. 1008 typ := v.Type() 1009 if typ.Elem().Kind() != reflect.Uint8 { 1010 s.errorString("Scan: can't handle type: " + val.Type().String()) 1011 } 1012 str := s.convertString(verb) 1013 v.Set(reflect.MakeSlice(typ, len(str), len(str))) 1014 for i := 0; i < len(str); i++ { 1015 v.Index(i).SetUint(uint64(str[i])) 1016 } 1017 case reflect.Float32, reflect.Float64: 1018 s.skipSpace(false) 1019 s.notEOF() 1020 v.SetFloat(s.convertFloat(s.floatToken(), v.Type().Bits())) 1021 case reflect.Complex64, reflect.Complex128: 1022 v.SetComplex(s.scanComplex(verb, v.Type().Bits())) 1023 default: 1024 s.errorString("Scan: can't handle type: " + val.Type().String()) 1025 } 1026 } 1027 } 1028 1029 // errorHandler turns local panics into error returns. 1030 func errorHandler(errp *error) { 1031 if e := recover(); e != nil { 1032 if se, ok := e.(scanError); ok { // catch local error 1033 *errp = se.err 1034 } else if eof, ok := e.(error); ok && eof == io.EOF { // out of input 1035 *errp = eof 1036 } else { 1037 panic(e) 1038 } 1039 } 1040 } 1041 1042 // doScan does the real work for scanning without a format string. 1043 func (s *ss) doScan(a []interface{}) (numProcessed int, err error) { 1044 defer errorHandler(&err) 1045 for _, field := range a { 1046 s.scanOne('v', field) 1047 numProcessed++ 1048 } 1049 // Check for newline if required. 1050 if !s.nlIsSpace { 1051 for { 1052 r := s.getRune() 1053 if r == '\n' || r == eof { 1054 break 1055 } 1056 if !isSpace(r) { 1057 s.errorString("Scan: expected newline") 1058 break 1059 } 1060 } 1061 } 1062 return 1063 } 1064 1065 // advance determines whether the next characters in the input match 1066 // those of the format. It returns the number of bytes (sic) consumed 1067 // in the format. Newlines included, all runs of space characters in 1068 // either input or format behave as a single space. This routine also 1069 // handles the %% case. If the return value is zero, either format 1070 // starts with a % (with no following %) or the input is empty. 1071 // If it is negative, the input did not match the string. 1072 func (s *ss) advance(format string) (i int) { 1073 for i < len(format) { 1074 fmtc, w := utf8.DecodeRuneInString(format[i:]) 1075 if fmtc == '%' { 1076 // %% acts like a real percent 1077 nextc, _ := utf8.DecodeRuneInString(format[i+w:]) // will not match % if string is empty 1078 if nextc != '%' { 1079 return 1080 } 1081 i += w // skip the first % 1082 } 1083 sawSpace := false 1084 for isSpace(fmtc) && i < len(format) { 1085 sawSpace = true 1086 i += w 1087 fmtc, w = utf8.DecodeRuneInString(format[i:]) 1088 } 1089 if sawSpace { 1090 // There was space in the format, so there should be space (EOF) 1091 // in the input. 1092 inputc := s.getRune() 1093 if inputc == eof { 1094 return 1095 } 1096 if !isSpace(inputc) { 1097 // Space in format but not in input: error 1098 s.errorString("expected space in input to match format") 1099 } 1100 s.skipSpace(true) 1101 continue 1102 } 1103 inputc := s.mustReadRune() 1104 if fmtc != inputc { 1105 s.UnreadRune() 1106 return -1 1107 } 1108 i += w 1109 } 1110 return 1111 } 1112 1113 // doScanf does the real work when scanning with a format string. 1114 // At the moment, it handles only pointers to basic types. 1115 func (s *ss) doScanf(format string, a []interface{}) (numProcessed int, err error) { 1116 defer errorHandler(&err) 1117 end := len(format) - 1 1118 // We process one item per non-trivial format 1119 for i := 0; i <= end; { 1120 w := s.advance(format[i:]) 1121 if w > 0 { 1122 i += w 1123 continue 1124 } 1125 // Either we failed to advance, we have a percent character, or we ran out of input. 1126 if format[i] != '%' { 1127 // Can't advance format. Why not? 1128 if w < 0 { 1129 s.errorString("input does not match format") 1130 } 1131 // Otherwise at EOF; "too many operands" error handled below 1132 break 1133 } 1134 i++ // % is one byte 1135 1136 // do we have 20 (width)? 1137 var widPresent bool 1138 s.maxWid, widPresent, i = parsenum(format, i, end) 1139 if !widPresent { 1140 s.maxWid = hugeWid 1141 } 1142 s.fieldLimit = s.limit 1143 if f := s.count + s.maxWid; f < s.fieldLimit { 1144 s.fieldLimit = f 1145 } 1146 1147 c, w := utf8.DecodeRuneInString(format[i:]) 1148 i += w 1149 1150 if numProcessed >= len(a) { // out of operands 1151 s.errorString("too few operands for format %" + format[i-w:]) 1152 break 1153 } 1154 field := a[numProcessed] 1155 1156 s.scanOne(c, field) 1157 numProcessed++ 1158 s.fieldLimit = s.limit 1159 } 1160 if numProcessed < len(a) { 1161 s.errorString("too many operands") 1162 } 1163 return 1164 }