众所周知啊（或许并不hh），写一个编译器需要词法、语法和代码生成这些部分。
本迷你编译器目的是接收一个算术表达式，生成汇编代码，并在linux上运行，从而生成结果。
如果没有Linux系统，可以把driver.c注释掉，在main里直接复制汇编代码文本，在虚拟机上跑。
为什么不写一个能在Windows上能直接跑出来的呢？因为我不会。。（众所周知啊，Linux和Windows所能接收的汇编语言是不一样的）
那么，什么是编译器？
C语言代码由固定的词汇按照固定的格式组织起来，简单直观，程序员容易识别和理解，但是对于CPU，C语言代码就是天书，根本不认识，CPU只认识几百个二进制形式的指令。这就需要一个工具，将C语言代码转换成CPU能够识别的二进制指令，也就是将代码加工成 .exe 程序；这个工具是一个特殊的软件，叫做编译器（Compiler）。
编译器能够识别代码中的词汇、句子以及各种特定的格式，并将他们转换成计算机能够识别的二进制形式，这个过程称为编译（Compile）。
编译也可以理解为“翻译”，类似于将中文翻译成英文、将英文翻译成象形文字，它是一个复杂的过程，大致包括词法分析、语法分析、语义分析、性能优化、生成可执行文件五个步骤，期间涉及到复杂的算法和硬件架构。对于学计算机或者软件的大学生，“编译原理”是一门专业课程，有兴趣的读者请自行阅读《编译原理》一书，这里我们不再展开讲解。
C语言的编译器有很多种，不同的平台下有不同的编译器，例如：
Windows 下常用的是微软开发的 cl.exe，它被集成在 Visual Studio 或 Visual C++ 中，一般不单独使用；
Linux 下常用的是 GUN 组织开发的 GCC，很多 Linux 发行版都自带 GCC；
Mac 下常用的是 LLVM/Clang，它被集成在 Xcode 中（Xcode 以前集成的是 GCC，后来由于 GCC 的不配合才改为 LLVM/Clang，LLVM/Clang 的性能比 GCC 更加强大）。
你的代码语法正确与否，编译器说了才算，我们学习C语言，从某种意义上说就是学习如何使用编译器，让编译器生成可执行程序（例如 Windows 下的 .exe 程序）。
编译器可以 100% 保证你的代码从语法上讲是正确的，因为哪怕有一点小小的错误，编译也不能通过，编译器会告诉你哪里错了，便于你的更改。
类的描述：Lexer提供词法，Parser提供语法，AstNode定义语法树为Parser服务，Print用来打印，CodeGen生成汇编代码，driver接收代码，main用来测试。
具体代码如下：
Lexer.h:
//
// Created by xiaoyu ren on 2022/11/21.
//
#ifndef COMPILER_LEXER_H
#define COMPILER_LEXER_H
#include#includenamespace compiler {enum class TokenKind{Add,
Sub,
Mul,
Div,
Num,
Eof,
Null
};
class Token{public:
TokenKind kind;
int value;
std::string_view content;
};
class Lexer {private:
std::string_view sourceCode;
std::shared_ptrcurrentToken;
char currentChar{' '};
int cursor{0};
public:
Lexer(const char *code){sourceCode = code;
}
void GetNextToken();
void GetNextChar();
std::shared_ptrGetCurrentToken();
};
}
#endif //COMPILER_LEXER_H
Lexer.cpp:
//
// Created by xiaoyu ren on 2022/11/21.
//
#include "Lexer.h"
void compiler::Lexer::GetNextToken() {while (isspace(currentChar)){GetNextChar();
}
TokenKind kind = TokenKind::Null;
int value = 0;
int startPos = cursor -1;
if (currentChar == '\0'){kind = TokenKind::Eof;
}
else if (currentChar == '+'){kind = TokenKind::Add;
GetNextChar();
}
else if (currentChar == '-'){kind = TokenKind::Sub;
GetNextChar();
}
else if (currentChar == '*'){kind = TokenKind::Mul;
GetNextChar();
}
else if (currentChar == '/'){kind = TokenKind::Div;
GetNextChar();
}
else if (std::isdigit(currentChar)){value = 0;
kind = TokenKind::Num;
do{value = value * 10 + currentChar - '0';
GetNextChar();
} while (isdigit(currentChar));
} else {printf("error:invalid type\n");
}
currentToken = std::make_shared();
currentToken->kind = kind;
currentToken->value = value;
currentToken->content = sourceCode.substr(startPos, cursor - startPos - 1);
}
void compiler::Lexer::GetNextChar() {if (cursor >= sourceCode.size()){currentChar = '\0';
cursor++;
} else {currentChar = sourceCode[cursor++];
}
}
std::shared_ptrcompiler::Lexer::GetCurrentToken() {return currentToken;
}
Parser.h:
//
// Created by xiaoyu ren on 2022/11/21.
//
#ifndef COMPILER_PARSER_H
#define COMPILER_PARSER_H
#include "Lexer.h"
#include "AstNode.h"
namespace compiler {class Parser {private:
Lexer &lexer;
std::shared_ptrParseExpr();
std::shared_ptrParseAddExpr();
std::shared_ptrParseMulExpr();
std::shared_ptrParsePrimaryExpr();
public:
Parser(Lexer &lexer):lexer(lexer){}
std::shared_ptrParse();
};
}
#endif //COMPILER_PARSER_H
Parser.cpp
//
// Created by xiaoyu ren on 2022/11/21.
//
#include "Parser.h"
std::shared_ptrcompiler::Parser::Parse() {auto node = std::make_shared();
node->Lhs = ParseExpr();
return node;
}
std::shared_ptrcompiler::Parser::ParseExpr() {return ParseAddExpr();
}
std::shared_ptrcompiler::Parser::ParseAddExpr() {std::shared_ptrleft = ParseMulExpr();
while (lexer.GetCurrentToken()->kind == TokenKind::Add || lexer.GetCurrentToken()->kind == TokenKind::Sub) {BinaryOperator binaryOperator = BinaryOperator::Add;
if (lexer.GetCurrentToken()->kind == TokenKind::Sub){binaryOperator = BinaryOperator::Sub;
}
lexer.GetNextToken();
auto node = std::make_shared();
node->binaryOperator = binaryOperator;
node->Lhs = left;
node->Rhs = ParseMulExpr();
left = node;
}
return left;
}
std::shared_ptrcompiler::Parser::ParseMulExpr() {std::shared_ptrleft = ParsePrimaryExpr();
while (lexer.GetCurrentToken()->kind == TokenKind::Mul || lexer.GetCurrentToken()->kind == TokenKind::Div) {BinaryOperator binaryOperator = BinaryOperator::Mul;
if (lexer.GetCurrentToken()->kind == TokenKind::Div){binaryOperator = BinaryOperator::Div;
}
lexer.GetNextToken();
auto node = std::make_shared();
node->binaryOperator = binaryOperator;
node->Lhs = left;
node->Rhs = ParsePrimaryExpr();
left = node;
}
return left;
}
std::shared_ptrcompiler::Parser::ParsePrimaryExpr() {auto node = std::make_shared();
node->value = lexer.GetCurrentToken()->value;
lexer.GetNextToken();
return node;
}
AstNode.h:
//
// Created by xiaoyu ren on 2022/11/21.
//
#ifndef COMPILER_ASTNODE_H
#define COMPILER_ASTNODE_H
#includenamespace compiler {class AstVisitor;
class AstNode {public:
virtual ~AstNode(){};
virtual void Accept(AstVisitor *visitor) {};
};
class ProgramNode : public AstNode{public:
std::shared_ptrLhs;
void Accept(AstVisitor *visitor) override;
};
enum class BinaryOperator{Add,
Sub,
Mul,
Div
};
class BinaryNode : public AstNode{public:
BinaryOperator binaryOperator;
std::shared_ptrLhs;
std::shared_ptrRhs;
void Accept(AstVisitor *visitor) override;
};
class ConstantNode : public AstNode{public:
int value;
void Accept(AstVisitor *visitor) override;
};
class AstVisitor{public:
virtual void VisitorProgramNode(ProgramNode *node) {};
virtual void VisitorBinaryNode(BinaryNode *node) {};
virtual void VisitorConstantNode(ConstantNode *node) {};
};
}
#endif //COMPILER_ASTNODE_H
AstNode.cpp:
//
// Created by xiaoyu ren on 2022/11/21.
//
#include "AstNode.h"
void compiler::BinaryNode::Accept(compiler::AstVisitor *visitor) {visitor->VisitorBinaryNode(this);
}
void compiler::ConstantNode::Accept(compiler::AstVisitor *visitor) {visitor->VisitorConstantNode(this);
}
void compiler::ProgramNode::Accept(compiler::AstVisitor *visitor) {visitor->VisitorProgramNode(this);
}
Print.h:
//
// Created by xiaoyu ren on 2022/11/22.
//
#ifndef COMPILER_PRINT_H
#define COMPILER_PRINT_H
#include "AstNode.h"
namespace compiler {class Print : public AstVisitor {private:
void VisitorBinaryNode(BinaryNode *node) override;
void VisitorConstantNode(ConstantNode *node) override;
public:
void VisitorProgramNode(ProgramNode *node) override;
};
}
#endif //COMPILER_PRINT_H
Print.cpp:
//
// Created by xiaoyu ren on 2022/11/22.
//
#include#include "Print.h"
void compiler::Print::VisitorProgramNode(compiler::ProgramNode *node) {node->Lhs->Accept(this);
printf("\n");
}
void compiler::Print::VisitorBinaryNode(compiler::BinaryNode *node) {node->Rhs->Accept(this);
node->Lhs->Accept(this);
switch (node->binaryOperator) {case BinaryOperator::Add:
printf("+ ");
break;
case BinaryOperator::Sub:
printf("- ");
break;
case BinaryOperator::Mul:
printf("* ");
break;
case BinaryOperator::Div:
printf("/ ");
break;
default:
assert(0);
}
}
void compiler::Print::VisitorConstantNode(compiler::ConstantNode *node) {printf("%d ", node->value);
}
CodeGen.h:
//
// Created by xiaoyu ren on 2022/11/21.
//
#ifndef COMPILER_CODEGEN_H
#define COMPILER_CODEGEN_H
#include "AstNode.h"
namespace compiler {class CodeGen : public AstVisitor {private:
int top{0};
void VisitorBinaryNode(BinaryNode *node) override;
void VisitorConstantNode(ConstantNode *node) override;
void Push();
void Pop(const char *reg);
public:
CodeGen(){}
void VisitorProgramNode(ProgramNode *node) override;
};
}
#endif //COMPILER_CODEGEN_H
CodeGen.cpp:
//
// Created by xiaoyu ren on 2022/11/21.
//
#include "CodeGen.h"
#includevoid compiler::CodeGen::VisitorProgramNode(compiler::ProgramNode *node) {printf("\t.text\n");
#ifdef __linux__
printf("\t.global prog\n");
printf("_prog\n");
#endif
printf("\tpush %%rbp\n");
printf("\tmove %%rsp, %%rbp\n");
printf("\tsub $32, %%rsp\n");
node->Lhs->Accept(this);
assert(top == 0);
printf("\tmove %%rbp, %%rsp\n");
printf("\tpop %%rbp\n");
printf("\tret\n");
}
void compiler::CodeGen::VisitorBinaryNode(compiler::BinaryNode *node) {node->Rhs->Accept(this);
Push();
node->Lhs->Accept(this);
Pop("%rdi");
switch (node->binaryOperator) {case BinaryOperator::Add:
printf("\tadd %%rdi, %%rax\n");
break;
case BinaryOperator::Sub:
printf("\tsub %%rdi, %%rax\n");
break;
case BinaryOperator::Mul:
printf("\timul %%rdi, %%rax\n");
break;
case BinaryOperator::Div:
printf("\tcqo\n");
printf("\tdiv %%rdi\n");
break;
default:
assert(0);
}
}
void compiler::CodeGen::VisitorConstantNode(compiler::ConstantNode *node) {printf("\tmove $%d, %%rax\n", node->value);
}
void compiler::CodeGen::Push() {printf("\tpush %%rax\n");
top++;
}
void compiler::CodeGen::Pop(const char *reg) {printf("\tpop %s\n", reg);
top--;
}
driver.c:
//
// Created by xiaoyu ren on 2022/11/23.
//
#includeint prog();
int main() {printf("%d\n", prog());
return 0;
} main.cpp:
#include#include "Lexer.h"
#include "Parser.h"
#include "Print.h"
#include "CodeGen.h"
int main() {const char *code = " 5 + 1 - 3 * 4 / 2";
compiler::Lexer lexer(code);
//test lexer
// do{// lexer.GetNextToken();
// std::cout<< lexer.GetCurrentToken()->content<< std::endl;
// } while (lexer.GetCurrentToken()->kind != compiler::TokenKind::Eof);
//test parser，后序遍历
lexer.GetNextToken();
compiler::Parser parser(lexer);
// compiler::Print visitor;
// auto root = parser.Parse();
// root->Accept(&visitor);
//test codeGen
compiler::CodeGen codeGen;
auto root = parser.Parse();
root->Accept(&codeGen);
//execute
// make
// ./compiler "5+1-3*4/2">tmp.s
// clang tmp.s ../driver.c -o tmp.out
// ./tmp.out
// 0
return 0;
}
如果你懒得自己复制，可以去走下面链接下载压缩包（为什么要1积分？因为你懒哈哈）
https://download.csdn.net/download/r643064456/87156158
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
