自己动手实现一个简单c编译器

最新推荐文章于 2025-06-26 10:25:59 发布
最新推荐文章于 2025-06-26 10:25:59 发布
阅读量7.3k 收藏 12
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 编程 文章标签： 笔记 编译器 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012773099/article/details/50082099
本文详细介绍了如何使用ANTLR和NASM改进类C编译器的语法支持，实现从基本计算器语法到更复杂语句的转换，并通过生成.s文件和汇编代码的步骤展示了这一过程。包括声明、赋值、函数、条件语句和循环语句的实现，最终通过Java程序调用生成的汇编代码验证了编译器的功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这学期的编译课程设计需要做一个类c编译器，准确的说是完善上学期做的大实验。

上学期的实验中，使用antlr完成的编译器识别的语法很有限，基本上是个计算器的语法，于是这次决定弄语法一个更加完整。

语法支持：

声明，赋值，函数,if-else,while,for。

首先是词法分析和语法分析,antlr源文件如下：

grammar c;
options{
    output=AST;
    ASTLabelType=CommonTree;
}

tokens{
PROG;STAT;IFSTAT;IF;ELSE;WHILESTAT;FORSTAT;DECLAREVAR;DECLAREFUNC;CALLFUNC;GIVEVALUE;CALL;FUNC1;FUNC2;FUNC3;FUNC4;
}

