一个简单的解释器

最新推荐文章于 2022-11-04 17:17:13 发布
最新推荐文章于 2022-11-04 17:17:13 发布
阅读量317 收藏
点赞数
分类专栏： 编译原理 文章标签： c++ 编译原理 AST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48201696/article/details/123649460
版权

词法分析 语法分析 抽象语法树 脚本解释器 程序执行
关键词由CSDN通过智能技术生成

实现一个简单的解释器

功能

  • 支持整形变量定义，int a
  • 支持赋值语句a = expression
  • 表达式可以使用变量
  • 支持AST的打印

文法

BNF规则描述文法

program::= statement+

statement::= intDeclaration | expressionStatement | assignStatement

intDeclaration::= INT ID ('=' expression)? ';'

expressionStatement::= expression ';'

assignStatement::= ID '=' expression ';'

expression::= expression1 ('+' expression1 | '-' expression1)* 

expression1::= expression2 ('*' expression2 | '/' expression2)*

expression2::= ID | NUM | '(' expression ')'

设计

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fgk1TZow-1647876869933)(C:\Users\20580\AppData\Roaming\Typora\typora-user-images\image-20220318170659566.png)]

实现

词法分析模块

词法分析的过程是将字符流识别出来变成一个个的词素Token,这个Token的定义，组织为

/* 词法单元模块 */
using Name = std::string;

// Token的枚举
enum TokenID{
    INT,    // int
    ID,     // id
    NUM,    // number
    OTHER,  // Other Char + - * / = ;
    UNDEF   // un define
};

// Token的定义，Name为Token的字符值，id为Token的编号
struct Token{
    Name value;
    TokenID id;
    Token():id(UNDEF),value(""){};
};

在项目中，笔者写了三个接口，分别为:

read： 从字符流中读取一个Token

peek： 从字符流中前看一个Token

lookAhead：从字符流中前看n个Token

他的源代码为

// 读取一个Token
Token read(){
    Token token;
    while (*p != '\0'){
        char character = *p;
        if(char_set.find(character) != char_set.cend()){
            p++;
            token.id = OTHER;
            token.value.push_back(character);
            return token;
        }else{
            if(character == ' ' || character == '\r' || character == '\n' || character == '\t'){
                p++;
                continue;
            }
            // 识别数字
            if(isDig(character)){
                token.id = NUM;
                readDig(token);
                return token;
            }
            // 识别int 和 id
            readIdOrInt(token);
            return token;
        }
    }
    token.id = UNDEF;
    return token;
}

// 预读n个token
std::vector<Token> lookAhead(int n){
    char *peek = p;
    std::vector<Token> tokens = {};
    for (int i = 0; i < n; ++i){
        if(*p == '\0')
            break;
        tokens.push_back(read());
    }
    p = peek;
    return tokens;
}

// 预读一个token
Token peek(){
    char *peek = p;  // p指向字符流的指针
    Token t = read();
    p = peek;
    return t;
}

语法分析模块生成AST

根据上面的文法描述，从顶层文法一层一层往下递归，来实现整个语法分析的过程，并且递归的构造AST，根据AST结点类型的不同，对于AST的组织也是仅仅使用了一个简单的定义，并且AST的结点类型使用一个枚举类型来声明，AST的定义为

/*语法分析，AST生成模块*/
enum ASTNodeType{
    IntDeclaration,
    AssignStatement,
    ExpressionStatement,
    AddNode,
    SubNode,
    MulNode,
    DivNode,
    ELENode,
};


class SimpleASTNode{
public:
    SimpleASTNode(ASTNodeType type):ast_type(type),childs{}, token(){}
    void addChild(SimpleASTNode *node){
        childs.push_back(node);
    }

