[用go实现解释器]笔记1-词法分析

news2024/10/5 16:27:44

本文是《用go实现解释器》的读书笔记

​

https://malred-blog​malred.github.io/2023/06/03/ji-suan-ji-li-lun-ji-shu-ji/shi-ti/go-compile/yong-go-yu-yan-shi-xian-jie-shi-qi/go-compiler-1/#toc-heading-6icon-default.png?t=N6B9http://个人博客该笔记地址

​github.com/malred/malangicon-default.png?t=N6B9http://代码仓库

1. 词法分析

1.1 词法分析

为了解释源代码,需要将其转换为易于理解的形式, 最终对代码求值之前, 需要两次转换源代码的表示形式

词法分析器的作用如下:

let x = 5 + 5; -> [LET,INDENTIFIER(“x”),EQUAL_SIGN,INTERGER(5),PLUS_SIGN,INTERGER(5),SEMICOLON] 设 x = 5 + 5;-> [LET，INDENTIFIER（“X”），EQUAL_SIGN，INTERGER（5），PLUS_SIGN，INTERGER（5），SEMICOLON]

不同词法分析器生成的词法单元会有区别

  • 空白字符不会被识别(python 等语言会)

  • 完整的词法分析器还可将行列号和文件名附加到词法单元中,后续语法分析可以更好地报错

1.2 定义词法单元

先定义词法分析器输出的词法单元 这是要解析的语句段(Monkey 语言)

let five = 5;
let ten = 10;

let add = fn(x,y) {
    x + y;
}

let result = add(five, ten);

  • 数字都是整数,按字面量处理,并赋予单独的类型

  • 变量名和数字等语言,统一用作标识符

  • 还有一些看着像标识符的,但实际是关键字,会特殊处理

定义 Token 数据结构,属性有 1.词法单元类型;2.字面量 词法单元类型定义为字符串,消耗一些性能,但是调试使用方便

// token/token.go
package token

// 词法单元类型
type TokenType string

// 词法单元
type Token struct {
    Type TokenType
    // 字面量
    Literal string
}

将词法单元类型定义为常量

const (
    // 特殊类型
    ILLEGAL = "ILLEGAL" // 未知字符
    EOF     = "EOF"     // 文件结尾

    // 标识符+字面量
    IDENT = "IDENT" // add, foobar, x, y
    INT   = "INT"   // 1343456

    // 运算符
    ASSIGN = "="
    PLUS   = "+"

    // 分隔符
    COMMA     = ","
    SEMICOLON = ";"

    LPAREN = "("
    RPAREN = ")"
    LBRACE = "{"
    RBRACE = "}"

    // 关键字
    FUNCTION = "FUNCTION"
    LET      = "LET"
)

1.3 词法分析器

词法分析器接收源代码(字符串),然后调用 NextToken()逐个遍历字符进行词法分析 生产环境,将文件名和行号附加到词法单元,最好使用 io.Reader 加上文件名来初始化词法分析器

// lexer/lexer.go
package lexer

type Lexer struct {
    input        string
    position     int  // 输入的字符串中的当前位置(指向当前字符)
    readPosition int  // 输入的字符串中的当前读取位置(指向当前字符串之后的一个字符(ch))
    ch           byte // 当前正在查看的字符
}

func New(input string) *Lexer {
    l := &Lexer{input: input}
    return l
}

// 读取下一个字符
func (l *Lexer) readChar() {
    if l.readPosition >= len(l.input) {
        l.ch = 0 // NUL的ASSII码(0)
    } else {
        // 读取
        l.ch = l.input[l.readPosition]
    }
    // 前移
    l.position = l.readPosition
    l.readPosition += 1
}

  • readChar 的作用是读取 input 中下个字符,然后将索引前推,NUL 字符的 ASCII 码是 0,表示”尚未读取任何内容”或”文件结尾”

  • 该分析器只支持 ASCII 字符,不能支持所有 Unicode 字符,如果要支持,则 l.ch 要改为 rune 类型,并且要修改读取下一个字符的方式,字符也有可能会是多字节,l.input[l.readPosition]将无法工作

