关于golang:使计算器支持语句块

44次阅读

共计 5730 个字符，预计需要花费 15 分钟才能阅读完成。

上面咱们来为计算器程序减少语句块性能，使得程序能够做批量运算，
相似于程序语言中的代码块。

这次的代码以上一篇《递归向下算法实现 Calc》
的代码为根底编写，如果发现不相熟当下的内容能够回顾一下之前的篇章。

package main

import (
    "fmt"
    "strconv"
    "io/ioutil"
    "./bklexer"
)

type Node interface {GetValue() float64
}

type Block struct {statements []Node
}

func NewBlock() *Block {return &Block{}
}

func (block *Block) AddStatement(statement Node) {block.statements = append(block.statements, statement)
}

func (block *Block) Eval() {
    for i, statement := range block.statements {fmt.Printf("out[%d] = %f\n", i, statement.GetValue())
    }
}

type Number struct {value float64}

func NewNumber(token *BKLexer.Token) *Number {value, _ := strconv.ParseFloat(token.Source, 64)
    return &Number{value: value}
}

func (number *Number) GetValue() float64 {return number.value}

type BinaryOpt struct {
    opt string
    lhs Node
    rhs Node
}

func NewBinaryOpt(token *BKLexer.Token, lhs Node, rhs Node) *BinaryOpt {return &BinaryOpt{opt: token.Source, lhs: lhs, rhs: rhs}
}

func (binaryOpt *BinaryOpt) GetValue() float64 {
    lhs, rhs := binaryOpt.lhs, binaryOpt.rhs
    switch binaryOpt.opt {case "+": return lhs.GetValue() + rhs.GetValue()
        case "-": return lhs.GetValue() - rhs.GetValue()
        case "*": return lhs.GetValue() * rhs.GetValue()
        case "/": return lhs.GetValue() / rhs.GetValue()
    }
    return 0
}

func parse(lexer *BKLexer.Lexer) *Block {block := NewBlock()
    token := lexer.NextToken()
    for token.TType == BKLexer.TOKEN_TYPE_NEWLINE {token = lexer.NextToken()
    }
    for token.TType != BKLexer.TOKEN_TYPE_EOF {statement := parse_binary_add(lexer)
        if statement == nil {return nil;}
        token = lexer.GetToken()
        if token.TType != BKLexer.TOKEN_TYPE_NEWLINE &&
           token.TType != BKLexer.TOKEN_TYPE_EOF {return nil;}
        block.AddStatement(statement)
        for token.TType == BKLexer.TOKEN_TYPE_NEWLINE {token = lexer.NextToken()
        }
    }
    return block
}

func parse_binary_add(lexer *BKLexer.Lexer) Node {lhs := parse_binary_mul(lexer)
    if lhs == nil {return nil}
    token := lexer.GetToken()
    for token.Source == "+" || token.Source == "-" {lexer.NextToken()
        rhs := parse_binary_mul(lexer)
        if rhs == nil {return nil}
        lhs = NewBinaryOpt(token, lhs, rhs)
        token = lexer.GetToken()}
    return lhs
}

func parse_binary_mul(lexer *BKLexer.Lexer) Node {lhs := parse_number(lexer)
    if lhs == nil {return nil}
    token := lexer.GetToken()
    for token.Source == "*" || token.Source == "/" {lexer.NextToken()
        rhs := parse_number(lexer)
        if rhs == nil {return nil}
        lhs = NewBinaryOpt(token, lhs, rhs)
        token = lexer.GetToken()}
    return lhs
}

func parse_number(lexer *BKLexer.Lexer) Node {token := lexer.GetToken()
    if token.Name == "LPAR" {lexer.NextToken()
        expr := parse_binary_add(lexer)
        if expr == nil {return nil}
        token := lexer.GetToken()
        if token.Name != "RPAR" {return nil}
        lexer.NextToken()
        return expr
    }
    if token.Name == "NUMBER" {number := NewNumber(token)
        lexer.NextToken()
        return number
    }
    return nil
}

func main() {fmt.Println("Hello My Calc.")

    lexer := BKLexer.NewLexer()
    lexer.AddRule("\\d+\\.?\\d*", "NUMBER")
    lexer.AddRule("\\+", "PLUS")
    lexer.AddRule("-", "MINUS")
    lexer.AddRule("\\*", "MUL")
    lexer.AddRule("/", "DIV")
    lexer.AddRule("\\(", "LPAR")
    lexer.AddRule("\\)", "RPAR")
    lexer.AddIgnores("[ \\f\\t]+")
    lexer.AddIgnores("#[^\\r\\n]*")

    bytes, err := ioutil.ReadFile("../test.txt")
    if err != nil {fmt.Println("read faild")
        return
    }
    code := string(bytes)
    fmt.Println(code)
    lexer.Build(code)
    result := parse(lexer)
    if result == nil {fmt.Println("null result")
        return
    }
    result.Eval()}

import (
    "fmt"
    "strconv"
    "io/ioutil"
    "./bklexer"
)

fmt 打印输出
strconv 字符串转换
io/ioutil 读取文件
./bklexer 用于词法解析

type Block struct {statements []Node
}

func NewBlock() *Block {return &Block{}
}

Block构造的成员 statements 用于存储每一条语句，咱们应用 NewBlock 办法实例这个构造。

