|
|
# 28｜增加更丰富的类型第3步：支持数组
|
|
|
|
|
|
你好，我是宫文学。
|
|
|
|
|
|
前面我们已经给我们的语言，增加了两种数据类型：浮点数和字符串。那么，今天这一节课，我们再继续增加一种典型的数据类型：数组。
|
|
|
|
|
|
数组也是计算机语言中最重要的基础类型之一。像C、Java和JavaScript等各种语言，都提供了对数组的原生支持。
|
|
|
|
|
|
数组跟我们之前已经实现过的number、string类型的数据类型相比，有明显的差异。所以在这里，你也能学到一些新的知识点，包括，如何对数组做类型处理、如何设计数组的内存布局，如何正确访问数组元素，等等。
|
|
|
|
|
|
在完成这节课的任务后，我们的语言将支持在数组中保存number和string类型的数据，甚至还可以支持多维数组。是不是感觉很强大呢？那就赶紧动手试一试吧！
|
|
|
|
|
|
那么这实现的第一步，我们需要修改编译器前端的代码，来支持与数组处理有关的语法。
|
|
|
|
|
|
## 修改编译器前端
|
|
|
|
|
|
在编译器前端，我们首先要增加与数组有关的语法规则。要增加哪些语法规则呢？我们来看看一个最常见的使用数组的例子中，都会涉及哪些语法特性。
|
|
|
|
|
|
```plain
|
|
|
let names:string[] = ["richard", "sam", "john"];
|
|
|
let ages:number[] = [8, 18, 28];
|
|
|
let a2:number[][] = [[1,2,3],[4,5]];
|
|
|
for (let i = 0; i< names.length; i++){
|
|
|
println(names[i]);
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在这个例子中，我们首先声明了一个字符串类型的数组，然后用一个数组字面量来初始化它。你还可以用同样的方法，声明并初始化一个number数组。最后，我们用names\[i\]这样的表达式来访问数组元素。
|
|
|
|
|
|
在这个例子中，你会发现三个与数组有关的语法现象，分别是**数组类型**、**数组字面量**和**下标表达式**。
|
|
|
|
|
|
首先是数组类型。在声明变量的时候，我们可以用string\[\]、number\[\]来表示一个数组类型。这个数组类型是一个基础类型再加上一对方括号\[\]。在这里，我们甚至还声明了一个二维数组。
|
|
|
|
|
|
所以，我们还需要扩展与类型有关的语法规则。你看看下面的语法规则，**你可以这样表示数组类型：“primaryType ‘\[’ ‘\]’”。而primaryType本身也可以是一个数组类型，这样就能表达多维数组了，比如a\[\]\[\]。**
|
|
|
|
|
|
```plain
|
|
|
primaryType : predefinedType | literal | typeReference | '(' type_ ')' | primaryType '[' ']' ;
|
|
|
|
|
|
```
|
|
|
|
|
|
不过，这是一个左递归的文法，就会遇到我们之前学过的左递归问题。我们可以改写一下，变成下面的文法：
|
|
|
|
|
|
```plain
|
|
|
primaryType : primaryTypeLeft ('[' ']')* ;
|
|
|
primaryTypeLeft : predefinedType | literal | typeReference | '(' type_ ')' | primaryType ;
|
|
|
|
|
|
```
|
|
|
|
|
|
这样的话，我们每次解析完毕一个primaryTypeLeft以后，再看看后面有没有跟着一对方括号就行了。如果出现多对方括号，就表示这是一个多维数组。
|
|
|
|
|
|
第二个语法现象是数组字面量，比如string字面量\[“richard”, “sam”, “john”\]和number字面量\[8, 18, 28\]。
|
|
|
|
|
|
这里，我们也总结出了数组字面量的语法规则：**每个数组字面量都是以方括号括起来的，方括号里面可以有一组元素，这些元素可以是一个表达式，或者是一个标识符，中间以逗号分割。**
|
|
|
|
|
|
```plain
|
|
|
primary: literal | functionCall | '(' expression ')' | typeOfExp | arrayLiteral;
|
|
|
arrayLiteral : ('[' elementList? ']');
|
|
|
elementList : arrayElement (','+ arrayElement)* ;
|
|
|
arrayElement : expression ','? ;
|
|
|
|
|
|
```
|
|
|
|
|
|
你要注意最后一条语法规则“arrayElement : expression ‘,’? ;”。这条语法规则的意思是，数组中的最后一个元素，后面仍然可以跟一个逗号。比如上面的number数组等价于\[8, 18, 28, \]。
|
|
|
|
|
|
第三个语法现象是下标表达式。我们可以用names\[i\]来引用数组的第i个元素。
|
|
|
|
|
|
所以，我们要扩展表达式的语法规则，**让基础式后面可以跟上一对方括号，变成一个下标表达式**。修改后的语法规则如下。这个文法的书写方式也同样避免了左递归。
|
|
|
|
|
|
```plain
|
|
|
expression: 'typeof' expression | assignment ('[' expression ']')* ;
|
|
|
|
|
|
```
|
|
|
|
|
|
上面就是目前我们需要扩展的语法规则了。为了支持新的语法规则，我们要创建几个新的AST节点对象：一个是ArrayPrimType，代表数组类型节点；第二个是ArrayLiteral，代表数组字面量；还有一个是IndexedExp，表示像a\[2\]这样的带有index的下标表达式。
|
|
|
|
|
|
在这里，你要注意，凡是表达式后面跟一个\[index\]，都表示访问该表达式的第n个元素。这个表达式不一定是个数组，只要是能够用下标访问的对象就行。比如，你可以像下面的程序那样，用下标访问一个字符串中的字符。
|
|
|
|
|
|
```plain
|
|
|
let name = "Richard";
|
|
|
name[1]; //返回'i'
|
|
|
|
|
|
```
|
|
|
|
|
|
在补充了相应的AST节点以后，我们就可以根据语法规则修改语法解析程序了。你可以试着运行下面这个的测试程序，用“node play example.ts -v”命令，带上参数-v，打印出AST来看看。
|
|
|
|
|
|
```plain
|
|
|
let a: number[]; //数组类型
|
|
|
let b = 4;
|
|
|
a = [1, 2, 3+3, b]; //数组字面量，其中的元素可以是表达式
|
|
|
println(a[2]); //下标表达式
|
|
|
|
|
|
```
|
|
|
|
|
|
在终端输出的AST如下图所示，我在里面标注了上面讨论到的几种AST节点。
|
|
|
|
|
|
|
|
|
|
|
|
你还可以看看语法分析程序对多维数组的支持情况，比如下面的示例程序：
|
|
|
|
|
|
```plain
|
|
|
let a2:number[][] = [[1,2,3],[4,5]]; //二维数组
|
|
|
println(a2);
|
|
|
println(a2[1]); //打印其中一个维度
|
|
|
println(a2[0][2]); //打印一个元素
|
|
|
|
|
|
```
|
|
|
|
|
|
它的AST结构如下图所示，你要注意，数组类型、数组字面量和数组元素的引用都是如何形成层层嵌套的结构的。
|
|
|
|
|
|
|
|
|
|
|
|
除了语法方面的工作以外，我们语义分析方面也要做一些增强，包括**类型处理**和**左值分析**等方面的工作。
|
|
|
|
|
|
为了实现类型处理，我们首先需要添加新的ArrayType类型。ArrayType类型会引用一个基础类型。到现在为止，我们的类型体系越来越丰富了，我把原来的类型体系图更新了一版，你可以看一下：
|
|
|
|
|
|
|
|
|
|
|
|
然后，在类型处理的时候，你还需要完成这几项工作。
|
|
|
|
|
|
首先，我们要能够根据类型声明的AST节点，计算出变量的类型。你可以参考[TypeResolver](https://gitee.com/richard-gong/craft-a-language/blob/master/28/semantic.ts#L123)中的代码：
|
|
|
|
|
|
```plain
|
|
|
visitArrayPrimTypeExp(te:ArrayPrimTypeExp):any{
|
|
|
//求出基础类型
|
|
|
let t = this.visit(te.primType) as Type;
|
|
|
|
|
|
//创建ArrayType
|
|
|
let t1 = new ArrayType(t);
|
|
|
|
|
|
return t1;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
第二，要计算出数组字面量的类型，并检查类型是否一致。比如，下面的示例程序中，数组字面量的类型是stirng\[\]，而变量a3的类型是number\[\]，所以会检查出类型错误出来。
|
|
|
|
|
|
```plain
|
|
|
let a3:number[] = ["Hello", "PlayScript"];
|
|
|
|
|
|
```
|
|
|
|
|
|
并且，如果数组字面量中的个别元素跟类型声明不一致，也需要能够检查出来：
|
|
|
|
|
|
```plain
|
|
|
let a4:number[] = [2, "PlayScript"];
|
|
|
|
|
|
```
|
|
|
|
|
|
具体实现你可以参考[TypeChecker](https://gitee.com/richard-gong/craft-a-language/blob/master/28/semantic.ts#L512)中的[visitArrayLiteral](https://gitee.com/richard-gong/craft-a-language/blob/master/28/semantic.ts#L1062)和[visitBinary](https://gitee.com/richard-gong/craft-a-language/blob/master/28/semantic.ts#L715)方法。代码有点多，我就不贴在文稿里了，你可以点击链接查看。
|
|
|
|
|
|
第三，我们还要能够根据下标表达式，计算每个表达式节点的类型。比如，在下面的示例程序中，a2、a2\[1\]、a2\[0\]\[2\]的类型就需要被精确地计算出来，这样才能在编译器后端生成正确的汇编代码。
|
|
|
|
|
|
```plain
|
|
|
let a2:number[][] = [[1,2,3],[4,5]];
|
|
|
println(typeof a2); //类型是number[][]
|
|
|
println(typeof a2[1]); //类型是number[]
|
|
|
println(typeof a2[0][2]); //类型是number
|
|
|
|
|
|
```
|
|
|
|
|
|
你可以在语义分析后的AST中看到这些表达式的类型信息，我在图片中都标注出来了。
|
|
|
|
|
|
|
|
|
|
|
|
你也可以看看typeof运算所打印出的结果。不过，TypeScript的typeof运算符输出的类型信息比较有限，只能看出a2和a2\[1\]是object类型，而a2\[0\]\[2\]是number类型，缺少更多的细节。
|
|
|
|
|
|
|
|
|
|
|
|
最后，我们还要让ArrayType能够像NamedType、ValueType等类型一样，采用集合运算的方法进行类型计算，以支持联合类型、类型窄化等场景。这里我就先不展开了，你可以看看[TypeUtil](https://gitee.com/richard-gong/craft-a-language/blob/master/28/types.ts)中的实现。
|
|
|
|
|
|
好了，完成与类型有关的处理以后，我们还要增强一下另一个功能，就是**左值分析**。
|
|
|
|
|
|
你还记得什么是左值吗？在表达式中，能够出现在赋值运算符左边的，就叫做左值。左值相当于是一个变量的地址。你通过这个地址，可以修改变量的值。
|
|
|
|
|
|
在下面的示例程序中，我们可以给数组元素赋值，那么这些数组元素也必须是左值才可以：
|
|
|
|
|
|
```plain
|
|
|
let a2:number[][] = [[1,2,3],[4,5]];
|
|
|
a2[0] = [4,5,6];
|
|
|
a2[0][1] = 7;
|
|
|
|
|
|
```
|
|
|
|
|
|
具体的实现，可以看一下[LeftValueAttributor](https://gitee.com/richard-gong/craft-a-language/blob/master/28/semantic.ts#L437)中的相关代码。
|
|
|
|
|
|
好了，完成上面工作以后，我们对编译器前端的增强就差不多了。接下来我们看看运行时的功能。
|
|
|
|
|
|
## 增强AST解释器
|
|
|
|
|
|
我们首先看看AST解释器。我们之前版本的AST解释器并不支持数组操作，所以我们把这个功能补上，以便跟编译成可执行程序的版本互相对比和验证。
|
|
|
|
|
|
要增强AST解释器，其实要做的工作还真不是太多。主要就是增加了**对下标表达式（IndexedExp）的处理**。它能返回下标表达式的值，包括左值和右值，分别用于对数组元素的写和读。
|
|
|
|
|
|
```plain
|
|
|
visitIndexedExp(exp:IndexedExp):any{
|
|
|
//下标应该是个整数
|
|
|
let index = this.visit(exp.indexExp);
|
|
|
|
|
|
let v = this.visit(exp.baseExp);
|
|
|
if (exp.isLeftValue){ //返回左值
|
|
|
if (v instanceof VarSymbol){
|
|
|
return new ArrayElementAddress(v, [index]);
|
|
|
}
|
|
|
else if (v instanceof ArrayElementAddress){
|
|
|
let indices = v.indices.concat([index]);
|
|
|
return new ArrayElementAddress(v.varSym, indices);
|
|
|
}
|
|
|
else{
|
|
|
console.log("Runtime error, '" + exp.baseExp.toString() + "' should return a left value");
|
|
|
}
|
|
|
}
|
|
|
else{ //返回右值
|
|
|
if (v instanceof VarSymbol){
|
|
|
let values = this.getVariableValue(v) as [];
|
|
|
return values[index];
|
|
|
}
|
|
|
else{ //如果是多维数组，比如a[0][1]，那么访问baseExp的时候(a[0])，会返回一个一维数组。
|
|
|
let values = v as[];
|
|
|
return values[index];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
这样修改完毕AST解释器以后，你可以用一个小小的测试程序看看它能否正常运行。比如你可以运行一下面的测试程序：
|
|
|
|
|
|
```plain
|
|
|
//字符串数组
|
|
|
let names:string[] = ["richard","sam", "john"];
|
|
|
names[1] = "julia"; //数组元素赋值，左值
|
|
|
for (let i = 0; i< 3; i++){
|
|
|
println(names[i]); //读取数组元素，右值
|
|
|
}
|
|
|
|
|
|
//number数组
|
|
|
let ages:number[] = [8, 18, 28];
|
|
|
ages[2] = 38; //数组元素赋值，左值
|
|
|
let sum:number = 0;
|
|
|
for (let i = 0; i<3; i++){
|
|
|
sum = sum + ages[i];//读取数组元素，右值
|
|
|
}
|
|
|
println(sum);
|
|
|
|
|
|
//二维数组
|
|
|
let a:number[][] = [[1,2,3],[4,5]]; //二维数组
|
|
|
a[0] = [4,5,6]; //修改一个维度
|
|
|
a[0][1] = 7; //修改一个元素
|
|
|
println(a); //打印二维数组
|
|
|
println(a[1]); //打印一维数组
|
|
|
println(a[0][2]); //打印一个元素
|
|
|
|
|
|
```
|
|
|
|
|
|
这个程序的输出结果我放在下面了，你能看到它确实能够处理数组了。
|
|
|
|
|
|
|
|
|
|
|
|
那接下来，我们再接再厉，让PlayScript能够把带有数组处理功能的程序编译成可执行文件。根据我们上两节课的经验，我们需要先设计一下与数组有关的内部对象以及相应的内置函数。
|
|
|
|
|
|
## 运行时的功能：PlayArray对象和内置函数
|
|
|
|
|
|
我们把内部的数组对象叫做PlayArray。PlayArray的设计与上一节课的PlayString有点类似，你可以看看它的代码：
|
|
|
|
|
|
```plain
|
|
|
typedef struct _PlayArray{
|
|
|
Object object;
|
|
|
//字符串的长度
|
|
|
size_t length;
|
|
|
|
|
|
//后面跟着的是数组数据
|
|
|
//我们不需要保存这个指针，只需要在PlayArray对象地址的基础上增加一个偏移量就行。
|
|
|
// void * data;
|
|
|
}PlayArray;
|
|
|
|
|
|
```
|
|
|
|
|
|
从代码中你能看出，PlayArray对象有一个对象头、还有一个字段记录数组中的元素个数，再后面跟着的就是具体的数组数据。
|
|
|
|
|
|
并且，我们也提供了几个内置函数，来支持基本的数组操作。其中最重要的就是创建指定长度的数组。我还写了一个宏来计算数组中某个元素的地址，这样我们就能对数组进行读写操作。
|
|
|
|
|
|
```plain
|
|
|
//创建指定元素个数的数组
|
|
|
PlayArray* array_create_by_length(size_t length);
|
|
|
|
|
|
//获取数组中某个元素的地址
|
|
|
#define PTR_ARRAY_ELEM(parr, index) (void *)(parr + sizeof(Object) + sizeof(size_t) + sizeof(double)*index)
|
|
|
|
|
|
```
|
|
|
|
|
|
在PlayArray对象的设计中，有一个问题需要你注意，就是怎么存储不同类型的数组元素。比如，PlayScript现在已经支持了浮点型数据和字符串数据，那如何用同一个PlayScript对象来存储这两种数据呢？
|
|
|
|
|
|
其实，对PlayArray对象来说，它并不关心存储的到底是什么类型的元素，它只关心这些元素占据多少个字节的内存，便于申请内存。
|
|
|
|
|
|
对于double数据来说，它们占据8个字节64位。而对于PlayString对象来说，我们只需要存储对象的引用，也就是对象的内存地址，这个地址也是8个字节64位的。所以，现在这个版本的PlayArray中，我们暂且认为每个元素占据8个字节就好了。如果数组大小是n，那就要为数组数据申请n\*8个字节的内存。
|
|
|
|
|
|
你也可以看到，在上面的宏中，如果你要获取数组元素的地址，会返回一个void \*。你可以把它强制转换成其他类型，比如转换成double \*，就能存取double型的数据。转换成PlayScript \*_，就能存取字符串对象的引用，也就是PlayScript_。
|
|
|
|
|
|
我用C语言做了一个示例程序[array.c](https://gitee.com/richard-gong/craft-a-language/blob/master/28/array.c)，来测试PlayArray对象有关的功能。你可以看一下我是如何获取数组元素的地址，并给数组元素赋值的。比如下面这个程序就是给数组元素赋double值：
|
|
|
|
|
|
```plain
|
|
|
//创建示例的number数组
|
|
|
PlayArray* sample_array_double(){
|
|
|
//创建数组
|
|
|
PlayArray * parr = array_create_by_length(3);
|
|
|
|
|
|
//给数据元素赋值
|
|
|
*((double *)PTR_ARRAY_ELEM(parr,0)) = 5;
|
|
|
*((double *)PTR_ARRAY_ELEM(parr,1)) = 10.5;
|
|
|
*((double *)PTR_ARRAY_ELEM(parr,2)) = 10.6;
|
|
|
|
|
|
return parr;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
然后你可以再把这些数据从double数组里读出来，并进行汇总。
|
|
|
|
|
|
```plain
|
|
|
//把number数组的元素汇总
|
|
|
double sum_array_double(PlayArray * parr){
|
|
|
//读取数据并汇总
|
|
|
double sum = 0;
|
|
|
for (int i = 0; i< parr->length; i++){
|
|
|
sum += *((double *)PTR_ARRAY_ELEM(parr,i));
|
|
|
}
|
|
|
|
|
|
return sum;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
对于字符串数组，我们也可以进行类似的处理。只不过，现在存取的对象是PlayScript\*，也就是字符串引用。
|
|
|
|
|
|
```plain
|
|
|
//创建示例的字符串数组
|
|
|
PlayArray* sample_array_string(){
|
|
|
//创建数组
|
|
|
PlayArray * parr = array_create_by_length(2);
|
|
|
|
|
|
//给数据元素赋值
|
|
|
*((PlayString **)PTR_ARRAY_ELEM(parr,0)) = string_create_by_cstr("Hello");
|
|
|
*((PlayString **)PTR_ARRAY_ELEM(parr,1)) = string_create_by_cstr(" PlayScript!");
|
|
|
|
|
|
return parr;
|
|
|
}
|
|
|
|
|
|
//把字符串数组的元素拼接在一起，形成一个新的字符串
|
|
|
PlayString* concat_array_string(PlayArray * parr){
|
|
|
PlayString* pstr;
|
|
|
|
|
|
if (parr->length > 0) pstr = *((PlayString**)PTR_ARRAY_ELEM(parr, 0));
|
|
|
|
|
|
for (int i = 1; i< parr->length; i++){
|
|
|
PlayString* pstr1 = *((PlayString**)PTR_ARRAY_ELEM(parr, i));
|
|
|
pstr = string_concat(pstr, pstr1);
|
|
|
}
|
|
|
|
|
|
return pstr;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
甚至，你还可以往数组里存其他数组的对象引用，这也就是多维数组的情况：
|
|
|
|
|
|
```plain
|
|
|
//创建一个示例的二维数组，其中一个维度是double类型，另一个维度是字符串数组
|
|
|
PlayArray * sample_array_2d(){
|
|
|
//创建数组
|
|
|
PlayArray * parr = array_create_by_length(2);
|
|
|
|
|
|
*((PlayArray **)PTR_ARRAY_ELEM(parr,0)) = sample_array_double();
|
|
|
*((PlayArray **)PTR_ARRAY_ELEM(parr,1)) = sample_array_string();
|
|
|
|
|
|
return parr;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
最后，你可以用make array命令，编译一下array.c示例程序，然后用./array来运行一下这个示例程序，看看它是否成功完成了与数组有关的操作，包括创建数组、往数组里存不同类型的数据，以及从数组里读取数据。
|
|
|
|
|
|
好，现在我们已经完成了运行时的准备工作了。现在只差最后一步工作了，就是修改编译器后端，来生成正确的汇编代码，从而编译成可执行文件。
|
|
|
|
|
|
## 修改编译器后端
|
|
|
|
|
|
在编译器的后端，为了支持数组运算，最重要的是完成下面几项工作：**根据数组字面量来创建数组对象，获取数组元素的地址，以及对寄存器分配算法进行必要的调整**。
|
|
|
|
|
|
我们先来看看第一项任务：把数组字面量转变成数组对象。
|
|
|
|
|
|
这是在[visitArrayLiteral](https://gitee.com/richard-gong/craft-a-language/blob/master/28/asm_x86-64.ts#L1436)中处理的。首先，它要调用内置函数创建一个数组对象。接着，要再计算出数组元素的地址，以便给数组的元素赋值。你可以查看一下示例代码。
|
|
|
|
|
|
第二项任务，是获取数组元素的地址。
|
|
|
|
|
|
在array.c示例程序中，你已经看到，在读写数组元素的时候，我们必须获取数组元素的地址。在生成汇编代码的时候，我们也要完成类似的任务。
|
|
|
|
|
|
首先，我们要根据PlayArray对象的地址计算出数组数据的地址。你已经知道，所有对象头的大小是16个字节，而记录数组元素个数的length字段占据4个字节。所以，你可以用一条指令把PlayArray的地址加上20，得到数组数据的地址。
|
|
|
|
|
|
那怎么访问数组中的某个元素呢？我们在汇编代码中已经使用过内存访问的操作数，就是基于寄存器的值，再加上或者减去一个偏移量的形式。假设我们把数组数据的开头地址存放到rax寄存器里，那么数组的第一个元素的内存地址是(%rax)，第二个元素的地址是8(%rax)，第三个元素的地址是16(%rax)，依次类推。
|
|
|
|
|
|
不过，上面这种格式是间接内存访问的简化形式。如果你还记得间接内存地址访问的完整形式，那么上述两个步骤可以合并成一条指令，比如使用20(%rax,%rdi,8)这样的格式可以直接计算出数组元素的地址。其中，20是对象头的偏移量，%rdi的值假设是2，2指的是第二个数组元素，8指的是每个数组元素占据8个字节。所以最后的地址是：%rax + 2\*8 + 20，正好就是第2个数组元素的地址。
|
|
|
|
|
|
第三项任务，是对寄存器分配算法进行必要的调整。
|
|
|
|
|
|
在对数组元素进行操作的时候，我们最好也先把它们挪到寄存器，在寄存器里进行相关计算。相关示例代码你可以查看[Lower类](https://gitee.com/richard-gong/craft-a-language/blob/master/28/asm_x86-64.ts#L1636)。
|
|
|
|
|
|
在对编译器的后端进行了上述修改以后，你就可以用它来编译带有数组运算的代码，并且生成可执行程序了。你可以参考[example\_array.ts](https://gitee.com/richard-gong/craft-a-language/blob/master/28/example_array.ts)示例代码，用make example\_array命令编译成汇编代码和可执行程序。你也可以多写点不同的程序玩一玩。
|
|
|
|
|
|
看着现在我们的语言能够支持复杂的、与数组有关的语法，甚至能支持多维数组，你会不会觉得很有成就感呢？
|
|
|
|
|
|
## 课程小结
|
|
|
|
|
|
这就是今天的所有的内容了。今天我们用了一节课的时间，给PlayScript增加了处理数组的能力。我建议你记住几个关键点：
|
|
|
|
|
|
首先，是语法处理方面的知识点。在今天的语法规则中，有两处规则如果处理不好，就会变成左递归文法。比如声明多维数组类型let a : number\[\]\[\]时，以及访问多维数组元素时，如a\[i\]\[j\]。你要看看我是怎么处理这两处文法的。在之前的课程中，我们处理连续赋值表达式，比如a=b=c的时候，我也使用了类似的文法和解析程序。如果后面有机会，我会把这个知识点再展开给你讲一讲。
|
|
|
|
|
|
第二，是内存布局设计方面的知识点。我们用一个统一的PlayScript对象来保存各种数据，包括基础数据number，以及以对象格式保存的String，甚至其他数组对象的引用。下一节课我们会讲到自定义对象，到时候你仍然可以把这些对象的引用保存到数组里。
|
|
|
|
|
|
第三，是关于如何访问数组的元素。在语义分析阶段，我们要能够区分左值和右值的场景。左值返回的是地址，而右值返回的是地址中的值。而在编译器的后端，你需要知道如何正确的计算数组元素的地址，从而转化成正确的操作数。
|
|
|
|
|
|
## 思考题
|
|
|
|
|
|
目前的设计中，数组中存放的元素的大小都是8个字节。如果我们需要存储其他长度的元素，比如4个字节的整型，应该如何修改当前的设计？哪些地方的程序也需要进行调整？欢迎在留言区分享你的观点。
|
|
|
|
|
|
欢迎把这节课分享给更多感兴趣的朋友。我是宫文学，我们下节课见。
|
|
|
|
|
|
## 资源链接
|
|
|
|
|
|
[这节课的示例代码在这里！](https://gitee.com/richard-gong/craft-a-language/tree/master/28)
|
|
|
|