在 New 中调用 readChar 以初始化

func New(input string) *Lexer {
    l := &Lexer{input: input}
    // 初始化 l.ch,l.position,l.readPosition
    l.readChar()
    return l
}

第一版 NextToken

// lexer/lexer.go
package lexer

import (
    "go-monkey-compiler/token"
)

// 创建词法单元的方法
func newToken(tokenType token.TokenType, ch byte) token.Token {
    return token.Token{
        Type:    tokenType,
        Literal: string(ch),
    }
}

// 根据当前的ch创建词法单元
func (l *Lexer) NextToken() token.Token {
    var tok token.Token

    switch l.ch {
    case '=':
        tok = newToken(token.ASSIGN, l.ch)
    case ';':
        tok = newToken(token.SEMICOLON, l.ch)
    case '(':
        tok = newToken(token.LPAREN, l.ch)
    case ')':
        tok = newToken(token.RPAREN, l.ch)
    case ',':
        tok = newToken(token.COMMA, l.ch)
    case '+':
        tok = newToken(token.PLUS, l.ch)
    case '{':
        tok = newToken(token.LBRACE, l.ch)
    case '}':
        tok = newToken(token.RBRACE, l.ch)
    case 0:
        tok.Literal = ""
        tok.Type = token.EOF
    }

    l.readChar()
    return tok
}

测试

// lexer/lexer_test.go
package lexer

import (
    "go-monkey-compiler/token"
    "testing"
)

func TestNextToken(t *testing.T) {
    input := `=+(){},;`

    tests := []struct {
        expectedType    token.TokenType
        expectedLiteral string
    }{
        {token.ASSIGN, "="},
        {token.PLUS, "+"},
        {token.LPAREN, "("},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.RBRACE, "}"},
        {token.COMMA, ","},
        {token.SEMICOLON, ";"},
        {token.EOF, ""},
    }

    l := New(input)

    for i, tt := range tests {
        tok := l.NextToken()

        if tok.Type != tt.expectedType {
            t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got==%q", i, tt.expectedType, tok.Type)
        }

        if tok.Literal != tt.expectedLiteral {
            t.Fatalf("tests[%d] - literal wrong. expected=%q, got==%q", i, tt.expectedLiteral, tok.Literal)
        }
    }

}

go test ./lexer

添加标识符/关键字/数字的处理

// lexer/lexer.go
// 判断读取到的字符是不是字母
func isLetter(ch byte) bool {
    return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
}

// 读取字母(标识符/关键字)
func (l *Lexer) readIdentifier() string {
    position := l.position
    for isLetter(l.ch) {
        // 如果接下来还有字母,就一直移动指针到不是字母
        l.readChar()
    }
    return l.input[position:l.position]
}

func (l *Lexer) NextToken() token.Token {
    var tok token.Token

    switch l.ch {
        // ...
    default:
        if isLetter(l.ch) {
            tok.Literal = l.readIdentifier()
            tok.Type = token.LookupIdent(tok.Literal)
            return tok
        } else {
            tok = newToken(token.ILLEGAL, l.ch)
        }
    }

    l.readChar()
    return tok
}

在 token.go 里添加识别关键字和用户定义标识符的方法

// 关键字map
var keywords = map[string]TokenType{
    "fn":  FUNCTION,
    "let": LET,
}

func LookupIdent(ident string) TokenType {
    // 从关键字map里找,找到了就说明是关键字
    if tok, ok := keywords[ident]; ok {
        return tok
    }
    // 标识符
    return IDENT
}

此时如果遇到空白字段,会报错 IDENT!=ILLEGAL,需要添加跳过空格的方法

// lexer/lexer.go

// 跳过空格
func (l *Lexer) skipWhitespace() {
    for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
        l.readChar()
    }
}

// 根据当前的ch创建词法单元
func (l *Lexer) NextToken() token.Token {
    var tok token.Token

    // 跳过空格
    l.skipWhitespace()

    switch l.ch {
        // ...
    }
    // ...
}

现在添加将数字转为词法单元的功能 数字的识别还可以是浮点数/16 进制/8 进制等,但是书中为了教学而简化了

