《用Go语言自制解释器》之第1章 词法分析

已于 2022-08-26 08:00:29 修改
阅读量844 收藏 10
点赞数 1
分类专栏： Go 文章标签： go 解释器
于 2022-08-26 07:59:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oqqyx1234567/article/details/126496686
版权

《用Go语言自制解释器》之第1章 词法分析

第1章 词法分析

1.1 词法分析

源代码
->（词法分析）
词法单元
->（语法分析）
抽象语法树

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
	STRING = "STRING" // "foobar"

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

	LT = "<"
	GT = ">"

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

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

	LPAREN   = "("
	RPAREN   = ")"
	LBRACE   = "{"
	RBRACE   = "}"
	LBRACKET = "["
	RBRACKET = "]"

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

1.3 词法分析器

定义

//lexer/lexer.go
package lexer

type Lexer struct {
	input string
	position int //当前字符位置
	readPosition int //下一个字符位置
	ch byte //当前字符
}

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

读取字符

//lexer/lexer.go
func (l *Lexer) readChar() {
	if l.readPosition >= len(l.input) { //到达input末尾
		l.ch = 0 //文件末尾
	} else {
		l.ch = l.input[l.readPosition]
	}
	l.position = l.readPosition
	l.readPosition += 1
}

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

获取单字符词法单元

//lexer/lexer.go
package lexer

import "monkey/token"

func (l *Lexer) NextToken() token.Token {
	var tok token.Token
	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.SLASH, l.ch)
	case '*':
		tok = newToken(token.ASTERISK, l.ch)
	case '<':
		tok = newToken(token.LT, l.ch)
	case '>':
		tok = newToken(token.GT, l.ch)
	case ';':
		tok = newToken(token.SEMICOLON, l.ch)
	case ':':
		tok = newToken(token.COLON, l.ch)
	case ',':
		tok = newToken(token.COMMA, l.ch)
	case '{':
		tok = newToken(token.LBRACE, l.ch)
	case '}':
		tok = newToken(token.RBRACE, l.ch)
	case '(':
		tok = newToken(token.LPAREN, l.ch)
	case ')':
		tok = newToken(token.RPAREN, l.ch)
	case '[':
		tok = newToken(token.LBRACKET, l.ch)
	case ']':
		tok = newToken(token.RBRACKET, l.ch)
	case 0:
		tok.Literal = ""
		tok.Type = token.EOF
	}

	l.readChar()
	return tok
}

func newToken(tokenType token.TokenType, ch byte) token.Token {
	return token.Token{Type: tokenType, Literal: string(ch)}
}

获取标识符词法单元

//lexer/lexer.go
package lexer

import "monkey/token"

func (l *Lexer) NextToken() token.Token {
	var tok token.Token
	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.SLASH, l.ch)
	case '*':
		tok = newToken(token.ASTERISK, l.ch)
	case '<':
		tok = newToken(token.LT, l.ch)
	case '>':
		tok = newToken(token.GT, l.ch)
	case ';':
		tok = newToken(token.SEMICOLON, l.ch)
	case ':':
		tok = newToken(token.COLON, l.ch)
	case ',':
		tok = newToken(token.COMMA, l.ch)
	case '{':
		tok = newToken(token.LBRACE, l.ch)
	case '}':
		tok = newToken(token.RBRACE, l.ch)
	case '(':
		tok = newToken(token.LPAREN, l.ch)
	case ')':
		tok = newToken(token.RPAREN, l.ch)
	case '[':
		tok = newToken(token.LBRACKET, l.ch)
	case ']':
		tok = newToken(token.RBRACKET, l.ch)
	case 0:
		tok.Literal = ""
		tok.Type = token.EOF
	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
}

//读取标识符字符串
func (l *Lexer) readIdentifier() string {
	position := l.position
	for isLetter(l.ch) {
		l.readChar()
	}
	return l.input[position:l.position]
}

//a-z_组成标识符
func isLetter(ch byte) bool {
	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
}

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

//判断标识符是是否是关键字
func LookupIdent(ident string) TokenType {
	if tok, ok := keywords[ident]; ok {
		return tok
	}
	return IDENT
}

跳过空白字符

//lexer/lexer.go
package lexer