func (block *Block) AddStatement(statement Node) {block.statements = append(block.statements, statement)
}

func (block *Block) Eval() {
    for i, statement := range block.statements {fmt.Printf("out[%d] = %f\n", i, statement.GetValue())
    }
}

AddStatement用于插入新的语句，Eval用于批量计算结果并打印进去。

func parse(lexer *BKLexer.Lexer) *Block {block := NewBlock()
    token := lexer.NextToken()
    for token.TType == BKLexer.TOKEN_TYPE_NEWLINE {token = lexer.NextToken()
    }
    for token.TType != BKLexer.TOKEN_TYPE_EOF {statement := parse_binary_add(lexer)
        if statement == nil {return nil;}
        token = lexer.GetToken()
        if token.TType != BKLexer.TOKEN_TYPE_NEWLINE &&
           token.TType != BKLexer.TOKEN_TYPE_EOF {return nil;}
        block.AddStatement(statement)
        for token.TType == BKLexer.TOKEN_TYPE_NEWLINE {token = lexer.NextToken()
        }
    }
    return block
}

parse中首先实例一个 block 构造对象，而后开始解析 Token，
应用循环解析的办法依序解析失去每一条 statement 并插入 block 中，最初返回 block。

须要留神的是咱们每一条语句的开端要么是换行要么是结尾，否则将被视为解析谬误并返回nil:

        token = lexer.GetToken()
        if token.TType != BKLexer.TOKEN_TYPE_NEWLINE &&
           token.TType != BKLexer.TOKEN_TYPE_EOF {return nil;}

在咱们解析完一条语句后，该当马上越过前面的换行符，这能够使得咱们在批量计算中疏忽空白行:

        for token.TType == BKLexer.TOKEN_TYPE_NEWLINE {token = lexer.NextToken()
        }

func parse_number(lexer *BKLexer.Lexer) Node {token := lexer.GetToken()
    
    ......

在 parse_number 函数中，
token := lexer.NextToken()变为 token := lexer.GetToken()，
因而咱们须要确保各个解析函数相互调用时须要先被动在以后函数中调用 NextToken() 办法。

例如:

......
func parse(lexer *BKLexer.Lexer) *Block {
    ......
    token := lexer.NextToken()
    for token.TType == BKLexer.TOKEN_TYPE_NEWLINE {token = lexer.NextToken()
    }
    for token.TType != BKLexer.TOKEN_TYPE_EOF {statement := parse_binary_add(lexer)
......
func parse_binary_add(lexer *BKLexer.Lexer) Node {
    ......
    for token.Source == "+" || token.Source == "-" {lexer.NextToken()
        rhs := parse_binary_mul(lexer)
    ......

lexer := BKLexer.NewLexer()
lexer.AddRule("\\d+\\.?\\d*", "NUMBER")
lexer.AddRule("\\+", "PLUS")
lexer.AddRule("-", "MINUS")
lexer.AddRule("\\*", "MUL")
lexer.AddRule("/", "DIV")
lexer.AddRule("\\(", "LPAR")
lexer.AddRule("\\)", "RPAR")
lexer.AddIgnores("[ \\f\\t]+")
lexer.AddIgnores("#[^\\r\\n]*")

须要留神的是这里对有效字符的设定还减少了新的规定 lexer.AddIgnores("#[^\\r\\n]*")，
这使得程序反对 Python 的正文语法。

bytes, err := ioutil.ReadFile("../test.txt")
if err != nil {fmt.Println("read faild")
    return
}
code := string(bytes)
fmt.Println(code)
lexer.Build(code)
result := parse(lexer)
if result == nil {fmt.Println("null result")
    return
}
result.Eval()

测试内容:

1 + 2 # plus
3 - 4

# here is a comment

5 * 6 # mul
7 / 8

1 + (2 - 3) * 4 / 5 # composite

运行后果:

➜ go run calc.go
Hello My Calc.
1 + 2 # plus
3 - 4

# here is a comment

5 * 6 # mul
7 / 8

1 + (2 - 3) * 4 / 5 # composite

out[0] = 3.000000
out[1] = -1.000000
out[2] = 30.000000
out[3] = 0.875000
out[4] = 0.200000

下篇《使程序语言反对变量》，欢送关注。

正文完

vim

发表至： vim

2021-03-31

0

关于vim:小知识Linux系统ssh连接的超时时间设置

关于vim:oeasy教您玩转vim-11-向前向后

关于vim:oeasy教您玩转vim-29-垂直翻页

关于vim:oeasy教您玩转vim-81-宏macro的进阶

关于数据建模:DataWorks数据建模公开课上线啦

关于golang:使计算器支持语句块

代码清单【go 语言为例】

引入须要应用的包

定义语句块构造体

为语句块构造增加成员办法

定义语法解释器入口函数

有几处批改须要留神

定义词法解析器规定

读取文件进行解析计算

应用一段测试脚本进行测试

Just My Socks（注册教程内含优惠码）

关于golang:使计算器支持语句块

代码清单【go 语言为例】

引入须要应用的包

定义语句块构造体

为语句块构造增加成员办法

定义语法解释器入口函数

有几处批改须要留神

定义词法解析器规定

读取文件进行解析计算

应用一段测试脚本进行测试

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）