// 跳过空格
func (l *Lexer) skipWhitespace() {
    for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
        l.readChar()
    }
}

// 判断是否是数字
func isDigit(ch byte) bool {
    return '0' <= ch && ch <= '9'
}

// 读取数字
func (l *Lexer) readNumber() string {
    // 记录起始位置
    position := l.position
    for isDigit(l.ch) {
        l.readChar()
    }
    return l.input[position:l.position]
}

// 根据当前的ch创建词法单元
func (l *Lexer) NextToken() token.Token {
    var tok token.Token

    // 跳过空格
    l.skipWhitespace()

    switch l.ch {
        // ...
    default:
        if isLetter(l.ch) {
            tok.Literal = l.readIdentifier()
            tok.Type = token.LookupIdent(tok.Literal)
            // 因为readIdentifier会调用readChar,所以提前return,不需要后面再readChar
            return tok
        } else if isDigit(l.ch) {
            tok.Type = token.INT
            tok.Literal = l.readNumber()
            return tok
        } else {
            tok = newToken(token.ILLEGAL, l.ch)
        }
    }

    l.readChar()
    return tok
}

拓展测试用例,处理开头提到的那个 Monkey 代码段

// lexer/lexer_test.go
package lexer

import (
    "go-monkey-compiler/token"
    "testing"
)

func TestNextToken(t *testing.T) {
    input :=
        `
    let five = 5;
    let ten = 10;
    let add = fn(x,y) {
        x + y;
    };

    let result = add(five, ten);
    `

    tests := []struct {
        expectedType    token.TokenType
        expectedLiteral string
    }{
        {token.LET, "let"},
        {token.IDENT, "five"},
        {token.ASSIGN, "="},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "ten"},
        {token.ASSIGN, "="},
        {token.INT, "10"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "add"},
        {token.ASSIGN, "="},
        {token.FUNCTION, "fn"},
        {token.LPAREN, "("},
        {token.IDENT, "x"},
        {token.COMMA, ","},
        {token.IDENT, "y"},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.IDENT, "x"},
        {token.PLUS, "+"},
        {token.IDENT, "y"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "result"},
        {token.ASSIGN, "="},
        {token.IDENT, "add"},
        {token.LPAREN, "("},
        {token.IDENT, "five"},
        {token.COMMA, ","},
        {token.IDENT, "ten"},
        {token.RPAREN, ")"},
        {token.SEMICOLON, ";"},
        {token.EOF, ""},
    }

    l := New(input)

    for i, tt := range tests {
        tok := l.NextToken()

        if tok.Type != tt.expectedType {
            t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got==%q", i, tt.expectedType, tok.Type)
        }

        if tok.Literal != tt.expectedLiteral {
            t.Fatalf("tests[%d] - literal wrong. expected=%q, got==%q", i, tt.expectedLiteral, tok.Literal)
        }
    }

}

1.4 拓展词法单元和词法分析器

添加对 == ! != - / * < > 和关键字 true false if else return 的支持 可分为

  • 单字符语法单元(如-,!)

  • 双字符语法单元(如==) <- 后续添加支持

  • 关键字语法定义(如 return)

添加对- / * < > 的支持 token 常量中添加新定义

const (
    // ...

    // 运算符
    ASSIGN   = "="
    PLUS     = "+"
    MINUS    = "-"
    BANG     = "!"
    ASTERISK = "*"
    SLASH    = "/"

    LT = "<"
    GT = ">"

    // ...
)

lexer.go 的 switch 中添加新的词法单元生成

// 根据当前的ch创建词法单元
func (l *Lexer) NextToken() token.Token {
    var tok token.Token

    // 跳过空格
    l.skipWhitespace()

    switch l.ch {
    case '=':
        tok = newToken(token.ASSIGN, l.ch)
    case '+':
        tok = newToken(token.PLUS, l.ch)
    case '-':
        tok = newToken(token.MINUS, l.ch)
    case '!':
        tok = newToken(token.BANG, l.ch)
    case '/':
        tok = newToken(token.SLASH, l.ch)
    case '*':
        tok = newToken(token.ASTERISK, l.ch)
    case '<':
        tok = newToken(token.LT, l.ch)
    case '>':
        tok = newToken(token.GT, l.ch)
    // ...
    }

    l.readChar()
    return tok
}

