/third_party/gofrontend/libgo/go/go/scanner/scanner.go
Go | 761 lines | 629 code | 55 blank | 77 comment | 182 complexity | 06aefca2fd87c7e4aaaae997bb52d19b MD5 | raw file
Possible License(s): BSD-3-Clause, MIT
- // 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 >= 0x80:
- // 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 >= 0x80 && unicode.IsLetter(ch)
- }
- func isDigit(ch rune) bool {
- return '0' <= ch && ch <= '9' || ch >= 0x80 && 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()
- }
- s.scanMantissa(10)
- }
- 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
- }