import "monkey/token"

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.SLASH, l.ch)
	case '*':
		tok = newToken(token.ASTERISK, l.ch)
	case '<':
		tok = newToken(token.LT, l.ch)
	case '>':
		tok = newToken(token.GT, l.ch)
	case ';':
		tok = newToken(token.SEMICOLON, l.ch)
	case ':':
		tok = newToken(token.COLON, l.ch)
	case ',':
		tok = newToken(token.COMMA, l.ch)
	case '{':
		tok = newToken(token.LBRACE, l.ch)
	case '}':
		tok = newToken(token.RBRACE, l.ch)
	case '(':
		tok = newToken(token.LPAREN, l.ch)
	case ')':
		tok = newToken(token.RPAREN, l.ch)
	case '[':
		tok = newToken(token.LBRACKET, l.ch)
	case ']':
		tok = newToken(token.RBRACKET, l.ch)
	case 0:
		tok.Literal = ""
		tok.Type = token.EOF
	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
}

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

读取数字词法单元

//lexer/lexer.go
package lexer

import "monkey/token"

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.SLASH, l.ch)
	case '*':
		tok = newToken(token.ASTERISK, l.ch)
	case '<':
		tok = newToken(token.LT, l.ch)
	case '>':
		tok = newToken(token.GT, l.ch)
	case ';':
		tok = newToken(token.SEMICOLON, l.ch)
	case ':':
		tok = newToken(token.COLON, l.ch)
	case ',':
		tok = newToken(token.COMMA, l.ch)
	case '{':
		tok = newToken(token.LBRACE, l.ch)
	case '}':
		tok = newToken(token.RBRACE, l.ch)
	case '(':
		tok = newToken(token.LPAREN, l.ch)
	case ')':
		tok = newToken(token.RPAREN, l.ch)
	case '[':
		tok = newToken(token.LBRACKET, l.ch)
	case ']':
		tok = newToken(token.RBRACKET, l.ch)
	case 0:
		tok.Literal = ""
		tok.Type = token.EOF
	default:
		if isLetter(l.ch) {
			tok.Literal = l.readIdentifier()
			//判断关键字或者标识符
			tok.Type = token.LookupIdent(tok.Literal)
			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
}

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

//0-9组成数字
func isDigit(ch byte) bool {
	return '0' <= ch && ch <= '9'
}

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

词法单元分类

单字符词法单元，-+/*等；
双字符词法单元，==等；
关键字词法单元，return等；
数字词法单元，12345等；
标识符词法单元，x等；

完整版词法单元解析

//lexer/lexer.go
package lexer

import "monkey/token"

func (l *Lexer) NextToken() token.Token {
	var tok token.Token
	l.skipWhitespace()
	switch l.ch {
	case '=':
		if l.peekChar() == '=' {
			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 '+':
		tok = newToken(token.PLUS, l.ch)
	case '-':
		tok = newToken(token.MINUS, l.ch)
	case '!':
		if l.peekChar() == '=' {
			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)
		}
	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)
	case ';':
		tok = newToken(token.SEMICOLON, l.ch)
	case ':':
		tok = newToken(token.COLON, l.ch)
	case ',':
		tok = newToken(token.COMMA, l.ch)
	case '{':
		tok = newToken(token.LBRACE, l.ch)
	case '}':
		tok = newToken(token.RBRACE, l.ch)
	case '(':
		tok = newToken(token.LPAREN, l.ch)
	case ')':
		tok = newToken(token.RPAREN, l.ch)
	case '"':
		tok.Type = token.STRING
		tok.Literal = l.readString()
	case '[':
		tok = newToken(token.LBRACKET, l.ch)
	case ']':
		tok = newToken(token.RBRACKET, l.ch)
	case 0:
		tok.Literal = ""
		tok.Type = token.EOF
	default:
		if isLetter(l.ch) {
			tok.Literal = l.readIdentifier()
			tok.Type = token.LookupIdent(tok.Literal)
			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
}

//窥视下一个字符，不会移动当前字符位置
func (l *Lexer) peekChar() byte {
	if l.readPosition >= len(l.input) {
		return 0
	} else {
		return l.input[l.readPosition]
	}
}

1.5 编写REPL

Read-Eval-Print Loop（读取-求值-打印 循环），控制台或交互模式。

源代码转换为词法单元并打印

//repl/repl.go
package repl

import (
	"bufio"
	"fmt"
	"io"
	"monkey/lexer"
	"monkey/token"
)

const PROMPT = ">>"

func Start(in io.Reader, out io.Writer) {
	scanner := bufio.NewScanner(in)
	for {
		fmt.Fprintf(out, PROMPT)
		scanned := scanner.Scan()
		if !scanned { //Ctrl+C跳出循环
			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)
		}
	}
}

//%v，打印结构体
 /*
type EqStruct struct{
	Name string
	Age  int32
}
e := EqStruct{Name:"2", Age:0}

//值
fmt.Printf("e=%v\n", e1)
//e={2 0}    

//字段名+值
fmt.Printf("e=%+v\n", e1)
//e={Name:2 Age:0}

//结构体值的Go语法表示
fmt.Printf("e=%#v\n", e1)
//e=main.EqStruct{Name:"2", Age:0} 
*/