测试

// lexer/lexer_test.go
package lexer

import (
    "go-monkey-compiler/token"
    "testing"
)

func TestNextToken(t *testing.T) {
    input :=
        `
    let five = 5;
    let ten = 10;

    let add = fn(x, y) {
    x + y;
    };

    let result = add(five, ten);
    !-/*5;
    5 < 10 > 5;
    `

    tests := []struct {
        expectedType    token.TokenType
        expectedLiteral string
    }{
        {token.LET, "let"},
        {token.IDENT, "five"},
        {token.ASSIGN, "="},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "ten"},
        {token.ASSIGN, "="},
        {token.INT, "10"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "add"},
        {token.ASSIGN, "="},
        {token.FUNCTION, "fn"},
        {token.LPAREN, "("},
        {token.IDENT, "x"},
        {token.COMMA, ","},
        {token.IDENT, "y"},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.IDENT, "x"},
        {token.PLUS, "+"},
        {token.IDENT, "y"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "result"},
        {token.ASSIGN, "="},
        {token.IDENT, "add"},
        {token.LPAREN, "("},
        {token.IDENT, "five"},
        {token.COMMA, ","},
        {token.IDENT, "ten"},
        {token.RPAREN, ")"},
        {token.SEMICOLON, ";"},
        {token.BANG, "!"},
        {token.MINUS, "-"},
        {token.SLASH, "/"},
        {token.ASTERISK, "*"},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.INT, "5"},
        {token.LT, "<"},
        {token.INT, "10"},
        {token.GT, ">"},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
    }

    l := New(input)

    for i, tt := range tests {
        tok := l.NextToken()

        if tok.Type != tt.expectedType {
            t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q",
                i, tt.expectedType, tok.Type)
        }

        if tok.Literal != tt.expectedLiteral {
            t.Fatalf("tests[%d] - literal wrong. expected=%q, got=%q",
                i, tt.expectedLiteral, tok.Literal)
        }
    }
}

进一步拓展,添加新关键字的解析 true false if else return 将新关键字分别添加到 token 的常量列表和 keywords 关键字 map 里

const (
    // ...

    // 关键字
    FUNCTION = "FUNCTION"
    LET      = "LET"
    TRUE     = "TRUE"
    FALSE    = "FALSE"
    IF       = "IF"
    ELSE     = "ELSE"
    RETURN   = "RETURN"
)

// 关键字map
var keywords = map[string]TokenType{
    "fn":     FUNCTION,
    "let":    LET,
    "true":   TRUE,
    "false":  FALSE,
    "if":     IF,
    "else":   ELSE,
    "return": RETURN,
}

测试

// lexer/lexer_test.go
package lexer

import (
    "go-monkey-compiler/token"
    "testing"
)

func TestNextToken(t *testing.T) {
    input :=
        `
    let five = 5;
    let ten = 10;

    let add = fn(x, y) {
    x + y;
    };

    let result = add(five, ten);
    !-/*5;
    5 < 10 > 5;

    if (5 < 10) {
        return true;
    } else {
        return false;
    }
    `

    tests := []struct {
        expectedType    token.TokenType
        expectedLiteral string
    }{
        {token.LET, "let"},
        {token.IDENT, "five"},
        {token.ASSIGN, "="},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "ten"},
        {token.ASSIGN, "="},
        {token.INT, "10"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "add"},
        {token.ASSIGN, "="},
        {token.FUNCTION, "fn"},
        {token.LPAREN, "("},
        {token.IDENT, "x"},
        {token.COMMA, ","},
        {token.IDENT, "y"},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.IDENT, "x"},
        {token.PLUS, "+"},
        {token.IDENT, "y"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "result"},
        {token.ASSIGN, "="},
        {token.IDENT, "add"},
        {token.LPAREN, "("},
        {token.IDENT, "five"},
        {token.COMMA, ","},
        {token.IDENT, "ten"},
        {token.RPAREN, ")"},
        {token.SEMICOLON, ";"},
        {token.BANG, "!"},
        {token.MINUS, "-"},
        {token.SLASH, "/"},
        {token.ASTERISK, "*"},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.INT, "5"},
        {token.LT, "<"},
        {token.INT, "10"},
        {token.GT, ">"},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.IF, "if"},
        {token.LPAREN, "("},
        {token.INT, "5"},
        {token.LT, "<"},
        {token.INT, "10"},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.RETURN, "return"},
        {token.TRUE, "true"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.ELSE, "else"},
        {token.LBRACE, "{"},
        {token.RETURN, "return"},
        {token.FALSE, "false"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
    }

    l := New(input)

    for i, tt := range tests {
        tok := l.NextToken()

        if tok.Type != tt.expectedType {
            t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q",
                i, tt.expectedType, tok.Type)
        }

        if tok.Literal != tt.expectedLiteral {
            t.Fatalf("tests[%d] - literal wrong. expected=%q, got=%q",
                i, tt.expectedLiteral, tok.Literal)
        }
    }
}

