package parser import ( "fmt" "unicode" "unicode/utf8" "github.com/d5/tengo/v2/token" ) // byte order mark const bom = 0xFEFF // ScanMode represents a scanner mode. type ScanMode int // List of scanner modes. const ( ScanComments ScanMode = 1 << iota DontInsertSemis ) // ScannerErrorHandler is an error handler for the scanner. type ScannerErrorHandler func(pos SourceFilePos, msg string) // Scanner reads the Tengo source text. It's based on Go's scanner // implementation. type Scanner struct { file *SourceFile // source file handle src []byte // source ch rune // current character offset int // character offset readOffset int // reading offset (position after current character) lineOffset int // current line offset insertSemi bool // insert a semicolon before next newline errorHandler ScannerErrorHandler // error reporting; or nil errorCount int // number of errors encountered mode ScanMode } // NewScanner creates a Scanner. func NewScanner( file *SourceFile, src []byte, errorHandler ScannerErrorHandler, mode ScanMode, ) *Scanner { if file.Size != len(src) { panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size, len(src))) } s := &Scanner{ file: file, src: src, errorHandler: errorHandler, ch: ' ', mode: mode, } s.next() if s.ch == bom { s.next() // ignore BOM at file beginning } return s } // ErrorCount returns the number of errors. func (s *Scanner) ErrorCount() int { return s.errorCount } // Scan returns a token, token literal and its position. func (s *Scanner) Scan() ( tok token.Token, literal string, pos Pos, ) { s.skipWhitespace() pos = s.file.FileSetPos(s.offset) insertSemi := false // determine token value switch ch := s.ch; { case isLetter(ch): literal = s.scanIdentifier() tok = token.Lookup(literal) switch tok { case token.Ident, token.Break, token.Continue, token.Return, token.Export, token.True, token.False, token.Undefined: insertSemi = true } case '0' <= ch && ch <= '9': insertSemi = true tok, literal = s.scanNumber(false) default: s.next() // always make progress switch ch { case -1: // EOF if s.insertSemi { s.insertSemi = false // EOF consumed return token.Semicolon, "\n", pos } tok = token.EOF case '\n': // we only reach here if s.insertSemi was set in the first place s.insertSemi = false // newline consumed return token.Semicolon, "\n", pos case '"': insertSemi = true tok = token.String literal = s.scanString() case '\'': insertSemi = true tok = token.Char literal = s.scanRune() case '`': insertSemi = true tok = token.String literal = s.scanRawString() case ':': tok = s.switch2(token.Colon, token.Define) case '.': if '0' <= s.ch && s.ch <= '9' { insertSemi = true tok, literal = s.scanNumber(true) } else { tok = token.Period if s.ch == '.' && s.peek() == '.' { s.next() s.next() // consume last '.' tok = token.Ellipsis } } case ',': tok = token.Comma case '?': tok = token.Question case ';': tok = token.Semicolon literal = ";" 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.AddAssign, '+', token.Inc) if tok == token.Inc { insertSemi = true } case '-': tok = s.switch3(token.Sub, token.SubAssign, '-', token.Dec) if tok == token.Dec { insertSemi = true } case '*': tok = s.switch2(token.Mul, token.MulAssign) 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.readOffset = s.offset + 1 s.insertSemi = false // newline consumed return token.Semicolon, "\n", pos } comment := s.scanComment() if s.mode&ScanComments == 0 { // skip comment s.insertSemi = false // newline consumed return s.Scan() } tok = token.Comment literal = comment } else { tok = s.switch2(token.Quo, token.QuoAssign) } case '%': tok = s.switch2(token.Rem, token.RemAssign) case '^': tok = s.switch2(token.Xor, token.XorAssign) case '<': tok = s.switch4(token.Less, token.LessEq, '<', token.Shl, token.ShlAssign) case '>': tok = s.switch4(token.Greater, token.GreaterEq, '>', token.Shr, token.ShrAssign) case '=': tok = s.switch2(token.Assign, token.Equal) case '!': tok = s.switch2(token.Not, token.NotEqual) case '&': if s.ch == '^' { s.next() tok = s.switch2(token.AndNot, token.AndNotAssign) } else { tok = s.switch3(token.And, token.AndAssign, '&', token.LAnd) } case '|': tok = s.switch3(token.Or, token.OrAssign, '|', 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 literal = string(ch) } } if s.mode&DontInsertSemis == 0 { s.insertSemi = insertSemi } return } func (s *Scanner) next() { if s.readOffset < len(s.src) { s.offset = s.readOffset if s.ch == '\n' { s.lineOffset = s.offset s.file.AddLine(s.offset) } r, w := rune(s.src[s.readOffset]), 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.readOffset:]) 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.readOffset += 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 } } func (s *Scanner) peek() byte { if s.readOffset < len(s.src) { return s.src[s.readOffset] } return 0 } func (s *Scanner) error(offset int, msg string) { if s.errorHandler != nil { s.errorHandler(s.file.Position(s.file.FileSetPos(offset)), msg) } s.errorCount++ } func (s *Scanner) scanComment() string { // initial '/' already consumed; s.ch == '/' || s.ch == '*' offs := s.offset - 1 // position of initial '/' var numCR int if s.ch == '/' { //-style comment // (the final '\n' is not considered part of the comment) s.next() for s.ch != '\n' && s.ch >= 0 { if s.ch == '\r' { numCR++ } s.next() } goto exit } /*-style comment */ s.next() for s.ch >= 0 { ch := s.ch if ch == '\r' { numCR++ } s.next() if ch == '*' && s.ch == '/' { s.next() goto exit } } s.error(offs, "comment not terminated") exit: lit := s.src[offs:s.offset] // On Windows, a (//-comment) line may end in "\r\n". // Remove the final '\r' before analyzing the text for line directives (matching the compiler). // Remove any other '\r' afterwards (matching the pre-existing behavior of the scanner). if numCR > 0 && len(lit) >= 2 && lit[1] == '/' && lit[len(lit)-1] == '\r' { lit = lit[:len(lit)-1] numCR-- } if numCR > 0 { lit = StripCR(lit, lit[1] == '*') } 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.readOffset = offs + 1 s.next() // consume initial '/' again }(s.offset - 1) // read ahead until a newline, EOF, or non-comment tok 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 tok return false } s.next() // consume '/' } return false } 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 (s *Scanner) scanMantissa(base int) { for digitVal(s.ch) < base { s.next() } } func (s *Scanner) scanNumber( seenDecimalPoint bool, ) (tok token.Token, lit string) { // digitVal(s.ch) < 10 offs := s.offset tok = token.Int defer func() { lit = string(s.src[offs:s.offset]) }() 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") } } return } // 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") } } return } 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 { offs := s.offset - 1 // '\'' opening already consumed 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 { offs := s.offset - 1 // '"' opening already consumed 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 (s *Scanner) scanRawString() string { offs := s.offset - 1 // '`' opening already consumed 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, false) } return string(lit) } // StripCR removes carriage return characters. func StripCR(b []byte, comment bool) []byte { c := make([]byte, len(b)) i := 0 for j, ch := range b { // In a /*-style comment, don't strip \r from *\r/ (incl. sequences of // \r from *\r\r...\r/) since the resulting */ would terminate the // comment too early unless the \r is immediately following the opening // /* in which case it's ok because /*/ is not closed yet. if ch != '\r' || comment && i > len("/*") && c[i-1] == '*' && j+1 < len(b) && b[j+1] == '/' { c[i] = ch i++ } } return c[:i] } func (s *Scanner) skipWhitespace() { for s.ch == ' ' || s.ch == '\t' || s.ch == '\n' && !s.insertSemi || s.ch == '\r' { s.next() } } 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 } 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 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 }