├── .gitignore ├── LICENSE ├── README.md ├── documents ├── 1.md ├── 2.md ├── 3.md ├── 4.md ├── 5.md └── 6.md ├── test.try └── tryC.c /.gitignore: -------------------------------------------------------------------------------- 1 | tryc 2 | tryC -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 云微 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # tryC - a small interpreter written by C 2 | 3 | tryC is a very simple interpreter made by hand in C language, about 570 lines: 4 | 5 | Use `recursive descent method` for grammatical analysis, do not explicitly build a grammar tree, generate intermediate code or target code; interpret and execute at the same time as grammatical analysis. 6 | 7 | The try language implemented by tryC: 8 | 9 | - `Dynamic types`, supported data types: `double-precision floating-point numbers`, `character types`, `strings`, `arrays of floating-point numbers`; 10 | - Support the definition of `functions` and `variables`, recursive call of functions, nested scope; 11 | 12 | tryC是一个用c语言手搓的非常简单的解释器，大约570行： 13 | 14 | 采用递归下降法进行语法分析，不显式构建语法树，不生成中间代码或目标代码，在语法分析的同时进行解释执行； 15 | 16 | tryC实现的try语言： 17 | - 动态类型，支持的数据类型：双精度浮点数、字符型、字符串、浮点数数组 18 | - 支持函数和变量的定义、函数的递归调用、嵌套作用域 19 | 20 | ### files： 21 | 22 | source：tryC.c 23 | 24 | example：test.try 25 | 26 | ### build and run： 27 | 28 | build: 29 | 30 | gcc -o tryc tryC.c 31 | 32 | usage: 33 | 34 | tryc [-d] filename 35 | 36 | ## documents in Chinese 37 | 38 | [用c语言手搓一个600行的类c语言解释器: 给编程初学者的解释器教程（1）- 目标和前言](https://blog.csdn.net/qq_42779423/article/details/105938297) 39 | 40 | [用c语言手搓一个600行的类c语言解释器: 给编程初学者的解释器教程（2）- 简介和设计](https://blog.csdn.net/qq_42779423/article/details/105939788) 41 | 42 | [用c语言手搓一个600行的类c语言解释器: 给编程初学者的解释器教程（3）- 词法分析](https://blog.csdn.net/qq_42779423/article/details/105948289) 43 | 44 | [用c语言手搓一个600行的类c语言解释器: 给编程初学者的解释器教程（4）- 语法分析1：EBNF和递归下降文法](https://blog.csdn.net/qq_42779423/article/details/105954353) 45 | 46 | [用c语言手搓一个600行的类c语言解释器: 给编程初学者的解释器教程（5）- 语法分析2: tryC的语法分析实现](https://blog.csdn.net/qq_42779423/article/details/105954455) 47 | 48 | [用c语言手搓一个600行的类c语言解释器: 给编程初学者的解释器教程（6）- 语义分析：符号表和变量、函数](https://blog.csdn.net/qq_42779423/article/details/105979594) -------------------------------------------------------------------------------- /documents/1.md: -------------------------------------------------------------------------------- 1 | # 用c语言手搓一个500+行的类c语言解释器: 给编程初学者的解释器教程（1）- 目标和前言 2 | 3 | 项目github地址及源码： 4 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 5 | 6 | ## 一个小目标 7 | 这一系列教程希望面向初学者，使用c语言手工实现一个简单的解释器来玩，不需要您掌握除了c语言以外的其他前置知识，也不需要您学习过编译原理的相关知识（当然如果能对简单的数据结构有所了解的话会更好，比如树、栈等）。 8 | 9 | > 写一个能执行代码的解释器不仅是一件很有（zhuang）趣（bi）的事情，大概也可以作为刚学习完c语言的一个练手的小项目啦 10 | 11 | 不同于大部分常见的其他只支持四则运算的所谓”手工解释器“教程，我们希望在代码结构尽量清晰的600行代码中，手工（不借助lex/yacc等工具）完成一个脚本语言“try”，实现以下功能： 12 | 13 | - 选择和循环的流程控制语句 14 | - 支持的数据类型：双精度浮点数、字符型、字符串、浮点数数组 15 | - 支持函数和变量的定义、函数的递归调用、嵌套作用域 16 | 17 | （如果看不懂下面这段也没关系，可以略过啦） 18 | 19 | > 这个小玩意采用递归下降法进行语法分析，同时不显式构建语法树，不生成中间代码或目标代码，在语法分析的同时进行解释执行； 20 | 21 | ### 解释器可运行的代码示例 22 | 递归计算文波那契数列 1 - 15，将结果存入数组中，并打印： 23 | 24 | ```c 25 | # Fibonacci sequence 26 | func fun{ 27 | if(x <= 2){ 28 | return(1); 29 | } 30 | y = 0; 31 | x = x - 1; 32 | y = fun(x); 33 | x = x - 1; 34 | return(y + fun(x)); 35 | }; 36 | 37 | # save the Fibonacci sequence of 1 to 15 in an array 38 | array arr(15); 39 | x = 1; 40 | while( x <= 15 ){ 41 | arr[x - 1] = fun(x); 42 | x = x + 1; 43 | } 44 | 45 | puts("Fibonacci sequence:"); 46 | # print the Fibonacci sequence of 1 to 15 47 | i = 0; 48 | while(i < 15){ 49 | print(arr[i]); 50 | i=i+1; 51 | } 52 | 53 | ``` 54 | 55 | （起名困难x）这个小玩意我们就随便叫它tryC吧，当做是一个小的尝试。 56 | 57 | 本人水平有限，如有疏漏之处，还请多多指教。 58 | 59 | ### 部分语言规则： 60 | 61 | - 注释在一行内，以‘#’开头； 62 | - 语句以‘;’结尾 63 | - 赋值语句类型： 64 | 65 | ```c 66 | x = 123.4; 67 | x = 'c'; 68 | x = "hello world!"; 69 | ``` 70 | 71 | - 循环语句： 72 | 73 | ```c 74 | while( bool ){ 75 | statements 76 | } 77 | ``` 78 | 79 | - 选择语句： 80 | 81 | ```c 82 | if( bool ){ 83 | statements 84 | } 85 | 86 | if( bool ){ 87 | statements 88 | }else{ 89 | statements 90 | } 91 | ``` 92 | 93 | - 定义函数：函数参数在定义中不出现，在调用中获取；返回值为double 94 | 95 | ```c 96 | func function_name{ 97 | ... 98 | return(expression); 99 | } 100 | 101 | ``` 102 | 103 | - 定义数组： 104 | 105 | ```c 106 | array array_name(array_length); 107 | 108 | ``` 109 | 110 | - 输入输出： 111 | 112 | ```c 113 | puts(string); 114 | print(num); 115 | read(num); 116 | ``` 117 | 118 | ## 写在前面 119 | 120 | ### 关于写这玩意的缘由（写的很乱可以不看系列） 121 | 122 | 之前大一学c语言的时候，老师要求实现一个四则运算的计算器，于是我想...要是能给计算器加上函数和变量的定义就好啦...那大概能算一个简单的解释器？我应该怎样去实现它呢？就去查了不少资料七拼八凑加上自己脑补搓了一个出来...虽然能跑起来但是代码混乱不堪一塌糊涂，不过也挺好玩的。 123 | 124 | 这里的部分是过了一年之后大二学编译原理的时候，把当时的代码用相对比较规范完善的方式重写了一遍，也因此希望把它整理成一个简单的教程，让c语言的初学者也可以愉快地搓一个解释器玩；或者让学过编译原理的同学，能够把理论和实践联系起来，（不要像我一样被一大堆的理论迷惑住或吓跑），对于如何构造一个解释器有个直观感性的认识，并且发现它并不像想象的那么困难。 125 | 126 | ### 需要了解的前置知识 127 | 128 | - c语言的指针、函数指针、结构体等 129 | - 递归的思想 130 | 131 | ### 心理准备 132 | 133 | - 写一个600行的解释器虽然不算什么大工程，但相关的原理还是稍微有些复杂的，可能需要多花一些时间理解程序的运行过程； 134 | 135 | - 代码可能难以调试，尤其在没有生成中间代码的情况下； 136 | 137 | ### 参考资料 138 | 139 | - 《编译原理及其实践》 140 | 141 | - [c4](https://github.com/rswier/c4) 142 | 用四个函数和很少的代码就完成了功能相当完善的 C 语言编译器, 并且能够自举；我自己写作的时候也借鉴了c4的许多实现思想； 143 | 144 | - [手把手教你构建 C 语言编译器](https://lotabout.me/2015/write-a-C-interpreter-0/) 145 | 对c4的一个重写版，附有详细的中文教程 146 | 147 | - [Let's Build a Compiler, by Jack Crenshaw ](https://compilers.iecc.com/crenshaw/) 148 | 一个英文的初学者教程，讲解如何实现一个编译器 149 | -------------------------------------------------------------------------------- /documents/2.md: -------------------------------------------------------------------------------- 1 | # 用c语言手搓一个500+行的类c语言解释器: 给编程初学者的解释器教程（2）- 简介和设计 2 | 3 | 项目github地址及源码： 4 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 5 | 6 | ## 需要了解的一些基本概念 7 | 8 | ### 编译器和解释器的区别不同 9 | 10 | 通常我们说的 “编译器” 是一种计算机程序，负责把一种编程语言编写的源码转换成另外一种计算机代码，后者往往是以二进制的形式被称为目标代码(object code)。这个转换的过程通常的目的是生成可执行的程序。 11 | 12 | 而解释器是一种计算机程序，它直接执行由编程语言或脚本语言编写的代码，它并不会把源代码预编译成机器码，而是一行一行地分析源代码并且直接执行，相对编译器而言可能效率较为低下，但实现也相对简单，并且容易在不同的机器上进行移植（比如x86和mips指令集的机器）。 13 | 14 | ### 先来看看通常的编译器是如何实现的： 15 | 16 | 编译器从源码翻译为目标代码大致需要这样几个步骤，每个步骤都依赖于上一个步骤的结果： 17 | 18 | 1. 词法分析： 19 | 20 | 编译器对源程序进行阅读，并将字符序列，也就是源代码中一个个符号收集到称作记号（token）的单元中；比如: 21 | 22 | ```c 23 | num = 123.4; 24 | ``` 25 | 26 | 这样个赋值语句中，变量num算是一个token，“=”符号算是一个token，“123.4”算是一个token；每个token有自己的类别和属性，比如“123.4”的类别是数字，属性（值）是123.4 27 | 28 | 2. 语法分析： 29 | 30 | 语法分析指将词法分析得到的标记流（token）进行分析，组成事先定义好的有意义的语句，这与自然语言中句子的语法分析类似。通常可以用抽象语法树表示语法分析的结果，比如赋值语句： 31 | 32 | ```c 33 | num = 123.4 * 3; 34 | ``` 35 | 36 | 可以用这样一个抽象语法树来表示: 37 | 38 | ```mermaid 39 | graph TD 40 | = --> num 41 | = --> * 42 | * --> 123.4 43 | * --> 3 44 | ``` 45 | 46 | 3. 语义分析： 47 | 程序的语义就是它的“意思”，程序的语义确定程序的运行方式。语义分析阶段通常包括声明和类型检查、计算需要的一些属性值等等。编译器在这个阶段中通常会维护一个叫做“符号表”的东西，保存变量的值、属性和名称。同样以 48 | 49 | ```c 50 | num = 123.4 * 3; 51 | ``` 52 | 53 | 为例，假如我们是第一次在这里遇见“num”，就将num的名称字符串“num” 和当前计算出来的初始值370.2插入符号表中，当下次再遇见num时。我们就知道它是一个数字，已经初始化完毕，并且当前值是370.2； 54 | 55 | 4. 目标代码生成： 56 | 在语义分析之后，我们就可以将语法分析和语义分析的结果（通常是抽象语法树）转换成可执行的目标代码。 57 | 58 | 解释器与编译器仅在代码生成阶段有区别，而在前三个阶段如词法分析、语法分析、语义分析基本是一样的。 59 | 60 | 当然，已经有许多工具可以帮助我们处理阶段1和2，如 flex 用于词法分析，bison 用于语法分析；但它们的功能都过于强大，屏蔽了许多实现上的细节，对于学习构建编译器帮助不大，所以我们要完全手写这些功能。 61 | 62 | > （实际上完成一个可以跑起来的解释器并不难，而且还是一件很有成就感的事，不是嘛？） 63 | 64 | ## tryC编译器的设计： 65 | 66 | 从上面可以看出，我们的tryC解释器需要这三个模块： 67 | 68 | 1. 词法分析 69 | 2. 语法分析 70 | 3. 语义分析和解释执行 71 | 72 | 需要这两个数据结构（用来在阶段之间保存或传递值）： 73 | 74 | 1. token，用来在词法分析和语法分析之间传递标记； 75 | 2. 符号表，保存语义分析阶段遇见的变量值，使用一个数组存储； 76 | 77 | 在了解过这些之后，我们先来大概看看代码的基本结构： 78 | 79 | （从上往下在代码中依次对应，“...”表示省略的相关代码，在后续文章中会详细讲解） 80 | 81 | - 数据结构的声明部分：token类型、符号表结构： 82 | 83 | ```c 84 | #include 85 | ... 86 | 87 | typedef struct symStruct { 88 | int type; 89 | char name[MAXNAMESIZE]; 90 | double value; 91 | .......... 92 | } symbol; 93 | symbol symtab[SYMTABSIZE]; // 符号表 94 | int symPointer = 0; 95 | 96 | char* src, * old_src; // 当前分析的源代码位置指针 97 | 98 | // tokens 的枚举类型 99 | enum { 100 | Num = 128, Char, Str, Array, Func, 101 | ........ 102 | }; 103 | 104 | // token 的表示形式 105 | int token; // current token type 106 | union tokenValue { 107 | symbol* ptr; 108 | double val; 109 | } token_val; 110 | 111 | ``` 112 | 113 | - 词法分析的两个函数： 114 | 115 | ```c 116 | // 获取输入流中的下一个记号： 117 | void next() { 118 | char* last_pos; 119 | 120 | while (token = *src) { 121 | ++src; 122 | if(token == AAA ){ 123 | ..... 124 | }else if(token == BBB ){ 125 | ..... 126 | } 127 | } 128 | } 129 | 130 | // 匹配一个记号，并获取下一个token： 131 | void match(int tk) { 132 | if (token == tk) { 133 | next(); 134 | } 135 | else { // 遇到了一个错误 136 | exit(-1); 137 | } 138 | } 139 | 140 | ``` 141 | 142 | - 语法分析和语义分析，以及执行阶段：使用递归下降法实现（后面会再提到什么是递归下降法啦） 143 | 144 | ```c 145 | 146 | // 计算表达式的值： 147 | double expression(){} 148 | double factor(){} 149 | double term(){} 150 | 151 | // 计算布尔表达式的值： 152 | int boolOR(); 153 | int boolAND(); 154 | int boolexp(); 155 | 156 | // 执行一个语句； 157 | double statement(); 158 | 159 | // 执行一个函数： 160 | double function(); 161 | 162 | ``` 163 | 164 | - main() 函数，代码的入口，并 165 | 166 | ```c 167 | 168 | int main(int argc, char** argv) 169 | { 170 | // 往符号表里面添加关键词 171 | int i, fd; 172 | src = "array func else if return while print puts read"; 173 | for (i = Array; i <= Read; ++i) { 174 | next(); 175 | symtab[symPointer -1].type = i; 176 | } 177 | 178 | src = old_src = (char*)malloc(POOLSIZE); // 分配空间 179 | 180 | .... 181 | 182 | fd = open(*argv, 0); // 打开读取文件 183 | 184 | read(fd, src, POOLSIZE - 1); 185 | 186 | src[i] = 0; 187 | close(fd); 188 | next(); 189 | while (token != 0) { // 一条一条语句执行 190 | statement(); 191 | } 192 | return 0; 193 | } 194 | 195 | ``` 196 | 197 | ## 重要概念 198 | 199 | - 编译器/解释器 200 | - 词法分析 201 | - 语法分析 202 | - 语义分析 203 | - token 204 | - 符号表 205 | 206 | 可参照github源码查看（如果觉得写得还行麻烦您帮我点个star哦） 207 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) -------------------------------------------------------------------------------- /documents/3.md: -------------------------------------------------------------------------------- 1 | # 用c语言手搓一个500+行的类c语言解释器: 给编程初学者的解释器教程（3）- 词法分析 2 | 3 | 项目github地址及源码： 4 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 5 | 6 | 这一篇讲讲在tryC中词法分析器是怎样构建的 7 | 8 | 9 | ## 词法分析器是什么玩意 10 | 11 | 回想一下上一篇我们说的词法分析阶段，编译器做了这样一件事： 12 | 13 | 对源程序进行阅读，并将字符序列，也就是源代码中一个个符号收集到称作记号（token）的单元中 14 | 15 | 帮编译器执行词法分析阶段的模块，就叫词法分析器啦。词法分析器能够对源码字符串做预处理，以减少语法分析器的复杂程度。 16 | 17 | 词法分析器以源码字符串为输入，输出为标记流（token stream），即一连串的标记，比如对于源代码中间: 18 | 19 | ```c 20 | num = 123.4; 21 | ``` 22 | 23 | 这样一个赋值语句中，变量num算是一个token，“=”符号算是一个token，“123.4”算是一个token；每个token有自己的类别和属性，比如“123.4”的类别是数字，属性（值）是123.4；每个token可以用这一对儿表示：{token, token value}，就像“123.4”可以表示为{Num, 123.4} 24 | 25 | 词法分析器输入上面那句话，就得到这样一个标记流： 26 | 27 | ```c 28 | {Sym, num}, {'=', assign}, {Num, 123.4} 29 | ``` 30 | 31 | ## 词法分析器的具体实现 32 | 33 | 由于词法分析器对于各个语言基本都是大同小异，在其他地方也有很多用途，并且手工构造的话实际上是一个很枯燥又容易出错的活计，因此其实已经有了不少现成的实现，比如 lex/flex 。 34 | 35 | 通常词法分析器的实现会涉及到正则表达式、状态机的一些相关知识，或者通过正则表达式用上面那些工具来生成。但对于我们这样一个简单的解释器来说，手工构造词法分析器，并且完全不涉及到正则表达式的知识，理解起来也并不是很困难啦。 36 | 37 | ### 先来看看token是怎样写的 38 | 39 | token的数据结构如下： 40 | 41 | ```c 42 | 43 | int token; // current token type 44 | union tokenValue { // token value 45 | symbol* ptr; 46 | double val; 47 | } token_val; 48 | ``` 49 | 50 | - 用一个整型变量 token 来表示当前的 token 是什么类型的； 51 | - 用一个联合体来表示附加的token属性，ptr可以附加指针类型的值，val可以附加数值。 52 | 53 | token 的类型采用枚举表示定义： 54 | 55 | ```c 56 | /* tokens and classes (operators last and in precedence order) */ 57 | enum { 58 | Num = 128, Char, Str, Array, Func, 59 | Else, If, Return, While, Print, Puts, Read, 60 | Assign, OR, AND, Equal, Sym, FuncSym, ArraySym, Void, 61 | Nequal, LessEqual, GreatEqual, Inc, Dec 62 | }; 63 | ``` 64 | 65 | 比如我们会将“==”标记为Equal，将Num标记为Sym等等。从这里也可以看出，一个标记（token）可能包含多个字符；而词法分析器能减小语法分析复杂度的原因，正是因为它相当于通过一定的编码（采用标记来表示一定的字符串）来压缩和规范化了源码。 66 | 67 | 另外，一些单个字符我们直接作为token返回，比如： 68 | 69 | ```c 70 | '}' '{' '(' ')' ';' '[' ']' ..... 71 | ``` 72 | 73 | ### 词法分析器真正干活的函数们 74 | 75 | 首先需要说明一下，源码字符串为输入，输出为标记流（token stream），这里的标记流并不是一次性将所有的源代码翻译成长长的一串标记串，而是需要一个标记的时候再转换一个标记，原因如下： 76 | 77 | 1. 字符串转换成标记流有时是有状态的，即与代码的上下文是有关系的。 78 | 2. 保存所有的标记流没有意义且浪费空间。 79 | 80 | 所以通常的实现是提供一个函数，每次调用该函数则返回下一个标记。这里说的函数就是 next() 。 81 | 82 | 这是next()的基本框架：其中“AAA”"BBB"是token类型； 83 | 84 | ```c 85 | void next() { 86 | while (token = *src) { 87 | ++src; 88 | if(token == AAA ){ 89 | ..... 90 | }else if(token == BBB ){ 91 | ..... 92 | } 93 | } 94 | } 95 | ``` 96 | 97 | 用while循环的原因有以下几个： 98 | 99 | - 处理错误： 100 | 如果碰到了一个我们不认识的字符，可以指出错误发生的位置，然后用while循环跳过当前错误，获取下一个token并继续编译； 101 | 102 | - 跳过空白字符； 103 | 在我们实现的tryC语言中，空格是用来作为分隔用的，并不作为语法的一部分。因此在实现中我们将它作为“不识别”的字符进行跳过。 104 | 105 | 现在来看看AAA、BBB具体是怎样判断的： 106 | 107 | #### 换行符和空白符 108 | 109 | ```c 110 | ... 111 | if (token == '\n') { 112 | old_src = src; // 记录当前行，并跳过； 113 | } 114 | else if (token == ' ' || token == '\t') { } 115 | ... 116 | 117 | ``` 118 | 119 | #### 注释 120 | 121 | ```c 122 | ... 123 | else if (token == '#') { // skip comments 124 | while (*src != 0 && *src != '\n') { 125 | src++; 126 | } 127 | } 128 | ... 129 | 130 | ``` 131 | 132 | #### 单个字符 133 | 134 | ```c 135 | ... 136 | else if ( token == '*' || token == '/' || token == ';' || token == ',' || 137 | token == '(' || token == ')' || token == '{' || token == '}' || token == '[' || token == ']') { 138 | return; 139 | } 140 | 141 | ... 142 | 143 | ``` 144 | 145 | #### 数字 146 | 147 | token 为Num； 148 | token_val.val为值； 149 | 150 | ```c 151 | ... 152 | else if (token >= '0' && token <= '9') { // process numbers 153 | token_val.val = (double)token - '0'; 154 | while (*src >= '0' && *src <= '9') { 155 | token_val.val = token_val.val * 10.0 + *src++ - '0'; 156 | } 157 | if (*src == '.') { 158 | src++; 159 | int countDig = 1; 160 | while (*src >= '0' && *src <= '9') { 161 | token_val.val = token_val.val + ((double)(*src++) - '0')/(10.0 * countDig++); 162 | } 163 | } 164 | token = Num; 165 | return; 166 | } 167 | 168 | ... 169 | 170 | ``` 171 | 172 | #### 字符串 173 | 174 | token 为Str； 175 | token_val.ptr保存字符串指针； 176 | 177 | ```c 178 | ... 179 | else if (token == '"' ) { // parse string 180 | last_pos = src; 181 | char tval; 182 | int numCount = 0; 183 | while (*src != 0 && *src != token) { 184 | src++; 185 | numCount++; 186 | } 187 | if (*src) { 188 | *src = 0; 189 | token_val.ptr = malloc(sizeof(char) * numCount + 8); 190 | strcpy(token_val.ptr, last_pos); 191 | *src = token; 192 | src++; 193 | } 194 | token = Str; 195 | return; 196 | } 197 | 198 | ... 199 | 200 | ``` 201 | 202 | #### 字符 203 | 204 | token 为Char； 205 | token_val.val为值； 206 | 207 | ```c 208 | ... 209 | else if (token == '\'') { // parse char 210 | token_val.val = *src++; 211 | token = Char; 212 | src++; 213 | return; 214 | } 215 | 216 | ... 217 | 218 | ``` 219 | 220 | #### 变量：这是最复杂的一部分 221 | 222 | 对变量的处理需要以下几个步骤： 223 | 1. 获取完整的变量名： 224 | 2. 在符号表中查找变量： 225 | 3. 如果在符号表中找到了变量，根据变量不同的类型，返回不同的token值； 226 | 4. 如果没有找到，在符号表中间插入新的变量 227 | 228 | 关于符号表具体的内容，会独立出一篇文章来解释。 229 | 230 | ```c 231 | ... 232 | else if ((token >= 'a' && token <= 'z') || (token >= 'A' && token <= 'Z') || (token == '_')) { 233 | last_pos = src - 1; // process symbols 234 | char nameBuffer[MAXNAMESIZE]; 235 | nameBuffer[0] = token; 236 | while ((*src >= 'a' && *src <= 'z') || (*src >= 'A' && *src <= 'Z') || (*src >= '0' && *src <= '9') || (*src == '_')) { 237 | nameBuffer[src - last_pos] = *src; 238 | src++; 239 | } 240 | nameBuffer[src - last_pos] = 0; // get symbol name 241 | int i; 242 | for (i = symPointer-1; i >= 0; --i) { // search symbol in symbol table 243 | if (strcmp(nameBuffer, symtab[i].name) == 0) { // if find symbol: return the token according to symbol type 244 | if (symtab[i].type == Num || symtab[i].type == Char) { 245 | token_val.ptr = &symtab[i]; 246 | token = Sym; 247 | } 248 | else if (symtab[i].type == FuncSym) { 249 | token_val.ptr = &symtab[i]; 250 | token = symtab[i].type; 251 | } 252 | else if (symtab[i].type == ArraySym) { 253 | token_val.ptr = &symtab[i]; 254 | token = symtab[i].type; 255 | } 256 | else { 257 | if (symtab[i].type == Void) { 258 | token = Sym; 259 | token_val.ptr = &symtab[i]; 260 | } 261 | else token = symtab[i].type; 262 | } 263 | return; 264 | } 265 | } 266 | strcpy(symtab[symPointer].name, nameBuffer); // if symbol not found, create a new one 267 | symtab[symPointer].levelNum = currentlevel; 268 | symtab[symPointer].type = Void; 269 | token_val.ptr = &symtab[symPointer]; 270 | symPointer++; 271 | token = Sym; 272 | return; 273 | } 274 | ... 275 | 276 | ``` 277 | 278 | #### 其他的一些符号，可能需要再多读取一个字符才能确定具体token 279 | 280 | ```c 281 | ... 282 | else if (token == '=') { // parse '==' and '=' 283 | if (*src == '=') { 284 | src++; 285 | token = Equal; 286 | } 287 | return; 288 | } 289 | else if (token == '+') { // parse '+' and '++' 290 | if (*src == '+') { 291 | src++; 292 | token = Inc; 293 | } 294 | return; 295 | } 296 | else if (token == '-') { // parse '-' and '--' 297 | if (*src == '-') { 298 | src++; 299 | token = Dec; 300 | } 301 | return; 302 | } 303 | else if (token == '!') { // parse '!=' 304 | if (*src == '=') { 305 | src++; 306 | token = Nequal; 307 | } 308 | return; 309 | } 310 | else if (token == '<') { // parse '<=', or '<' 311 | if (*src == '=') { 312 | src++; 313 | token = LessEqual; 314 | } 315 | return; 316 | } 317 | else if (token == '>') { // parse '>=', or '>' 318 | if (*src == '=') { 319 | src++; 320 | token = GreatEqual; 321 | } 322 | return; 323 | } 324 | else if (token == '|') { // parse '||' 325 | if (*src == '|') { 326 | src++; 327 | token = OR; 328 | } 329 | return; 330 | } 331 | else if (token == '&') { // parse '&&' 332 | if (*src == '&') { 333 | src++; 334 | token = AND; 335 | } 336 | return; 337 | } 338 | 339 | ... 340 | 341 | ``` 342 | 343 | 344 | #### 错误处理 345 | 346 | ```c 347 | ... 348 | else { 349 | printf("unexpected token: %d\n", token); 350 | } 351 | 352 | ... 353 | 354 | ``` 355 | 356 | #### match函数：用于匹配当前token并获取下一个token 357 | 358 | ```c 359 | // 匹配一个记号，并获取下一个token： 360 | void match(int tk) { 361 | if (token == tk) { 362 | next(); 363 | } 364 | else { // 遇到了一个错误 365 | exit(-1); 366 | } 367 | } 368 | 369 | ``` 370 | 371 | 可对照源码查看（如果觉得写得还行麻烦您帮我点个star哦） 372 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 373 | 374 | -------------------------------------------------------------------------------- /documents/4.md: -------------------------------------------------------------------------------- 1 | # 用c语言手搓一个500+行的类c语言解释器: 给编程初学者的解释器教程（4）- 语法分析1：EBNF和递归下降文法 2 | 3 | 项目github地址及源码： 4 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 5 | 6 | 这一章开始进入解释器的核心部分: 语法分析器； 7 | 8 | 我们来看看两个概念，EBNF和递归下降文法，以及如何用这两个方法来计算tryC中的表达式。 9 | 10 | ## 基本概念 11 | 12 | 就像之前所说的那样，语法分析指将词法分析得到的标记流（token）进行分析，组成事先定义好的有意义的语句。那么如何完成这样一个工作呢？我们可以借助一个叫“BNF”的数学工具。 13 | 14 | ### BNF与上下文无关文法 15 | 16 | Backus-Naur符号（就是众所周知的BNF或Backus-Naur Form）是描述语言的形式化的数学方法，由John Backus (也许是Peter Naur)开发，最早用于描述Algol 60编程语言的语法。 17 | 18 | BNF类似一种数学游戏：从一个符号开始（叫做起始标志，实例中常用S表示），然后给出替换前面符号的规则。 19 | 20 | BNF语法定义的语言是一个字符串集合，可以按照下述规则书写，这些规则叫做书写规范（产生式规则），例如一个四则运算表达式可以表示为： 21 | 22 | ```c 23 | exp -> exp op exp | ( exp ) | number 24 | op -> + | - | * | / 25 | ``` 26 | 27 | 其中'|'用于表示可选择的不同项，"->"用于表示推导规则，从产生式左边的符号可以推导出产生式右边的符号； 28 | 29 | 要解析一个表达式，我们可以完成这样一个替换：对于 30 | 31 | ```c 32 | (3+2)*4 33 | ``` 34 | 35 | 可以替换为 36 | 37 | ```c 38 | exp => exp op exp => exp * number 39 | => ( exp ) * number 40 | => ( exp op exp ) * number 41 | => ( number + number ) * number 42 | ``` 43 | 44 | 其中我们把能够被替换的符号叫做非终结符，不能被替换的叫做终结符。 45 | 46 | 上下文无关文法就是说，这个文法中所有的产生式左边只有一个非终结符，就像上面写的那个文法一样。通常我们在编译器构建中使用的都是上下文无关文法。 47 | 48 | ### EBNF 49 | 50 | EBNF是基本巴科斯范式(BNF)元语法符号表示法的一种扩展，主要对BNF中常见的两种情况，即重复项和可选项添加了相应的语法规则，如用方括号"[ .... ]" 51 | 表示可选部分，用花括号"{ ... }"表示重复出现的部分，如上面那个文法可以改写为： 52 | 53 | ```c 54 | exp -> exp { op exp } | ( exp ) | number 55 | op -> + | - | * | / 56 | ``` 57 | 58 | 又比如对于if语句可以写成： 59 | 60 | ```c 61 | if-stmt -> if ( exp ) statement; [ else statement; ] 62 | ``` 63 | 64 | ### 递归下降文法 65 | 66 | 递归下降分析法也很简单，就是用函数的调用来模拟BNF的替换过程，我们只需要为每个非终结符定义一个分解函数，它就能从起始非终结符开始，不断地调用非终结符的分解函数，不断地对非终结符进行分解，直到匹配输入的终结符。 67 | 68 | 当然，递归下降分析并不是对于所有的文法都能正常使用的，例如经典的左递归问题：比如这样一个文法 69 | 70 | ```c 71 | exp -> exp { op exp } | ( exp ) | number 72 | op -> + | - | * | / 73 | ``` 74 | 75 | 对于exp的替换需要调用exp的分解函数，而exp的分解函数一进来就调用它自身（即最左边的符号），就会导致无限递归。这时就需要对文法进行改造。 76 | 77 | 实际上，EBNF文法就是为了映射递归下降分析法的具体程序实现而设计的，因此我们这里就用EBNF文法来实现递归下降分析。 78 | 79 | ## 来看看怎样用递归下降文法计算tryC中的表达式 80 | 81 | 上面说了一大堆，现在看看实际的计算表达式的实现是怎样的呢 82 | 83 | ### 算术表达式 84 | 85 | tryC中需要计算四则运算表达式的EBNF文法如下： 86 | 87 | ```c 88 | exp -> term { addop term } 89 | term -> factor { mulop factor } 90 | factor -> number | ( exp ) 91 | addop -> + | - 92 | mulop -> * | / 93 | ``` 94 | 95 | 这里对文法进行了一定的改造，让它能够正确表达四则运算的优先级，同时避免了左递归的问题，具体可以自己试着验证一下。 96 | 97 | tryC中算术表达式具体的代码实现(就是上述文法直接转换过来的啦)： 98 | 99 | (在下一篇文章中还会提及表达式中对变量的处理过程) 100 | 101 | ```c 102 | double term() { 103 | double temp = factor(); 104 | while (token == '*' || token == '/') { 105 | if (token == '*') { 106 | match('*'); 107 | temp *= factor(); 108 | } 109 | else { 110 | match('/'); 111 | temp /= factor(); 112 | } 113 | } 114 | return temp; 115 | } 116 | 117 | double factor() { 118 | double temp = 0; 119 | if (token == '(') { 120 | match('('); 121 | temp = expression(); 122 | match(')'); 123 | } 124 | else if(token == Num || token == Char){ 125 | temp = token_val.val; 126 | match(Num); 127 | } 128 | else if (token == Sym) { 129 | temp = token_val.ptr->value; 130 | match(Sym); 131 | } 132 | else if (token == FuncSym) { 133 | return function(); 134 | } 135 | else if (token == ArraySym) { 136 | symbol* ptr = token_val.ptr; 137 | match(ArraySym); 138 | match('['); 139 | int index = (int)expression(); 140 | if (index >= 0 && index < ptr->value) { 141 | temp = ptr->pointer.list[index].value; 142 | } 143 | match(']'); 144 | } 145 | return temp; 146 | } 147 | 148 | double expression() { 149 | double temp = term(); 150 | while (token == '+' || token == '-') { 151 | if (token == '+') { 152 | match('+'); 153 | temp += term(); 154 | } 155 | else { 156 | match('-'); 157 | temp -= term(); 158 | } 159 | } 160 | return temp; 161 | } 162 | 163 | ``` 164 | ### 布尔表达式 165 | tryC中同样设计了布尔表达式： 166 | 167 | tryC中需要计算四则运算表达式的EBNF文法如下： 168 | 169 | ```c 170 | boolOR = boolAND { '||' boolAND } 171 | boolAND = boolexp { '||' boolexp } 172 | boolexp -> exp boolop exp | ( boolOR ) | !boolexp 173 | boolop -> > | < | >= | <= | == 174 | ``` 175 | 176 | 代码实现： 177 | 178 | ```c 179 | int boolexp() { 180 | if (token == '(') { 181 | match('('); 182 | int result = boolOR(); 183 | match(')'); 184 | return result; 185 | } 186 | else if (token == '!') { 187 | match('!'); 188 | return boolexp(); 189 | } 190 | double temp = expression(); 191 | if (token == '>') { 192 | match('>'); 193 | return temp > expression(); 194 | } 195 | else if (token == '<') { 196 | match('<'); 197 | return temp < expression(); 198 | } 199 | else if (token == GreatEqual) { 200 | match(GreatEqual); 201 | return temp >= expression(); 202 | } 203 | else if (token == LessEqual) { 204 | match(LessEqual); 205 | return temp <= expression(); 206 | } 207 | else if (token == Equal) { 208 | match(Equal); 209 | return temp == expression(); 210 | } 211 | return 0; 212 | } 213 | 214 | int boolAND() { 215 | int val = boolexp(); 216 | while (token == AND) { 217 | match(AND); 218 | if (val == 0) return 0; // short cut 219 | val = val & boolexp(); 220 | if (val == 0) return 0; 221 | } 222 | return val; 223 | } 224 | 225 | int boolOR() { 226 | int val = boolAND(); 227 | while (token == OR) { 228 | match(OR); 229 | if (val == 1) return 1; // short cut 230 | val = val | boolAND(); 231 | } 232 | return val; 233 | } 234 | ``` 235 | 236 | ## 一些重要概念 237 | 238 | - 终结符/非终结符 239 | - BNF/EBNF 240 | - 上下文无关文法 241 | - 递归下降法 242 | 243 | 244 | 可对照源码查看（如果觉得写得还行麻烦您帮我点个star哦） 245 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 246 | -------------------------------------------------------------------------------- /documents/5.md: -------------------------------------------------------------------------------- 1 | # 用c语言手搓一个500+行的类c语言解释器: 给编程初学者的解释器教程（5）- 语法分析2: tryC的语法分析实现 2 | 3 | 项目github地址及源码： 4 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 5 | 6 | ## tryC的语法分析 7 | 8 | 完整的tryC文法： 9 | 10 | (这里我们用单引号包裹那些在BCNF文法定义中出现但又作为终结符出现的字符) 11 | 12 | ```c 13 | exp -> term { addop term } 14 | term -> factor { mulop factor } 15 | factor -> number | ( exp ) | Sym | array_name '[' exp ']' | function // 处理数组单元、函数、变量等 16 | addop -> + | - 17 | mulop -> * | / 18 | 19 | boolOR = boolAND { '||' boolAND } 20 | boolAND = boolexp { '||' boolexp } 21 | boolexp -> exp boolop exp | ( boolOR ) | !boolexp 22 | boolop -> > | < | >= | <= | == 23 | 24 | statement -> '{' { statement } '}' | // 语句块 25 | if-stmt -> if ( exp ) statement [ else statement ] | // 选择语句 26 | while-stmt -> while ( exp ) statement | // 循环语句 27 | Sym = exp; | // 赋值语句 28 | print ( exp ); | // 输入输出语句 29 | puts ( Str ); | 30 | read ( Sym ); | 31 | return ( exp ); | // 函数的返回语句 32 | func func_name statement; | // 函数定义 33 | array array_name length; | // 数组定义 34 | ``` 35 | 36 | ## statement的代码实现 37 | 38 | 布尔表达式和算术表达式的代码之前已经讲过了，这里看看statement的实现，以及如何在语法分析的同时解释执行： 39 | 40 | 这里使用的方法是，对于流程控制语句，在语法分析的时候就进行条件判断，如果if判断失败或者while不进入循环块，就跳过该语句块不进行语法分析、解释执行； 41 | 42 | 其中RETURNFLAG用来表示在函数中返回，跳过剩余的语句；statement默认返回0，当有return语句在其中出现时才需要使用返回值。 43 | 44 | ### 代码块： 45 | 46 | 在一个statement中通过花括号包含多个语句 47 | 48 | ```c 49 | double statement() { 50 | if (token == '{') { 51 | match('{'); 52 | while (token != '}') { 53 | if (RETURNFLAG == statement()) 54 | return RETURNFLAG; 55 | } 56 | match('}'); 57 | } 58 | .... 59 | ``` 60 | 61 | ### if语句 62 | 由于tryC解释器是边进行语法分析，边解释执行的，因此如果不需要解释执行执行某一个语句块，就调用函数 63 | 64 | ```c 65 | skipStatments() 66 | ``` 67 | 68 | 跳过该语句块，不对其进行语法分析，不解释执行；（在if语句和while语句中使用）： 69 | 70 | ```c 71 | ... 72 | else if (token == If) { 73 | match(If); 74 | match('('); 75 | int boolresult = boolOR(); 76 | match(')'); 77 | if (boolresult) { 78 | if (RETURNFLAG == statement()) 79 | return RETURNFLAG; 80 | } 81 | else skipStatments(); 82 | if (token == Else) { 83 | match('Else'); 84 | if (!boolresult) { 85 | if (RETURNFLAG == statement()) 86 | return RETURNFLAG; 87 | } 88 | else skipStatments(); 89 | } 90 | } 91 | ... 92 | 93 | ``` 94 | 95 | 其中skipStatments()的实现如下： 96 | 97 | ```c 98 | void skipStatments() { 99 | if(token == '{') 100 | token = *src++; 101 | int count = 0; 102 | while (token && !(token == '}' && count == 0)) { 103 | if (token == '}') count++; 104 | if (token == '{') count--; 105 | token = *src++; 106 | } 107 | match('}'); 108 | } 109 | ``` 110 | 111 | ### while语句 112 | 113 | ```c 114 | ... 115 | else if (token == While) { 116 | match(While); 117 | char* whileStartPos = src; 118 | char* whileStartOldPos = old_src; 119 | int boolresult; 120 | do { 121 | src = whileStartPos; 122 | old_src = whileStartOldPos; 123 | token = '('; 124 | match('('); 125 | boolresult = boolOR(); 126 | match(')'); 127 | if (boolresult) { 128 | if (RETURNFLAG == statement()) 129 | return RETURNFLAG; 130 | } 131 | else skipStatments(); 132 | }while (boolresult); 133 | } 134 | ... 135 | 136 | ``` 137 | 138 | ### 赋值语句 139 | 140 | 赋值语句的左边可以是数组中间的一个单元，也可以是一个变量，右边是字符串或表达式、字符。 141 | 142 | (在下一篇文章中还会提及具体变量赋值的实现) 143 | 144 | 数组需要先定义才能进行赋值。 145 | 146 | ```c 147 | ... 148 | else if (token == Sym || token == ArraySym) { 149 | symbol* s = token_val.ptr; 150 | int tktype = token; 151 | int index; 152 | match(tktype); 153 | if (tktype == ArraySym) { 154 | match('['); 155 | index = expression(); 156 | match(']'); 157 | match('='); 158 | if (index >= 0 && index < s->value) { 159 | s->pointer.list[index].value = expression(); 160 | } 161 | } 162 | else { 163 | match('='); 164 | if (token == Str) { 165 | s->pointer.funcp = (char*)token_val.ptr; 166 | s->type = Str; 167 | match(Str); 168 | } 169 | else if (token == Char) { 170 | s->value = token_val.val; 171 | s->type = Char; 172 | match(Char); 173 | } 174 | else { 175 | s->value = expression(); 176 | s->type = Num; 177 | } 178 | } 179 | match(';'); 180 | } 181 | ... 182 | 183 | ``` 184 | 185 | ### 定义函数语句 186 | 187 | 定义函数的时候并不执行函数体，所以同样跳过语句块； 188 | 189 | ```c 190 | ... 191 | else if (token == Func) { 192 | match(Func); 193 | symbol* s = token_val.ptr; 194 | s->type = FuncSym; 195 | match(Sym); 196 | s->pointer.funcp = src; 197 | s->value = token; 198 | skipStatments(); 199 | match(';'); 200 | } 201 | ... 202 | 203 | ``` 204 | 205 | ### 定义数组语句 206 | 207 | 定义数组并分配空间 208 | 209 | ```c 210 | ... 211 | else if (token == Array) { 212 | match(Array); 213 | symbol* s = token_val.ptr; 214 | match(Sym); 215 | match('('); 216 | int length = (int)expression(); 217 | match(')'); 218 | s->pointer.list = (double*)malloc(sizeof(struct symStruct) * length + 1); 219 | for (int i = 0; i < length; ++i) 220 | s->pointer.list[i].type = Num; 221 | s->value = length; 222 | s->type = ArraySym; 223 | match(';'); 224 | } 225 | ... 226 | 227 | ``` 228 | 229 | ### 返回语句 230 | 231 | 返回RETURNFLAG作为标志； 232 | 233 | ```c 234 | ... 235 | else if (token == Return) { 236 | match(Return); 237 | match('('); 238 | return_val = expression(); 239 | match(')'); 240 | match(';'); 241 | return RETURNFLAG; 242 | } 243 | ... 244 | 245 | ``` 246 | 247 | ### 输入输出语句 248 | ```c 249 | ... 250 | else if (token == Print || token == Read || token == Puts) { 251 | int func = token; 252 | double temp; 253 | match(func); 254 | match('('); 255 | switch (func) { 256 | case Print: 257 | temp = expression(); 258 | printf("%lf\n", temp); 259 | break; 260 | case Puts: 261 | printf("%s\n", (char*)token_val.ptr); 262 | match(Str); 263 | break; 264 | case Read: 265 | scanf("%lf", &token_val.ptr->value); 266 | token_val.ptr->type = Num; 267 | match(Sym); 268 | } 269 | match(')'); 270 | match(';'); 271 | } 272 | return 0; 273 | } 274 | 275 | ``` 276 | 277 | 可对照源码查看（如果觉得写得还行麻烦您帮我点个star哦） 278 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 279 | -------------------------------------------------------------------------------- /documents/6.md: -------------------------------------------------------------------------------- 1 | # 用c语言手搓一个500+行的类c语言解释器: 给编程初学者的解释器教程（6）- 语义分析：符号表和变量、函数 2 | 3 | 项目github地址及源码： 4 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 5 | 6 | 这一部分，我们再回过头来看看变量、函数是怎样存储和处理的、以及符号表是怎样构建的。 7 | 8 | ## 符号表 9 | 10 | 我们先来回顾一下符号表的定义： 11 | 12 | > 符号表是一种用于语言翻译器（例如编译器和解释器）中的数据结构。在符号表中，程序源代码中的每个标识符都和它的声明或使用信息绑定在一起，比如其数据类型、作用域以及内存地址。 13 | 14 | 简单来说就是，我们在符号表中存储对应的变量的各种信息，在定义的时候对符号表进行插入，以便下次碰见它的时候可以知道这个变量的具体信息。 15 | 16 | 我们可以在符号表中保存五种变量：Num（数值）, Char（字符）, Str（字符串）, Array（数组）, Func（函数） 17 | 18 | tryC符号表的完整定义如下： 19 | 20 | ```c 21 | /* this structure represent a symbol store in a symbol table */ 22 | typedef struct symStruct { 23 | int type; // 符号的类型: Num, Char, Str, Array, Func 24 | char name[MAXNAMESIZE]; // 符号名称 25 | double value; // 如果是数值变量，记录它的值; 如果是数组或者字符串，记录它的长度 26 | union { 27 | char* funcp; // 指向函数定义在源代码中位置的字符指针 28 | struct symStruct* list; // 指向数组列表 29 | } pointer; 30 | int levelNum; // 作用域层 31 | } symbol; 32 | symbol symtab[SYMTABSIZE]; // 用数组定义符号表 33 | int symPointer = 0; // 符号表数组当前使用的最大下标的指针+1（栈顶 + 1） 34 | int currentlevel = 0; // 当前作用域层 35 | ``` 36 | 37 | ## 作用域 38 | 39 | 作用域就是程序中定义的变量所存在的区域，超过该区域变量就不能被访问。 40 | 41 | （这里就不具体举例介绍了） 42 | 43 | 作用域可以相互嵌套；当内层作用域和外层作用域存在同名变量时，在内层的程序访问的应当是内层的变量，在外层的程序访问的应当是外层的变量；在函数中的变量，只有在所在函数被调用时才动态地为变量分配存储单元，并在调用结束时回收。 44 | 45 | 作用域可以是块作用域、函数作用域等，tryC中只实现了函数作用域。 46 | 47 | 我们可以用currentlevel这个变量记录当前的嵌套深度； 48 | 49 | ```c 50 | int currentlevel = 0; 51 | ``` 52 | 53 | 对于函数作用域我们可以这样处理：在函数调用时加深作用域层，并把需要传入的参数插入符号表；并在函数退出的时候，删除该作用域层的所有变量，并减少作用域层，对应代码如下： 54 | 55 | ```c 56 | double function() { 57 | currentlevel++; 58 | return_val = 0; 59 | 60 | ..... 61 | 62 | while (symtab[symPointer - 1].levelNum == currentlevel) { 63 | symPointer--; 64 | } 65 | currentlevel--; 66 | return return_val; 67 | } 68 | ``` 69 | 70 | 由于插入的变量肯定在符号表数组的最上面，因此只要减少符号表数组最大值的指针就可以表示删除啦。 71 | 72 | ## 变量 73 | 74 | 对变量的处理主要分为几个部分： 75 | 76 | - 词法分析阶段，当我们遇见一个标识符名称时，需要返回对应的token； 77 | - 在表达式中，当遇见一个变量时，我们需要获取它的值； 78 | - 在定义语句中，对变量进行定义和在符号表中插入相关信息； 79 | 80 | ### 词法分析阶段 81 | 82 | 当我们在词法分析的时候，对变量的处理需要以下几个步骤： 83 | 1. 获取完整的变量名： 84 | 2. 在符号表中查找变量，从上往下查找，这样返回的一定是最近作用域的那个变量： 85 | 3. 如果在符号表中找到了变量，根据变量不同的类型，返回不同的token值； 86 | 4. 如果没有找到，在符号表中间插入新的变量，返回的token值为void；这时应该对应赋值语句 87 | 88 | ```c 89 | ... 90 | else if ((token >= 'a' && token <= 'z') || (token >= 'A' && token <= 'Z') || (token == '_')) { 91 | last_pos = src - 1; // process symbols 92 | char nameBuffer[MAXNAMESIZE]; 93 | nameBuffer[0] = token; 94 | while ((*src >= 'a' && *src <= 'z') || (*src >= 'A' && *src <= 'Z') || (*src >= '0' && *src <= '9') || (*src == '_')) { 95 | nameBuffer[src - last_pos] = *src; 96 | src++; 97 | } 98 | nameBuffer[src - last_pos] = 0; // get symbol name 99 | int i; 100 | for (i = symPointer-1; i >= 0; --i) { // search symbol in symbol table 101 | if (strcmp(nameBuffer, symtab[i].name) == 0) { // if find symbol: return the token according to symbol type 102 | if (symtab[i].type == Num || symtab[i].type == Char) { 103 | token_val.ptr = &symtab[i]; 104 | token = Sym; 105 | } 106 | else if (symtab[i].type == FuncSym) { 107 | token_val.ptr = &symtab[i]; 108 | token = symtab[i].type; 109 | } 110 | else if (symtab[i].type == ArraySym) { 111 | token_val.ptr = &symtab[i]; 112 | token = symtab[i].type; 113 | } 114 | else { 115 | if (symtab[i].type == Void) { 116 | token = Sym; 117 | token_val.ptr = &symtab[i]; 118 | } 119 | else token = symtab[i].type; 120 | } 121 | return; 122 | } 123 | } 124 | strcpy(symtab[symPointer].name, nameBuffer); // if symbol not found, create a new one 125 | symtab[symPointer].levelNum = currentlevel; 126 | symtab[symPointer].type = Void; 127 | token_val.ptr = &symtab[symPointer]; 128 | symPointer++; 129 | token = Sym; 130 | return; 131 | } 132 | ... 133 | 134 | ``` 135 | 136 | ### 在表达式中对变量的处理： 137 | 138 | 在表达式中遇到的标识符可能是三种形式： 139 | 1. 普通变量：Char或Num，token_val传递数值类型； 140 | 2. 函数变量：进行调用函数操作； 141 | 3. 数组变量：获取token_val传递的数组指针，获取下标，进行边界检查，获取元素； 142 | 143 | ```c 144 | double factor() { 145 | double temp = 0; 146 | ..... 147 | else if (token == Sym) { // 普通变量 148 | temp = token_val.ptr->value; 149 | match(Sym); 150 | } 151 | else if (token == FuncSym) { // 函数变量 152 | return function(); 153 | } 154 | else if (token == ArraySym) { // 数组变量 155 | symbol* ptr = token_val.ptr; 156 | match(ArraySym); 157 | match('['); 158 | int index = (int)expression(); 159 | if (index >= 0 && index < ptr->value) { 160 | temp = ptr->pointer.list[index].value; 161 | } 162 | match(']'); 163 | } 164 | return temp; 165 | } 166 | ``` 167 | 168 | ### 在变量定义语句中对变量的处理 169 | 170 | 由于是动态类型语言，我们对变量的定义语句也是变量的赋值语句；根据赋值的类型确定变量的类型。进入赋值语句时，传递过来的token_val包含的是一个指向当前变量结构体的指针，赋值就是对其进行操作： 171 | 172 | 赋值语句的左边可以是数组中间的一个单元，也可以是一个变量，右边是字符串或表达式、字符。 173 | 174 | 数组需要先定义才能进行赋值。 175 | 176 | ```c 177 | ... 178 | else if (token == Sym || token == ArraySym) { 179 | symbol* s = token_val.ptr; 180 | int tktype = token; 181 | int index; 182 | match(tktype); 183 | if (tktype == ArraySym) { // 对数组进行特殊判断：获取要赋值的数组单元； 184 | match('['); 185 | index = expression(); 186 | match(']'); 187 | match('='); 188 | if (index >= 0 && index < s->value) { 189 | s->pointer.list[index].value = expression(); 190 | } 191 | } 192 | else { 193 | match('='); 194 | if (token == Str) { // 根据赋值类型进行不同的操作 195 | s->pointer.funcp = (char*)token_val.ptr; 196 | s->type = Str; 197 | match(Str); 198 | } 199 | else if (token == Char) { 200 | s->value = token_val.val; 201 | s->type = Char; 202 | match(Char); 203 | } 204 | else { 205 | s->value = expression(); 206 | s->type = Num; 207 | } 208 | } 209 | match(';'); 210 | } 211 | ... 212 | 213 | ``` 214 | 215 | ## 函数 216 | 217 | tryC的函数实现完整代码：这个函数做了以下几件事： 218 | 219 | 1. 对变量的作用域进行控制； 220 | 2. 将函数参数中的变量直接插入作用域； 221 | 3. 保存当前词法分析的源代码位置和token，并跳转到函数定义时的源代码位置和token； 222 | 4. 语法分析和执行定义时的函数体，如果碰到返回语句，就将返回值存入return_val； 223 | 5. 恢复保存的当前源代码位置和token； 224 | 6. 返回值从全局变量return_val中获取； 225 | 226 | 由于function()函数本身是递归的，且变量作用域等可以得到控制，因此可以实现函数的递归调用。 227 | 228 | ```c 229 | double function() { 230 | currentlevel++; 231 | return_val = 0; // 对变量的作用域进行控制； 232 | 233 | symbol* s = token_val.ptr; // 将函数参数中的变量直接插入作用域； 234 | match(FuncSym); 235 | match('('); 236 | while (token != ')') { 237 | symtab[symPointer] = *token_val.ptr; 238 | strcpy(symtab[symPointer].name, token_val.ptr->name); 239 | symtab[symPointer].levelNum = currentlevel; 240 | symPointer++; 241 | match(Sym); 242 | if (token == ',') 243 | match(','); 244 | } 245 | match(')'); 246 | char* startPos = src; // 保存当前词法分析的源代码位置和token 247 | char* startOldPos = old_src; 248 | int startToken = token; 249 | old_src = src = s->pointer.funcp; // 跳转到函数定义时的源代码位置和token； 250 | token = (int)s->value; 251 | statement(); // 语法分析和执行定义时的函数体 252 | src = startPos; 253 | old_src = startOldPos; 254 | token = startToken; // 恢复保存的当前源代码位置和token； 255 | 256 | while (symtab[symPointer - 1].levelNum == currentlevel) { 257 | symPointer--; 258 | } 259 | currentlevel--; 260 | return return_val; 261 | } 262 | ``` 263 | 264 | 可对照源码查看（如果觉得写得还行麻烦您帮我点个star哦） 265 | [https://github.com/yunwei37/tryC](https://github.com/yunwei37/tryC) 266 | -------------------------------------------------------------------------------- /test.try: -------------------------------------------------------------------------------- 1 | # Fibonacci sequence 2 | func fun{ 3 | if(x <= 2){ 4 | return(1); 5 | } 6 | y = 0; 7 | x = x - 1; 8 | y = fun(x); 9 | x = x - 1; 10 | return(y + fun(x)); 11 | }; 12 | 13 | # save the Fibonacci sequence of 1 to 15 in an array 14 | array arr(15); 15 | x = 1; 16 | while( x <= 15 ){ 17 | arr[x - 1] = fun(x); 18 | x = x + 1; 19 | } 20 | 21 | puts("Fibonacci sequence:"); 22 | # print the Fibonacci sequence of 1 to 15 23 | i = 0; 24 | while(i < 15){ 25 | print(arr[i]); 26 | i=i+1; 27 | } 28 | -------------------------------------------------------------------------------- /tryC.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #define POOLSIZE (256 * 1024) // arbitrary size 10 | #define SYMTABSIZE (1024*8) // size of the symbol table stack 11 | #define MAXNAMESIZE 32 // size of variable/function name 12 | #define RETURNFLAG DBL_MAX // indicate a return statement has occured in a function 13 | 14 | /* this structure represent a symbol store in a symbol table */ 15 | typedef struct symStruct { 16 | int type; //the type of the symbol: Num, Char, Str, Array, Func 17 | char name[MAXNAMESIZE]; // record the symbol name 18 | double value; // record the symbol value, or the length of string or array 19 | union { 20 | char* funcp; // pointer to an array or an function 21 | struct symStruct* list; 22 | } pointer; 23 | int levelNum; // indicate the declare nesting level 24 | } symbol; 25 | symbol symtab[SYMTABSIZE]; 26 | int symPointer = 0; // the symbol stack pointer 27 | int currentlevel = 0; // current nesting level 28 | 29 | char* src, * old_src; // the text process currently 30 | 31 | enum { 32 | debug, run 33 | }; 34 | int compileState = run; // current interpre state 35 | 36 | double return_val = 0; // used for reserve the return value of function 37 | 38 | /* tokens and classes (operators last and in precedence order) */ 39 | enum { 40 | Num = 128, Char, Str, Array, Func, 41 | Else, If, Return, While, Print,Puts, Read, 42 | Assign, OR, AND, Equal, Sym, FuncSym, ArraySym, Void, 43 | Nequal, LessEqual, GreatEqual 44 | }; 45 | int token; // current token type 46 | union tokenValue { 47 | symbol* ptr; // used when return a string or a symbol address for assignment 48 | double val; // token value, for Char or Num 49 | } token_val; 50 | 51 | /*--------------- function declaration ---------------*/ 52 | double function(); 53 | double statement(); 54 | int boolOR(); 55 | int boolAND(); 56 | int boolexp(); 57 | double expression(); 58 | double factor(); 59 | double term(); 60 | void match(int tk); 61 | void next(); 62 | 63 | /* ------------------- lexical analysis ---------------------------------*/ 64 | /* get the next token of the input string */ 65 | 66 | void next() { 67 | char* last_pos; 68 | 69 | while ((token = *src)) { 70 | ++src; 71 | if (token == '\n') { // a new line 72 | if(compileState == debug) // if on debug mode, print the currnet process line 73 | printf("%.*s", (int)(src - old_src), old_src); 74 | old_src = src; 75 | } 76 | else if (token == '#') { // skip comments 77 | while (*src != 0 && *src != '\n') { 78 | src++; 79 | } 80 | } 81 | else if ((token >= 'a' && token <= 'z') || (token >= 'A' && token <= 'Z') || (token == '_')) { 82 | last_pos = src - 1; // process symbols 83 | char nameBuffer[MAXNAMESIZE]; 84 | nameBuffer[0] = token; 85 | while ((*src >= 'a' && *src <= 'z') || (*src >= 'A' && *src <= 'Z') || (*src >= '0' && *src <= '9') || (*src == '_')) { 86 | nameBuffer[src - last_pos] = *src; 87 | src++; 88 | } 89 | nameBuffer[src - last_pos] = 0; // get symbol name 90 | int i; 91 | for (i = symPointer-1; i >= 0; --i) { // search symbol in symbol table 92 | if (strcmp(nameBuffer, symtab[i].name) == 0) { // if find symbol: return the token according to symbol type 93 | if (symtab[i].type == Num || symtab[i].type == Char) { 94 | token_val.ptr = &symtab[i]; 95 | token = Sym; 96 | } 97 | else if (symtab[i].type == FuncSym) { 98 | token_val.ptr = &symtab[i]; 99 | token = symtab[i].type; 100 | } 101 | else if (symtab[i].type == ArraySym) { 102 | token_val.ptr = &symtab[i]; 103 | token = symtab[i].type; 104 | } 105 | else { 106 | if (symtab[i].type == Void) { 107 | token = Sym; 108 | token_val.ptr = &symtab[i]; 109 | } 110 | else token = symtab[i].type; 111 | } 112 | return; 113 | } 114 | } 115 | strcpy(symtab[symPointer].name, nameBuffer); // if symbol not found, create a new one 116 | symtab[symPointer].levelNum = currentlevel; 117 | symtab[symPointer].type = Void; 118 | token_val.ptr = &symtab[symPointer]; 119 | symPointer++; 120 | token = Sym; 121 | return; 122 | } 123 | else if (token >= '0' && token <= '9') { // process numbers 124 | token_val.val = (double)token - '0'; 125 | while (*src >= '0' && *src <= '9') { 126 | token_val.val = token_val.val * 10.0 + *src++ - '0'; 127 | } 128 | if (*src == '.') { 129 | src++; 130 | int countDig = 1; 131 | while (*src >= '0' && *src <= '9') { 132 | token_val.val = token_val.val + ((double)(*src++) - '0')/(10.0 * countDig++); 133 | } 134 | } 135 | token = Num; 136 | return; 137 | } 138 | else if (token == '\'') { // parse char 139 | token_val.val = *src++; 140 | token = Char; 141 | src++; 142 | return; 143 | } 144 | else if (token == '"' ) { // parse string 145 | last_pos = src; 146 | int numCount = 0; 147 | while (*src != 0 && *src != token) { 148 | src++; 149 | numCount++; 150 | } 151 | if (*src) { 152 | *src = 0; 153 | token_val.ptr = malloc(sizeof(char) * numCount + 8); 154 | strcpy((char *)token_val.ptr, last_pos); 155 | *src = token; 156 | src++; 157 | } 158 | token = Str; 159 | return; 160 | } 161 | else if (token == '=') { // parse '==' and '=' 162 | if (*src == '=') { 163 | src++; 164 | token = Equal; 165 | } 166 | return; 167 | } 168 | else if (token == '!') { // parse '!=' 169 | if (*src == '=') { 170 | src++; 171 | token = Nequal; 172 | } 173 | return; 174 | } 175 | else if (token == '<') { // parse '<=', or '<' 176 | if (*src == '=') { 177 | src++; 178 | token = LessEqual; 179 | } 180 | return; 181 | } 182 | else if (token == '>') { // parse '>=', or '>' 183 | if (*src == '=') { 184 | src++; 185 | token = GreatEqual; 186 | } 187 | return; 188 | } 189 | else if (token == '|') { // parse '||' 190 | if (*src == '|') { 191 | src++; 192 | token = OR; 193 | } 194 | return; 195 | } 196 | else if (token == '&') { // parse '&&' 197 | if (*src == '&') { 198 | src++; 199 | token = AND; 200 | } 201 | return; 202 | } 203 | else if ( token == '*' || token == '/' || token == ';' || token == ',' || token == '+' || token == '-' || 204 | token == '(' || token == ')' || token == '{' || token == '}' || token == '[' || token == ']') { 205 | return; 206 | } 207 | else if (token == ' ' || token == '\t') { } 208 | else { 209 | printf("unexpected token: %d\n", token); 210 | } 211 | } 212 | } 213 | 214 | void match(int tk) { 215 | if (token == tk) { 216 | if (compileState == debug) { 217 | if(isprint(tk)) 218 | printf("match: %c\n", tk ); 219 | else 220 | printf("match: %d\n", tk); 221 | } 222 | next(); 223 | } 224 | else { 225 | printf("line %.*s:expected token: %d\n", (int)(src - old_src), old_src, tk); 226 | exit(-1); 227 | } 228 | } 229 | 230 | /*-------------------------- grammatical analysis and run ----------------------------------*/ 231 | 232 | double term() { 233 | double temp = factor(); 234 | while (token == '*' || token == '/') { 235 | if (token == '*') { 236 | match('*'); 237 | temp *= factor(); 238 | } 239 | else { 240 | match('/'); 241 | temp /= factor(); 242 | } 243 | } 244 | return temp; 245 | } 246 | 247 | double factor() { 248 | double temp = 0; 249 | if (token == '(') { 250 | match('('); 251 | temp = expression(); 252 | match(')'); 253 | } 254 | else if(token == Num || token == Char){ 255 | temp = token_val.val; 256 | match(token); 257 | } 258 | else if (token == Sym) { 259 | temp = token_val.ptr->value; 260 | match(Sym); 261 | } 262 | else if (token == FuncSym) { 263 | return function(); 264 | } 265 | else if (token == ArraySym) { 266 | symbol* ptr = token_val.ptr; 267 | match(ArraySym); 268 | match('['); 269 | int index = (int)expression(); 270 | if (index >= 0 && index < ptr->value) { 271 | temp = ptr->pointer.list[index].value; 272 | } 273 | match(']'); 274 | } 275 | return temp; 276 | } 277 | 278 | double expression() { 279 | double temp = term(); 280 | while (token == '+' || token == '-') { 281 | if (token == '+') { 282 | match('+'); 283 | temp += term(); 284 | } 285 | else { 286 | match('-'); 287 | temp -= term(); 288 | } 289 | } 290 | return temp; 291 | } 292 | 293 | int boolexp() { 294 | if (token == '(') { 295 | match('('); 296 | int result = boolOR(); 297 | match(')'); 298 | return result; 299 | } 300 | else if (token == '!') { 301 | match('!'); 302 | return boolexp(); 303 | } 304 | double temp = expression(); 305 | if (token == '>') { 306 | match('>'); 307 | return temp > expression(); 308 | } 309 | else if (token == '<') { 310 | match('<'); 311 | return temp < expression(); 312 | } 313 | else if (token == GreatEqual) { 314 | match(GreatEqual); 315 | return temp >= expression(); 316 | } 317 | else if (token == LessEqual) { 318 | match(LessEqual); 319 | return temp <= expression(); 320 | } 321 | else if (token == Equal) { 322 | match(Equal); 323 | return temp == expression(); 324 | } 325 | return 0; 326 | } 327 | 328 | void skipBoolExpr() { 329 | int count = 0; 330 | while (token && !(token == ')' && count == 0)) { 331 | if (token == '(') count++; 332 | if (token == ')') count--; 333 | token = *src++; 334 | } 335 | } 336 | 337 | int boolAND() { 338 | int val = boolexp(); 339 | while (token == AND) { 340 | match(AND); 341 | if (val == 0){ 342 | skipBoolExpr(); 343 | return 0; // short cut 344 | } 345 | val = val & boolexp(); 346 | if (val == 0) return 0; 347 | } 348 | return val; 349 | } 350 | 351 | int boolOR() { 352 | int val = boolAND(); 353 | while (token == OR) { 354 | match(OR); 355 | if (val == 1){ 356 | skipBoolExpr(); 357 | return 1; // short cut 358 | } 359 | val = val | boolAND(); 360 | if (val == 1) return 1; 361 | } 362 | return val; 363 | } 364 | 365 | void skipStatments() { 366 | if(token == '{') 367 | token = *src++; 368 | int count = 0; 369 | while (token && !(token == '}' && count == 0)) { 370 | if (token == '}') count++; 371 | if (token == '{') count--; 372 | token = *src++; 373 | } 374 | match('}'); 375 | } 376 | 377 | double statement() { 378 | if (token == '{') { 379 | match('{'); 380 | while (token != '}') { 381 | if (RETURNFLAG == statement()) 382 | return RETURNFLAG; 383 | } 384 | match('}'); 385 | } 386 | else if (token == If) { 387 | match(If); 388 | match('('); 389 | int boolresult = boolOR(); 390 | match(')'); 391 | if (boolresult) { 392 | if (RETURNFLAG == statement()) 393 | return RETURNFLAG; 394 | } 395 | else skipStatments(); 396 | if (token == Else) { 397 | match(Else); 398 | if (!boolresult) { 399 | if (RETURNFLAG == statement()) 400 | return RETURNFLAG; 401 | } 402 | else skipStatments(); 403 | } 404 | } 405 | else if (token == While) { 406 | match(While); 407 | char* whileStartPos = src; 408 | char* whileStartOldPos = old_src; 409 | int boolresult; 410 | do { 411 | src = whileStartPos; 412 | old_src = whileStartOldPos; 413 | token = '('; 414 | match('('); 415 | boolresult = boolOR(); 416 | match(')'); 417 | if (boolresult) { 418 | if (RETURNFLAG == statement()) 419 | return RETURNFLAG; 420 | } 421 | else skipStatments(); 422 | }while (boolresult); 423 | } 424 | else if (token == Sym || token == ArraySym) { 425 | symbol* s = token_val.ptr; 426 | int tktype = token; 427 | int index; 428 | match(tktype); 429 | if (tktype == ArraySym) { 430 | match('['); 431 | index = expression(); 432 | match(']'); 433 | match('='); 434 | if (index >= 0 && index < s->value) { 435 | s->pointer.list[index].value = expression(); 436 | } 437 | } 438 | else { 439 | match('='); 440 | if (token == Str) { 441 | s->pointer.funcp = (char*)token_val.ptr; 442 | s->type = Str; 443 | match(Str); 444 | } 445 | else if (token == Char) { 446 | s->value = token_val.val; 447 | s->type = Char; 448 | match(Char); 449 | } 450 | else { 451 | s->value = expression(); 452 | s->type = Num; 453 | } 454 | } 455 | match(';'); 456 | } 457 | else if (token == Array) { 458 | match(Array); 459 | symbol* s = token_val.ptr; 460 | match(Sym); 461 | match('('); 462 | int length = (int)expression(); 463 | match(')'); 464 | s->pointer.list = malloc(sizeof(struct symStruct) * length + 1); 465 | for (int i = 0; i < length; ++i) 466 | s->pointer.list[i].type = Num; 467 | s->value = length; 468 | s->type = ArraySym; 469 | match(';'); 470 | } 471 | else if (token == Func) { 472 | match(Func); 473 | symbol* s = token_val.ptr; 474 | s->type = FuncSym; 475 | match(Sym); 476 | s->pointer.funcp = src; 477 | s->value = token; 478 | skipStatments(); 479 | match(';'); 480 | } 481 | else if (token == Return) { 482 | match(Return); 483 | match('('); 484 | return_val = expression(); 485 | match(')'); 486 | match(';'); 487 | return RETURNFLAG; 488 | } 489 | else if (token == Print || token == Read || token == Puts) { 490 | int func = token; 491 | double temp; 492 | match(func); 493 | match('('); 494 | switch (func) { 495 | case Print: 496 | temp = expression(); 497 | printf("%lf\n", temp); 498 | break; 499 | case Puts: 500 | printf("%s\n", (char*)token_val.ptr); 501 | match(Str); 502 | break; 503 | case Read: 504 | scanf("%lf", &token_val.ptr->value); 505 | token_val.ptr->type = Num; 506 | match(Sym); 507 | } 508 | match(')'); 509 | match(';'); 510 | } 511 | return 0; 512 | } 513 | 514 | double function() { 515 | currentlevel++; 516 | return_val = 0; 517 | 518 | symbol* s = token_val.ptr; 519 | match(FuncSym); 520 | match('('); 521 | while (token != ')') { 522 | symtab[symPointer] = *token_val.ptr; 523 | strcpy(symtab[symPointer].name, token_val.ptr->name); 524 | symtab[symPointer].levelNum = currentlevel; 525 | symPointer++; 526 | match(Sym); 527 | if (token == ',') 528 | match(','); 529 | } 530 | match(')'); 531 | char* startPos = src; 532 | char* startOldPos = old_src; 533 | int startToken = token; 534 | old_src = src = s->pointer.funcp; 535 | token = (int)s->value; 536 | statement(); 537 | src = startPos; 538 | old_src = startOldPos; 539 | token = startToken; 540 | 541 | while (symtab[symPointer - 1].levelNum == currentlevel) { 542 | symPointer--; 543 | } 544 | currentlevel--; 545 | return return_val; 546 | } 547 | 548 | /*----------------------------------------------------------------*/ 549 | 550 | int main(int argc, char** argv) 551 | { 552 | int i, fd; 553 | src = "array func else if return while print puts read"; 554 | for (i = Array; i <= Read; ++i) { 555 | next(); 556 | symtab[symPointer -1].type = i; 557 | } 558 | if (!(src = old_src = (char*)malloc(POOLSIZE))) { 559 | printf("could not malloc(%d) for source area\n", POOLSIZE); 560 | return -1; 561 | } 562 | 563 | ++argv; --argc; 564 | if (argc > 0) { 565 | if (**argv == '-' && (*argv)[1] == 'd') { 566 | compileState = debug; 567 | ++argv; --argc; 568 | } 569 | else { 570 | compileState = run; 571 | } 572 | } 573 | if (argc < 1) { 574 | printf("usage: tryc [-d] file ...\n"); 575 | return -1; 576 | } 577 | 578 | if ((fd = open(*argv, 0)) < 0) { // read the source file 579 | printf("could not open(%s)\n", *argv); 580 | return -1; 581 | } 582 | if ((i = read(fd, src, POOLSIZE - 1)) <= 0) { 583 | printf("read() returned %d\n", i); 584 | return -1; 585 | } 586 | src[i] = 0; // add EOF character 587 | close(fd); 588 | next(); 589 | while (token != 0) { 590 | statement(); 591 | } 592 | return 0; 593 | } 594 | 595 | 596 | --------------------------------------------------------------------------------