拓展,添加对!=和==的支持 添加常量

const (
    // ...

    EQ     = "=="
    NOT_EQ = "!="

    // ...
)

因为每次读入一个字符,所以不能直接 case !=来判别,应该复用!和=的判断分支,根据下一个字符来决定是返回=还是==

// 向前查看一个字符,但是不移动指针
func (l *Lexer) peekChar() byte {
    if l.readPosition >= len(l.input) {
        return 0
    } else {
        return l.input[l.readPosition]
    }
}

// 根据当前的ch创建词法单元
func (l *Lexer) NextToken() token.Token {
    var tok token.Token

    // 跳过空格
    l.skipWhitespace()

    switch l.ch {
    case '=':
        if l.peekChar() == '=' {
            // 记录当前ch (=)
            ch := l.ch
            l.readChar()
            literal := string(ch) + string(l.ch)
            tok = token.Token{Type: token.EQ, Literal: literal}
        } else {
            tok = newToken(token.ASSIGN, l.ch)
        }
    // ...
    case '!':
        if l.peekChar() == '=' {
            // 记录当前ch (!)
            ch := l.ch
            l.readChar()
            literal := string(ch) + string(l.ch)
            tok = token.Token{Type: token.NOT_EQ, Literal: literal}
        } else {
            tok = newToken(token.BANG, l.ch)
        }

    // ...
    }

    l.readChar()
    return tok
}
测试

 

// lexer/lexer_test.go
package lexer

import (
    "go-monkey-compiler/token"
    "testing"
)

func TestNextToken(t *testing.T) {
    input :=
        `
    let five = 5;
    let ten = 10;

    let add = fn(x, y) {
    x + y;
    };

    let result = add(five, ten);
    !-/*5;
    5 < 10 > 5;

    if (5 < 10) {
        return true;
    } else {
        return false;
    }

    10 == 10;
    10 != 9;
    `

    tests := []struct {
        expectedType    token.TokenType
        expectedLiteral string
    }{
        {token.LET, "let"},
        {token.IDENT, "five"},
        {token.ASSIGN, "="},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "ten"},
        {token.ASSIGN, "="},
        {token.INT, "10"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "add"},
        {token.ASSIGN, "="},
        {token.FUNCTION, "fn"},
        {token.LPAREN, "("},
        {token.IDENT, "x"},
        {token.COMMA, ","},
        {token.IDENT, "y"},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.IDENT, "x"},
        {token.PLUS, "+"},
        {token.IDENT, "y"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "result"},
        {token.ASSIGN, "="},
        {token.IDENT, "add"},
        {token.LPAREN, "("},
        {token.IDENT, "five"},
        {token.COMMA, ","},
        {token.IDENT, "ten"},
        {token.RPAREN, ")"},
        {token.SEMICOLON, ";"},
        {token.BANG, "!"},
        {token.MINUS, "-"},
        {token.SLASH, "/"},
        {token.ASTERISK, "*"},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.INT, "5"},
        {token.LT, "<"},
        {token.INT, "10"},
        {token.GT, ">"},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.IF, "if"},
        {token.LPAREN, "("},
        {token.INT, "5"},
        {token.LT, "<"},
        {token.INT, "10"},
        {token.RPAREN, ")"},
        {token.LBRACE, "{"},
        {token.RETURN, "return"},
        {token.TRUE, "true"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.ELSE, "else"},
        {token.LBRACE, "{"},
        {token.RETURN, "return"},
        {token.FALSE, "false"},
        {token.SEMICOLON, ";"},
        {token.RBRACE, "}"},
        {token.INT, "10"},
        {token.EQ, "=="},
        {token.INT, "10"},
        {token.SEMICOLON, ";"},
        {token.INT, "10"},
        {token.NOT_EQ, "!="},
        {token.INT, "9"},
        {token.SEMICOLON, ";"},
        {token.EOF, ""},
    }

    l := New(input)

    for i, tt := range tests {
        tok := l.NextToken()

        if tok.Type != tt.expectedType {
            t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q",
                i, tt.expectedType, tok.Type)
        }

        if tok.Literal != tt.expectedLiteral {
            t.Fatalf("tests[%d] - literal wrong. expected=%q, got=%q",
                i, tt.expectedLiteral, tok.Literal)
        }
    }
}

