...
Run Format

Source file src/go/scanner/scanner.go

Documentation: go/scanner

  // Copyright 2009 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 scanner implements a scanner for Go source text.
  // It takes a []byte as source which can then be tokenized
  // through repeated calls to the Scan method.
  //
  package scanner
  
  import (
  	"bytes"
  	"fmt"
  	"go/token"
  	"path/filepath"
  	"strconv"
  	"unicode"
  	"unicode/utf8"
  )
  
  // An ErrorHandler may be provided to Scanner.Init. If a syntax error is
  // encountered and a handler was installed, the handler is called with a
  // position and an error message. The position points to the beginning of
  // the offending token.
  //
  type ErrorHandler func(pos token.Position, msg string)
  
  // A Scanner holds the scanner's internal state while processing
  // a given text. It can be allocated as part of another data
  // structure but must be initialized via Init before use.
  //
  type Scanner struct {
  	// immutable state
  	file *token.File  // source file handle
  	dir  string       // directory portion of file.Name()
  	src  []byte       // source
  	err  ErrorHandler // error reporting; or nil
  	mode Mode         // scanning mode
  
  	// scanning state
  	ch         rune // current character
  	offset     int  // character offset
  	rdOffset   int  // reading offset (position after current character)
  	lineOffset int  // current line offset
  	insertSemi bool // insert a semicolon before next newline
  
  	// public state - ok to modify
  	ErrorCount int // number of errors encountered
  }
  
  const bom = 0xFEFF // byte order mark, only permitted as very first character
  
  // Read the next Unicode char into s.ch.
  // s.ch < 0 means end-of-file.
  //
  func (s *Scanner) next() {
  	if s.rdOffset < len(s.src) {
  		s.offset = s.rdOffset
  		if s.ch == '\n' {
  			s.lineOffset = s.offset
  			s.file.AddLine(s.offset)
  		}
  		r, w := rune(s.src[s.rdOffset]), 1
  		switch {
  		case r == 0:
  			s.error(s.offset, "illegal character NUL")
  		case r >= utf8.RuneSelf:
  			// not ASCII
  			r, w = utf8.DecodeRune(s.src[s.rdOffset:])
  			if r == utf8.RuneError && w == 1 {
  				s.error(s.offset, "illegal UTF-8 encoding")
  			} else if r == bom && s.offset > 0 {
  				s.error(s.offset, "illegal byte order mark")
  			}
  		}
  		s.rdOffset += w
  		s.ch = r
  	} else {
  		s.offset = len(s.src)
  		if s.ch == '\n' {
  			s.lineOffset = s.offset
  			s.file.AddLine(s.offset)
  		}
  		s.ch = -1 // eof
  	}
  }
  
  // A mode value is a set of flags (or 0).
  // They control scanner behavior.
  //
  type Mode uint
  
  const (
  	ScanComments    Mode = 1 << iota // return comments as COMMENT tokens
  	dontInsertSemis                  // do not automatically insert semicolons - for testing only
  )
  
  // Init prepares the scanner s to tokenize the text src by setting the
  // scanner at the beginning of src. The scanner uses the file set file
  // for position information and it adds line information for each line.
  // It is ok to re-use the same file when re-scanning the same file as
  // line information which is already present is ignored. Init causes a
  // panic if the file size does not match the src size.
  //
  // Calls to Scan will invoke the error handler err if they encounter a
  // syntax error and err is not nil. Also, for each error encountered,
  // the Scanner field ErrorCount is incremented by one. The mode parameter
  // determines how comments are handled.
  //
  // Note that Init may call err if there is an error in the first character
  // of the file.
  //
  func (s *Scanner) Init(file *token.File, src []byte, err ErrorHandler, mode Mode) {
  	// Explicitly initialize all fields since a scanner may be reused.
  	if file.Size() != len(src) {
  		panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
  	}
  	s.file = file
  	s.dir, _ = filepath.Split(file.Name())
  	s.src = src
  	s.err = err
  	s.mode = mode
  
  	s.ch = ' '
  	s.offset = 0
  	s.rdOffset = 0
  	s.lineOffset = 0
  	s.insertSemi = false
  	s.ErrorCount = 0
  
  	s.next()
  	if s.ch == bom {
  		s.next() // ignore BOM at file beginning
  	}
  }
  
  func (s *Scanner) error(offs int, msg string) {
  	if s.err != nil {
  		s.err(s.file.Position(s.file.Pos(offs)), msg)
  	}
  	s.ErrorCount++
  }
  
  var prefix = []byte("//line ")
  
  func (s *Scanner) interpretLineComment(text []byte) {
  	if bytes.HasPrefix(text, prefix) {
  		// get filename and line number, if any
  		if i := bytes.LastIndex(text, []byte{':'}); i > 0 {
  			if line, err := strconv.Atoi(string(text[i+1:])); err == nil && line > 0 {
  				// valid //line filename:line comment
  				filename := string(bytes.TrimSpace(text[len(prefix):i]))
  				if filename != "" {
  					filename = filepath.Clean(filename)
  					if !filepath.IsAbs(filename) {
  						// make filename relative to current directory
  						filename = filepath.Join(s.dir, filename)
  					}
  				}
  				// update scanner position
  				s.file.AddLineInfo(s.lineOffset+len(text)+1, filename, line) // +len(text)+1 since comment applies to next line
  			}
  		}
  	}
  }
  
  func (s *Scanner) scanComment() string {
  	// initial '/' already consumed; s.ch == '/' || s.ch == '*'
  	offs := s.offset - 1 // position of initial '/'
  	hasCR := false
  
  	if s.ch == '/' {
  		//-style comment
  		s.next()
  		for s.ch != '\n' && s.ch >= 0 {
  			if s.ch == '\r' {
  				hasCR = true
  			}
  			s.next()
  		}
  		if offs == s.lineOffset {
  			// comment starts at the beginning of the current line
  			s.interpretLineComment(s.src[offs:s.offset])
  		}
  		goto exit
  	}
  
  	/*-style comment */
  	s.next()
  	for s.ch >= 0 {
  		ch := s.ch
  		if ch == '\r' {
  			hasCR = true
  		}
  		s.next()
  		if ch == '*' && s.ch == '/' {
  			s.next()
  			goto exit
  		}
  	}
  
  	s.error(offs, "comment not terminated")
  
  exit:
  	lit := s.src[offs:s.offset]
  	if hasCR {
  		lit = stripCR(lit)
  	}
  
  	return string(lit)
  }
  
  func (s *Scanner) findLineEnd() bool {
  	// initial '/' already consumed
  
  	defer func(offs int) {
  		// reset scanner state to where it was upon calling findLineEnd
  		s.ch = '/'
  		s.offset = offs
  		s.rdOffset = offs + 1
  		s.next() // consume initial '/' again
  	}(s.offset - 1)
  
  	// read ahead until a newline, EOF, or non-comment token is found
  	for s.ch == '/' || s.ch == '*' {
  		if s.ch == '/' {
  			//-style comment always contains a newline
  			return true
  		}
  		/*-style comment: look for newline */
  		s.next()
  		for s.ch >= 0 {
  			ch := s.ch
  			if ch == '\n' {
  				return true
  			}
  			s.next()
  			if ch == '*' && s.ch == '/' {
  				s.next()
  				break
  			}
  		}
  		s.skipWhitespace() // s.insertSemi is set
  		if s.ch < 0 || s.ch == '\n' {
  			return true
  		}
  		if s.ch != '/' {
  			// non-comment token
  			return false
  		}
  		s.next() // consume '/'
  	}
  
  	return false
  }
  
  func isLetter(ch rune) bool {
  	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
  }
  
  func isDigit(ch rune) bool {
  	return '0' <= ch && ch <= '9' || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
  }
  
  func (s *Scanner) scanIdentifier() string {
  	offs := s.offset
  	for isLetter(s.ch) || isDigit(s.ch) {
  		s.next()
  	}
  	return string(s.src[offs:s.offset])
  }
  
  func digitVal(ch rune) int {
  	switch {
  	case '0' <= ch && ch <= '9':
  		return int(ch - '0')
  	case 'a' <= ch && ch <= 'f':
  		return int(ch - 'a' + 10)
  	case 'A' <= ch && ch <= 'F':
  		return int(ch - 'A' + 10)
  	}
  	return 16 // larger than any legal digit val
  }
  
  func (s *Scanner) scanMantissa(base int) {
  	for digitVal(s.ch) < base {
  		s.next()
  	}
  }
  
  func (s *Scanner) scanNumber(seenDecimalPoint bool) (token.Token, string) {
  	// digitVal(s.ch) < 10
  	offs := s.offset
  	tok := token.INT
  
  	if seenDecimalPoint {
  		offs--
  		tok = token.FLOAT
  		s.scanMantissa(10)
  		goto exponent
  	}
  
  	if s.ch == '0' {
  		// int or float
  		offs := s.offset
  		s.next()
  		if s.ch == 'x' || s.ch == 'X' {
  			// hexadecimal int
  			s.next()
  			s.scanMantissa(16)
  			if s.offset-offs <= 2 {
  				// only scanned "0x" or "0X"
  				s.error(offs, "illegal hexadecimal number")
  			}
  		} else {
  			// octal int or float
  			seenDecimalDigit := false
  			s.scanMantissa(8)
  			if s.ch == '8' || s.ch == '9' {
  				// illegal octal int or float
  				seenDecimalDigit = true
  				s.scanMantissa(10)
  			}
  			if s.ch == '.' || s.ch == 'e' || s.ch == 'E' || s.ch == 'i' {
  				goto fraction
  			}
  			// octal int
  			if seenDecimalDigit {
  				s.error(offs, "illegal octal number")
  			}
  		}
  		goto exit
  	}
  
  	// decimal int or float
  	s.scanMantissa(10)
  
  fraction:
  	if s.ch == '.' {
  		tok = token.FLOAT
  		s.next()
  		s.scanMantissa(10)
  	}
  
  exponent:
  	if s.ch == 'e' || s.ch == 'E' {
  		tok = token.FLOAT
  		s.next()
  		if s.ch == '-' || s.ch == '+' {
  			s.next()
  		}
  		if digitVal(s.ch) < 10 {
  			s.scanMantissa(10)
  		} else {
  			s.error(offs, "illegal floating-point exponent")
  		}
  	}
  
  	if s.ch == 'i' {
  		tok = token.IMAG
  		s.next()
  	}
  
  exit:
  	return tok, string(s.src[offs:s.offset])
  }
  
  // scanEscape parses an escape sequence where rune is the accepted
  // escaped quote. In case of a syntax error, it stops at the offending
  // character (without consuming it) and returns false. Otherwise
  // it returns true.
  func (s *Scanner) scanEscape(quote rune) bool {
  	offs := s.offset
  
  	var n int
  	var base, max uint32
  	switch s.ch {
  	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
  		s.next()
  		return true
  	case '0', '1', '2', '3', '4', '5', '6', '7':
  		n, base, max = 3, 8, 255
  	case 'x':
  		s.next()
  		n, base, max = 2, 16, 255
  	case 'u':
  		s.next()
  		n, base, max = 4, 16, unicode.MaxRune
  	case 'U':
  		s.next()
  		n, base, max = 8, 16, unicode.MaxRune
  	default:
  		msg := "unknown escape sequence"
  		if s.ch < 0 {
  			msg = "escape sequence not terminated"
  		}
  		s.error(offs, msg)
  		return false
  	}
  
  	var x uint32
  	for n > 0 {
  		d := uint32(digitVal(s.ch))
  		if d >= base {
  			msg := fmt.Sprintf("illegal character %#U in escape sequence", s.ch)
  			if s.ch < 0 {
  				msg = "escape sequence not terminated"
  			}
  			s.error(s.offset, msg)
  			return false
  		}
  		x = x*base + d
  		s.next()
  		n--
  	}
  
  	if x > max || 0xD800 <= x && x < 0xE000 {
  		s.error(offs, "escape sequence is invalid Unicode code point")
  		return false
  	}
  
  	return true
  }
  
  func (s *Scanner) scanRune() string {
  	// '\'' opening already consumed
  	offs := s.offset - 1
  
  	valid := true
  	n := 0
  	for {
  		ch := s.ch
  		if ch == '\n' || ch < 0 {
  			// only report error if we don't have one already
  			if valid {
  				s.error(offs, "rune literal not terminated")
  				valid = false
  			}
  			break
  		}
  		s.next()
  		if ch == '\'' {
  			break
  		}
  		n++
  		if ch == '\\' {
  			if !s.scanEscape('\'') {
  				valid = false
  			}
  			// continue to read to closing quote
  		}
  	}
  
  	if valid && n != 1 {
  		s.error(offs, "illegal rune literal")
  	}
  
  	return string(s.src[offs:s.offset])
  }
  
  func (s *Scanner) scanString() string {
  	// '"' opening already consumed
  	offs := s.offset - 1
  
  	for {
  		ch := s.ch
  		if ch == '\n' || ch < 0 {
  			s.error(offs, "string literal not terminated")
  			break
  		}
  		s.next()
  		if ch == '"' {
  			break
  		}
  		if ch == '\\' {
  			s.scanEscape('"')
  		}
  	}
  
  	return string(s.src[offs:s.offset])
  }
  
  func stripCR(b []byte) []byte {
  	c := make([]byte, len(b))
  	i := 0
  	for _, ch := range b {
  		if ch != '\r' {
  			c[i] = ch
  			i++
  		}
  	}
  	return c[:i]
  }
  
  func (s *Scanner) scanRawString() string {
  	// '`' opening already consumed
  	offs := s.offset - 1
  
  	hasCR := false
  	for {
  		ch := s.ch
  		if ch < 0 {
  			s.error(offs, "raw string literal not terminated")
  			break
  		}
  		s.next()
  		if ch == '`' {
  			break
  		}
  		if ch == '\r' {
  			hasCR = true
  		}
  	}
  
  	lit := s.src[offs:s.offset]
  	if hasCR {
  		lit = stripCR(lit)
  	}
  
  	return string(lit)
  }
  
  func (s *Scanner) skipWhitespace() {
  	for s.ch == ' ' || s.ch == '\t' || s.ch == '\n' && !s.insertSemi || s.ch == '\r' {
  		s.next()
  	}
  }
  
  // Helper functions for scanning multi-byte tokens such as >> += >>= .
  // Different routines recognize different length tok_i based on matches
  // of ch_i. If a token ends in '=', the result is tok1 or tok3
  // respectively. Otherwise, the result is tok0 if there was no other
  // matching character, or tok2 if the matching character was ch2.
  
  func (s *Scanner) switch2(tok0, tok1 token.Token) token.Token {
  	if s.ch == '=' {
  		s.next()
  		return tok1
  	}
  	return tok0
  }
  
  func (s *Scanner) switch3(tok0, tok1 token.Token, ch2 rune, tok2 token.Token) token.Token {
  	if s.ch == '=' {
  		s.next()
  		return tok1
  	}
  	if s.ch == ch2 {
  		s.next()
  		return tok2
  	}
  	return tok0
  }
  
  func (s *Scanner) switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Token) token.Token {
  	if s.ch == '=' {
  		s.next()
  		return tok1
  	}
  	if s.ch == ch2 {
  		s.next()
  		if s.ch == '=' {
  			s.next()
  			return tok3
  		}
  		return tok2
  	}
  	return tok0
  }
  
  // Scan scans the next token and returns the token position, the token,
  // and its literal string if applicable. The source end is indicated by
  // token.EOF.
  //
  // If the returned token is a literal (token.IDENT, token.INT, token.FLOAT,
  // token.IMAG, token.CHAR, token.STRING) or token.COMMENT, the literal string
  // has the corresponding value.
  //
  // If the returned token is a keyword, the literal string is the keyword.
  //
  // If the returned token is token.SEMICOLON, the corresponding
  // literal string is ";" if the semicolon was present in the source,
  // and "\n" if the semicolon was inserted because of a newline or
  // at EOF.
  //
  // If the returned token is token.ILLEGAL, the literal string is the
  // offending character.
  //
  // In all other cases, Scan returns an empty literal string.
  //
  // For more tolerant parsing, Scan will return a valid token if
  // possible even if a syntax error was encountered. Thus, even
  // if the resulting token sequence contains no illegal tokens,
  // a client may not assume that no error occurred. Instead it
  // must check the scanner's ErrorCount or the number of calls
  // of the error handler, if there was one installed.
  //
  // Scan adds line information to the file added to the file
  // set with Init. Token positions are relative to that file
  // and thus relative to the file set.
  //
  func (s *Scanner) Scan() (pos token.Pos, tok token.Token, lit string) {
  scanAgain:
  	s.skipWhitespace()
  
  	// current token start
  	pos = s.file.Pos(s.offset)
  
  	// determine token value
  	insertSemi := false
  	switch ch := s.ch; {
  	case isLetter(ch):
  		lit = s.scanIdentifier()
  		if len(lit) > 1 {
  			// keywords are longer than one letter - avoid lookup otherwise
  			tok = token.Lookup(lit)
  			switch tok {
  			case token.IDENT, token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN:
  				insertSemi = true
  			}
  		} else {
  			insertSemi = true
  			tok = token.IDENT
  		}
  	case '0' <= ch && ch <= '9':
  		insertSemi = true
  		tok, lit = s.scanNumber(false)
  	default:
  		s.next() // always make progress
  		switch ch {
  		case -1:
  			if s.insertSemi {
  				s.insertSemi = false // EOF consumed
  				return pos, token.SEMICOLON, "\n"
  			}
  			tok = token.EOF
  		case '\n':
  			// we only reach here if s.insertSemi was
  			// set in the first place and exited early
  			// from s.skipWhitespace()
  			s.insertSemi = false // newline consumed
  			return pos, token.SEMICOLON, "\n"
  		case '"':
  			insertSemi = true
  			tok = token.STRING
  			lit = s.scanString()
  		case '\'':
  			insertSemi = true
  			tok = token.CHAR
  			lit = s.scanRune()
  		case '`':
  			insertSemi = true
  			tok = token.STRING
  			lit = s.scanRawString()
  		case ':':
  			tok = s.switch2(token.COLON, token.DEFINE)
  		case '.':
  			if '0' <= s.ch && s.ch <= '9' {
  				insertSemi = true
  				tok, lit = s.scanNumber(true)
  			} else if s.ch == '.' {
  				s.next()
  				if s.ch == '.' {
  					s.next()
  					tok = token.ELLIPSIS
  				}
  			} else {
  				tok = token.PERIOD
  			}
  		case ',':
  			tok = token.COMMA
  		case ';':
  			tok = token.SEMICOLON
  			lit = ";"
  		case '(':
  			tok = token.LPAREN
  		case ')':
  			insertSemi = true
  			tok = token.RPAREN
  		case '[':
  			tok = token.LBRACK
  		case ']':
  			insertSemi = true
  			tok = token.RBRACK
  		case '{':
  			tok = token.LBRACE
  		case '}':
  			insertSemi = true
  			tok = token.RBRACE
  		case '+':
  			tok = s.switch3(token.ADD, token.ADD_ASSIGN, '+', token.INC)
  			if tok == token.INC {
  				insertSemi = true
  			}
  		case '-':
  			tok = s.switch3(token.SUB, token.SUB_ASSIGN, '-', token.DEC)
  			if tok == token.DEC {
  				insertSemi = true
  			}
  		case '*':
  			tok = s.switch2(token.MUL, token.MUL_ASSIGN)
  		case '/':
  			if s.ch == '/' || s.ch == '*' {
  				// comment
  				if s.insertSemi && s.findLineEnd() {
  					// reset position to the beginning of the comment
  					s.ch = '/'
  					s.offset = s.file.Offset(pos)
  					s.rdOffset = s.offset + 1
  					s.insertSemi = false // newline consumed
  					return pos, token.SEMICOLON, "\n"
  				}
  				comment := s.scanComment()
  				if s.mode&ScanComments == 0 {
  					// skip comment
  					s.insertSemi = false // newline consumed
  					goto scanAgain
  				}
  				tok = token.COMMENT
  				lit = comment
  			} else {
  				tok = s.switch2(token.QUO, token.QUO_ASSIGN)
  			}
  		case '%':
  			tok = s.switch2(token.REM, token.REM_ASSIGN)
  		case '^':
  			tok = s.switch2(token.XOR, token.XOR_ASSIGN)
  		case '<':
  			if s.ch == '-' {
  				s.next()
  				tok = token.ARROW
  			} else {
  				tok = s.switch4(token.LSS, token.LEQ, '<', token.SHL, token.SHL_ASSIGN)
  			}
  		case '>':
  			tok = s.switch4(token.GTR, token.GEQ, '>', token.SHR, token.SHR_ASSIGN)
  		case '=':
  			tok = s.switch2(token.ASSIGN, token.EQL)
  		case '!':
  			tok = s.switch2(token.NOT, token.NEQ)
  		case '&':
  			if s.ch == '^' {
  				s.next()
  				tok = s.switch2(token.AND_NOT, token.AND_NOT_ASSIGN)
  			} else {
  				tok = s.switch3(token.AND, token.AND_ASSIGN, '&', token.LAND)
  			}
  		case '|':
  			tok = s.switch3(token.OR, token.OR_ASSIGN, '|', token.LOR)
  		default:
  			// next reports unexpected BOMs - don't repeat
  			if ch != bom {
  				s.error(s.file.Offset(pos), fmt.Sprintf("illegal character %#U", ch))
  			}
  			insertSemi = s.insertSemi // preserve insertSemi info
  			tok = token.ILLEGAL
  			lit = string(ch)
  		}
  	}
  	if s.mode&dontInsertSemis == 0 {
  		s.insertSemi = insertSemi
  	}
  
  	return
  }
  

View as plain text