ID  :	('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
    ;

INT :	'0'..'9'+
    ;

FLOAT 
    :   ('0'..'9')+ '.' ('0'..'9')* EXPONENT?  
    |   '.' ('0'..'9')+ EXPONENT?
    |   ('0'..'9')+ EXPONENT 
    ;

num	:	INT
	|	FLOAT
;

num_type	:	'int'
	|	'float'
	;

COMMENT
    :   '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;}
    |   '/*' ( options {greedy=false;} : . )* '*/' {$channel=HIDDEN;}
    ;

WS  :   ('\r'|'\n'|' '|'\t')+{$channel=HIDDEN;};
END	:	';'
	;
	
boolexpr	:	expr	('=='^|'!='^|'>'^|'<'^|'>='^|'<='^)	expr
	;
expr	:	multexpr	(('+'^	|	'-'^)	multexpr)*
;

multexpr	:	atom	(('*'^|'/'^)	atom)*
;

atom	:	'('	expr	')'     ->      ^(expr)
	|	num
	|	ID
	|	callfunc
	;
	
declarevar	:	'int'^	ID
	|	'float'^	ID
	;
	
	
givevalue	:	ID 	'='	expr
	->	^('='	ID	expr)
	;
	
ifstat	options{ backtrack=true;  }
	:	'if'	'('	boolexpr	')'	'{'	s1=stat*	'}'	'else'	'{'	s2=stat*	'}'
	->	^(IF	boolexpr	$s1	ELSE	$s2)
	|	'if'	'('	boolexpr	')'	'{'	stat*	'}'
	->	^(IF	boolexpr	stat*)
	;
	
whilestat	options{ backtrack=true;  }
	:	'while'	'('	boolexpr	')'	'{'	stat*	'}'
	->	^('while'	boolexpr	stat*)	
	;

forstat	options{ backtrack=true;  }
	:	'for'	'('	s1=givevalue	';'	s2=boolexpr	';'	s3=givevalue	')'	'{'	s4=stat*	'}'
	->	^('for'	$s1	$s2	$s4     $s3)
	;

declarefunc
	:	'void'	ID	'('	')'	'{'	stat*	'}'	->	^(FUNC1 ID	stat*)
	|	('int'|'float')	ID	'('	')'	'{'	stat*	'return'	expr	END	'}'	->	^(FUNC2	ID	stat*	expr)
	|	'void'	ID	'('	(num_type	ID)	(','	(num_type	ID))*	')'	'{'	stat*	'}'	->
		^(FUNC3	ID	(num_type	ID)+	stat*)
	|	('int'|'float')	ID	'('	(num_type	ID)	(','	(num_type	ID))*	')'	'{'	stat*	'return'	expr	END	'}'	
	->	^(FUNC4	ID	(num_type	ID)+	stat*	expr)
	;	

callfunc	:	ID	'('	')'	->	^(CALL	ID)
	|	ID	'('	expr	(','	expr)*	')'	->	^(CALL	ID	expr	(expr)*)
	;

stat	:	declarevar	END	->	^(DECLAREVAR	declarevar)
	|	givevalue	END->	^(GIVEVALUE	givevalue)
	|	ifstat	->	^(IFSTAT	ifstat)
	|	forstat	->	^(FORSTAT	forstat)
	|	whilestat	->	^(WHILESTAT	whilestat)
	|	declarefunc	->	^(DECLAREFUNC	declarefunc)
	|	callfunc	END	->	^(CALLFUNC	callfunc)
	;

prog	:	stat*	->	^(PROG	stat*)
	;

fragment
EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;

这个grammar输出一个ast

输入为

int b;
void main(){
if(b==0){
b=34;
}
print(b);
}
void test(int a){
print(a);
}
的时候,
生成的抽象语法树如下，

(PROG (DECLAREVAR (int b)) (DECLAREFUNC (FUNC1 main (IFSTAT (IF (== b 0) (GIVEVALUE (= b 34)))) (CALLFUNC (CALL print b)))) (DECLAREFUNC (FUNC3 test int a (CALLFUNC (CALL print a)))))


然后是树解析器，这一步就是把上面的ast转变为汇编，主要是注意函数调用需要平衡堆栈，其他倒没什么，为了方便调试，生成.s文件中嵌入了一个print()函数

tree grammar cTree;
options{
tokenVocab=c;
ASTLabelType=CommonTree;
output=template;
}

@headers{

}

@members{
int	index=0;
int     data_index=0;
int 	labelindex=0;
int 	labelindex_if=0;
int     num=0;
int     labelindex_bool=0;
int     labelindex_while=0;
int     labelindex_for=0;
int     labelindex_func=0;
String  []text  =       new     String[1000];
String  []data  =       new     String[1000];
}

boolexpr	:	^('=='	s1=expr	s2=expr)
	{text[index++]="pop rax";text[index++]="pop rbx";text[index++]="cmp eax,ebx";text[index++]="jz label_bool_1"+labelindex_bool+"";text[index++]="push 0";text[index++]="jmp label_bool_2"+labelindex_bool+"";text[index++]="label_bool_1"+labelindex_bool+":push 1";text[index++]="label_bool_2"+labelindex_bool+":";
        labelindex_bool++;}
	|	^('!='	s1=expr	s2=expr)
	{text[index++]="pop rax";text[index++]="pop rbx";text[index++]="cmp eax,ebx";text[index++]="jnz label_bool_1"+labelindex_bool+"";text[index++]="push 0";text[index++]="jmp label_bool_2"+labelindex_bool+"";text[index++]="label_bool_1"+labelindex_bool+":push 1";text[index++]="label_bool_2"+labelindex_bool+":";
        labelindex_bool++;}
	|	^('>='	s1=expr	s2=expr)
	{text[index++]="pop rax";text[index++]="pop rbx";text[index++]="cmp eax,ebx";text[index++]="jng label_bool_1"+labelindex_bool+"";text[index++]="push 0";text[index++]="jmp label_bool_2"+labelindex_bool+"";text[index++]="label_bool_1"+labelindex_bool+":push 1";text[index++]="label_bool_2"+labelindex_bool+":";
        labelindex_bool++;}
	|	^('<='	s1=expr	s2=expr)
	{text[index++]="pop rax";text[index++]="pop rbx";text[index++]="cmp eax,ebx";text[index++]="jnl label_bool_1"+labelindex_bool+"";text[index++]="push 0";text[index++]="jmp label_bool_2"+labelindex_bool+"";text[index++]="label_bool_1"+labelindex_bool+":push 1";text[index++]="label_bool_2"+labelindex_bool+":";
        labelindex_bool++;}
	|	^('>'	s1=expr	s2=expr)
	{text[index++]="pop rax";text[index++]="pop rbx";text[index++]="cmp eax,ebx";text[index++]="jl label_bool_1"+labelindex_bool+"";text[index++]="push 0";text[index++]="jmp label_bool_2"+labelindex_bool+"";text[index++]="label_bool_1"+labelindex_bool+":push 1";text[index++]="label_bool_2"+labelindex_bool+":";
        labelindex_bool++;}
	|	^('<'	s1=expr	s2=expr)
	{text[index++]="pop rax";text[index++]="pop rbx";text[index++]="cmp eax,ebx";text[index++]="jg label_bool_1"+labelindex_bool+"";text[index++]="push 0";text[index++]="jmp label_bool_2"+labelindex_bool+"";text[index++]="label_bool_1"+labelindex_bool+":push 1";text[index++]="label_bool_2"+labelindex_bool+":";
        labelindex_bool++;}
	;
expr	:	^('+'	s1=expr	s2=expr){text[index++]="pop rbx";text[index++]="pop rax";text[index++]="add eax,ebx";text[index++]="push rax";}
	|	^('-'	s1=expr	s2=expr){text[index++]="pop rbx";text[index++]="pop rax";text[index++]="sub eax,ebx";text[index++]="push rax";}
	|	^('*'	s1=expr	s2=expr){text[index++]="pop rbx";text[index++]="pop rax";text[index++]="mul eax,ebx";text[index++]="push rax";}
	|	^('/'	s1=expr	s2=expr){text[index++]="pop rbx";text[index++]="pop rax";text[index++]="div eax,ebx";text[index++]="push rax";}
	|	INT{text[index++]="mov eax,"+$INT+"";text[index++]="push rax";}
	|	FLOAT{text[index++]="mov eax,"+$FLOAT+"";text[index++]=" push rax";}
	|	ID{text[index++]="mov eax,["+$ID+"]";text[index++]="push rax";}
	|	callfunc{text[index++]="push rax";}
	;

	
declarevar	:	^('int'	ID){data[data_index++]=$ID+" dd	 0";}
	|	^('float'	ID){data[data_index++]=$ID+" dd	 0";}
	;
	
givevalue	:	^('='	ID	expr){text[index++]="pop rax";text[index++]="mov ["+$ID+"],eax";}
	;
	
ifstat	options{backtrack=true;}
	:	^(IF	boolexpr{text[index++]="pop rax";text[index++]="cmp eax,1";text[index++]="jnz label_if0"+labelindex_if+"";}
		s=stat*{text[index++]="label_if0"+labelindex+":";}){labelindex_if++;}
	|	^(IF	boolexpr{text[index++]="pop rax";text[index++]="cmp eax,1";text[index++]="jnz label_if1"+labelindex_if+"";}
		s1=stat*{text[index++]="jmp label_if2"+labelindex_if+"";text[index++]="label1_if1"+labelindex_if+":";}
		 ELSE 
		 s2=stat*{text[index++]="label_if2"+labelindex_if+":";}){labelindex_if++;}
	;
	
	
whilestat	:	^('while'{text[index++]="label_while"+labelindex_while+":";}	boolexpr{text[index++]="pop rax";text[index++]="cmp eax,1";text[index++]="jnz label_while2"+labelindex_while+"";}
	stat*{text[index++]="jmp label_while"+labelindex_while+"\nlabel_while2"+labelindex_while+":";}){labelindex_while++;}
	;

forstat	:	^('for'	s1=givevalue{text[index++]="label_for"+labelindex_for+":";}
	s2=boolexpr{text[index++]="pop rax";text[index++]="cmp eax,1";text[index++]="jnz label_for2"+labelindex_for+"";}
	s4=stat*	
	s3=givevalue{text[index++]="jmp label_for"+labelindex_for+"";text[index++]="label_for2"+labelindex_for+":";}	){labelindex_for++;}
	;

declarefunc
	:	^(FUNC1	
		ID	{text[index++]="jmp label_func"+labelindex_func+"";text[index++]="label_"+$ID+":";text[index++]="push rbp";text[index++]="mov rbp,rsp";}
		s1=stat*	{text[index++]="mov rsp,rbp";text[index++]="pop rbp";text[index++]="ret";text[index++]="label_func"+labelindex_func+":";}){labelindex_func++;}
	|	^(FUNC2	ID{text[index++]="jmp label"+labelindex+"";text[index++]="label_"+$ID+":";text[index++]="push rbp";text[index++]="mov rbp,rsp";}
		stat*	
		expr{text[index++]="pop rax";text[index++]="mov rsp,rbp";text[index++]="pop rbp";text[index++]="ret";text[index++]="label"+labelindex+":";}){labelindex++;}
	|	^(FUNC3	a=ID{text[index++]="jmp label_func"+labelindex_func+"";text[index++]="label_"+$a+":";}	
	(('int'|'float'){text[index++]="push rbp";text[index++]="mov rbp,rsp";}	b=ID{text[index++]="mov rax,[ rbp+"+8+"+8+"+8*num+"]";text[index++]="mov ["+$b+"],rax";num--;data[data_index++]=$b+" dd 0";})+	
	stat*{text[index++]="mov rsp,rbp";text[index++]="pop rbp";text[index++]="ret";text[index++]="label_func"+labelindex_func+":";})
       	{labelindex_func++;}
	|	^(FUNC4{num=0;}	a=ID{text[index++]="jmp label_func"+labelindex_func+"";text[index++]="label_"+$a+":";}
		(('int'|'float'){text[index++]="push rbp";text[index++]="mov rbp,rsp";}	b=ID{text[index++]="mov rax,[ rbp+"+8+"+"+8*num+"]";text[index++]="mov ["+$b+"],rax";num--;data[data_index++]=$b+" dd 0";})+
        	stat*	
		expr{text[index++]="pop rax";text[index++]="mov rsp,rbp";text[index++]="pop rbp";text[index++]="ret";text[index++]="label"+labelindex_func+":";})
        {labelindex++;}
	;	

callfunc	:	^(CALL	ID){text[index++]="call label_"+$ID+"";}
	|	^(CALL	ID{num=0;}	(expr{num++;})+){text[index++]="push "+num;text[index++]="call label_"+$ID+"";}
	;

stat	:	^(DECLAREVAR	declarevar)
	|	^(GIVEVALUE	givevalue)
	|	^(IFSTAT	ifstat)
	|	^(FORSTAT	forstat)
	|	^(WHILESTAT	whilestat)
	|	^(DECLAREFUNC	declarefunc)
	|	^(CALLFUNC	callfunc)
	;

prog	:	^(PROG	stat*)
        {
                System.out.println("section .data\nt resb 100\nbuffer db 0 ,0,0");
                for(int i=0;i<data_index;i++){
                        System.out.println(data[i]);                
                }                
                System.out.println("section .text\nglobal _start\n_start:\n");
                for(int i=0;i<index;i++){
                        System.out.println(text[i]);                
                }
                System.out.println("call label_main\njmp label_a\nlabel_print:\nxor rcx,rcx\nxor rax,rax\npush rbp\nmov rbp,rsp\nmov rax,[rbp+8+8*2]\nlabel_prog:\nmov rbx,10\ndiv bl\nadd ah,30h\nmov ebx,buffer\nsub ebx,ecx\ndec ebx\nmov [ebx],ah\nmov ah,0\ninc rcx\ncmp rax,0\njnz label_prog\nmov ax,4\nmov ebx,1\nmov edx,ecx\nmov ecx,buffer\nsub ecx,edx\nint 80h\nmov rsp,rbp\npop rbp\nret\nlabel_a:\nmov ax,1\nmov ebx,0\nint 0x80\n");       
        }
	;
主程序，调用.g文件生成的java文件如下 

//cm.java
import java.io.*;
import org.antlr.runtime.ANTLRFileStream;
import org.antlr.runtime.CommonTokenStream;
import org.antlr.runtime.tree.CommonTree;
import org.antlr.runtime.tree.CommonTreeNodeStream;


public class cm {

    public static void main(String args[]) throws Exception {

        cLexer lex = new cLexer(new ANTLRFileStream("./input.txt"));
        CommonTokenStream tokens = new CommonTokenStream(lex);

        cParser par = new cParser(tokens);
	
	cParser.prog_return ret = par.prog();
		
  	CommonTree t = ret.tree;
       // System.out.println(t.toStringTree());
	CommonTreeNodeStream nodes = new CommonTreeNodeStream(t);
	nodes.setTokenStream(tokens);
	cTree walker = new cTree(nodes);
	
	walker.prog();
			
	}
    
}
这样，就得到了.s文件，使用nasm生成.o文件后，生成可执行文件，测试 

java org.antlr.Tool c.g
java org.antlr.Tool cTree.g
javac *.java
java cm > input.s
nasm -f elf64 input.s
ld -s -o input input.o



github          https://github.com/lizhongguo/myc

手把手教你从零实现一个编译器（一）
大厂小码农的博客
04-24 1055
写解释器就像拼乐高，编译原理竟能这么玩？
用C++实现一个简单编译器
qq_73990157的博客
03-23 1164
主函数从输入文件中读取代码，进行语法分析，构建抽象语法树，生成目标代码，最后执行这些代码的过程。在LLVM中创建这个函数意味着你可以在你的LLVM的代码中使用。展示了如何构建一个抽象语法树（AST），并将其转换成LLVM中间表示（IR），然后编译和执行这些IR。这个函数演示了如何在LLVM中定义和使用自己的函数，以及如何调用其他函数（如。，从而在LLVM上下文中创建这些函数。准备好执行环境，然后运行主函数它接受一个空参数列表，并返回执行结果。这个函数的目的是在LLVM的上下文中创建一个代表。
简单的C编译器实现
01-13
一个简单的c编译器实现，编译原理课的大作业，写的一般，还可以优化，但基本功能都已实现。仅供参考。
自己动手开发编译器（十二）生成托管代码
weixin_34194317的博客
08-02 175
前一阶段我们完成了编译器中的重要阶段——语义分析。现在，程序中的每一个变量和类型都有其正确的定义；每一个表达式和语句的类型都是合法的；每一处方法调用都选择了正确的方法定义。现在即将进入下一个阶段——代码生成。代码生成的最终目的，是生成能在目标机器上运行的机器码，或者可以和其他库链接在一起的可重定向对象。代码生成，和这一阶段的各个优化手段，统称为编译器的后端。目前大部分编译器，在代码生成时，都倾向于...
深入理解C语言编译器代码实现
最新发布
weixin_30653091的博客
06-26 582
词法规则通常由正则表达式定义，并通过状态机（如DFA或NFA）实现。词法规则可以分为多个类别，如标识符、数字常量、字符串常量、运算符和分隔符等。以下是一个简单的词法规则集的示例：<标识符> ::= <字母> { <字母> | <数字> }<数字> ::= <数字> <字母> | <字母><运算符> ::= '+' | '-' | '*' | '/'词法分析器根据这些规则将源代码字符序列分词，生成标记序列。
自己动手写一个编译器
热门推荐
weixin_55229531的博客
07-25 6万+
Pcode 是 TinyC 编译器的中间代码，是本人参考 pascal 编译器的中间代码 pcode 、并结合逆波兰表达式（后缀表达式）的逻辑后，设计出的一种非常简单的、基于栈和符号表的虚拟代码。Pcode 虚拟机是一个用来运行 Pcode 命令的、假想的机器，它包括：一个代码区（code）、一个指令指针（eip）、一个栈（stack）、一个变量表（var_table)、一个函数表（func_table）以及一个标签表（label_table）。
一个编译器的实现1——开篇
weixin_33962923的博客
03-09 178
一直就想弄懂编译原理，弄明白编译器是怎么工作的。 学了编译原理的课，只理解到了语法分析，后面的理解就无法再在想象中完成了。 于是想做一个编译器。虽然书上把编译原理讲的那么深奥难懂，但是说穿了，编译器也只不过是几个算法而已。书也有，编程也学了，算法现成的，写个编译器，有什么难的呢。就这么愉快的决定了~ 目标确定为：写个C语言的编译器，包括词法分析、语法分析、语义分析、中间代码生成，代码优化。如...
实现一个简单的编译器
weixin_33919941的博客
08-01 2179
简单的说 编译器 就是语言翻译器，它一般将高级语言翻译成更低级的语言，如 GCC 可将 C/C++ 语言翻译成可执行机器语言，Java 编译器可以将 Java 源代码翻译成 Java 虚拟机可以执行的字节码。 编译器如此神奇，那么它到底是如何工作的呢?本文将简单介绍编译器的原理，并实现一个简单的编译器，使它能编译我们自定义语法格式的源代码。(文中使用的...
动手写一个C语言编译器
12-22
动手编写一个C语言编译器是一项挑战性的任务，但也是一个深入了解计算机工作原理的绝佳途径。编译器将高级语言转化为机器可执行的指令，涉及语言学、计算机科学和软件工程等多个领域。以下是一些关键的知识点： 1. ...
一个简易c语言的编译器源码
04-16
标题 "一个简易C语言的编译器源码" 指的是一个用于解析和转换C语言源代码的简单实现。这个项目通常是为了教学目的或个人兴趣而创建的，旨在帮助开发者理解编译器的工作原理。编译器是将高级语言（如C语言）转化为...
一个最简的C语言编译器.zip
06-13
总的来说，构建一个最简的C语言编译器是一个既有挑战性又富有教育意义的项目，它不仅帮助我们理解编译原理，而且为我们提供了探索计算机底层运作的窗口。如果你对计算机科学的奥秘感兴趣，不妨尝试一下，也许你会在...
FakeCc:自制编译器FakeCc
05-19
自制编译器FakeCc 介绍 以C语言编译过程为基础,融合一些java的语法,用java语言编写出一门新的编程语言,使用者可以更改源代码src中的文件,按照自己喜欢的语法规则来定制. 语法规则的改变 实现了c语言的基本数据类型,除掉了union联合体类型,增加了boolean类型; 更改了c语言中数组的定义顺序,由char a[10]改成了char[10] a; 实现了指针的功能,指针与指针不能进行加减运算,能和整数类型进行基本运算; 实现了const,typedef等关键字的功能,删除volatile auto register关键字; 结构体不能作为函数参数传入,也不能作为函数返回值; 头文件导入改成了import的形式; if while for goto break等循环控制语句均实现; 删除了堆上分配内存的功能(allocate),内存都在函数栈上分配; 默认在X86平台上编译,
一个java实现的简易编译器
02-23
这是一个用java实现的简易的编译器，他能将一个具有加法和乘法的算术表达式编译成类汇编语言，这是我博文对应的代码，具体请参看我的博文： http://blog.youkuaiyun.com/tyler_download/article/details/50668983 例如输入 1+2*3+4; end end是必须的，表示输入结束，然后程序输出： t0 = 1 t1 = 2 t2 = 3 t1 *= t2 t0 += t1 t1 = 4 t0 += t1
自制c语言编译器
05-27
编译原理课程设计学完之后，自己做了一个编译器，里面有文档 ，可以翻译成汇编语言
自制编译器：词法分析器
锐之锋芒
04-21 4014
词法分析器代码已上传到个人资源中。 当我们的程序源文件进入编译器，首先遇到的就是词法分析器。 词法分析器的作用就是解析源文件，分析出其中的词素，并把这个词素的顺序集输入给语法分析器。 接上篇把所谓的词素也就是终结符号列出来： if else while ( ) { } cpreop bitop logiop armtcop number literal id NUL new [ ] b
简单的c编译器(c语言实现),实现简易的C语言编译器（part 12）
weixin_42149153的博客
05-18 796
这一部分，我们将基于之前创建好的抽象语法树为源代码生成具体的汇编语言代码。在这之前，我们先来看看下面这段源代码对应生成的汇编代码的内容：int foo(_foo:push %rbpmov %rsp,%rbpint a, mov %edi,-0x4(%rbp)int b mov %esi,-0x8(%...
简单的c编译器c语言实现原理,简单C语言编译器(编译原理)
weixin_31236309的博客
05-18 253
#include#include#include#include#include#include#include#include#define NULL 0struct Stack // 栈结构体: 序号、内容、连接下一结点指针{int num;char name;struct Stack *next;};struct Guiyue// 规则集结构体:序号、规则长度、符号、连接下一结点指针{i...
【自制编译器】（一）
lrxcsdn的博客
01-16 379
自制编译器
自制编译器（—）
qq_42106837的博客
09-06 1365
本系列参考国外自制编译器系列教程：https://ruslanspivak.com/lsbasi-part1/ 中文版参考如下两位大神： http://www.opython.com/interpreter https://www.zhihu.com/column/c_1383722427357159424 目标是实现一个简单的基于python的编译器，目的是为了加深对python的理解。 目前进度如下：已成功实现第一、第二两部分内容。 不过，在实现过程中，发现原文的小小失误，特来记录。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值