自制程序语言・递归向下算法实现Calc

bxt_kk2024-02-02 11:25

利用递归向下算法结合我们的BKLexer实现支持四则运算与括号优先级的计算器程序。

代码清单【Golang】

go 复制代码 
package main

import (
    "fmt"
    "os"
    "bufio"
    "strings"
    "strconv"
    "./bklexer"
)

type Node interface {
    GetValue() float64
}

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) Node {
    result := parse_binary_add(lexer)
    token := lexer.GetToken()
    if token.TType != BKLexer.TOKEN_TYPE_EOF {
        return nil
    }
    return result
}

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 == "-" {
        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 == "/" {
        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.NextToken()
    if token.Name == "LPAR" {
        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]+")

    reader := bufio.NewReader(os.Stdin)
    for true {
        fmt.Print("> ")
        inputs, _ := reader.ReadString('\n')
        inputs = strings.Trim(inputs, " \f\t\n")
        if inputs == "quit" {
            break
        }
        if inputs != "" {
            lexer.Build(inputs)
            result := parse(lexer)
            if result == nil {
                positon := lexer.GetToken().Col
                fmt.Println("error in :", positon)
                continue
            }
            fmt.Println("out =", result.GetValue())
        }

    }

    fmt.Println("bye!")
}

运行测试

go 复制代码 
➜ go calc.go 

Hello My Calc.
> 1 + (2 - 3) * 4 / 5      
out = 0.19999999999999996
> quit
bye!

引入需要的包

go 复制代码 
import (
    "fmt"
    "os"
    "bufio"
    "strings"
    "strconv"
    "./bklexer"
)
  • fmt 打印输出
  • os + bufio 读取用户输入
  • strings 处理字符串
  • strconv 解析字符串
  • bklexer 用于词法分析

定义接口

go 复制代码 
type Node interface {
    GetValue() float64
}

Node作为接口将用于指向其它的结构，其GetValue方法可以获得节点的数值。

定义数字节点

go 复制代码 
type Number struct {
    value float64
}

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

Number作为数字类型的节点，有成员value用于存储数值，使用NewNumber函数可以实例它。

实现数字节点的接口方法

go 复制代码 
func (number *Number) GetValue() float64 {
    return number.value
}

定义运算操作节点

go 复制代码 
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}
}

BinaryOpt作为运算操作节点，成员opt记录运算符号，lhs、rhs分别为表达式左、右两边的内容，如1+2中的1与2。使用NewBinaryOpt函数实例它。

实现运算节点的接口方法

go 复制代码 
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
}

我们需要根据运算操作符号opt判断lhs与rhs的值究竟以怎样的方式进行计算。

定义语法解析的入口函数

go 复制代码 
func parse(lexer *BKLexer.Lexer) Node {
    result := parse_binary_add(lexer)
    token := lexer.GetToken()
    if token.TType != BKLexer.TOKEN_TYPE_EOF {
        return nil
    }
    return result
}

入口函数parse接收到*BKLexer.Lexer类型的参数后，立即将其发送到parse_binary_add中，尝试解析运算等级与加法操作相同的运算操作。最后判断当前token是否为结尾，若不是则返回nil否则返回解析结果。

定义加法等级运算操作的解析函数

go 复制代码 
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 == "-" {
        rhs := parse_binary_mul(lexer)
        if rhs == nil {
            return nil
        }
        lhs = NewBinaryOpt(token, lhs, rhs)
        token = lexer.GetToken()
    }
    return lhs
}

当函数接收到参数lexer并运行时会先尝试解析乘法等级的运算操作，如果解析完毕并成功返回则判断当前token的字面量决定是否需要构建加法等级运算节点，如果需要则尝试进行另一个乘法等级的运算操作解析，解析成功则根据opt构建当前运算等级的节点对象。

定义乘法等级运算操作的解析函数

go 复制代码 
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 == "/" {
        rhs := parse_number(lexer)
        if rhs == nil {
            return nil
        }
        lhs = NewBinaryOpt(token, lhs, rhs)
        token = lexer.GetToken()
    }
    return lhs
}

parse_binary_mul基本和parse_binary_add一样，只是在运行开始是尝试解析数字或括号表达式的内容，在判断需要构建乘法等级运算节点的时候也是尝试解析另一个数字或括号表达式的内容。

定义数字与括号表达式的解析函数

go 复制代码 
func parse_number(lexer *BKLexer.Lexer) Node {
    token := lexer.NextToken()
    if token.Name == "LPAR" {
        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
}

首先取得下一个token，判断是否是左括号，如果是则可能为括号表达式，需要尝试进行解析，如果解析成功还需要判断结尾是否为右括号，全部成功则返回解析的表达式节点，否则返回nil。若一开始的token不是左括号而是数字则实例一个数字节点并返回。若既不是左括号又不是数字则返回nil。

定义词法分析器规则

go 复制代码 
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]+")

循环读取用户输入并解析计算

go 复制代码 
reader := bufio.NewReader(os.Stdin)
for true {
    fmt.Print("> ")
    inputs, _ := reader.ReadString('\n')
    inputs = strings.Trim(inputs, " \f\t\n")
    if inputs == "quit" {
        break
    }
    if inputs != "" {
        lexer.Build(inputs)
        result := parse(lexer)
        if result == nil {
            positon := lexer.GetToken().Col
            fmt.Println("error in :", positon)
            continue
        }
        fmt.Println("out =", result.GetValue())
    }
}
fmt.Println("bye!")

当解析函数parse返回的内容不是nil时可以使用GetValue函数计算表达式并得到结果。

相关推荐
临沂堇20 分钟前
CCF刷题计划——训练计划（反向拓扑排序）
数据结构·c++·算法·拓扑·ccf
铁匠匠匠24 分钟前
【C总集篇】第八章 数组和指针
c语言·开发语言·数据结构·经验分享·笔记·学习·算法
Unicorn建模27 分钟前
2024“华为杯”中国研究生数学建模竞赛（E题）深度剖析|数学建模完整过程+详细思路+代码全解析
python·算法·数学建模
咕咕吖30 分钟前
二叉树的层序遍历(c)
数据结构·算法
“JB...One”1 小时前
openssl-AES-128-CTR加解密结构体
linux·数据结构·算法·ssl
爱数模的小云1 小时前
【华为杯】2024华为杯数模研赛D题 解题思路
算法·华为
好记性＋烂笔头2 小时前
hot100-438. 找到字符串中所有字母异位词
算法
六点半8882 小时前
【C/C++】速通涉及string类的经典编程题
c语言·开发语言·c++·算法
学地理的小胖砸3 小时前
【高分系列卫星简介】
开发语言·数码相机·算法·遥感·地理信息
yanyanwenmeng4 小时前
matlab基础
开发语言·算法·matlab
热门推荐
01CCF-CSP认证考试 202406-3 文本分词 100分题解02RAG 实践- Ollama+RagFlow 部署本地知识库032024年高教社杯数学建模国赛C题超详细解题思路分析04实战 | 基于YOLOv9和OpenCV实现车辆跟踪计数（步骤 + 源码）05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07软件工程从理论到实践客观题汇总(头歌第一章至第八章)08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）