diff --git a/scanner.go b/scanner.go
index 4f2755a..bae23e1 100644
--- a/scanner.go
+++ b/scanner.go
@@ -49,257 +49,257 @@ func DefaultTranslations() map[Symbol]Symbol {
// return self.current
// }
-func (self *scanner) readChar() (ch byte, err error) {
- if ch, err = self.stream.ReadByte(); err == nil {
+func (scanner *scanner) readChar() (ch byte, err error) {
+ if ch, err = scanner.stream.ReadByte(); err == nil {
if ch == '\n' {
- self.row++
- self.column = 0
+ scanner.row++
+ scanner.column = 0
} else {
- self.column++
+ scanner.column++
}
}
return
}
-func (self *scanner) unreadChar() (err error) {
- if err = self.stream.UnreadByte(); err == nil {
- if self.column--; self.column == 0 {
- if self.row--; self.row == 0 {
+func (scanner *scanner) unreadChar() (err error) {
+ if err = scanner.stream.UnreadByte(); err == nil {
+ if scanner.column--; scanner.column == 0 {
+ if scanner.row--; scanner.row == 0 {
err = errors.New("unread beyond the stream boundary")
} else {
- self.column = 1
+ scanner.column = 1
}
}
}
return
}
-func (self *scanner) lastPos() (r, c int) {
- if self.prev != nil {
- r = self.prev.row
- c = self.prev.col
+func (scanner *scanner) lastPos() (r, c int) {
+ if scanner.prev != nil {
+ r = scanner.prev.row
+ c = scanner.prev.col
}
return
}
-func (self *scanner) Previous() *Token {
- return self.prev
+func (scanner *scanner) Previous() *Token {
+ return scanner.prev
}
-func (self *scanner) Next() (tk *Token) {
- self.prev = self.current
- tk = self.current
- self.current = self.fetchNextToken()
+func (scanner *scanner) Next() (tk *Token) {
+ scanner.prev = scanner.current
+ tk = scanner.current
+ scanner.current = scanner.fetchNextToken()
return tk
}
-func (self *scanner) fetchNextToken() (tk *Token) {
+func (scanner *scanner) fetchNextToken() (tk *Token) {
var ch byte
- if err := self.skipBlanks(); err != nil {
- return self.makeErrorToken(err)
+ if err := scanner.skipBlanks(); err != nil {
+ return scanner.makeErrorToken(err)
}
escape := false
for {
- ch, _ = self.readChar()
+ ch, _ = scanner.readChar()
switch ch {
case '+':
- if next, _ := self.peek(); next == '+' {
- tk = self.moveOn(SymDoublePlus, ch, next)
+ if next, _ := scanner.peek(); next == '+' {
+ tk = scanner.moveOn(SymDoublePlus, ch, next)
} else if next == '=' {
- tk = self.moveOn(SymPlusEqual, ch, next)
+ tk = scanner.moveOn(SymPlusEqual, ch, next)
} else {
- tk = self.makeToken(SymPlus, ch)
+ tk = scanner.makeToken(SymPlus, ch)
}
case '-':
- if next, _ := self.peek(); next == '-' {
- tk = self.moveOn(SymDoubleMinus, ch, next)
+ if next, _ := scanner.peek(); next == '-' {
+ tk = scanner.moveOn(SymDoubleMinus, ch, next)
} else if next == '=' {
- tk = self.moveOn(SymMinusEqual, ch, next)
+ tk = scanner.moveOn(SymMinusEqual, ch, next)
} else {
- tk = self.makeToken(SymMinus, ch)
+ tk = scanner.makeToken(SymMinus, ch)
}
case '*':
- if next, _ := self.peek(); next == '*' {
- tk = self.moveOn(SymDoubleStar, ch, next)
+ if next, _ := scanner.peek(); next == '*' {
+ tk = scanner.moveOn(SymDoubleStar, ch, next)
// } else if next == '/' {
// tk = self.moveOn(SymClosedComment, ch, next)
} else {
- tk = self.makeToken(SymStar, ch)
+ tk = scanner.makeToken(SymStar, ch)
}
case '/':
- if next, _ := self.peek(); next == '*' {
- self.readChar()
- tk = self.fetchBlockComment()
+ if next, _ := scanner.peek(); next == '*' {
+ scanner.readChar()
+ tk = scanner.fetchBlockComment()
} else if next == '/' {
- self.readChar()
- tk = self.fetchOnLineComment()
+ scanner.readChar()
+ tk = scanner.fetchOnLineComment()
} else {
- tk = self.makeToken(SymSlash, ch)
+ tk = scanner.makeToken(SymSlash, ch)
}
case '\\':
if escape {
- tk = self.makeToken(SymBackSlash, ch)
+ tk = scanner.makeToken(SymBackSlash, ch)
escape = false
} else {
escape = true
}
case '|':
- if next, _ := self.peek(); next == '|' {
- tk = self.moveOn(SymDoubleVertBar, ch, next)
+ if next, _ := scanner.peek(); next == '|' {
+ tk = scanner.moveOn(SymDoubleVertBar, ch, next)
} else {
- tk = self.makeToken(SymVertBar, ch)
+ tk = scanner.makeToken(SymVertBar, ch)
}
case ',':
- tk = self.makeToken(SymComma, ch)
+ tk = scanner.makeToken(SymComma, ch)
case '^':
- tk = self.makeToken(SymCaret, ch)
+ tk = scanner.makeToken(SymCaret, ch)
case ':':
- if next, _ := self.peek(); next == ':' {
- tk = self.moveOn(SymDoubleColon, ch, next)
+ if next, _ := scanner.peek(); next == ':' {
+ tk = scanner.moveOn(SymDoubleColon, ch, next)
} else {
- tk = self.makeToken(SymColon, ch)
+ tk = scanner.makeToken(SymColon, ch)
}
case ';':
- tk = self.makeToken(SymSemiColon, ch)
+ tk = scanner.makeToken(SymSemiColon, ch)
case '.':
//if next, _ := self.peek(); next >= '0' && next <= '9' {
// tk = self.parseNumber(ch)
//} else if next == '/' {
- if next, _ := self.peek(); next == '/' {
- tk = self.moveOn(SymDotSlash, ch, next)
+ if next, _ := scanner.peek(); next == '/' {
+ tk = scanner.moveOn(SymDotSlash, ch, next)
} else if next == '.' {
- if next1, _ := self.peek(); next1 == '.' {
- tk = self.moveOn(SymTripleDot, ch, next, next1)
+ if next1, _ := scanner.peek(); next1 == '.' {
+ tk = scanner.moveOn(SymTripleDot, ch, next, next1)
} else {
- tk = self.moveOn(SymDoubleDot, ch, next)
+ tk = scanner.moveOn(SymDoubleDot, ch, next)
}
} else {
- tk = self.makeToken(SymDot, ch)
+ tk = scanner.makeToken(SymDot, ch)
}
case '\'':
if escape {
- tk = self.makeToken(SymQuote, ch)
+ tk = scanner.makeToken(SymQuote, ch)
escape = false
} else {
- tk = self.fetchString(ch)
+ tk = scanner.fetchString(ch)
}
case '"':
if escape {
- tk = self.makeToken(SymDoubleQuote, ch)
+ tk = scanner.makeToken(SymDoubleQuote, ch)
escape = false
} else {
- tk = self.fetchString(ch)
+ tk = scanner.fetchString(ch)
}
case '`':
- tk = self.makeToken(SymBackTick, ch)
+ tk = scanner.makeToken(SymBackTick, ch)
case '!':
- if next, _ := self.peek(); next == '=' {
- tk = self.moveOn(SymNotEqual, ch, next)
+ if next, _ := scanner.peek(); next == '=' {
+ tk = scanner.moveOn(SymNotEqual, ch, next)
} else {
- tk = self.makeToken(SymExclamation, ch)
+ tk = scanner.makeToken(SymExclamation, ch)
}
case '?':
- if next, _ := self.peek(); next == '?' {
- tk = self.moveOn(SymDoubleQuestion, ch, next)
+ if next, _ := scanner.peek(); next == '?' {
+ tk = scanner.moveOn(SymDoubleQuestion, ch, next)
} else if next == '=' {
- tk = self.moveOn(SymQuestionEqual, ch, next)
+ tk = scanner.moveOn(SymQuestionEqual, ch, next)
} else if next == '!' {
- tk = self.moveOn(SymQuestionExclam, ch, next)
+ tk = scanner.moveOn(SymQuestionExclam, ch, next)
} else {
- tk = self.makeToken(SymQuestion, ch)
+ tk = scanner.makeToken(SymQuestion, ch)
}
case '&':
- if next, _ := self.peek(); next == '&' {
- tk = self.moveOn(SymDoubleAmpersand, ch, next)
+ if next, _ := scanner.peek(); next == '&' {
+ tk = scanner.moveOn(SymDoubleAmpersand, ch, next)
} else {
- tk = self.makeToken(SymAmpersand, ch)
+ tk = scanner.makeToken(SymAmpersand, ch)
}
case '%':
- tk = self.makeToken(SymPercent, ch)
+ tk = scanner.makeToken(SymPercent, ch)
case '#':
- tk = self.makeToken(SymHash, ch)
+ tk = scanner.makeToken(SymHash, ch)
case '@':
- if next, _ := self.peek(); (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
- self.readChar()
- if tk = self.fetchIdentifier(next); tk.Sym == SymIdentifier {
+ if next, _ := scanner.peek(); (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
+ scanner.readChar()
+ if tk = scanner.fetchIdentifier(next); tk.Sym == SymIdentifier {
//tk.Sym = SymIdRef
tk.source = "@" + tk.source
} else {
- tk = self.makeErrorToken(fmt.Errorf("invalid variable reference %q", tk.source))
+ tk = scanner.makeErrorToken(fmt.Errorf("invalid variable reference %q", tk.source))
}
} else if next == '@' {
- tk = self.moveOn(SymDoubleAt, ch, next)
+ tk = scanner.moveOn(SymDoubleAt, ch, next)
} else {
- tk = self.makeToken(SymAt, ch)
+ tk = scanner.makeToken(SymAt, ch)
}
case '_':
- tk = self.makeToken(SymUndescore, ch)
+ tk = scanner.makeToken(SymUndescore, ch)
case '=':
- if next, _ := self.peek(); next == '=' {
- tk = self.moveOn(SymDoubleEqual, ch, next)
+ if next, _ := scanner.peek(); next == '=' {
+ tk = scanner.moveOn(SymDoubleEqual, ch, next)
} else {
- tk = self.makeToken(SymEqual, ch)
+ tk = scanner.makeToken(SymEqual, ch)
}
case '<':
- if next, _ := self.peek(); next == '=' {
- tk = self.moveOn(SymLessOrEqual, ch, next)
+ if next, _ := scanner.peek(); next == '=' {
+ tk = scanner.moveOn(SymLessOrEqual, ch, next)
} else if next == '<' {
- tk = self.moveOn(SymAppend, ch, next)
+ tk = scanner.moveOn(SymAppend, ch, next)
} else if next == '>' {
- tk = self.moveOn(SymLessGreater, ch, next)
+ tk = scanner.moveOn(SymLessGreater, ch, next)
} else {
- tk = self.makeToken(SymLess, ch)
+ tk = scanner.makeToken(SymLess, ch)
}
case '>':
- if next, _ := self.peek(); next == '=' {
- tk = self.moveOn(SymGreaterOrEqual, ch, next)
+ if next, _ := scanner.peek(); next == '=' {
+ tk = scanner.moveOn(SymGreaterOrEqual, ch, next)
} else if next == '>' {
- tk = self.moveOn(SymInsert, ch, next)
+ tk = scanner.moveOn(SymInsert, ch, next)
} else {
- tk = self.makeToken(SymGreater, ch)
+ tk = scanner.makeToken(SymGreater, ch)
}
case '$':
- if next, _ := self.peek(); next == '(' {
- tk = self.moveOn(SymDollarRound, ch, next)
+ if next, _ := scanner.peek(); next == '(' {
+ tk = scanner.moveOn(SymDollarRound, ch, next)
tk.source += ")"
} else if next == '$' {
- tk = self.moveOn(SymDoubleDollar, ch, next)
+ tk = scanner.moveOn(SymDoubleDollar, ch, next)
} else {
- tk = self.makeToken(SymDollar, ch)
+ tk = scanner.makeToken(SymDollar, ch)
}
case '(':
- if next, _ := self.peek(); next == ')' {
- tk = self.moveOn(SymOpenClosedRound, ch, next)
+ if next, _ := scanner.peek(); next == ')' {
+ tk = scanner.moveOn(SymOpenClosedRound, ch, next)
} else {
- tk = self.makeToken(SymOpenRound, ch)
+ tk = scanner.makeToken(SymOpenRound, ch)
}
case ')':
- tk = self.makeToken(SymClosedRound, ch)
+ tk = scanner.makeToken(SymClosedRound, ch)
case '[':
- tk = self.makeToken(SymOpenSquare, ch)
+ tk = scanner.makeToken(SymOpenSquare, ch)
case ']':
- tk = self.makeToken(SymClosedSquare, ch)
+ tk = scanner.makeToken(SymClosedSquare, ch)
case '{':
- tk = self.makeToken(SymOpenBrace, ch)
+ tk = scanner.makeToken(SymOpenBrace, ch)
case '}':
- tk = self.makeToken(SymClosedBrace, ch)
+ tk = scanner.makeToken(SymClosedBrace, ch)
case '~':
- tk = self.makeToken(SymTilde, ch)
+ tk = scanner.makeToken(SymTilde, ch)
case 0:
if escape {
- tk = self.makeErrorToken(errors.New("incomplete escape sequence"))
+ tk = scanner.makeErrorToken(errors.New("incomplete escape sequence"))
}
escape = false
default:
if /*ch == '_' ||*/ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') {
- if tk = self.fetchIdentifier(ch); tk.Sym == SymKwFunc {
- if next, _ := self.peek(); next == '(' {
- tk = self.moveOn(SymFuncDef, ch, next)
+ if tk = scanner.fetchIdentifier(ch); tk.Sym == SymKwFunc {
+ if next, _ := scanner.peek(); next == '(' {
+ tk = scanner.moveOn(SymFuncDef, ch, next)
}
}
} else if ch >= '0' && ch <= '9' {
- tk = self.parseNumber(ch)
+ tk = scanner.parseNumber(ch)
}
}
if !escape {
@@ -307,14 +307,14 @@ func (self *scanner) fetchNextToken() (tk *Token) {
}
}
if tk == nil {
- tk = NewErrorToken(self.row, self.column, fmt.Errorf("unknown symbol '%c'", ch))
+ tk = NewErrorToken(scanner.row, scanner.column, fmt.Errorf("unknown symbol '%c'", ch))
}
return
}
-func (self *scanner) sync(err error) error {
+func (scanner *scanner) sync(err error) error {
if err == nil {
- err = self.unreadChar()
+ err = scanner.unreadChar()
}
return err
}
@@ -335,32 +335,32 @@ func isHexDigit(ch byte) bool {
return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
}
-func (self *scanner) initBase(sb *strings.Builder, currentFirstCh byte) (firstCh byte, numBase int, digitFunc func(byte) bool, err error) {
+func (scanner *scanner) initBase(currentFirstCh byte) (firstCh byte, numBase int, digitFunc func(byte) bool, err error) {
var ch byte
var digitType string
firstCh = currentFirstCh
digitFunc = isDecimalDigit
numBase = 10
- if ch, err = self.peek(); err == nil {
+ if ch, err = scanner.peek(); err == nil {
if ch == 'b' || ch == 'B' {
numBase = 2
digitType = "binary"
- self.readChar()
+ scanner.readChar()
digitFunc = isBinaryDigit
- firstCh, err = self.readChar()
+ firstCh, err = scanner.readChar()
} else if ch == 'o' || ch == 'O' {
numBase = 8
digitType = "octal"
- self.readChar()
+ scanner.readChar()
digitFunc = isOctalDigit
- firstCh, err = self.readChar()
+ firstCh, err = scanner.readChar()
} else if ch == 'x' || ch == 'X' {
numBase = 16
digitType = "hex"
- self.readChar()
+ scanner.readChar()
digitFunc = isHexDigit
- firstCh, err = self.readChar()
+ firstCh, err = scanner.readChar()
}
if err == nil && !digitFunc(firstCh) {
if len(digitType) == 0 {
@@ -374,7 +374,7 @@ func (self *scanner) initBase(sb *strings.Builder, currentFirstCh byte) (firstCh
return
}
-func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
+func (scanner *scanner) parseNumber(firstCh byte) (tk *Token) {
var err error
var ch byte
var sym Symbol = SymInteger
@@ -383,9 +383,9 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
var numBase = 10
if firstCh == '0' {
- firstCh, numBase, isDigit, err = self.initBase(&sb, firstCh)
+ firstCh, numBase, isDigit, err = scanner.initBase(firstCh)
}
- for ch = firstCh; err == nil && isDigit(ch); ch, err = self.readChar() {
+ for ch = firstCh; err == nil && isDigit(ch); ch, err = scanner.readChar() {
sb.WriteByte(ch)
}
@@ -393,9 +393,9 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
if err == nil && ch == '.' {
sym = SymFloat
sb.WriteByte(ch)
- ch, err = self.readChar()
+ ch, err = scanner.readChar()
if ch >= '0' && ch <= '9' {
- for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
+ for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = scanner.readChar() {
sb.WriteByte(ch)
}
}
@@ -404,32 +404,32 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
if ch == 'e' || ch == 'E' {
sym = SymFloat
sb.WriteByte(ch)
- if ch, err = self.readChar(); err == nil {
+ if ch, err = scanner.readChar(); err == nil {
if ch == '+' || ch == '-' {
sb.WriteByte(ch)
- ch, err = self.readChar()
+ ch, err = scanner.readChar()
}
if ch >= '0' && ch <= '9' {
- for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
+ for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = scanner.readChar() {
sb.WriteByte(ch)
}
} else {
- err = fmt.Errorf("[%d:%d] expected integer exponent, got %c", self.row, self.column, ch)
+ err = fmt.Errorf("[%d:%d] expected integer exponent, got %c", scanner.row, scanner.column, ch)
}
}
} else if ch == '(' {
sym = SymFraction
sb.WriteByte(ch)
- ch, err = self.readChar()
- for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
+ ch, err = scanner.readChar()
+ for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = scanner.readChar() {
sb.WriteByte(ch)
}
if err == nil {
if ch != ')' {
- err = fmt.Errorf("[%d:%d] expected ')', got '%c'", self.row, self.column, ch)
+ err = fmt.Errorf("[%d:%d] expected ')', got '%c'", scanner.row, scanner.column, ch)
} else {
sb.WriteByte(ch)
- _, err = self.readChar()
+ _, err = scanner.readChar()
}
}
}
@@ -437,10 +437,10 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
}
if err != nil && err != io.EOF {
- tk = self.makeErrorToken(err)
+ tk = scanner.makeErrorToken(err)
} else {
var value any
- err = self.sync(err)
+ err = scanner.sync(err) // TODO: Check this function
txt := sb.String()
if sym == SymFloat {
value, err = strconv.ParseFloat(txt, 64)
@@ -450,39 +450,39 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
value, err = strconv.ParseInt(txt, numBase, 64)
}
if err == nil {
- tk = self.makeValueToken(sym, txt, value)
+ tk = scanner.makeValueToken(sym, txt, value)
} else {
- tk = self.makeErrorToken(err)
+ tk = scanner.makeErrorToken(err)
}
}
return
}
-func (self *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
+func (scanner *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
var err error
var sb strings.Builder
- for ch := firstCh; err == nil && (ch == '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')); ch, err = self.readChar() {
+ for ch := firstCh; err == nil && (ch == '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')); ch, err = scanner.readChar() {
sb.WriteByte(ch)
}
if err != nil && err != io.EOF {
- tk = self.makeErrorToken(err)
- } else if err = self.sync(err); err != nil && err != io.EOF {
- tk = self.makeErrorToken(err)
+ tk = scanner.makeErrorToken(err)
+ } else if err = scanner.sync(err); err != nil && err != io.EOF {
+ tk = scanner.makeErrorToken(err)
} else {
txt := sb.String()
uptxt := strings.ToUpper(txt)
if sym, ok := keywords[uptxt]; ok {
- tk = self.makeKeywordToken(sym, uptxt)
+ tk = scanner.makeKeywordToken(sym, uptxt)
} else if uptxt == `TRUE` {
- tk = self.makeValueToken(SymBool, txt, true)
+ tk = scanner.makeValueToken(SymBool, txt, true)
} else if uptxt == `FALSE` {
- tk = self.makeValueToken(SymBool, txt, false)
- } else if ch, _ := self.peek(); ch == '(' {
- self.readChar()
- tk = self.makeValueToken(SymFuncCall, txt+"(", txt)
+ tk = scanner.makeValueToken(SymBool, txt, false)
+ } else if ch, _ := scanner.peek(); ch == '(' {
+ scanner.readChar()
+ tk = scanner.makeValueToken(SymFuncCall, txt+"(", txt)
} else {
- tk = self.makeValueToken(SymIdentifier, txt, txt)
+ tk = scanner.makeValueToken(SymIdentifier, txt, txt)
}
}
@@ -502,29 +502,29 @@ func (self *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
return
}
-func (self *scanner) fetchBlockComment() *Token {
- return self.fetchUntil(SymComment, false, '*', '/')
+func (scanner *scanner) fetchBlockComment() *Token {
+ return scanner.fetchUntil(SymComment, false, '*', '/')
}
-func (self *scanner) fetchOnLineComment() *Token {
- return self.fetchUntil(SymComment, true, '\n')
+func (scanner *scanner) fetchOnLineComment() *Token {
+ return scanner.fetchUntil(SymComment, true, '\n')
}
-func (self *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk *Token) {
+func (scanner *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk *Token) {
var err error
var ch byte
var sb strings.Builder
var value string
ring := NewByteSlider(len(endings))
endReached := false
- for ch, err = self.readChar(); err == nil && !endReached; {
+ for ch, err = scanner.readChar(); err == nil && !endReached; {
sb.WriteByte(ch)
ring.PushEnd(ch)
if ring.Equal(endings) {
value = sb.String()[0 : sb.Len()-len(endings)]
endReached = true
} else {
- ch, err = self.readChar()
+ ch, err = scanner.readChar()
}
}
if !endReached && allowEos {
@@ -533,18 +533,18 @@ func (self *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk
}
if endReached {
- tk = self.makeValueToken(sym, "", value)
+ tk = scanner.makeValueToken(sym, "", value)
} else {
- tk = self.makeErrorToken(err)
+ tk = scanner.makeErrorToken(err)
}
return
}
-func (self *scanner) fetchString(termCh byte) (tk *Token) {
+func (scanner *scanner) fetchString(termCh byte) (tk *Token) {
var err error
var ch, prev byte
var sb strings.Builder
- for ch, err = self.readChar(); err == nil; ch, err = self.readChar() {
+ for ch, err = scanner.readChar(); err == nil; ch, err = scanner.readChar() {
if prev == '\\' {
switch ch {
case '"':
@@ -572,65 +572,65 @@ func (self *scanner) fetchString(termCh byte) (tk *Token) {
}
if err != nil {
if err == io.EOF {
- tk = self.makeErrorToken(errors.New("missing string termination \""))
+ tk = scanner.makeErrorToken(errors.New("missing string termination \""))
} else {
- tk = self.makeErrorToken(err)
+ tk = scanner.makeErrorToken(err)
}
} else {
txt := sb.String()
- tk = self.makeValueToken(SymString, `"`+txt+`"`, txt)
+ tk = scanner.makeValueToken(SymString, `"`+txt+`"`, txt)
}
return
}
-func (self *scanner) peek() (next byte, err error) {
+func (scanner *scanner) peek() (next byte, err error) {
var one []byte
- if one, err = self.stream.Peek(1); err == nil {
+ if one, err = scanner.stream.Peek(1); err == nil {
next = one[0]
}
return
}
-func (self *scanner) skipBlanks() (err error) {
+func (scanner *scanner) skipBlanks() (err error) {
var one []byte
- for one, err = self.stream.Peek(1); err == nil && one[0] <= 32; one, err = self.stream.Peek(1) {
- self.readChar()
+ for one, err = scanner.stream.Peek(1); err == nil && one[0] <= 32; one, err = scanner.stream.Peek(1) {
+ scanner.readChar()
}
return
}
-func (self *scanner) translate(sym Symbol) Symbol {
- if self.translations != nil {
- if translatedSym, ok := self.translations[sym]; ok {
+func (scanner *scanner) translate(sym Symbol) Symbol {
+ if scanner.translations != nil {
+ if translatedSym, ok := scanner.translations[sym]; ok {
return translatedSym
}
}
return sym
}
-func (self *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
- tk = NewToken(self.row, self.column, self.translate(sym), string(chars))
+func (scanner *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
+ tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
for i := 1; i < len(chars); i++ {
- self.readChar()
+ scanner.readChar()
}
return
}
-func (self *scanner) makeToken(sym Symbol, chars ...byte) (tk *Token) {
- tk = NewToken(self.row, self.column, self.translate(sym), string(chars))
+func (scanner *scanner) makeToken(sym Symbol, chars ...byte) (tk *Token) {
+ tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
return
}
-func (self *scanner) makeKeywordToken(sym Symbol, upperCaseKeyword string) (tk *Token) {
- tk = NewToken(self.row, self.column, self.translate(sym), upperCaseKeyword)
+func (scanner *scanner) makeKeywordToken(sym Symbol, upperCaseKeyword string) (tk *Token) {
+ tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), upperCaseKeyword)
return
}
-func (self *scanner) makeValueToken(sym Symbol, source string, value any) (tk *Token) {
- tk = NewValueToken(self.row, self.column, self.translate(sym), source, value)
+func (scanner *scanner) makeValueToken(sym Symbol, source string, value any) (tk *Token) {
+ tk = NewValueToken(scanner.row, scanner.column, scanner.translate(sym), source, value)
return
}
-func (self *scanner) makeErrorToken(err error) *Token {
- return NewErrorToken(self.row, self.column, err)
+func (scanner *scanner) makeErrorToken(err error) *Token {
+ return NewErrorToken(scanner.row, scanner.column, err)
}