    // eval AST 执行AST, 打印结果
    int eval(){
        switch (ast_type) {
            case IntDeclaration:{
                printf("Decl var: %s\n", token.value.c_str());
                var_map[token.value] = 0;
                if(!childs.empty()){
                    childs[0]->eval();
                }
                break;
            }
            case AssignStatement:{
                if(var_map.find(token.value) == var_map.cend()){
                    printf("[ERROR]:Var %s is not define\n", token.value.c_str());
                    throw std::exception();
                }else{
                    int value = childs[0]->eval();
                    var_map[token.value] = value;
                    printf("Assign %s = %d\n", token.value.c_str(), value);
                }
                break;
            };
            case ExpressionStatement:{
                int value = childs[0]->eval();
                printf("expression res: %d\n", value);
                break;
            }
            case AddNode:{
                return childs[0]->eval() + childs[1]->eval();
            };
            case SubNode:{
                return childs[0]->eval() - childs[1]->eval();
            };
            case MulNode:{
                return childs[0]->eval() * childs[1]->eval();
            };
            case DivNode:{
                return childs[0]->eval() / childs[1]->eval();
            };
            case ELENode:{
                if(token.id == NUM)
                    return atoi(token.value.c_str());
                else if(token.id == ID){
                    if(var_map.find(token.value) == var_map.cend()){
                        printf("[ERROR]:Var %s is not define\n", token.value.c_str());
                        throw std::exception();
                    }
                    return var_map[token.value];
                }else{
                    printf("[ERROR]:Unknown error!\n");
                    throw std::exception();
                }
            };
            default:{
                std::cerr<<"[ERROR]:Unknown AST type"<<std::endl;
                return -1;
            }
        }
        return 0;
    }

    //printAST 打印AST
    void printAST(std::string tab){
        switch(ast_type){
            case IntDeclaration:{
                printf("%sIntDeclarationNode:%s\n", tab.c_str(), token.value.c_str());
                if(!childs.empty()){
                    tab.append("    ");
                    childs[0]->printAST(tab);
                }
                return;
            }
            case AssignStatement:{
                printf("%sAssignNode:%s\n", tab.c_str(), token.value.c_str());
                tab.append("    ");
                childs[0]->printAST(tab);
                return;
            }
            case ExpressionStatement:{
                printf("%sExpressionNode:\n", tab.c_str());
                tab.append("    ");
                childs[0]->printAST(tab);
                return;
            }
            case AddNode:{
                printf("%sAddNode:\n", tab.c_str());
                tab.append("    ");
                childs[0]->printAST(tab);
                childs[1]->printAST(tab);
                return;
            }
            case SubNode:{
                printf("%sSubNode:\n", tab.c_str());
                tab.append("    ");
                childs[0]->printAST(tab);
                childs[1]->printAST(tab);
                return;
            }
            case MulNode:{
                printf("%sMulNode:\n", tab.c_str());
                tab.append("    ");
                childs[0]->printAST(tab);
                childs[1]->printAST(tab);
                return;
            }
            case DivNode:{
                printf("%sDivNode:\n", tab.c_str());
                tab.append("    ");
                childs[0]->printAST(tab);
                childs[1]->printAST(tab);
                return;
            }
            case ELENode:{
                if(token.id == ID){
                    printf("%sIDNode:%s\n", tab.c_str(), token.value.c_str());
                }else if(token.id == NUM){
                    printf("%sNUMNode:%s\n", tab.c_str(), token.value.c_str());
                }
                return;
            }
        }
    }

    void setToken(Token tok){
        token.id = tok.id;
        token.value = tok.value;
    }
private:
    ASTNodeType ast_type;
    Token token;
    std::vector<SimpleASTNode*> childs;
};

基于上面的AST构造，依照文法， 从顶层往下层构造AST，每一个非终结符使用一个函数构造

// 表达式求值
SimpleASTNode* expression();
SimpleASTNode* expression1();
SimpleASTNode* expression2();