主函数

//main.go
package main
import (
	"fmt"
	"monkey/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)
}

1.6 完整工程

monkey\token\token.go

package token

type TokenType string

const (
	ILLEGAL = "ILLEGAL"
	EOF     = "EOF"

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

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

	LT = "<"
	GT = ">"

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

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

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

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

type Token struct {
	Type    TokenType
	Literal string
}

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

func LookupIdent(ident string) TokenType {
	if tok, ok := keywords[ident]; ok {
		return tok
	}
	return IDENT
}

monkey\lexer\lexer.go

package lexer

import "monkey/token"

type Lexer struct {
	input        string
	position     int  // 当前字符位置
	readPosition int  // 下一个字符位置
	ch           byte // 当前字符
}

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

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

	l.skipWhitespace()

	switch l.ch {
	case '=':
		if l.peekChar() == '=' {
			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 '+':
		tok = newToken(token.PLUS, l.ch)
	case '-':
		tok = newToken(token.MINUS, l.ch)
	case '!':
		if l.peekChar() == '=' {
			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)
		}
	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)
	case ';':
		tok = newToken(token.SEMICOLON, l.ch)
	case ',':
		tok = newToken(token.COMMA, l.ch)
	case '{':
		tok = newToken(token.LBRACE, l.ch)
	case '}':
		tok = newToken(token.RBRACE, l.ch)
	case '(':
		tok = newToken(token.LPAREN, l.ch)
	case ')':
		tok = newToken(token.RPAREN, l.ch)
	case 0:
		tok.Literal = ""
		tok.Type = token.EOF
	default:
		if isLetter(l.ch) {
			tok.Literal = l.readIdentifier()
			tok.Type = token.LookupIdent(tok.Literal)
			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
}

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

func (l *Lexer) readChar() {
	if l.readPosition >= len(l.input) {
		l.ch = 0
	} else {
		l.ch = l.input[l.readPosition]
	}
	l.position = l.readPosition
	l.readPosition += 1
}

func (l *Lexer) peekChar() byte {
	if l.readPosition >= len(l.input) {
		return 0
	} else {
		return l.input[l.readPosition]
	}
}

func (l *Lexer) readIdentifier() string {
	position := l.position
	for isLetter(l.ch) {
		l.readChar()
	}
	return l.input[position:l.position]
}

func (l *Lexer) readNumber() string {
	position := l.position
	for isDigit(l.ch) {
		l.readChar()
	}
	return l.input[position:l.position]
}

func isLetter(ch byte) bool {
	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
}

func isDigit(ch byte) bool {
	return '0' <= ch && ch <= '9'
}

func newToken(tokenType token.TokenType, ch byte) token.Token {
	return token.Token{Type: tokenType, Literal: string(ch)}
}

monkey\lexer\lexer_test.go

package lexer

import (
	"testing"
	"monkey/token"
)

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)
		}
	}
}

monkey\repl\repl.go

package repl

import (
	"bufio"
	"fmt"
	"io"
	"monkey/lexer"
	"monkey/token"
)

const PROMPT = ">>"

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

	for {
		fmt.Fprintf(out, PROMPT)
		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)
		}
	}
}

monkey\main.go

package main

import (
	"fmt"
	"monkey/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)
}

monkey\run.txt

go mod init monkey

go test .\lexer