1.5 编写 REPL

REPL 即 Read-Eval-Print-Loop(读取-求值-打印循环) REPL 读取输入,传给解释器求值,任何输出,并重复之前的步骤 这里是输入源代码,然后每次读取一行,直到遇到 EOF,期间输出词法生成器生成的词法单元

// repl/repl.go
package repl

import (
    "bufio"
    "fmt"
    "go-monkey-compiler/token"
    "go-monkey-compiler/lexer"
    "io"
)

const PROMPT = ">> "

func Start(in io.Reader, out io.Writer) {
    scanner := bufio.NewScanner(in)

    for {
        scanned := scanner.Scan()
        if !scanned {
            return
        }

        line := scanner.Text()
        l := lexer.New(line)

        for tok := l.NextToken(); tok.Type != token.EOF; tok = l.NextToken() {
            fmt.Fprintf(out, "%+v\n", tok)
        }
    }
}

创建 main.go,启动 REPL

// main.go
package main

import (
    "fmt"
    "go-monkey-compiler/repl"
    "os"
    "os/user"
)

func main() {
    user, err := user.Current()
    if err != nil {
        panic(err)
    }
    fmt.Printf("Hello %s! This is the Monkey programming language!\n", user.Username)
    fmt.Printf("Feel free to type in commands\n")
    repl.Start(os.Stdin, os.Stdout)
}

测试

​

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/825976.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

入行软件测试的一些工作感悟

入行软件测试的一些工作感悟

成为xx一员测试已经有1年半了&#xff0c;一直没有真正坐下来花些时间将自己的思路理清一下。刚好近期公司落地了OKR&#xff0c;给自己制定了OKR之后思路终于开始清晰起来&#xff0c;朦朦胧胧地开始看清了远方的路&#xff0c;麻着胆子分析一下自己&#xff0c;毕竟摸黑走路的…
阅读更多...
Screens 4 for mac VNC客户端 强大的远程控制工具

Screens 4 for mac VNC客户端 强大的远程控制工具

Screens 4 for Mac 是一款功能强大的 VNC 客户端软件&#xff0c;为 Mac 用户提供了便捷的远程访问和控制解决方案。无论您是需要远程管理服务器、办公电脑&#xff0c;还是需要远程协助他人解决问题&#xff0c;Screens 4 都是您的理想选择。 Screens 4 for Mac具备简洁直观的…
阅读更多...
小白到运维工程师自学之路 第六十二集 （docker持久化与数据卷容器）

小白到运维工程师自学之路 第六十二集 （docker持久化与数据卷容器）

一、概述 Docker持久化是指将容器中的数据持久保存在主机上&#xff0c;以便在容器重新启动或迁移时不丢失数据。由于Docker容器是临时和可变的&#xff0c;它们的文件系统默认是易失的&#xff0c;这意味着容器中的任何更改或创建的文件都只存在于此容器的生命周期内。但是&a…
阅读更多...
基于低代码平台快速搭建应用