/**
 * 文法描述，采用扩展BNF写法
 * program::= statement+
 * statement::= intDeclaration | expressionStatement | assignStatement
 * intDeclaration::= INT ID ('=' expression)? ';'
 * expressionStatement::= expression ';'
 * assignStatement::= ID '=' expression ';'
 * expression::= expression1 ('+' expression1 | '-' expression1)*
 * expression1::= expression2 ('*' expression2 | '/' expression2)*
 * expression2::= ID | NUM | '(' expression ')'
 */

SimpleASTNode* expression2(){
    SimpleASTNode *node = nullptr;
    char *loc = p;
    Token token = peek();
    if(token.id == ID || token.id == NUM){
        read();
        if(token.id == ID){
            Token t = peek();
            if(t.value == "="){
                p = loc;
                return nullptr;
            }
        }
        node = new SimpleASTNode(ELENode);
        node->setToken(token);
        return node;
    }else if(token.value == "("){
        read();
        node = expression();
        if(node == nullptr){
            printf("[ERROR]:Undefined Statement\n");
            throw std::exception();
        }
        token = peek();
        if(token.value != ")"){
            printf("[ERROR]:Undefined Statement\n");
            throw std::exception();
        }
        read();
    }
    return node;
}

SimpleASTNode* expression1(){
    //expression1::= expression2 (* expression2 | / expression2)*
    SimpleASTNode *node = expression2();
    if(node == nullptr)
        return node;
    Token t = peek();
    SimpleASTNode *p = node;
    SimpleASTNode *root;
    while (t.id == OTHER && (t.value == "*" || t.value == "/")){
        if(t.value == "*"){
            root = new SimpleASTNode(MulNode);
        }else{
            root = new SimpleASTNode(DivNode);
        }
        root->addChild(p);
        read();
        node = expression2();
        if(node == nullptr){
            printf("[ERROR]:Undefined Statement\n");
            throw std::exception();
        }
        root->addChild(node);
        p = root;
        t = peek();
    }
    return p;
}

SimpleASTNode* expression(){
    // expression::= expression1 (+ expression1 | - expression1)*
    SimpleASTNode *node = expression1();
    if(node == nullptr)
        return node;
    Token t = peek();
    SimpleASTNode *p = node;
    SimpleASTNode *root;
    if(t.value == "="){
        printf("[ERROR]:Undefined Statement\n");
        throw std::exception();
    }
    while (t.id == OTHER && (t.value == "+" || t.value == "-")){

        if(t.value == "+"){
            root = new SimpleASTNode(AddNode);
        }else{
            root = new SimpleASTNode(SubNode);
        }
        root->addChild(p);
        read();
        node = expression1();
        if(node == nullptr){
            printf("[ERROR]:Undefined Statement\n");
            throw std::exception();
        }
        root->addChild(node);
        p = root;
        t = peek();
    }
    return p;
}

//
SimpleASTNode* intDeclaration(){
    SimpleASTNode *node = nullptr;
    Token token = peek();
    if(token.id == INT){
        read(); // 消耗一个字符
        node = new SimpleASTNode(IntDeclaration);
        token = read();
        if(token.id != ID){
            printf("[ERROR]:Undefined Statement\n");
            throw std::exception();
        }else{
            node->setToken(token);
            Token tokens = token;
            token = peek();
            if(token.id == OTHER && token.value == "="){
                // 添加子节点
                read();
                SimpleASTNode *childs = new SimpleASTNode(AssignStatement);
                childs->setToken(tokens);
                SimpleASTNode *child = expression();
                if(child != nullptr){
                    node->addChild(childs);
                    childs->addChild(child);

                }else{
                    printf("[ERROR]:Undefined Statement\n");
                    throw std::exception();
                }
            }else if(token.value != "" && token.value != ";"){
                printf("[ERROR]:Undefined Statement\n");
                throw std::exception();
            }
            token = read();
            if(token.value != ";"){
                printf("[ERROR]:Statement '%s' not have ';'\n", statement);
                throw std::exception();
            }
        }
    }
    return node;
}