go run main.go
mali378287007
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bpp:用Go语言编写的B ++解释器！
04-02
B ++ 用Go语言编写的B ++解释器！ 安装 要安装或更新B ++，请执行 go get -u github.com/Nv7-Github/Bpp 基本用法 要运行文件，请执行 bpp -file filename 例如，要运行kin示例，请执行 bpp -file examples/kin.bpp 程序参数 B ++程序支持参数，这些参数使用ARGS标记读取。 要通过命令行工具传递参数，只需在-args标志中传递逗号分隔的值。 例子： bpp -file filename -args arg1,arg2,arg3 在您自己的代码中使用它 您可以在自己的代码中使用它。 为此，首先，编译程序。 你可以这样做 prog , err := parser . Parse ( src ) 处理err以查找编译时错误。 然后，要执行程序并获取输出，请执行 out , err := prog
go-ast-book：《 Go语法树入门-开启自制编程语言和编译器之旅》（开源免费图书Go语言进阶掌握抽象语法树Go语言AST凹语言）
02-04
Go语法树入门-开启自制编程语言和编译器之旅！ Go语言QQ群：102319854，1055927514 光谷码农课堂： ://study.163.com/provider/480000001914454/index.htm 凹语言（凹读音“ Wa”）（Wa编程语言）： : 蚂蚁金服招聘云原生方向和编程语言方向职位（杭州/ P7）：云原生方向要求熟悉k8s配套工具，如kubectl，kustomize，kubebuilder，operator；编程语言方向要求对语言对语言解释器（如py / js / lua / wasm等），工具链，配套SDK有一定的兴趣和实践经验。欢迎各位同学咨询或推
【Interpreter】构建简单的解释器（第2部分—Go语言实现）
问题不大
01-02 3652
文章目录【Interpreter】构建简单的解释器（第1部分—练习—Go语言实现）一、练习题目二、代码三、运行结果 【Interpreter】构建简单的解释器（第1部分—练习—Go语言实现） 一、练习题目 修改代码，允许输入多位数整数，例如 “12+3” 添加一个忽略空白字符的方法，让计算器可以处理带有空白字符的输入，如 “12 + 3” 修改代码，使用 ‘-’ 代替 ‘+’ 来处理像 “7-...
推荐项目：wagon - WebAssembly在Go中的强大解释器
gitblog_00033的博客
05-16 298
推荐项目：wagon - WebAssembly在Go中的强大解释器 项目地址:https://gitcode.com/go-interpreter/wagon 项目介绍 wagon 是一个基于Go语言的WebAssembly（简称WASM）解释器，为Go程序员提供了一个工具集，可以解码和执行WASM二进制文件。虽然目前项目处于只读模式并寻找新的维护者，但其提供的功能和潜在价值仍然不容忽视。 项目...
《用Go语言自制解释器》之第3章 求值
yxqq378287007的博客
08-30 448
《用Go语言自制解释器》之第3章 求值
6月书讯 | 9本新书上市，阵容强大，闭眼入！
图灵教育
06-30 238
6 月书讯姗姗来迟，不知不觉半年时光悄然过去，回想起年初的读书目标，不知你完成了多少？本月 9 本新书，有硅谷创业教父保罗·格雷厄姆文集《黑客与画家》的 10 万册纪念版、还有畅销经典 Linux 命令行“圣经”升级版《Linux 命令行与 shell 脚本编程大全（第4版）》。啃不动“龙书”“虎书”？本月两本“猴书”带你走入自制的世界。另外，万众期待的《程序员的数学4》...
《用Go语言自制解释器》之第4章 扩展解释器
yxqq378287007的博客
09-01 646
《用Go语言自制解释器》之第4章 扩展解释器
CMM.rar_CMM解释器_CMM词法_CMM语言_CMM语言解释器_cmm词法分析
09-19
词法分析是编译器或解释器的第一步，它将源代码分解成一系列的词法单元，也称为标记（tokens），这些标记代表了语言的基本元素。在"**CMM语言解释器**"中，词法分析是至关重要的，因为它为语法解析提供输入，确保...
基于Java实现的CMM语言解释器，包括词法分析，语法分析等
最新发布
05-16
【作品名称】：基于Java实现的CMM语言解释器，包括词法分析，语法分析等 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍...
编译原理：手工构造TINY语言的词法分析器.zip
05-07
词法分析器，又称为扫描器或tokenizer，是编译器的第一阶段。它的任务是读取源代码，识别出一个个称为“标记”(token)的最小语法单位，如关键字、标识符、常量、运算符等。在这个过程中，我们需要了解TINY语言的词法...
编译原理实验一——C 语言词法分析器设计与实现
08-29
在编译原理中，词法分析器（也称为扫描器）是第一个处理源代码的组件。它的主要任务是： 1. **定义单词的构词规则**：词法分析器需要明确识别出构成源代码的各个元素，如关键字、标识符、常量、运算符、分隔符等。...
Writing An Interpreter In Go图书，代码(mobi,pdf,epub)
08-08
用go语言写解释器，图书（Pdf，mobi，epub格式），还有代码。这些资源，我都放在了压缩包里。
Go-go.vm一个简单的虚拟机-编译器和解释器-用golang编写
08-13
go.vm 一个简单的虚拟机 - 编译器和解释器 - 用golang编写
goawk：使用Go语言编写的POSIX兼容AWK解释器
02-03
GoAWK：用Go编写的AWK解释器 AWK是一种引人入胜的文本处理语言，在阅读了令人愉快的简洁的我受到启发，用Go 为其编写了一个解释器。 这样就完成了功能，并针对“一个真正的AWK”测试套件进行了测试。 基本用法 要使用命令行版本，只需使用go get安装它，然后使用goawk运行它（假定$GOPATH/bin在您的PATH ）： $ go get github.com/benhoyt/goawk $ goawk ' BEGIN { print "foo", 42 } ' foo 42 $ echo 1 2 3 | goawk ' { print $1 + $3 } ' 4 在Windows上， "是shell引用字符，所以使用"周围的命令行对整个AWK程序，并使用'周围AWK字符串-这是一个非POSIX扩展，使GoAWK更容易使用在Windows上： C:\ > goawk " BEGIN { print 'foo', 42 } " foo 42 要在Go程序中使用它，可以直接调用interp.Exec()来满足简单的需求： input := bytes . NewR
interpreter_go：用Golang内置的基本解释器
02-17
interpreter_go：用Golang内置的基本解释器
java解释器初步之词法分析
10-30
在这个初步的Java解释器中，重点在于词法分析，这是编译器设计过程中的第一步。词法分析，也称为扫描，是从源代码中识别出有意义的符号，即标记（tokens），这些标记构成了程序的基本构建块。本项目不仅实现了词法...
纯golang写的解释器，轻量级编程语言开发
pywee的博客
11-13 584
利用纯 golang 编写的解释器，目前在持续开发中，我计划把它写成一个轻量级的编程语言用于web开发。如果能够顺利实现所需要的基本功能，那么通过它编写一个golang模板引擎将会非常容易。
【Interpreter】构建简单的解释器（第1部分—Go语言实现）
问题不大
01-15 4320
文章目录【Interpreter】构建简单的解释器（第1部分—Go语言实现）一、描述二、代码三、运行结果 【Interpreter】构建简单的解释器（第1部分—Go语言实现） 一、描述 能够计算两个个位整数的和，如 3 + 5。 二、代码 // 使用 Go 简单实现 package main import ( "bufio" "fmt" "os" "strings" "uni...
go语言实现指令集和解释器
csdn闻声即知人的博客
03-20 168
指令集和解释器Java虚拟机指的是一台虚拟的机器，字节码就是运行在这台虚拟机器上的机器码。每个类或者接口都会被Java编译器编译成一个class文件，类或者接口的方法信息放在class文件的method_info结构中，如果方法不是抽象方法，也不是本地方法，方法的Java代码就会被编译器编译成字节码，存放在method_info结构体的Code属性中。每条字节码指令是以一个单字节的操作码(opcode)开头，这就是字节码名称的由来。
用c++自制词法分析器
11-14
自制词法分析器是一个非常有趣的项目，它可以帮助我们理解编程语言中的词法结构。在C语言中，我们可以使用lex和yacc这两个工具来实现自制词法分析器。 首先，我们需要定义一些正则表达式来描述编程语言中的常见词法结构，比如标识符、关键字、运算符、常量等。然后，我们可以使用lex工具来将这些正则表达式转换为对应的词法分析器代码。 接着，我们需要编写一些语法规则来描述编程语言中的语法结构，比如表达式、语句、函数等。然后，我们可以使用yacc工具来将这些语法规则转换为对应的语法分析器代码。 最后，我们需要将词法分析器和语法分析器结合起来，构建一个完整的编程语言解析器。通过这个解析器，我们可以将源代码转换为抽象语法树，并对其进行语法分析，从而实现对源代码的解析和理解。 通过自制词法分析器，我们可以更深入地理解编程语言的词法结构和语法结构，从而提升我们的编程能力。同时，这个项目也可以让我们学习到很多关于编译原理和语言解析的知识，是一个非常值得尝试的学习项目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值