基于低代码平台快速搭建应用

一、前言 近年来&#xff0c;SaaS行业的迅猛发展带动了低代码领域的快速兴起。国外的低代码创业公司如Mendix、Outsystems&#xff0c;以及国内的软件业巨头如华为、用友、金蝶等和小众高性价比的引迈JNPF都已经纷纷涉足低代码市场。根据Transparency Market Research的报告&am…
阅读更多...
独立站运营要做哪些工作？包含哪些模块？

独立站运营要做哪些工作？包含哪些模块？

在电商行业中&#xff0c;广告投放和设计等岗位的招聘可能会相对容易&#xff0c;但真正理解并有效执行独立站运营的人员却十分稀少。因此&#xff0c;今天将聚焦于独立站的运营&#xff0c;特别是针对精品垂直站和品牌站的运营。 首先&#xff0c;我们需要了解“运营”的含义…
阅读更多...
vue2使用v-viewer实现图片预览

vue2使用v-viewer实现图片预览

v-viewer 用于图片浏览的Vue组件&#xff0c;支持旋转、缩放、翻转等操作&#xff0c;基于viewer.js。 中文文档&#xff1a;Vue图片浏览组件v-viewer&#xff0c;支持旋转、缩放、翻转等操作 | Mirari’s Blog 代码示例&#xff1a;https://mirari.cc/v-viewer/ 在Vue.js 2…
阅读更多...
Java并发系列之三：乐观锁机制

Java并发系列之三：乐观锁机制

上一篇悲观锁中&#xff0c;我们讲到悲观锁的四种状态时&#xff0c;提到了“无锁”这种状态&#xff0c;并解释其有两种语义&#xff0c;一种是对共享资源不进行任何同步原语保护&#xff1b;另一种是共享资源会出现被竞争的情况&#xff0c;但是不使用操作系统同步进行保护&a…
阅读更多...
17、Spring6整合JUnit5

17、Spring6整合JUnit5

目录 17、Spring6整合JUnit5 17.1 Spring对JUnit4的支持 准备工作&#xff1a; 声明Bean spring.xml 单元测试&#xff1a; 17.2 Spring对JUnit5的支持 17、Spring6整合JUnit5 17.1 Spring对JUnit4的支持 准备工作&#xff1a; <?xml version"1.0" enco…
阅读更多...
Java课题笔记~ MyBatis映射文件

Java课题笔记~ MyBatis映射文件

映射文件是MyBatis中的重要组成部分&#xff0c;它包含了开发中编写的SQL语句、参数、结果集等。映射文件需要通过MyBatis配置文件中的<mapper>元素引入才能生效。MyBatis规定了映射文件的层次结构。 1、映射文件概览 <?xml version"1.0" encoding"…
阅读更多...
浅谈document.write()输出样式

浅谈document.write()输出样式

浅谈document.write()输出样式 js中的最基本的命令之一&#xff1a;document.write&#xff08;&#xff09;&#xff0c;用于简单的打印内容到页面上&#xff0c;可以逐字打印你需要的内容——document.write("content"),这里content就是需要输出的内容&#xff1b;…
阅读更多...
2023 ChinaJoy 圆满闭幕，FairGuard游戏加固亮相 BTOB 展区

2023 ChinaJoy 圆满闭幕，FairGuard游戏加固亮相 BTOB 展区

提振行业 产业复苏 2023年7月28日至7月31日&#xff0c;第二十届中国国际数码互动娱乐展览会( ChinaJoy)于上海新国际博览中心圆满举办。本届ChinaJoy作为疫情结束后的第一个国际性数字娱乐领域的重要产业盛会&#xff0c;对于提振行业信心、加快产业复苏、增进国际间的交流与…
阅读更多...
如何成为linux服务端C++开发专家?

如何成为linux服务端C++开发专家?