SimpleASTNode* expressionStatement(){
    char *loc = p;
    SimpleASTNode *expr = new SimpleASTNode(ExpressionStatement);
    SimpleASTNode *node = expression();
    if(node != nullptr){
        Token token = read();
        if(token.value != ";"){
            printf("[ERROR]:Statement '%s' not have ';'\n", statement);
            throw std::exception();
        }
        expr->addChild(node);
        return expr;
    }else{
        p = loc;
    }
    return node;
}

SimpleASTNode* assignmentStatement(){
    SimpleASTNode *node = nullptr;
    Token token = peek();
    if(token.id == ID){
        read();
        node = new SimpleASTNode(AssignStatement);
        node->setToken(token);
        token = peek();
        if(token.value == "="){
            read();
            SimpleASTNode *child = expression();
            if(p == nullptr){
                printf("[ERROR]:Undefined Statement\n");
                throw std::exception();
            }else{
                node->addChild(child);
                token = read();
                if(token.value != ";"){
                    printf("[ERROR]:Statement '%s' not have ';'\n", statement);
                    throw std::exception();
                }
            }
        }else{
            printf("[ERROR]:Undefined Statement\n");
            throw std::exception();
        }
    }
    return node;
}

主程序

/*主函数*/
int main(int argc, char *argv[]) {
    bool verbose = false;
    if(argc >= 2){
        verbose = true;
    }
    statement = (char*)calloc(256,sizeof(char));
    printf("======== Simple Script Hello! ========\n");
    while(true){
        printf("@>>>");
        std::cin.getline(statement, 256);
        p = statement;
        if(strcmp(statement, "exit") == 0){
            printf("======== Simple Script Bye! ========\n");
            break;
        }
        SimpleASTNode *root = nullptr;
        try{
            root = intDeclaration();
            if(root != nullptr){
                root->eval();
                if(verbose){
                    printf("AST:\n");
                    root->printAST("    ");
                }
                continue;
            }
            root = expressionStatement();
            if(root != nullptr){
                root->eval();
                if(verbose){
                    printf("AST:\n");
                    root->printAST("    ");
                }
                continue;
            }
            root = assignmentStatement();
            if(root != nullptr){
                root->eval();
                if(verbose){
                    printf("AST:\n");
                    root->printAST("    ");
                };
                continue;
            }
        }catch(...){
            continue;
        }
    }
    return 0;
}

最后结果

image-20220321232939644

源码

arqqqq/SimpleScript: A simple script executor (github.com)

问号小朋友
关注
专栏目录
一个简单的解释器——python实现
架构师专栏
09-27 9941
一直以来都对编译器和解析器有着很大的兴趣，也很清楚一个编译器的概念和整体的框架，但是对于细节部分却不是很了解。我们编写的程序源代码实际上就是一串字符序列，编译器或者解释器可以直接理解并执行这个字符序列，这看起来实在是太奇妙了。本文会用python实现一个简单的解析器，用于解释一种小的列表操作语言（类似于python的list）。其实编译器、解释器并不神秘，只要对基本的理论理解之后，实现起来也比较简
实现一个简单的解释器（5）
ElegantHedgehog的博客
01-30 143
译自：https://ruslanspivak.com/lsbasi-part5/ （已获得作者授权） 你如何处理和了解像创建解释器或编译器这样复杂的事情？在开始时，一切看上去都像是一团乱七八糟的纱线，你需要解开缠结才能得到完美的球。 到达那里的方法是将它解开一个线，一次解开一个结。不过有时候，你可能会觉得自己听不懂某些内容，但必须继续前进，我向你保证，如果你足够坚持，它最终将“咔嗒”一声被解开。 在理解如何创建解释器和编译器的过程中，最好的建议之一是阅读文章中的解释，阅读代码，然后自己编写代码，...
简单的汇编语言解释器的实现
05-29
一个简单的汇编语言解释器，用oop的实现
实现一个简单的解释器（4）
qq_35382207的博客
01-31 235
译自：https://ruslanspivak.com/lsbasi-part4/ （已获得作者授权，个别语句翻译的不到位，我会将原句跟在后边作为参考） 你是在被动地学习这些文章中的材料还是在积极地实践它？希望你一直在积极练习。 孔子曾经说过： “闻之我也野。” “视之我也饶。” “行之我也明。” 在上一篇文章中，我们学习了如何解析（识别）和解释具有任意数量的加或减运算的算术表达式，例如"7 - 3 + 2 - 1"，还了解了语法图以及如何用它来表示(specify)编程语言的语法。 ...
C语言实现简单解释器（interpreter）
最新发布
JiawenLee的博客
11-04 2648
C语言初级实战：实现简单MATLAB interpreter
实现一个简单的解释器（6）
rizon886的博客
01-29 143
译自：https://ruslanspivak.com/lsbasi-part6/ （已获得作者授权） 今天，我们通过将带括号的表达式添加到语法，并实现一个能够计算任意深度嵌套表达式的解释器来结束对算术表达式的讨论。 让我们开始吧！ 首先，让我们修改语法以支持括号内的表达式，正如在第5部分中所记得的那样，factor规则用于表达式中的基本单位，在那篇文章中，我们仅有的基本单位是整数，今天我们添加了另外一个基本单位，也就是带括号的表达式。 这是我们更新的语法： expr和term与第5部分完全相同，...
Prefix-Expression-Evaluator:一个简单解释器的实现，用于使用lex和yaac解析器评估给定的前缀表达CGF
04-11
一个简单解释器的实现，用于使用lex和yacc解析器评估给定的前缀表达CGF。 这是我们为第六学期CDSS mini项目提交的材料。 构建口译员 使用以下命令编译.y（yacc）文件： yacc -y -d yacc_compile.y -d选项：如果...
一个简单的brainfuck语言的解释器.zip
10-18
一个简单的brainfuck语言的解释器.zip一个简单的brainfuck语言的解释器.zip一个简单的brainfuck语言的解释器.zip一个简单的brainfuck语言的解释器.zip一个简单的brainfuck语言的解释器.zip
从零用Go实现一个python简单解释器
01-20
解释型语言区别于编译型型语言,他有一个很大的缺点由于不需要事前先编译成机器码,而是在动态执行的时候在解释器运行期间那一条解释一条,这些被解释完成的代码 会在内存中存放 python中称为 code object(代码对象)，...
一个简易Lisp解释器1
08-03
实现一个Lisp解释器，特别是Scheme的一个子集，涉及识别和处理语言的六种特殊形式，如条件语句（if）、赋值（set!）、过程调用等，以及变量、常量和表达式的解析。 构建一个Scheme解释器的过程通常包括以下几个步骤...
怎样写一个解释器-20120801.pdf
08-13
要编写一个解释器，编程者需要具备良好的编程基础知识，例如熟悉Scheme语言及递归等编程技巧。由于解释器的复杂性，初学者在编写时应避免一开始就尝试实现过于复杂的编程语言，比如JavaScript或Python，这可能会导致...
让我们做一个简单的解释器（四）
echoecho的博客
07-20 364
原文：Let’s Build A Simple Interpreter. Part 4. 你是在被动地（passively）学习文章中的内容，还是积极地（actively）跟着练习呢？我真的希望你是后者~ 还记得孔夫子说的话吗？ 不闻不若闻之，闻之不若见之，见之不若知之，知之不若行之。 译：（在学习中）听说比不听好，见到比听说好，知晓比见到好，实践比知晓好，学习的最终就是实践，实践了，就明白了。 “I hear and I forget.” “I see and I remember.”
最简单的解释器模式
xie__jin__cheng的博客
03-01 492
理解：一个被解释对象（Context），把该对象交给解释器，解释器(AbstractExpression)会对该对象的符号用相应的解释模型（XExpression）去解释。 这个解释可能有点太抽象了，但是解释模式本身就是这些，而解释的过程往往会很负责，这个模式的难点，不在于模式本身，而在于模式的运用。 上代码吧：（如果您觉得：这简单的有点过分了把，那么请看另一篇《解释模式简单实现》） #inclu...
【编译原理】构建一个简单的解释器（Let’s Build A Simple Interpreter. Part 7.）（笔记）解释器 interpreter 解析器 parser 抽象语法树AST
Dontla的博客
07-29 1369
【编译原理】让我们来构建一个简单的解释器（Let’s Build A Simple Interpreter. Part 7.） 文章目录python代码 正如我上次向您保证的那样，今天我将讨论我们将在本系列的其余部分中使用的中心数据结构之一，所以系好安全带，让我们开始吧。 到目前为止，我们将解释器（interpreter ）和解析器（parser ）代码混合在一起，一旦解析器识别出某种语言结构，如加法、减法、乘法或除法，解释器就会对表达式求值。这种解释器被称为语法导向解释器。它们通常对输入进行一次传递，适用
记一个简单的文本解释器的开发
qq_17610889的博客
02-10 531
最近疫情严重，在家也没有什么事情可以做，我就在想，要不然我自己先把毕设做了吧，毕竟6月份我就离开中专上大专了，没一个好的毕设可不行，不说有多好，起码不能是Hello World级别的吧。我上网查阅了很多资料，最后将毕设项目定为一个简单的解释器（Interpreter），效果是我输入一段比较自然的，接近人类所说话，程序可以解释这段话的核心含义，并且执行，目前我设置的解释器功能有赋值变量，获取变量的值...
自制简易解释器
τ's blog
02-20 2575
title: 自制简易解释器 date: 2019-02-18 22:00:01 tags: interpreter categories: compilation blog: https://withas.me 自制简易解释器 用C语言写了一个简单的动态语言解释器, 代码放在了github上面:hedegehog. 编译, 运行可以看看github上的readme. 先简单介绍下这门语言. ...
【Interpreter】构建简单的解释器（第1部分）
问题不大
12-26 3808
文章目录【Interpreter】构建简单的解释器（第1部分） 【Interpreter】构建简单的解释器（第1部分） 简单翻译了下，方便查看，水平有限，喜欢的朋友去看 原文！ “If you don’t know how compilers work, then you don’t know how computers work. If you’re not 100% sure wheth...
造个简易的 php 解释器,自制简易解释器
weixin_30062561的博客
03-26 210
title: 自制简易解释器date: 2019-02-18 22:00:01origin: 自制简易解释器自制简易解释器用C语言写了一个简单的动态语言解释器, 代码放在了github上面:hedegehog. 编译, 运行可以看看github上的readme.先简单介绍下这门语言. hedgehog 的多数设计和 python 比较相似, 无需声明变量类型, if,for等语句没有块级作用域. ...
实现一个简单的解释器（1）
cnmeimei的博客
02-01 873
译自：https://ruslanspivak.com/lsbasi-part1/ （已获作者授权） “如果你不知道编译器的工作方式，那么你将不知道计算机的工作方式。如果你不能100％确定是否知道编译器的工作方式，那么你将不知道它们的工作方式。” ——史蒂夫·耶格 无论你是新手还是经验丰富的软件开发人员，如果你不知道编译器和解释器的工作方式，那么你也不知道计算机的工作方式，就是这么简单。 那么，你知道编译器和解释器如何工作吗？ 你是否100％确定知道它们的工作原理？ 如果没有的话： 或者，如果你确...
从零开始：一步步教你构建解释器
"这篇文章主要介绍了如何编写一个解释器，作者以一个名为‘R2’的简单语言为例，通过使用 Scheme 语言的实现——Racket，向读者展示了从基础到逐步增强语言特性的过程。文章强调从简单语言开始，避免一开始就尝试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值