想成为linux服务端C开发专家&#xff0c;只能自己慢慢学&#xff0c;在实践中摸索&#xff0c;我敢说没几个人说自己是linux服务端C开发专家 ! 这里说下鹅厂关于Linux C方向 的使用场景 。 进腾讯最好的方向是 Linux C方向&#xff0c;目前腾讯由于历史原因&#xff0c;还有游…
阅读更多...
16、外部配置源与外部配置文件及JSON配置

16、外部配置源与外部配置文件及JSON配置

外部配置源与外部配置文件及JSON配置 application.properties application.yml 这些是配置文件&#xff0c; 命令行配置、环境变量配置、系统属性配置源&#xff0c;这些属于配置源。 外部配置源的作用&#xff1a; Spring Boot相当于对Spring框架进行了封装&#xff0c;Spri…
阅读更多...
java环境搭建 Ubuntu Linux

java环境搭建 Ubuntu Linux

jdk的安装和配置环境变量 使用apt sudo apt install default-jdk若是安装成功了在终端输入java -version来查看是否安装成功 使用官网下载的jdk包 直接在百度上搜索jdk&#xff0c;选择图片这个 网址:jdk下载网址 若是arm就选择带有arm的&#xff0c;反之选择x64的&#…
阅读更多...
智能疏散照明控制系统在世博文化中心的应用

智能疏散照明控制系统在世博文化中心的应用

安科瑞 华楠 摘要:世博文化中心作为世博园区一轴四馆的核心建筑之一&#xff0c;其建筑面积大&#xff0c;人员密集&#xff0c;人流通道众多&#xff0c;疏散路径复杂。为了确保火灾发生时人员能安全、迅速的疏散&#xff0c;在电气设计中设置了一套智能疏散照明系统。通过介…
阅读更多...
wps 预加载项插件本地开发启动项目打开wps 客户端，未看到加载项菜单，

wps 预加载项插件本地开发启动项目打开wps 客户端，未看到加载项菜单，

wps 预加载项插件本地开发启动项目打开wps 客户端&#xff0c;未看到加载项菜单&#xff0c;请检查本地c盘安装目录下“jsplugins.xml”信息是否添加成功 如下图 name 插件项目 url 本地插件运行地址及端口 <jsplugins><jspluginonline name"wps-soft-copyright…
阅读更多...
什么是软件检测证明材料，如何才能获得软件检测证明材料?

什么是软件检测证明材料，如何才能获得软件检测证明材料?

一、什么是软件检测证明材料 软件检测证明材料是指在软件开发和发布过程中&#xff0c;为了证明软件的质量和合法性&#xff0c;进行的一系列检测和测试的结果的集合。它是软件开发者和用户之间信任的桥梁&#xff0c;可以帮助用户了解软件的性能和安全性&#xff0c;让用户放…
阅读更多...
docker 哨兵模式和集群模式安装Redis7.0.12

docker 哨兵模式和集群模式安装Redis7.0.12

docker 哨兵模式和集群模式安装Redis7.0.12 1.下载镜像 1.1 配置阿里云加速源 墙外能访问https://hub.docker.com/_/redis 的可跳过 https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors 登录后选择左侧的镜像工具>镜像加速器&#xff0c;获取加速器地址&#…
阅读更多...
企业数字化转型的核心是什么？

企业数字化转型的核心是什么？

如今&#xff0c;各行各业都在布局数字化转型&#xff0c;而对于中国传统制造业来说&#xff0c;数字化转型更是当务之急&#xff0c;但由于制造企业组织、业务、产品和价值链的复杂性&#xff0c;为数字化转型带来诸多障碍。这篇就来重点分享下&#xff0c;制造业如何做好数字…
阅读更多...
传智教育院校邦首期图灵计划—黑马菁英班正式开班!

传智教育院校邦首期图灵计划—黑马菁英班正式开班!

7月30日&#xff0c;大家期待已久的首期图灵计划——黑马菁英班正式开班&#xff01;班级开班的那一刻&#xff0c;同学们的学习热情立即被点燃&#xff01; 这个班级匹配当代大学生特点&#xff0c;在课程设置、讲师团队、班级管理等方面做到顶配&#xff0c;建立课程教学与人…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023