太强了!鹅厂程序员“自研”脚本语言 eben

583c9542abc75e5356551845a7a43817.gif# 关注并星标腾讯云开发者

# 每周4 | 鹅厂一线程序员,为你“试毒”新技术

# 第5期 | 腾讯donghui:从0到1:如何设计实现一门自己的脚本语言?

483fc5f224d43e19d3f52402fb6dbc0c.png

1757bb3803adab052f56e6ea43ab0aea.png

计算机科学家 David Wheeler 有一句名言,“All problems in computer science can be solved by another level of indirection, except for the problem of too many layers of indirection.”。大意是指,计算机科学中所有问题都可以通过多一个间接层来解决,除了间接层太多这个问题本身。

编译就是为了解决计算机科学中“人如何更好地指挥机器干活”问题而生的“indirection”。

1010001111101100100011011101001010010111011010000000001000111000100010000 1111100110010001111111101000100110110111011111101010111111001001101101110 1110011001111010111100010100000111011111000101011110000101111011111111110 0110000001110010010000110001010010010111110011001111011001111100110001100 1010001011100001000111000111010110000110110101000111101110011101101110111

上面是一段二进制数据,机器可以高效地识别这些 0 和 1 组成的数字信号并加以应用,但是人脑不行。人脑不擅长处理这些枯燥冗长的信号。所以,上古时期的计算机科学家们为了方便,将某些二进制数据赋予含义,发明了早期的机器码( Machine Code )。

fd0ef8ad379ad1d83358ef000bbaad08.jpeg

如上图所见,机器码中加入了一些自然语言的语义元素。人脑理解起来比原始二进制数据要容易一些,但依旧很费神。之后计算机科学家们在此基础上又改良出了汇编语言,进一步有所改进,但在构建大型软件工程时仍然很费神。一代又一代的计算机工作者们为了自己及后人的幸福,自1957年起,绞尽脑汁地发明了上百门对人脑更友好的高级编程语言。笔者列举大家可能听过的高级语言如下。

年份

语言

1957

FORTRAN

1958

LISP

1959

COBOL

1964

BASIC

1970

Pascal

1972

C

1978

SQL

1980

C++

1986

Objective-C

1987

Perl

1990

Haskell

1990

Python

1993

Lua

1995

Ruby

1995

Java

1995

JavaScript

1995

PHP

2001

C#

2003

Scala

2009

Go

2012

TypeScript

2014

Swift

2015

Rust

...

...

这些高级语言要么着重运行性能,要么着重开发效率,要么着重业务安全。总而言之,相比低级语言,它们都可以帮助计算机工作者们用更低的心智负担去更好地利用机器解决问题。但是,这些高级语言不能直接控制机器,需要有一个过程将这些高级语言转换成低级语言机器码从而去控制机器,这个过程就是编译。

b898d59058dd642d42811855f1930d99.png

一个完整的编译流程包含扫描,解析,分析,转译,优化,生成几个步骤,其中有些步骤是可选项,如下图所示:

3b1b184bc82af19c255558ae55776541.png

以下面的 Go 代码为例。

a := (base + 10.2) / 2

经过扫描后得到词元列表 Tokens:a, :=, (, base, +, 10.2, ), /, 2。再将该词元列表解析,得到语法树如下。

4c1ee1d8eadf00eb1fdda605d58320ec.png

得到语法树后,可以选择直接转译成其他高级语言或者语义分析转成中间结果。这里的语法树可以选择直接转译成 JavaScript。

var a = (base + 10.2) / 2;

或者,也可以选择转成中间结果。中间结果是初始输入和最终输出的中间态,可以是控制流程图(CFG, Control Flow Graph)或者静态单一赋值(SSA, Static Single Assignment)等等形式。其中 CFG 大致形态如下图所示:

beb2d0e818af9a3cf919dc34697a5558.jpeg

中间结果一般比较抽象,不会与具体的特定机器架构(x86, ARM等)绑定。因此,中间结果既可以选择生成自定义字节码,也可以选择借助编译器框架(比如LLVM)生成多种平台的本地机器码,从而实现编程语言的跨平台特性。

对性能没有极致追求的编程语言,一般会为了易维护性而选择生成自定义字节码。自定义字节码虽无法直接指挥机器硬件执行, 但可以借助虚拟机(Virtual Machine)去控制。虚拟机拥有语言开发者心中理想的 CPU 架构,它能够忽略现实中各硬件平台的差异,直接执行开发者设计的理想的字节码(Byte Code)指令。

以下文即将介绍的字节码为例,上文的简单代码可以转化成如下字节码指令。

// a := (base + 10.2) / 2
0000    1 OP_GET_GLOBAL       1 'base'
0002    | OP_CONSTANT         2 '10.2'
0004    | OP_ADD
0005    | OP_CONSTANT         3 '2'
0007    | OP_DIVIDE
0008    | OP_DEFINE_GLOBAL    0 'a'
0010    2 OP_NIL
0011    | OP_RETURN

根据这些字节码指令的名称,读者可以猜测它完成了获取一个变量、构建一些常量、做了一些算数运算等等工作。

执行编译过程的工具自然就是编译器 Compiler。广义上,编译器可以指代一切将高级语言源代码编译成底层指令的工具。但是狭义上,编译工具可以分为编译器 Compiler 和 解释器 Interpreter。其中,编译器特指将源代码转换成其他格式,但是不执行的工具。解释器特指转换过程中直接执行源代码,即所谓“解释执行”的工具。

文中主要知识来自于 Robert Nystrom 的 "Crafting Interpreters" 和 Roberto Ierusalimschy 的 "The Implementation of Lua 5.0" 以及 "The Design of Lua"。

按如上狭义定义的话,GCC、Clang、Rust 之类可以称为编译器,Ruby 早期版本、PHP早期版本可以称为解释器,而 CPython 这种则是二者的中间态。

简单介绍了编译基本原理后,让笔者站在 Dart 语言贡献者 Robert Nystrom 和 Lua 语言作者 Roberto Ierusalimschy 等巨人的肩膀上带读者一起领略下从0到1创建一门脚本语言的精彩。

534aa08f26ab4e4dca8049f77d8bcf1b.png

既然是在鹅厂学习创建的脚本语言,就暂且将其命名为企鹅脚本,简称为鹅本,英文名 eben。鹅本的解释器就叫鹅本解释器,它对应的文件后缀是.eb。鹅本学习借鉴了 Python,NodeJS 等语言的执行程序,既可以以 REPL 模式运行(直接执行 eben 可执行文件),也可以以文件模式运行(eben FILE_PATH,可执行文件后面带脚本文件路径)。

48f13045372626fdcce606c089a8aee6.jpeg

   3.1 基础概念
   3.1.1 BNF 范式

eben 的语法规则借鉴了 Python,Rust,C/C++ 等语言。以下面打印语句为例。

print "hello" + " world";print 5 > 9;print 4 * 9 + -8 / 2;

将其抽象成 BNF 范式 则是:

printStmt -> "print" expression ";" ;

该范式指明打印语句由“print”关键字加上 expression(表达式),再加上一个“;”组成。其中,expression 可以进一步具象化成其他子范式。以 print 5 > 9; 为例,expression 范式可以具象成 comparison 比较表达式子范式。

expression -> ...| comparison | ... ;
comparison -> term (">" | ">=" | "<" | "<=") term ;

term 是比较式中的项,对应到上面代码语句中就是 5 和 9。

再以 print 4 * 9 + -8 / 2; 为例,term 可以再行细分拆解成如下范式。

term -> factor ( ( "-" | "+") factor )* ;
factor -> unary ( ( "/" | "*" ) unary )* ;

factor 就是算术运算中的因子。星号 * 的含义与正则表达式中星号相同,表示其左边括号括住的部分可以出现任意次。四则运算中乘除法的运算优先级高于加减法,所以范式中加减运算里的 factor 可以再细分成乘除运算表达式。语法解析的过程是自上而下递归执行的,所以越在内里的范式,最终执行的优先级越高。此处设计可以保证算术表达式中乘除部分优先于加减部分完成。

范式中的 unary 对应一元运算项,比如 -8 / 2 中 -8 就是一元运算项,它所携带的负号符号 - 就是一元运算符。它的优先级高于四则算术运算。

其他范式层层递进具象化的流程与 printStmt 大致相似。若以 class 声明语句为例,eben 中代码如下所示:

class Bird {
  fly() { print "Hi, sky!"; }
}
class Canary : Bird {
  eat() {}
}

‍

其相关范式如下。

classDecl -> "class" IDENTIFIER ( ":" IDENTIFIER)? "{" function* "}" ;
function -> IDENTIFIER "(" parameters? ")" block ;
parameters -> IDENTIFIER ( "," IDENTIFIER )* ;
IDENTIFIER -> ALPHA ( ALPHA | DIGIT )* ;

类声明由 class 关键字跟随一个标识符 IDENTIFIER 开头,其后是可选的继承符号及父类标识符。再之后是花括号囊括的主体,其中可包含任意个函数 function 定义。函数声明由标识符跟随一对小括号组成,小括号中是可选的参数列表 parameters ,小括号后跟随一个函数主体。参数列表由逗号间隔的多个标识符组成。标识符由字母开头,其后再跟随任意个字母 ALPHA 或数字 DIGIT。

eben 中其他语句的范式与此处例子大同小异,不再赘述。

   3.1.2 字节码

eben 借鉴了 Python、Lua 等语言的设计,也采用了虚拟机运行自定义字节码的执行模式。常用字节码如下所示:

字节码

含义

OP_ADD

加法、拼接操作

OP_SUBTRACT

减法操作

OP_MULTIPLY

乘法操作

OP_DIVIDE

除法操作

OP_NEGATE

取负操作

OP_NOT

取反操作

OP_JUMP

跳跃操作

OP_CALL

调用操作

OP_PRINT

打印操作

OP_RETURN

返回操作

OP_CLASS

定义类操作

OP_EQUAL

等值判断操作

OP_POP

出栈操作

OP_CONSTANT

常量创建操作

OP_GET_LOCAL

获取局部变量操作

OP_DEFINE_GLOBAL

定义全局变量操作

...

...

eben 中所有的代码都会转化成上述字节码,再到虚拟机中执行。

以 var b = "hello" + "world";\nprint b; 为例,其可以转化成如下字节码。

0000    1 OP_CONSTANT         1 'hello' // 创建字面常量 "hello"
0002    | OP_CONSTANT         2 'world' // 创建字面常量 "world"
0004    | OP_ADD // 字符串拼接
0005    | OP_DEFINE_GLOBAL    0 'b' // 定义全局变量 b
0007    2 OP_GET_GLOBAL       3 'b' // 获取全局变量 b
0009    | OP_PRINT // 打印
   3.1.3 虚拟机

虚拟机是 eben 的核心所在。它负责管理内存,维护函数调用栈,管理全局变量,衔接系统函数,执行字节码等等。eben 由 C 语言开发,虚拟机在 C 代码中的大致结构如下。

typedef struct {  CallFrame frames[FRAMES_MAX]; // 函数调用栈  
Value stack[STACK_MAX]; // 值栈  
Value *stackPop; // 栈顶指针  
Table globals; // 全局表,存放变量、函数  
ObjUpvalue *openUpvalues; // 闭包值链表,用于存放函数闭包所需的参数  
Obj *objects; // 对象链表,用于垃圾回收等  ...} VM;

执行字节码的主逻辑就是一个超大的 switch 语句,其形态如下。

Result run() {
  for(;;) {
    switch(instruction = READ_BYTE()) { // 获取下一条字节码
      case OP_CONSTANT: ...;break;
      case OP_POP: pop();break;
      case OP_GET_GLOBAL: ...;break;
      case OP_ADD: ...;break;
      case OP_CLOSURE: ...;break;
      case OP_CLASS: push(OBJ_VAL(newClass(READ_STRING())));break; // 创建类对象
      ...
    }
  }
}

了解了 BNF 范式,字节码,虚拟机这些基础概念之后,下面就可以探究 eben 编译执行的主要流程。

   3.2 词法扫描

词法扫描是对源代码进行处理的第一个步骤,负责将 eben 代码转换成一串词元 Tokens。如果发现词法错误,则直接报错返回。业界大型编程语言一般采用专业的辅助工具来完成词法分析扫描,比如 Yacc 和 Lex。不过这些工具会引入很多额外开销,增加开发者的心智负担。本文为了更清晰地讲解词法扫描的原理,选择使用手写扫描法。eben 中基本词元的 BNF 范式如下所示:

NUMBER -> DIGIT+ ( "." DIGIT+ )? ; // 数值
IDENTIFIER -> ALPHA ( ALPHA | DIGIT )* ; // 标识符 
ALPHA -> "a" ... "z" | "A" .. "Z" | "_" ; // 字母(包含下划线)
DIGIT -> "0" ... "9" ; // 数字
STRING -> '"' (^")* '"' ; // 字符串(^" 表示非引号)

词法扫描会读入源代码文件,逐个字符地检测判定,将判定结果加入到 Tokens 词元列表中。

// 是否是字母或下划线
bool isAlpha(char c) {
  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
}
// 是否是数字
bool isDigit(char c) { return c >= '0' && c <= '9'; }
// 扫描数字
Token number() {
  while(isDigit(peek(0))
    advance(); // 游标前进
  // 小数部分
  if(peek(0) == '.' && isDigit(peek(1))) {
    advance();
    while(isDigit(peek(0)))
      advance();
  }
  return makeToken(TOKEN_NUMBER);
}
// 扫描字符串
Token string() {
  while(peek(0) != '"' && !isAtEnd()) {
    advance();
  }
  if(isAtEnd())
    return error("未收尾的字符串");
  advance();
  return makeToken(TOKEN_STRING);
}

整体扫描逻辑也可以用一个大型 switch 实现,大致如下所示:

Token scan() {
  char c = advance();
  if(isAlpha(c)) // 检测到字母或下划线
    return identifer(); // 扫描标识符
  if(isDigit(c)) // 检测到数字
    return number(); // 扫描数值
  switch(c) {
    case '+': return makeToken(TOKEN_PLUS); // 扫描加法符号
    // 依据下个字符的情况,扫描小于等于号,或者小于号
    case '<': return makeToken(match('=') ? TOKEN_LESS_EQUAL : TOKEN_LESS);
    ...
    case '"': return string(); // 扫描字符串,直到遇到收尾双引号
  }
  // 遇到无法匹配的字符,报错
  return error("未识别字符");
}

没有遇到词法错误的情况下,编译器通过不停地调用 scan() 函数就可以完成源代码的词法扫描。scan() 第4行处 identifier() 函数有些特殊,它扫描出标识符后,不能直接当作普通标识符给变量名、函数名使用,还需要先过滤出 eben 自身保留关键字。保留关键字如下表所示:

关键字

含义

and

逻辑与

class

类声明

else

条件控制:否则

FALSE

布尔值:假

for

循环

fn

函数声明

if

条件控制:如果

nil

空值

or

逻辑或

print

打印

retturn

返回

super

父类引用

this

实例自身引用

TRUE

布尔值:真

var

变量声明

while

循环

过滤出保留关键字的简单方法是每得到一个标识符,就遍历上表中的值,并逐个进行字符串 strncmp 判等操作。虽然也可以得到结果,但是不够高效。更好的方式是使用字典树 Trie 进行过滤。eben 中部分关键字构建出来的 Trie 结构大致如下所示:

9cfb0ef48bfbf98bf2125a6de7dff1f1.png

有了 Trie 后,不用每次都遍历全表,只需要对特定字符做运算处理即可,大致逻辑如下所示:

swtich(c1) {
  case 'a': return checkReserved("nd", TOKEN_AND); // checkReserved 判断剩下的字符串是否相同,同则返回 TOKEN_AND
  case 'f': {
    ...
    switch(c2) {
      case 'a': return checkReserved("lse", TOKEN_FALSE); // f + a + lse 三部分都匹配的话,返回 TOKEN_FALSE
      case 'o': return checkReserved("r", TOKEN_FOR);
      case 'n': return checkReserved("", TOKEN_FUNC);
    }
  }
  case 'v': return checkReserved("ar", TOKEN_VAR);
  ...
}
return TOKEN_IDENTIFIER; // 没有匹配,说明不是保留关键字

符号、数值、字符串、标识符等都被成功处理后,源代码就变成了 Tokens。下面就可以进行语法解析。

   3.3 语法解析

eben 的语法规则中,整个程序可以由如下范式表达。

// 程序代码由任意条声明加上文件结束符组成
program -> decl* EOF ;
// 声明可以是类声明、函数声明、变量声明等,还可以是语句
decl -> classDecl | funcDecl | varDecl | stmt ;
// 语句可以是表达式语句,for循环,if条件,打印,返回,while循环,区块等
stmt -> exprStmt | forStmt | ifStmt | printStmt | returnStmt | whileStmt | block ;

上面的 decl,stmt 等都可以继续往下具象化。依据这些范式,语法解析的主体逻辑如下所示:

void compile(const char *source) {
  ...
  scan(); // 完成词法扫描
  while(!match(TOKEN_EOF)) {
    declaration(); // 循环解析声明语句,直到文件结束
  }
  ...
}
static void declaration() {
  if(match(TOKEN_CLASS)) {
    classDeclaration(); // 解析类声明
  } else if(match(TOKEN_FUNC)) {
    funcDeclaration(); // 解析函数声明
  } else if(match(TOKEN_VAR)) {
    varDeclaration(); // 解析变量声明
  } else {
    statement(); // 解析其他语句
  }
}
static void statement() {
  if(match(TOKEN_PRINT)) {
    printStatement(); // 解析打印语句
  } else if(match(TOKEN_FOR)) {
    forStatement(); // 解析 for 循环语句
  }
  ... // 解析其他语句
  else {
    expressionStatement(); // 解析表达式语句
  }
}
...

每一种声明范式都有其对应的解析函数。以其中的 funcDeclaration 函数声明为例,其主要语法解析逻辑如下。

static void funcDeclaration() {
  uint8_t funcNameIndex = parseVariable("此处需要函数名"); // 解析函数名标识符,失败则报错
  consumeToken(TOKEN_LEFT_PAREN, "需要左括号"); // 完成左括号解析,不存在则报错
  if(!check(TOKEN_RIGHT_PAREN)) { // 如果下一个token不是右括号,代表有函数形参列表
    do {
      uint8_t paramNameIndex = parseVariable("需要形式参数名称");
      defineVariable(paramNameIndex);
    } while(match(TOKEN_COMMA)); // 遇到逗号代表还有参数,循环解析下去
  }
  consumeToken(TOKEN_RIGHT_PAREN, "需要右括号"); // 完成右括号解析,不存在则报错
  consumeToken(TOKEN_LEFT_BRACE, "需要左花括号"); // 完成左花括号解析,不存在则报错
  block(); // 解析函数体,函数体是一个区块 block
  ...
  defineVariable(funcNameIndex); // 将函数名放入全局表中
}

其他声明的语法解析与上述函数声明的解析大同小异。主要是将上游的 Tokens 按照 BNF 范式解析出来,生成下游运行需要的字节码指令及其数据。如果过程中遇到不符合 BNF 范式的 Token,将检测到的全部错误打包反馈给用户,方便用户调整修复。

   3.4 底层数据结构

语法解析流程不仅会生成字节码指令,还会生成运行时所需的底层数据。数据主要有 4 种类型,这4种底层数据类型可以呈现出 eben 脚本中所有的用户数据类型。

typedef enum {
  VAL_BOOL, // 布尔类型
  VAL_NIL, // 空类型
  VAL_NUMBER, // 数值类型
  VAL_OBJ // 对象类型
} ValueType;

其中 VAL_BOOL , VAL_NIL , VAL_NUMBER 表示常见的基础类型,VAL_OBJ 表示 eben 底层实现中的复杂类型。这些类型统一用 Value 结构体来呈现,枚举字段 type 表示 Value 类型,联合字段 as 承载 Value 实际存储或指向的值。

typedef struct {
  ValueType type; // 数据类型
  // 使用联合实现空间复用,节约内存
  union {
    bool boolean; // C 中 bool 类型来表示 eben 布尔类型
    double number; // C 中 double 类型来表示 eben 数值类型
    Obj *obj; // C 中 Obj* 指针来指向动态分配的复杂结构
  } as;
} Value;

Obj* 结构体指针所指向的复杂结构还可以再度细分。

typedef enum {
  OBJ_CLASS, // 类
  OBJ_CLOSURE, // 闭包
  OBJ_FUNCTION, // 函数
  OBJ_INSTANCE, // 实例
  OBJ_NATIVE, // 本地函数
  OBJ_STRING, // 字符串
  OBJ_UPVALUE, // 闭包参数
} ObjType;


struct Obj {
  ObjType type; // Object 类型
  bool isMarked; // 用于 GC 标记,下文将介绍
  struct Obj *next; // 链表指针
}

Obj 结构体中包含具体复杂结构的枚举类型,GC 标记位,链表指针等元信息。它可以嵌入到各个细分类型结构体的头部,从而方便虚拟机统一分配管理对象。

以 ObjString 和 ObjClass 具体结构为例,其主要字段如下。

typedef struct {
  Obj obj; // 元信息
  int length;
  char *chars;
} ObjString;


typedef struct {
  Obj obj; // 元信息
  ObjString *name;
  Table methods;
} ObjClass;

C 语言的特性使得定义在结构体头部的字段在内存中也会被分配到该结构体头部位置。所以, ObjClass* 和 ObjString* 等指针指向 struct ObjClass 和 struct ObjString 的内存开始处的同时也在指向对应的 struct Obj 的内存开始处,故 C 代码中可以安全地将二者转化为 Obj* 指针,反向亦然。这个特性使得一些面向对象语言中才常见的操作在 C 中成为可能。下面代码就利用了该特性将 Obj* 转化成具体类型指针来进行各种内存释放操作。

void freeObject(Obj *object) {
  switch(object->type) {
    case OBJ_CLASS: {
      ObjClass *klass = (ObjClass *)object;
      freeTable(&klass->methods);
      FREE(ObjClass, object);
      break;
    }
    case OBJ_STRING: {
      ObjString *string = (ObjString *)object;
      FREE_ARRAY(char, string->chars, string->length+1);
      FREE(ObjString, object);
      break;
    }
    ... // 其他类型对象的释放
  }
}

eben 使用 ObjXXX 这些底层数据结构相互配合,完美地实现了脚本代码中类、实例、函数、闭包、字符串等等数据类型的操作。

   3.5 变量
   3.5.1 全局变量

在 eben 中声明变量很简单,其语法范式如下所示:

varDecl -> "var" IDENTIFIER ( "=" expression )? ";" ;

变量声明时,初始值是可选项。没有初始值的变量默认赋值为 nil。

var abc = "hello"; // 赋值 "hello"
var bcd; // 没有赋初始值,默认为 nil

如果变量被声明在顶级作用域,就称之为全局变量。解析过程中, TOKEN_VAR 会触发以下变量解析逻辑。

static void varDeclaration() {
    uint8_t global = parseVariable("需要变量名"); // 解析变量名,获取序号
  if(match(TOKEN_EQUAL)) {
    expression(); // 继续解析等于号右侧的表达式,此处就是 "hello" 字符串
  } else {
    emitByte(OP_NIL); // 直接生成压入空值字节码
  }
  consumeToken(TOKEN_SEMICOLON, "声明结尾需要分号");
  emitBytes(OP_DEFINE_GLOBAL, global); // 带入序号,生成定义变量字节码
}

parseVariable 函数解析出代码中的abc, bcd,它们就是范式中的 IDENTIFIER 。如果检测到有等号 TOKEN_EQUAL ,则尝试解析出等号右边的表达式,此处字符串 "hello"会生成 OP_CONSTANT 字节码,用来填入字面常量值;否则,直接生成 OP_NIL 字节码,用来填入空值。最后一步生成的 OP_DEFINE_GLOBAL 字节码会读取上一步压入的值,要么是某常量,要么是空值,将其写入到虚拟机全局表 vm.globals 中。如下所示:

case OP_DEFINE_GLOBAL: {
  ObjString *name = READ_STRING_FROM_CONSTANTS(); // 从常量列表中取出之前暂存的变量名
  tableSet(&vm.globals, name, peek(0)); // peek(0) 取出值栈的栈顶元素
  pop(); // 使用完成,弹出栈顶元素
  break;
}

OP_DEFINE_GLOBAL 字节码负责写入变量, OP_GET_GLOBAL 字节码则负责读取变量。以 print abc;为例,第一步是读取变量 abc 的值。

case OP_GET_GLOBAL: {
  ObjString *name = READ_STRING_FROM_CONSTANTS(); // 获得变量名 "abc"
  Value value;
  if(!tableGet(&vm.globals, name, &value)) { // 用 "abc" 去全局表中查找,找到则将值回填到 value 中
    runtimeError("未定义变量 %s", name->chars); // 如果没找到,报“未定义的变量”错误
    return RUNTIME_ERROR;
  }
  push(value); // 如果存在,压入值栈待后续使用
  break;
}

OP_GET_GLOBAL 将变量值压入栈后,第二步则是print 生成的 OP_PRINT 字节码将其取出并打印。

case OP_PRINT:
  printValue(pop());
  break;
   3.5.2 局部变量

局部变量声明的语法与全局变量无异,不过它必须声明在非顶级作用域,比如嵌套区块内,函数体内等等。下面的例子中,除了值为 global a 的变量 a,其余都是局部变量。

如上文所述,值为global a的全局变量 a 存放在虚拟机的全局表 vm.globals 中,所以它会一直存活到脚本结束。值为outer a, outer b 的 a, b 和值为inner a 的 a 都是局部变量,它们的名字只会被存放在其所属作用域 current->locals 中(current代表当前 scope 作用域)。这就意味着局部变量会随着作用域的结束而消亡。所以,此处代码例子中最后两句 print a; 打印的都是当前所处作用域中的值。

嵌套最里层的 print a; 打印结果是 inner a。这是因为,eben 尝试使用变量时,会优先查找当前作用域的局部变量,存在则使用,不存在则往外层继续找。如果一直到了顶层连全局变量都找不到,直接报“未定义变量”错误。

int arg = resolveLocal(current, &name); // 尝试查找局部变量,递归向外执行
if(arg != -1) {
  op = OP_GET_LOCAL;
} else {
  op = OP_GET_GLOBAL;
}
emitBytes(op, arg); // 传入变量序号,生成获取变量字节码

局部变量的生命周期比全局变量短,都会随着作用域的开始而存在,其结束而消亡。所以,局部变量不需要存在全局表中,只需要存在栈上即可。需要时压入,用完则弹出。虚拟机需要取局部变量时,也只要找到其序号,再次压入栈顶即可。

case OP_GET_LOCAL: {
  uint8_t index = READ_BYTE(); // 在字节码数据中读出上文代码中传入的 arg,即变量序号
  push(vm.stack[index]); // 将序号对应的值压入栈顶,以备后续使用
  break;
}
   3.6 条件控制

eben 中条件控制语句主要有 if 语句,while 循环,for 循环,逻辑与 and 和逻辑或 or 。其中 and, or 与 C 系列语言中的 &&, || 逻辑运算符类似,有短路运算(shortcut)效果。

   3.6.1 if 语句

条件控制语句允许用户根据条件的真假,选择不同的逻辑分支进行执行。但是 eben 在解析时会把所有逻辑分支都解析成一长串字节码,然后按照代码中出现的顺序线性地加入到最终的字节码串中。所以,“选择不同的逻辑分支进行执行”需要虚拟机能够 Jump 跳过某一段字节码,直接执行其后的内容。以下面的 if 语句为例。

if(true) {
  print "hi";
}
print "hello";

编译之后的字节码内容如下。

0000    1 OP_TRUE // 将布尔值 true 压入值栈
0001    | OP_JUMP_IF_FALSE    1 -> 11 // 如果为假,跳到 0011 处
0004    | OP_POP // 弹出栈顶值
0005    2 OP_CONSTANT         0 'hi'
0007    | OP_PRINT
0008    3 OP_JUMP             8 -> 12 // 无条件跳到 0012 处
0011    | OP_POP // 弹出栈顶值
0012    4 OP_CONSTANT         1 'hello'
0014    | OP_PRINT

0001处的 OP_JUMP_IF_FALSE 由 if 语句生成。如果条件值为假,跳过整个 if 分支;如果为真,则正常执行 if 分支内容,并在0008处无条件跳过 else 分支内容(用户没有写 else 分支情况下,eben 会自动加入空的 else 分支)。本例中并未写 else 分支,否则会在 0011 到 0012 间生成其对应的字节码。

解析 if 语句的逻辑如下所示:

static void ifStatement() {
  consumeToken(TOKEN_LEFT_PAREN, "需要左括号"); // 完成左括号解析,不存在则报错
  expression(); // 解析括号中的条件表达式
  consumeToken(TOKEN_RIGHT_PAREN, "需要右括号");
  int thenJump = emitJump(OP_JUMP_IF_FALSE); // 生成条件跳跃字节码
  emitByte(OP_POP); // 弹出条件表达式的值,用完即丢
  statement(); // 解析 if 分支中语句
  int elseJump = emitJump(OP_JUMP); // 生成无条件跳跃字节码
  patchJump(thenJump); // 计算并回填跳跃距离
  emitByte(OP_POP);
  if(match(TOKEN_ELSE)) // 如果 else 存在,解析其分支语句
    statement();
  patchJump(elseJump); // 计算并回填跳跃距离
}

代码中的 patchJump 是为了将 OP_JUMP, OP_JUMP_IF_FALSE 字节码所需的跳跃距离回填到字节码参数中。因为在解析 if 语句的条件时,编译器并不知道 if 分支中内容有多少,也不知道会产生多少条字节码,所以只能等解析完分支之后再去回填参数。最后一句的 pathcJump(elseJump); 为 else 分支回填跳跃距离也是同样原理。

   3.6.2 while 循环

while 循环的条件控制在 OP_JUMP, OP_JUMP_IF_FALSE 字节码之外增加了一个 OP_LOOP 字节码。前二者负责向前跳,后者负责向后跳。

OP_JUMP 配合负数参数也可以实现向后跳跃。不过字节码指令及其参数在虚拟机内部都使用 uint8_t 类型存储,故此处不使用负数以防诸多麻烦。

while 样例脚本代码如下。

var a = 5;
while(a > 0) {
    a = a - 1;
}

转化成字节码如下。

0000    1 OP_CONSTANT         1 '5'
0002    | OP_DEFINE_GLOBAL    0 'a'
0004    2 OP_GET_GLOBAL       2 'a'
0006    | OP_CONSTANT         3 '0'
0008    | OP_GREATER // 判断 a 是否大于 0
0009    | OP_JUMP_IF_FALSE    9 -> 24 // 如果判定为假,跳过整个循环体
0012    | OP_POP
0013    3 OP_GET_GLOBAL       5 'a'
0015    | OP_CONSTANT         6 '1'
0017    | OP_SUBTRACT
0018    | OP_SET_GLOBAL       4 'a'
0020    | OP_POP
0021    4 OP_LOOP            21 -> 4 // 跳回到 0004 处,再次进行条件判定
0024    | OP_POP

这里的核心是 0009 处的 OP_JUMP_IF_FALSE 和 0021 处的 OP_LOOP,分别负责“条件不成立时跳过循环体”和“跳到条件判定处继续执行”。编译器对 while 循环的解析逻辑如下所示:

static void whileStatement() {
  consumeToken(TOKEN_LEFT_PAREN, "需要左括号"); // 完成左括号解析,不存在则报错
  expression(); // 解析括号中的条件表达式
  consumeToken(TOKEN_RIGHT_PAREN, "需要右括号");
  int exitJump = emitJump(OP_JUMP_IF_FALSE); // 生成跳出循环体的条件跳跃字节码
  emitByte(OP_POP);
  statement(); // 解析循环体中语句
  emitLoop(loopStart); // 生成跳回字节码 OP_LOOP
  patchJump(exitJump); // 回填跳跃的距离参数
  emitByte(OP_POP);
}
   3.6.3 for 循环

for 循环用到的跳跃字节码指令与 while 循环相同,但是因为其特殊语句结构,跳跃的逻辑会相对复杂。以下面的 for 循环代码为例。

for(var i=0; i<5; i=i+1) {
    print i;
}

var i=0; 初始化部分只会执行1次;i<5; 条件判定部分每次循环都需要验证计算;i=i+1 更新部分则在每次循环体执行完之后执行。该段代码生成的字节码如下所示:

0000    1 OP_CONSTANT         0 '0' // 生成字面量 0
0002    | OP_GET_LOCAL        1 // 获取序号 1 处局部变量值,即 i 的值
0004    | OP_CONSTANT         1 '5' // 生成字面量 5
0006    | OP_LESS // 判断是否小于 5
0007    | OP_JUMP_IF_FALSE    7 -> 31 // 如果为假,跳过循环体
0010    | OP_POP
0011    | OP_JUMP            11 -> 25 // 无条件跳到 0025 处,跳过更新部分,循环体执行之后才执行这里
0014    | OP_GET_LOCAL        1
0016    | OP_CONSTANT         2 '1'
0018    | OP_ADD // 将序号 1 处局部变量,即 i 的值加1
0019    | OP_SET_LOCAL        1
0021    | OP_POP
0022    | OP_LOOP            22 -> 2 // 跳回到 0002 处进行条件判定
0025    2 OP_GET_LOCAL        1 // 执行循环体内逻辑
0027    | OP_PRINT // 打印变量值
0028    3 OP_LOOP            28 -> 14 // 执行完循环体后,跳回到 0014 处,执行 i=i+1 更新部分逻辑
0031    | OP_POP
0032    | OP_POP

编译器对 for 循环的转化逻辑如下所示:

static void forStatement() {
  consumeToken(TOKEN_LEFT_PAREN, "需要左括号"); // 完成左括号解析,不存在则报错
  // 初始化部分
  if(match(TOKEN_SEMICOLON)) { // for(;...) 形式,空初始化,无需操作
  } else if(match(TOKEN_VAR)) { // for(var i=0;...) 形式,声明新的循环变量 i
    varDeclaration();
  } else { // for(i=0;...) 形式,直接使用外界的变量 i;或者是只需要其副作用的任意表达式
    expressionStatement();
  }
  // 条件部分
  ...
  int exitJump = -1;
  if(!match(TOKEN_SEMICOLON)) { // 不是分号,条件部分不为空
    ...
    exitJump = emitJump(OP_JUMP_IF_FALSE); // 如果假,跳出循环体
    ...
  }
  // 更新部分
  if(!match(TOKEN_RIGHT_PAREN)) { // 不是右括号,更新部分不为空
    int bodyJump = emitJump(OP_JUMP); // 无条件跳到循环体部分
    ...
    emitLoop(loopStart); // 执行完更新之后跳回到条件判定处
    loopStart = ...;
    patchJump(bodyJump);
  }
  statement(); // 解析循环体中语句
  emitLoop(loopStart); // 跳回到更新部分去执行
  if(exitJump != -1) {
      patchJump(exitJump); // 回填跳跃的距离参数
      emitByte(OP_POP);
  }
}
   3.6.4 逻辑与和或

and 和 or 逻辑运算符因为有 短路运算 效果,所以也可以用来做条件控制。以下面的“ and 逻辑与”为例。

if(true and true) { // 为了样例简便,矫揉造作了这里的写法
    print "AND is ok";
}

对应的字节码如下。

0000    1 OP_TRUE
0001    | OP_JUMP_IF_FALSE    1 -> 6 // 如果假,跳到 0006。此处真,不跳。
0004    | OP_POP
0005    | OP_TRUE
0006    | OP_JUMP_IF_FALSE    6 -> 16 // 如果假,跳到 0016。此处真,不跳。
0009    | OP_POP
0010    2 OP_CONSTANT         0 'AND is ok'
0012    | OP_PRINT // 正常执行打印
0013    3 OP_JUMP            13 -> 17
0016    | OP_POP

如果用户代码改成:

if(false and true) {
    print "shortcut";
}

对应的字节码如下。

0000    1 OP_FALSE
0001    | OP_JUMP_IF_FALSE    1 -> 6 // 如果假,跳到 0006。此处假,跳。
0004    | OP_POP
0005    | OP_TRUE
0006    | OP_JUMP_IF_FALSE    6 -> 16 // 0004 和 0005 处的操作被跳过,目前栈顶值还是假,跳到 0016
0009    | OP_POP
0010    2 OP_CONSTANT         0 'shortcut'
0012    | OP_PRINT
0013    3 OP_JUMP            13 -> 17
0016    | OP_POP // 打印操作被跳过

如上注释所示, and 左边的值为假后,后面的操作全部被跳过。这证实了 eben 中逻辑运算符有短路运算效果。

and 运算符的解析逻辑如下。

static void andOperator()
{
    int endJump = emitJump(OP_JUMP_IF_FALSE); // 生成跳跃字节码
    emitByte(OP_POP); // 左边值出栈
    ... // 继续解析右边的表达式,可能有 a and b and c and d 的情况
    patchJump(endJump); // 回填跳跃的距离参数
}

or 逻辑运算符也有同样效果。

if(true or false) {
    print "shortcut";
}

这段脚本的字节码如下。

0000    1 OP_TRUE
0001    | OP_JUMP_IF_FALSE    1 -> 7 // 如果假,跳到 0007。此处真,不跳。
0004    | OP_JUMP             4 -> 9 // 直接跳到 0009
0007    | OP_POP
0008    | OP_FALSE
0009    | OP_JUMP_IF_FALSE    9 -> 19 // 0007 和 0008 处的操作被跳过,目前栈顶值还是真,不跳
0012    | OP_POP
0013    2 OP_CONSTANT         0 'shortcut'
0015    | OP_PRINT // 正常执行打印
0016    3 OP_JUMP            16 -> 20
0019    | OP_POP

or 左边的结果为真后,条件判定中后面的表达式全部被跳过,符合预期。or 运算符的解析逻辑如下。

static void orOperator()
{
  int elseJump = emitJump(OP_JUMP_IF_FALSE); // 如果假,跳到 or 右边第一个值处继续判定
  int endJump = emitJump(OP_JUMP);  // 如果真,跳过整个判定条件表达式
  
  patchJump(elseJump); // 回填 or 左边值判定假后跳跃的距离参数
  emitByte(OP_POP); // 左边值出栈
  
  ... // 继续解析右边的表达式
  patchJump(endJump); // 回填跳跃整个条件表达式的距离参数
}
   3.7 函数

eben 中 函数 的使用如下所示:

fn 关键字借鉴自 Rust ,它既不像 f 那么单薄,也不像 function 那般冗长。

fn sayHi(first, last) {
    print "Hi, " + first + " " + last + "!";
}


sayHi("Code", "读者");

这段脚本编译成字节码后,脚本主体 <script> 生成了一段字节码, sayHi 函数也生成了一段自己的字节码。这样的设计是为了方便后文介绍的 CallFrame 调用栈帧实现隔离。

== sayHi == // sayHi 函数体
0000    2 OP_CONSTANT         0 'Hi, ' // 构建字面常量
0002    | OP_GET_LOCAL        1 // 获取序号 1 处局部变量,即第一个参数 first
0004    | OP_ADD // 字符串拼接
0005    | OP_CONSTANT         1 ' '  // 构建字面常量
0007    | OP_ADD // 字符串拼接
0008    | OP_GET_LOCAL        2 // 获取序号 2 处局部变量,即第二个参数 last
0010    | OP_ADD // 字符串拼接
0011    | OP_CONSTANT         2 '!'  // 构建字面常量
0013    | OP_ADD // 字符串拼接
0014    | OP_PRINT // 打印
0015    3 OP_NIL
0016    | OP_RETURN // 该函数没有明确返回值,故默认返回值为 nil
== <script> == // 脚本主体
0000    3 OP_CLOSURE          1 <fn sayHi> // 构建函数
0002    | OP_DEFINE_GLOBAL    0 'sayHi' // sayHi 函数加入到全局表
0004    5 OP_GET_GLOBAL       2 'sayHi' // 从全局表中获取 sayHi 函数
0006    | OP_CONSTANT         3 'Code' // 构建字面常量
0008    | OP_CONSTANT         4 '读者' // 构建字面常量
0010    | OP_CALL             2 // 调用 sayHi 函数
0012    | OP_POP // 弹出栈顶值

函数相关的两个关键字节码是 OP_CLOSURE 和 OP_CALL 。二者分别用来生成函数和调用函数。如果不考虑闭包的话,前者本该叫做 OP_FUNCTION 。eben 为了代码实现的方便、统一,将闭包函数和非闭包函数的构建都归一到 OP_CLOSURE 字节码指令中。

虚拟机遇到 OP_CLOSURE 指令时,先构建 ObjFunction,再包装成 ObjClosure,压入栈中供后续使用。

case OP_CLOSURE: {
  ObjFunctioin *function = AS_FUNCTION(READ_CONSTANT()); // 根据序号读出函数对象
  ObjClosure *closure = newClosure(function); // 构建闭包对象
  push(OBJ_VAL(closure)); // 将 sayHi 函数压入值栈,供后面的 OP_DEFINE_GLOBAL 指令使用
  ...
  break;
}

编译器对 sayHi 函数定义的解析流程如下。

static void function(FunctionType type)
{
    ...
    consumeToken(TOKEN_LEFT_PAREN, "需要左括号");
    if (!check(TOKEN_RIGHT_PAREN)) // 如果没有遇到右括号,解析参数
    {
        do
        {
            ... // 解析函数形式参数
        } while (match(TOKEN_COMMA));// 如果遇到逗号,继续解析下一个参数
    }
    consumeToken(TOKEN_RIGHT_PAREN, "需要右括号");
    consumeToken(TOKEN_LEFT_BRACE, "需要左花括号");
    block(); // 解析函数体


    ObjFunction *function = ...; // 构建函数对象
    emitBytes(OP_CLOSURE, makeConstant(OBJ_VAL(function))); // 生成 OP_CLOUSRE 字节码指令
    ...
}

OP_CALL 是函数最核心的字节码指令,其在虚拟机中执行逻辑如下。

case OP_CALL: {
  int argCount = READ_BYTE(); // 获取函数参数个数
  if(!call_(peek(argCount), argCount)) { // 调用 call_ 完成调用逻辑,peek(argCount) 是指栈顶往下 argCount 个位置的函数对象
    return RUNTIME_ERROR; // 失败则报运行时错误
  }
  frame = &vm.frames[vm.frameCount - 1]; // 成功完成,重新指向栈顶下方的函数调用栈帧
  break;
}

peek(1) 读取栈顶往下一个位置的元素,peek(argCount)则读取栈顶往下argCount个位置的元素。这个位置存放的正是事先安排好的函数对象,这个位置之上的argCount个位置则存放函数调用所需要的参数。eben 函数调用的具体工作由 call_ C 函数实现。

static bool call_(ObjClosure *closure, int argCount) //如前文所述,ObjClosure 就是封装后的 ObjFunction
{
    if (argCount != closure->function->arity) { // 检查参数个数,不匹配则打回
        runtimeError("需要 %d 个参数,提供了 %d 个", closure->function->arity, argCount); 
        return false;
    }


  // 调用层数超出限制,给出经典的 Stack Overflow 错误
    if (vm.frameCount == FRAMES_MAX) {
        runtimeError("栈溢出");
        return false;
    }


  // 构建调用栈帧,压入调用栈
    CallFrame *frame = &vm.frames[vm.frameCount++];
    frame->closure = closure;
  // ip 即 instruction pointer 指令指针,指向函数体内字节码,比如上文中 sayHi 函数的字节码
    frame->ip = closure->function->chunk.code;
  // 函数调用所需参数列表指向虚拟机值栈对应位置
    frame->slots = vm.stackTop - argCount - 1;
    return true;
}

调用栈帧 CallFrame 的结构如下。

typedef struct {
  ObjClosure *closure; // 闭包对象
  uint8_t *ip; // 指向当前指令的指令指针 Instruction Pointer,有些语言里会称作 Program Counter (PC)
  Value *slots; // 参数列表指针
} CallFrame;

代码中,frame->ip = closure->function->chunk.code; 语句是将指令指针指向被调函数(比如 sayHi 函数)字节码指令开始处。逐条执行该处的指令就代表该函数正在被调用。frame->slots = vm.stackTop - argCount - 1; 将参数列表指针指向虚拟机值栈中函数对象所在位置,这样通过frame->slots就可以直接访问函数对象及其参数,如下图所示:

6ea6b882b9fdcf72439e48f67062d628.png

frame->slots设置完成后,栈上的值正好与函数调用所需的形式参数 Parameter first 和 last按序匹配,例子中的 Code 和 读者也就成了本次函数调用的实际参数 Argument 。

有了 CallFrame 之后,递归 Recursion 也可以轻松实现。在栈没有溢出的前提下,不停地压入新的 CallFrame 即可。以下面这个矫揉做作的求和程序为例。

fn adder(operand) {
    if(operand <= 0) {
        return 0;
    }
    return operand + adder(operand - 1);
}


print adder(5);

编译产出的字节码如下。

== adder ==
0000    2 OP_GET_LOCAL        1
0002    | OP_CONSTANT         0 '0'
0004    | OP_GREATER
0005    | OP_NOT // operand <= 0 等价于 !(operand > 0)
0006    | OP_JUMP_IF_FALSE    6 -> 16 // 未达到基准条件,跳到 0016
0009    | OP_POP
0010    3 OP_CONSTANT         1 '0'
0012    | OP_RETURN
0013    4 OP_JUMP            13 -> 17
0016    | OP_POP
0017    5 OP_GET_LOCAL        1
0019    | OP_GET_GLOBAL       2 'adder'
0021    | OP_GET_LOCAL        1
0023    | OP_CONSTANT         3 '1'
0025    | OP_SUBTRACT // 当前参数减 1 后的值放入栈顶
0026    | OP_CALL             1 // 再次发起调用,即再压入一个 CallFrame
0028    | OP_ADD // 将当前参数与调用产生的值相加
0029    | OP_RETURN
== <script> ==
0000    6 OP_CLOSURE          1 <fn adder>
0002    | OP_DEFINE_GLOBAL    0 'adder' // 定义这个全局函数
0004    8 OP_GET_GLOBAL       2 'adder'
0006    | OP_CONSTANT         3 '5'
0008    | OP_CALL             1
0010    | OP_PRINT

脚本主体的逻辑清晰简单,定义一个 adder 函数,然后传参给它并调用,最后打印出结果。adder 函数内部通过 OP_JUMP* 指令构成递归的 基准条件 Base Case ,再用 OP_CALL 引发递归调用。递归调用会不断压入新栈帧,直到遇到基准条件,然后再逐层弹出,返回到调用点位置。

   3.8 闭包

闭包 Closure 可以使函数变得更加方便,是提升语言开发效率的一大利器。以下面闭包代码为例。

== myFunc ==
0000    4 OP_GET_UPVALUE      0 // 获取被闭包的参数
0002    | OP_PRINT // 打印
0003    5 OP_NIL
0004    | OP_RETURN
== makeFunc ==
0000    2 OP_CONSTANT         0 'hello'
0002    5 OP_CLOSURE          1 <fn myFunc> // 生成闭包函数,并携带闭包参数
0004      |                     local 1 // myFunc 携带的闭包参数是从父函数的局部变量捕获所得,即脚本中的 a
0006    6 OP_GET_LOCAL        2 // myFunc 是内部函数,所以也是 local
0008    | OP_RETURN
== <script> ==
0000    7 OP_CLOSURE          1 <fn makeFunc> // 生成函数
0002    | OP_DEFINE_GLOBAL    0 'makeFunc'
0004    9 OP_GET_GLOBAL       3 'makeFunc'
0006    | OP_CALL             0
0008    | OP_DEFINE_GLOBAL    2 'f'
0010   10 OP_GET_GLOBAL       4 'f'
0012    | OP_CALL             0 // 调用 f 函数
0014    | OP_POP

myFunc 内部函数意图打印其父函数的局部变量 a 。如果没有闭包机制的话,局部变量 a 会随着 makeFunc 函数作用域的结束而消失。最后一句 f(); 也就无法打印一个不存在的变量。好在 eben 有闭包机制,所以该语句可以成功打印出 hello 。这段脚本对应的字节码如下。

获取闭包参数的指令叫作 OP_GET_UPVALUE,这里是借鉴了 Lua 作者的叫法。Lua 内部将实现闭包的数据结构称为 Upvalue 。

makeFunc 中 OP_CLOSURE 字节码指令除了会创建闭包对象外,还会捕获局部变量,将其当作潜在的闭包参数。

case OP_CLOSURE: {
  ...
  ObjClosure *closure = newClosure(function);
  push(OBJ_VAL(closure));
  for(...) {
    ...
    if(isLocal) {
      closure->upvalues[i] = captureUpvalue(...); // 捕获潜在闭包参数
    } else {
    ...
    }
  }
  ...
}


static ObjUpvalue *captureUpvalue(Value *local) {
  ...
  ObjUpvalue *upvalue = vm.openUpvalues;
  ...
  ObjUpvalue *newUpvalue = newUpvalue(local);
  newUpvalue->next = upvalue;
  ...
  vm.openUpvalues = newUpvalue;
  ...
}

OP_CLOSURE  中触发的 captureUpvalue 函数将潜在的闭包参数加入到 vm.openUpvalues 链表中。而字节码 OP_RETURN 中触发的 closeUpvalues函数会把用到的局部变量从栈上搬到堆上,延长其生命周期。

case OP_RETURN: {
  ...
  closeUpvalues(frame->slots);
  ...
}
static void closeUpvalues(Value *last)
{
  // 在 frame->slots 之后的变量全部搬到堆上
    while (vm.openUpvalues != NULL && vm.openUpvalues->location >= last)
    {
        ObjUpvalue *upvalue = vm.openUpvalues;
        upvalue->closed = *upvalue->location; // 原本栈上的值拷贝到 closed 字段中,也就到了堆上
        upvalue->location = &upvalue->closed; // 指针位置指向 closed 字段
        vm.openUpvalues = upvalue->next;
    }
}

上面用到的闭包参数对象 ObjUpvalue 的内部结构如下。

typedef struct ObjUpvalue
{
    Obj obj; // 元信息头部
    Value *location; // 记录该变量原本在栈上的位置
    Value closed; // 如果该变量被闭包,将 location 指向的值拷贝到此处。即从栈上搬到堆上,保证其长期存活
    struct ObjUpvalue *next; // 链表指针
} ObjUpvalue;

后面在 myFunc 函数执行到 print a;时,虚拟机会按照本地变量,闭包值,全局变量的顺序去查找对应的值。

if arg = resolveLocal(current, &name);
if(arg != -1) { // 找到了局部变量,生成 OP_GET_LOCAL 字节码
  ... 
} else if(arg = resolveUpvalue(current, &name)) != -1) { // 找到了闭包参数,生成 OP_GET_UPVALUE 字节码
  emitBytes(OP_GET_UPVALUE, arg);
} else { // 当作全局变量处理,生成 OP_GET_GLOBAL,如果还是没有就报“未定义”错误
  ...
}

上面用到的 resolveUpvalue 函数内部会递归调用,这样可以保证在多层嵌套的情况下也能获取到外层参数。

static int resolveUpvalue(Token *name) {
  ...
  int local = resolveLocal(parent, name); // 先尝试从父作用域的局部变量中找
  if(local != -1) {
    return addUpvalue(...); // 记录下闭包参数,下同
  }
  int upvalue = resolveUpvalue(parent, name); // 如果没找到,再从父作用域的闭包参数中找,递归调用到顶为止
  if(upvalue != -1) {
    return addUpvalue(...);
  }
  return -1; // 找不到则返回
}

如上代码所示,addUpvalue 函数既可用于将父作用域的局部变量加入到当前作用域闭包参数中,也可用于将父作用域“继承”而来的闭包参数加入到当前作用域闭包参数中。

本例中,myFunc 没找到局部变量 a,但找到了闭包参数 a。所以,它生成了 OP_GET_UPVALUE 字节码指令。虚拟机执行 OP_GET_UPVALUE 指令时会从闭包函数对象的 upvalues 列表中获取对应的闭包参数。

case OP_GET_UPVALUE: {
  uint8_t slot = READ_BYTE();
  push(*frame->closure->upvalues[slot]->location);
  break;
}

如前文 closeUpvalues 函数所述,upvalues[slot]->location 此刻已经指向其结构体自身的 closed 字段。因为该闭包参数整个结构体都存活在堆上,所以myFunc 函数可以在 makeFunc 作用域结束后依然正确地拿到 a 的值并打印。

   3.9 面向对象
class Cake {
  eat() { // 定义成员函数 eat
    var adjective = "好吃";
    print "这个" + this.flavor + "蛋糕真" + adjective + "!";
  }
}


var cake = Cake();
cake.flavor = "巧克力"; // 动态地设置实例字段
cake.eat(); // 输出“这个巧克力蛋糕真好吃!”

class Cake 中的 Cake 就是类,var cake = Cake() 中的cake就是类调用后生成的实例,而cake.eat() 中的 eat 就是该类的成员方法。

   3.9.1 类与实例

上面脚本中,定义类以及构建实例部分的字节码如下所示:

0000    1 OP_CLASS            0 'Cake' // 定义 Cake 类
0002    | OP_DEFINE_GLOBAL    0 'Cake' // 加到全局表
0004    | OP_GET_GLOBAL       1 'Cake'
...
0010    6 OP_POP
0011    8 OP_GET_GLOBAL       5 'Cake'
0013    | OP_CALL             0 // 调用 Cake(),因为 Cake 未指定构造函数,故使用默认的无参构造函数
0015    | OP_DEFINE_GLOBAL    4 'cake' // 加到全局表
0017    9 OP_GET_GLOBAL       6 'cake'
...

解析类定义的逻辑如下所示:

static void classDeclaration() {
  consumeToken(TOKEN_IDENTIFER, "需要类名");
  ...
  emitBytes(OP_CLASS, ...); // 生成 OP_CLASS 字节码
  ...
  if(match(TOKEN_COLON)) { // 如果有冒号符号,尝试解析父类
    ...
  }
  namedVariable(className, ...); // 生成 OP_DEFINE_GLOBAL,加入到全局表,这样可以允许成员方法引用该类
  consumeToken(TOKEN_LEFT_BRACE, "需要左花括号");
    while (!check(TOKEN_RIGHT_BRACE) && !check(TOKEN_EOF))
    {
        method(); // 在遇到右花括号之前,循环解析成员方法
    }
    consumeToken(TOKEN_RIGHT_BRACE, "需要右花括号");
  ...
}

OP_CLASS 字节码负责构建 ObjClass 类对象并将其压入栈。

case OP_CLASS: {
  ObjString *name = READ_STRING();
  ObjClass *klass = ALLOCATE_OBJ(ObjClass, OBJ_CLASS); // 初始化结构体
  klass->name = name;
  initTable(&klass->methods); // 初始化类成员方法表
  push(OBJ_VAL(klass)); // 压入值栈,方便后续调用
  break;
}

ObjClass 的结构如下。

typedef struct
{
    Obj obj; // 元信息
    ObjString *name; // 类名
    Table methods; // 成员方法表
} ObjClass;

类定义中只需要定义成员方法,不需要定义字段。字段都可以被动态设置,以代码中 cake.flavor = "巧克力"; 语句为例,其对应字节码如下所示:

...
0017    9 OP_GET_GLOBAL       6 'cake' // 获得 cake 实例
0019    | OP_CONSTANT         8 '巧克力'
0021    | OP_SET_PROPERTY     7 'flavor' // 设置 cake 实例的属性
...

如 OP_SET_PROPERTY 名称所示,该指令用于设置实例字段值,其执行逻辑如下。

case OP_SET_PROPERTY: {
  if(!IS_INSTANCE(peek(1)) { // 只有类的实例才可以动态设置字段
    runtimeError("只有实例才允许字段赋值");
    return RUNTIME_ERROR;
  }
  ObjInstance *instance = AS_INSTANCE(peek(1)); // 获得实例对象
  tableSet(&instance->fields, READ_STRING(), ...); // 设置其字段表的值
  ...
  break;
}

其中 ObjInstance 的结构如下所示:

typedef struct
{
    Obj obj; // 元信息
    ObjClass *klass; // 所属的类
    Table fields; // 字段表
} ObjInstance;

脚本代码中 cake.eat(); 语句是对该实例的成员方法的调用,其字节码如下。

0024   10 OP_GET_GLOBAL       9 'cake' // 从全局表中获得 cake 实例
0026    | OP_INVOKE        (0 args)   10 'eat' // 调用成员方法 eat,携带 0 个参数

OP_INVOKE 指令尝试找到成员方法并发起调用,如果找不到则报运行时错误。

case OP_INVOKE: {
  ObjString *method = READ_STRING(); // 获得方法名
  int argCount = READ_BYTE(); // 获取参数个数
  if(!invoke(method, argCount)) { // 发起调用
    return RUNTIME_ERROR;
  }
  frame = &vm.frames[vm.frameCount - 1]; // 成功完成,重新指向栈顶下方的函数调用栈帧
  break;
}


static bool invoke(ObjString *name, int argCount) {
  Value receiver = peek(argCount); // 获得实例对象
  ...
  ObjInstance *instance = AS_INSTANCE(receiver); // 转成具体类型
  ...
  ObjClass *klass = instance->class;
  Value method;
  if(!tableGet(&klass->method, name, &method)) { // 从实例关联的类中查找成员方法
    runtimeError("未定义属性 '%s'", name->chars);
    return false;
  }
  return call_(AS_CLOSURE(method), argCount); // 包装成闭包对象,像普通函数一样调用
}
   3.9.2 成员方式

样例脚本中 Cake 类定义了一个成员方法 eat() {...},其产生的字节码如下所示:

0024   10 OP_GET_GLOBAL       9 'cake' // 从全局表中获得 cake 实例
0026    | OP_INVOKE        (0 args)   10 'eat' // 调用成员方法 eat,携带 0 个参数

OP_CLOSURE 在前文介绍过,负责生成一个闭包对象。 OP_METHOD 字节码是构建成员方法的关键,其在虚拟机中的执行逻辑如下。

case OP_METHOD: {
  ObjString *name = READ_STRING();
  Value method = peek(0); // 获得栈顶已经包装好成员方法的闭包对象
  ObjClass *klass = AS_CLASS(peek(1)); // 获取栈顶下方的 Cake 类
  tableSet(&klass->methods, name, method); // 把闭包对象加入到类的 `methods` 表中,如果 name 已经存在,覆盖旧值
  pop(); // 弹出栈顶元素
  break;
}

前文在解析类的时候,method() 函数被用来循环解析类的成员方法,其具体逻辑如下。

static void method() {
  consumeToken(TOKEN_IDENTIFIER, "需要方法名");
  ...
  if(token.length == 4 && memcmp(token.name, "init", 4) == 0) {
    // 如果成员方法名为 "init",表示是构造函数,走特殊逻辑
    ...
  }
  // 同前文普通函数解析方法
  ...
  emitBytes(OP_ClOSURE, ...); // 生成 OP_CLOSURE 字节码
  emitBytes(OP_METHOD, ...); // 生成 OP_METHOD 字节码
}
   3.9.3 构造函数

构造函数是一种特殊的成员方法,它用来构建类的实例。eben 中规定方法名叫 init 的成员方法为构造函数。和其他语言一样,构造函数不能随意指定返回值,因为它的返回值只能是该类的实例。上文的 Cake 类如果加上构造函数,其效果如下。

class Cake {
  init(color) {
    this.color = color; // 设置 color 字段
  }


  eat() {
    print "这个" + this.color + "蛋糕真不错!";
  }
}


var cake = Cake("粉色");
cake.eat();

对应的字节码如下。

== init ==
0000    3 OP_GET_LOCAL        0 // 获得序号 0 的局部变量,即 this,此位置专门预留给 this
0002    | OP_GET_LOCAL        1 // 获得序号 1 的局部变量,即 color 参数
0004    | OP_SET_PROPERTY     0 'color' // 将参数赋值到 this 的属性 color 中
0006    | OP_POP
0007    4 OP_GET_LOCAL        0 // 获得序号 0 的局部变量,即this
0009    | OP_RETURN // 返回 this,即实例自身
== eat ==
0000    7 OP_CONSTANT         0 '这个'
0002    | OP_GET_LOCAL        0 // 获得序号 0 的局部变量,即this
0004    | OP_GET_PROPERTY     1 'color' // 获得 this 上的属性字段 color
0006    | OP_ADD // 字符串拼接
0007    | OP_CONSTANT         2 '蛋糕真不错!'
...
== <script> ==
0000    1 OP_CLASS            0 'Cake'
0002    | OP_DEFINE_GLOBAL    0 'Cake'
0004    | OP_GET_GLOBAL       1 'Cake'
0006    4 OP_CLOSURE          3 <fn init> // 生成构造函数包装而成的闭包对象
0008    | OP_METHOD           2 'init' // 构造函数加入到类的成员方法表
...

eben 中构造函数不需要也不允许指定返回值,一律在底层自动返回该类的实例。所以,在 eben 的类构造函数中使用 return 关键字会导致语法报错。

static void retrunStatement() {
  ...
  if(current->type == TYPE_INITIALIZER) {
    error("不可以在构造函数内使用 return。");
  }
  ...
}

如前所述,eben 中普通函数在没有指定返回值的情况下,会默认返回空值 nil 。所以,编译器解析 eben 函数过程中调用 emitReturn 时需要对两种情况分别处理。

static void emitReturn() {
  if(current->type == TYPE_INITIALIZER) { // 是构造函数
    emitBytes(OP_GET_LOCAL, 0); // this 处在局部变量预留位置 0
  } else { // 是普通函数
    emitByte(OP_NIL);
  }
  emitByte(OP_RETURN); // 生成返回操作字节码
}

名为 init 的成员方法归类为 TYPE_INITIALIZER 类型,其余方法都归类为 TYPE_METHOD 类型。

   3.9.4 构造函数

eben 中子类既可以继承 Inherit 父类方法,也可以覆盖 Override 父类方法,甚至还可以在子类方法中通过 super 关键字调用父类方法。

class Cake {
  eat() {
    print "这个蛋糕真好吃!";
  }


  make() {
    print "做蛋糕很辛苦.";
  }
}


class BananaCake : Cake { // BananaCake 继承 Cake
  eat() { // 覆盖父类同名方法
    super.eat(); // 调用父类的方法
    print "加了香蕉更好吃!";
  }
}


var bc = BananaCake(); // 构建实例
bc.make(); // 调用继承而来的方法 make,输出“做蛋糕很辛苦.”
bc.eat(); // 调用覆盖方法 eat,输出“这个蛋糕真好吃!\n加了香蕉更好吃!”

其生成的字节码如下所示:

== eat == // Cake 中 eat 方法
...
== make == // Cake 中 make 方法
...
== eat ==
0000   13 OP_GET_LOCAL        0 // 获得 this
0002    | OP_GET_UPVALUE      0 // 获得 super
0004    | OP_SUPER_INVOKE  (0 args)    0 'eat' // 调用父类方法 eat
0007    | OP_POP
0008   14 OP_CONSTANT         1 '加了香蕉更好吃!'
0010    | OP_PRINT
0011   15 OP_NIL
0012    | OP_RETURN
== <script> ==
0000    1 OP_CLASS            0 'Cake' // 生成父类 Cake
... // 生成父类 Cake 成员方法
0015   11 OP_CLASS            6 'BananaCake' // 生成子类 BananaCake
0017    | OP_DEFINE_GLOBAL    6 'BananaCake'
0019    | OP_GET_GLOBAL       7 'Cake'
0021    | OP_GET_GLOBAL       8 'BananaCake'
0023    | OP_INHERIT // 继承父类的方法(只继承方法,不继承字段,因为后者都是动态设置)
0024    | OP_GET_GLOBAL       9 'BananaCake' // 开始生成其成员方法
... // OP_METHOD 指令,此处略去
0033    | OP_CLOSE_UPVALUE
0034   18 OP_GET_GLOBAL      13 'BananaCake'
0036    | OP_CALL             0 // 调用默认构造函数
0038    | OP_DEFINE_GLOBAL   12 'bc'
0040   19 OP_GET_GLOBAL      14 'bc'
0042    | OP_INVOKE        (0 args)   15 'make' // 调用继承来的 make 方法
0045    | OP_POP
0046   20 OP_GET_GLOBAL      16 'bc'
0048    | OP_INVOKE        (0 args)   17 'eat' // 调用 eat 方法
...

字节码中出现的新指令是 OP_SUPER_INVOKE 和 OP_INHERIT ,分别负责调用父类方法和构建继承关系。OP_SUPER_INVOKE 与前文的 OP_INVOKE 主体逻辑相似,区别是调用主体从当前类方法变成父类方法。

...
ObjClass *superclass = AS_CLASS(pop()); // pop() 出来的参数是事先放置的父类
if(!invokeFromClass(superclass, method, argcount)) {
  return RUNTIME_ERROR;
}
...

编译器在解析 super 关键字时,如果解析完 super.IDENTIFIER (比如 super.eat) 后再遇到左括号,就会触发父类方法调用逻辑。

uint8_t argCount = argumentList(); // 解析函数参数,返回参数个数
namedVariable("super", ...); // 通过 resolveLocal, resolveUpvalue 查找逻辑找到闭包参数 super
emitBytes(OP_SUPER_INVOKE, name); // 生成 OP_SUPER_INVOKE 指令,本例中 name 就是 "eat" 函数对象的序号
emitByte(argCount); // 生成参数个数

super 能被子类方法引用,是因为在解析子类时该值早已被提前放入。

static void classDeclaration() {
  ...
  if(match(TOKEN_COLON)) { // 遇到冒号,有继承父类关系,当前类是一个子类
    consumeToken(TOKEN_IDENTIFIER, "需要父类名称.");
        variable(false); // 获取父类,压入值栈
    ...
    addLocal("super"); // super 加到局部变量列表,让其被闭包捕获,方便子类方法引用
    defineVariable(0);
    ...
  }
  ...
}

eben 中子类只能继承父类的方法,不能继承字段,所以 OP_INHERIT 的逻辑比较简单。

case OP_INHERIT: {
  Value superclass = peek(1);
  ...
  ObjClass *subclass = AS_CLASS(peek(0));
  // 将父类方法表拷贝到子类方法表
  tableAddAll(&AS_CLASS(superclass)->methods, &subclass->methods);
  pop(); // 弹出子类
  break;
}

OP_INHERIT 执行完之后才会循环执行子类中的 OP_METHOD 指令,逐个添加成员方法。因此,调用 tableAddAll 函数不会导致子类方法被父类同名方法覆盖。OP_INHERIT 字节码也是由编译器解析“类声明”函数 classDeclaration 生成。

static void classDeclaration() {
  ...
  if(match(TOKEN_COLON)) { // 遇到冒号,有继承父类关系
    ...
    namedVariable(className, ...); // 生成 OP_GET_GLOBAL 指令,加载 BananaCake 类进栈
    emitByte(OP_INHERIT); // 生成继承指令
  }
  ...
}
   3.10 垃圾回收

开发过程中,总要有人操心内存管理。要么是语言使用者(比如 C/C++ 使用者和 ARC 出现之前的 Obj-C 使用者),要么是语言作者(比如 Java、Python、C#、Go 的作者)。eben 带有 Garbage Collection 垃圾自动回收特性(简称 GC) ,所以 eben 使用者比较幸运,不需要操心内存管理。

如前文所介绍,eben 脚本语言中的函数、闭包参数、闭包、类、实例、绑定方法等等都有其对应的底层类型,大致结构如下所示:

typedef struct
{
  Obj obj; // 元信息
    ...
  ObjY *someObject; // 可能包含任意个对其他复杂类型的引用
  Table someTable; // 可能包含自定义的哈希表结构体
  char *chars; // 可能包含字符串指针
} ObjX;

虚拟机中通过 freeObject 函数来释放这些底层类型的内存。

void freeObject(Obj *object) {
  swtich(object->type) {
    case OBJ_CLASS: { // 类对象
      ObjClass *klass = (ObjClass *)object;
      freeTable(&klass->methods); // 释放其方法表
      FREE(ObjClass, object); // 释放结构自身
      break;
    }
    ...
    case OBJ_STRING: { // 字符串对象
      ObjString *string = (ObjString*)object;
      FREE_ARRAY(char, string->chars, string->length+1); // 尾部的'\0'也一起释放
      FREE(ObjString, object); // 释放结构自身
      break;
    }
    ...
  }
}

其他底层类型的释放逻辑与上面二者大同小异。理论上,只要虚拟机能够将所有需要释放的对象归置到一起,再全部释放,就可以避免内存泄漏,也就可以管理好内存。为了判断对象是否需要释放,eben 在每一个底层类型头部都嵌套了 Obj obj 字段。该字段中内含的 isMarked 布尔字段被用来判断对象是否该释放。

struct Obj {
  ObjType type; // OBJ_CLASS, OBJ_FUNCTION, OBJ_STRING 等等枚举值
  bool isMarked; // 是否被标记
  struct Obj *next; // 链接串接指针
}

看到 isMarked 字段,读者大概已经猜到 eben 中会使用 Mark-Sweep 方法来清理内存。业界有很多高级垃圾回收算法来高效地完成回收,本文为了简便使用了最朴素但是也蛮高效的 Mark-Sweep 标记清除方法。其主要流程如下表所示:

初始状态标记 Mark清除 Sweep
995842ec4569c12ebf539aae193b3926.png147501af9c4532bdc39796719432fd59.pngdc1fe0faf8e0da78c9d0159a4a7ef7e1.png
存在引用无法可达的对象将 root 出发引用可达的对象标记成黑色将未标记的对象清除

如表中所示,垃圾回收主要有标记和清除两大步骤。其中标记步骤可以再细分成 markRoots 和 markByReferences ,如下所示:

void gc() {
  markRoots(); // 虚拟机主结构直接引用的对象称为 root,将其全部标记
  markByReferences(); // 从 root 出发,根据引用关系在所有对象中访问扩散并标记
  sweep(); // 清除所有没被标记过的对象
  ...
}

markRoots 负责标记虚拟机直接引用的对象。

static void markRoots() {
  for(Value *slot = vm.stack; slot < vm.stackTop; slot++) {
    markValue(*slot);
  }
  ... // 其他直接引用的对象
  markTable(&vm.globals);
  markObject((Obj *)vm.initString);
  ...
}

其中 markObject 是最细粒度的基础操作,其他 mark 函数都是其封装。

void markObject(Obj *object) {
  ...
  if(object->isMarked)
    return; // 已经标记过,返回
  object->isMarked = true; // 标记
  ...
  vm.grayStack[vm.grayCount++] = object; // 加入到已访问节点栈中
}

在虚拟机主结构直接引用的 root 对象都标记完之后,通过 root 对象的引用关系访问扩散并标记。

static void markByReferences() {
  while(vm.grayStack > 0) { // 取出节点访问栈中全部对象为止
    Obj *object = vm.grayStack[--vm.grayCount];
    switch(object->type) {
      ...
      case OBJ_CLASS: { // 按类型标记类对象
        ObjClass *klass = (ObjClass *)objects;
        markObject((Obj *)klass->name); // 标记 Class 中引用的名称字段 name
        markTable(&klass->methods); // 标记 Class 中引用的方法表字段 methods
        break;
      }
      case OBJ_FUNCTION: { // 按类型标记函数对象
        ObjFunction *func = (ObjFunction *)object;
        markObject((Obj *)func->name); // 标记 Function 中引用的名称字段 name
        markArray(&func->chunk.constants); // 标记 Function 中引用的常量表字段 constants
        break;
      }
      ... // 其他需要标记其字段的对象
    }
  }
}

当能被访问到的对象全部被标记后,GC 流程开始清除没被标记的对象,即没人使用的对象。

static void sweep() {
  Obj *prev = NULL;
  Obj *object = vm.objects; // vm.objects 链表中维护系统分配出来的所有对象,它不参与 markRoots
  while(object != NULL) {
    if(!object->isMarked) {
      Obj *garbage = object; // 锁定垃圾对象
      // 链表删除节点处理
      object = object->next;
      if(prev != NULL) {
        previous->next = object;
      } else {
        vm.objects = object;
      }
      freeObject(garbage); // 清除垃圾对象
    }
    ... // 其他维护工作
  }
}

vm.objects 链表维护虚拟机中所有对象,因此 markRoots 操作会避开此处,否则所有对象都至少有这里的引用关系存在。eben 虚拟机在创建对象时,都会将其加入到 vm.objects 链表中。

static Obj *allocateObject(size_t size, ObjType type) {
  Obj *object = (Obj *)custom_allocate(NULL, 0, size); // 使用自定义的内存分配函数
  ...
  object->next = vm.objects; // 加入到链表头位置
  vm.objects = object;
  ...
}

上面代码中的 custom_allocate 内存分配函数在分配内存前会有一个已使用内存空间阈值检查,一旦达到阈值,会启动垃圾回收机制。

void *custom_allocate(void *pointer, size_t oldSize, size_t newSize) { // 所有新对象的生成对会用到此函数
  vm.bytesAllocated += newSize - oldSize;
  if(vm.bytesAllocated > vm.nextGC) { // 大于阈值,发起 gc
    gc();
  }
  ...
}

为了防止内存分配到达临界点附近时频繁超过阈值,虚拟机会在每次 gc 时调整阈值到一个更宽裕的值。

void gc() {
  ...
  vm.nextGC = vm.bytesAllocated * GC_GROW_FACTOR;
}

至此,一个完整的垃圾回收机制就完成了。

b62ad44c3f3db71222596b911584b10e.png

56f2f1191ec348f7a7c54738948618e3.jpeg


了解完 eben 的内在之后,想必读者再看到这个 REPL 会更感亲切,也更感透彻。

笔者在学习完 Robert Nystrom 的 "Crafting Interpreters" 全书和 Roberto Ierusalimschy 的 Lua 设计论文后,就对编译原理有了远比之前更透彻的理解。既钦佩于作者才华之美,又感叹他们计算机教育水平之高。基于前文的编程语言诞生时间表,笔者又理了一份编程语言作者表,方便读者直观地感受他们的编译原理发展水平之高。

年份语言主要作者国籍
1957FORTRANJohn Backus美国
1958LISPJohn McCarthy美国
1970PascalNiklaus Wirth瑞士
1972CDennis Ritchie美国
1978SQLDonald D. Chamberlin, Raymond F. Boyce美国
1980C++Bjarne Stroustrup丹麦
1986Objective-CBrad Cox美国
1987PerlLarry Wall美国
1990PythonGuido van Rossum荷兰
1993LuaRoberto Ierusalimschy巴西
1995Ruby松本行弘日本
1995JavaJames Gosling加拿大
1995JavaScriptBrendan Eich美国
1995PHPRasmus Lerdorf加拿大
2001C#Anders Hejlsberg丹麦
2003ScalaMartin Odersky德国
2009GoRob Pike, Ken Thompson 等美国
2012TypeScriptAnders Hejlsberg丹麦
2014SwiftChris Lattner美国
2015RustGraydon Hoare加拿大
............

如果此文能激起读者的学习兴趣,能激起读者对编译原理乃至计算机其他领域深刻知识的探索欲望,笔者深感荣幸。

-End-

原创作者|donghui

📢有了自己的脚本语言之后,你会做些什么功能?欢迎留言。我们将挑选一则最有趣的答案,为其留言者送出腾讯定制—手机支架1个。10月19日中午12点开奖。

25716624696d96acde387ac038f8a23e.png

📢📢欢迎加入腾讯云开发者社群,社群专享券、大咖交流圈、第一手活动通知、限量鹅厂周边能你来~

02d97702856b13c10c7cb1f88f8aaab9.png

(长按图片立即扫码)

f180fe52bc4a10d596ed6e798e9c6da4.png

3f93c586c34002ee03b331b4d52c1dbe.png

739c72409942ababa9bc02d60406b2db.png

a077f98dd5ceae6d9999e507207785fe.png

5f58e71c75c30f54e6a67fabe7d13ab0.png

关注并星标腾讯云开发者

每周4看鹅厂程序员测评新技术

相关推荐

大模型的Agent Skill功能,在LLM HTTP底层交互流中是怎么承载的?

网络文章文本的 skill,昨天我实现了之后也就开始好奇起 Skills 的底层原理了——相比起各种花里胡哨的 agrnt 应用,我一直以来都很对大模型在纯粹的 HTTP 交互层面是如何交互的更感兴趣。Skill 的全部"魔法"都发生在 system prompt 的措辞和 SKILL.md 文件的编写质量上——本质上是一种 prompt engineering + 文件系统的组合。但是各种天花乱坠的 skills,是如何在底层的 HTTP 中,与大模型——这个只会嘴遁的工具交互的呢?

QcloudCommunity的博客 407

万字入门AI Infra:深入理解大模型中的数学与Infra优化

关注腾讯云开发者,一手技术干货提前解锁👇AI Infra科普、入门或者进阶 ~~ 不到 5 万字,带你融会贯通理解大模型的数学、算法、硬件到系统工程。任何问题欢迎沟通交流。可怕,我竟然有点认同这句话。当然大概率是因为姚顺宇太懂AI了,而我则是因为无知者无畏。不过仔细想想,大模型推理中的数学逻辑确实不复杂,很多原理只需要高中数学知识就能看懂。但是为什么像 vLLM 这种推理系统这么复杂呢?本文将拆解大模型中几个核心操作(RMSNorm、Softmax、Causal Mask、Sampling)背后的数学与

QcloudCommunity的博客 1170

平平无奇的源码,竟藏着Agent的核心秘密?

System Prompt 是剧本,Skill 是剧本的扩展包,Agent Loop 是演员按剧本行动。欢迎留言,我们将邀请作者针对性回复你的评论,我们将选取1则优质的评论,送出腾讯云定制文件袋套装。,让 Agent 能主动"巡逻",而不只是被动等待用户消息。OpenClaw 的 System Prompt 分层结构。的"行为底线",任何 Skill 或用户命令都无法覆盖它。精华 2:Skill 的"按需加载"避免 token 浪费。精华 1:System Prompt 是"分层乐高积木"

QcloudCommunity的博客 426

QQ音乐Harness Engineering实践

一个看似简单的需求,背后可能牵动服务调用链、配置、灰度、埋点、错误码、接口契约和历史兼容性。当 AI 开始快速生成大量代码,真正的瓶颈就不再是"写不出来",而是"看不完、想不清、管不住"。在对话式编码阶段,一种典型的工作模式逐渐流行:开发者把需求丢给 AI,扫一眼输出"看起来对"就直接采纳,不审 diff、不追问逻辑、不验证边界。以音乐商业化业务为例,一个需求可能从 TAPD 单开始,经过需求评审、技术方案、服务影响面分析、IDL 契约变更、业务代码实现、测试验证、CR、灰度上线,最后才进入稳定运行。

QcloudCommunity的博客 716

从Prompt、Context到Harness,工程的三次进化与终局之战

同时,强制要求散落各处的决策记录(Slack、邮件、文档)全部迁移至代码仓库,确保 Agent 的唯一信息来源是可信的、版本受控的仓库。更坑爹的是,研究表明,当上下文过长时,模型会出现"中间遗忘(Lost in the Middle)"现象:它对开头和结尾的内容记忆较好,对中间大段内容的关注度大幅下降。这篇文章,我想带你完整走一遍这三次进化的逻辑:它们分别解决了什么问题,它们之间是什么关系,它们的边界在哪里,以及:当三者融合,AI 工程师的终极形态究竟是什么?大语言模型的本质,就是这位金鱼助理。

QcloudCommunity的博客 719

让Skill自己训练自己:8阶段Loop、3层评测、5维AND门控,从此实现自进化

所以每一轮改动都是有据可查的,不是「感觉这里可以优化」,而是「Case 41 挂了,因为 agent 把离职问题路由到了邮箱分类,但正确答案在通讯录,所以我改 root_index.md 加个易混淆提示」。但让我最后决定把它记录下来的,不是这的个「吸收」过程,而是它真的在替我探索我不想费脑力触达的边界,这看起来更像是一个机器智能应该有的样子。不准跨层,每轮只改一层的东西。但我经过这 19 轮之后觉得,更准确的描述是互补——你在明处看着,AI 在暗处替你试错,你看不见的那一半就是 AI 能贡献的地方。

QcloudCommunity的博客 1128

只加两行代码,为什么要两天?一文深度理解业务系统的复杂性

关注腾讯云开发者,一手技术干货提前解锁👇业务系统复杂性一直是令开发者头痛的问题。复杂的不是增加一个需求需要耗费多少时间,而是在增加一个需求后带来的蝴蝶效应:其它功能会不会受到影响、要如何去找到这些影响,最终如何实现系统正常运行......功能之间隐秘增加的耦合、不可避免的代码腐化在导致业务复杂性增加。大家都在说的软件开发提效到底在提什么?程序员日常工作中应该如何提升开发效率?敏捷开发、瀑布流式开发孰是孰非?欢迎阅读。业务背景与目标我依然非常清晰地记得某个时候,我所在团队 Leader 曾讲过一段话:“我担

QcloudCommunity的博客 713

从零设计生产级 Multi-Agent Harness:架构、评估、记忆、成本与 MCP 工具接入全拆解

在 AI Agent 领域,Multi-Agent Harness 指的是把多个 Agent 的能力、工具、状态、通信、编排、监控统一收束在一个运行时之内的框架。第三,Agent 路由。一个输入框,一个大模型,几个工具,一段写得很漂亮的 System Prompt,再配上一个炫酷的前端,看起来就像一个能干活的“数字员工”。Multi-Agent 完全不一样——它有计划、有中间步骤、有工具调用、有 Agent 协作、有重试、有反思、有最终合成。增加 Budget、权限、重试、压缩、轨迹评估、审计、回归测试。

QcloudCommunity的博客 710

拆完Hermes源码,我发现Agent的“自我进化“根本不需要训练模型

两个月 5.2 万 Star,Hermes Agent 用一个"LLM 审判官"机制实现了 Agent 的自我进化——不改模型权重,只改"怎么用模型"的策略。OpenClaw(社区昵称"龙虾"🦞)是 2025-2026 年最火的开源 Agent 框架,30 万+ Star,插件市场 ClawHub 里有数千个插件,能接入 Telegram、WhatsApp、Slack、飞书、企业微信——几乎是一个"个人 AI 操作系统"。Skill 是英语写的,Memory 是英语写的,审查 Prompt 也是英语写的。

QcloudCommunity的博客 911

AI Infra 其实没有多少新东西

传统 Infra 追求横向扩展,而 AI Infra 呈现 “AI 大型机”特性,是因为传统后台服务的可以容忍毫秒级延迟,但 AI 集群不行,GPU 的算力是 CPU 的数百倍,微秒级的延时等待也会造成很大的算力损耗,需要硬件的高度集成。在可预见的1-3年的未来,这样的专用硬件+网络的集中式架构很难发生比较大的改变。与之相似,模型推理的批处理就是将多个输入样本打包(batch),将原本串行的 N 次轻量的推理计算,合并为 1 次重量的计算,实现单位时间内处理更多的请求,提高了 GPU 利用率。

QcloudCommunity的博客 826

程序员越早想通这些越好

永远没有正确架构,你永远无法偿还完所有的技术债务,如同你永远不会设计出完美的界面,请避开完美主义的陷阱,永远没有完美的代码,能够满足当前需求,又为未来不管是自己还是他人留有扩展空间,就很好了。我们努力的方向就是将现实世界映射到有限的数据结构中,这就需要用户自定义类型,如果你的代码中包含类似 trader portfolio 这样的概念,你就可以使用他们的名称来建模,而不是使用基本数据类型复杂嵌套表述你的目的。从另一个角度看,代码里的注释都是补丁,是碎片化的,局部的注释很难推导模块整体的顺序及耦合关系。

QcloudCommunity的博客 466

RAG已死?不,是Grep回归了!

这样一来可以直接复用已有的计算缓存,只为新增的增量部分付全价,前面累积的大头按约 1/10 的缓存价计费。所以实际的工具组合方式是灵活的:Grep(默认模式)→ Read 是最常见的路径,但 Grep(content 模式)可以独立使用,LLM 也可以直接调 Read(如果已经知道文件路径),或者一次同时发起多个 Grep 并行搜索。它从零开始构建自己的对话历史,不继承主对话的消息,这意味着它搜索过程中产生的大量 grep 结果、代码片段都留在自己的 context 里,主对话只收到一段总结性的文本结论。

QcloudCommunity的博客 576

深入浅出Harness Engineerring之核心模式与理念

在智能体生命周期的关键节点(如会话开始、工具调用后)自动触发预设动作(如代码格式化),由系统确保关键流程被执行,不依赖可能被模型遗忘的指令。简单讲就是利用向量存储这个技术,来实现模糊检索,原理是:即使字面不同,但语义相近的文本,其向量在数学空间中的位置也很接近。根据命令类型、参数和影响,自动评估其风险等级(安全、有风险、危险),并采取自动执行、请求确认或直接拦截等不同策略。关键特性是可隔离、可重建、可扩展。不是一次判断就定终身,允许你改变、允许情况复杂,通过不断观察、思考、调整,越来越懂真实的你。

QcloudCommunity的博客 625

Harness Engineering实践心得:如何高效驾驭AI?

但如果这些经验被拆成一条条 Rule、一个个 Skill、一项项 Script 检查——"XAML 不能有中文"、"编译要用这个路径的 MSBuild"、"SVN 命令必须带认证参数"——AI 就能在秒级时间里"吸收"十年的踩坑经验。然后可以看到下方的图,我的PM会很顺利的调度其他agent分别负责不同的事项,遇到问题的时候也能准确的找到合适的agent。MCP 本质上是在扩展 AI 的"感知范围"——Rule 管"该怎么做",Skill 管"怎么操作",MCP 管"能看到什么、能碰到什么"。

QcloudCommunity的博客 843

从第一性原理思考 Agentic Engineering

需要注意的是,这一结论是有条件的:如果 AI 缺乏领域知识,过早介入反而可能引入 1.2 节所述的"似是而非"损耗——因此上下文供给(实践 1)是 AI 全链条参与的前提,而非结果。通过一个专门的自迭代 Skill 实现——当 AI 在协作过程中识别到自己被纠正(用户否定了 AI 的输出并给出了正确方向),它自动评估这个错误的根因,搜索现有的 Rules 和 Skills 中是否已有针对该类问题的处理规则。事实上,越是复杂的项目,工程师的认知负担越重(公理 3),AI 分担认知负担的潜在边际价值也越大。

QcloudCommunity的博客 757

万字干货!Harness Engineering如何工程化落地?

关注腾讯云开发者,一手技术干货提前解锁👇Harness Engineering 的概念已经火了有一阵了,全网很多文章基本都是在讲理念,讲为什么今天做 AI 开发,不能只靠一段提示词,也不能把模型当一个“更聪明的代码补全”。但与此同时,一个问题也在持续地发酵:这个问题特别重要。因为 Harness 这个词听上去很大,很像一个抽象的方法论,但它如果不能落到工程、目录、文档、脚本、工作流里,那它最后就只是一句漂亮的话。事实上,不同项目落地出来的 Harness,表面上可能完全不一样。有的项目是 CI 很强,有的

QcloudCommunity的博客 1171

全方位对比:Hermes VS OpenClaw

多账号矩阵运营 如果你的业务涉及同时管理多个社交媒体账号、多个平台的内容分发、多渠道的客户互动——OpenClaw是目前市场上的"无可替代的底座"。一个有专业背景的个人,现在可以快速构建一个垂直领域的AI助手:比如"财务分析Hermes"、"法律咨询Hermes"、"技术架构Hermes",直接通过微信提供服务,积累自己的专业IP。跨平台生态融合 如果你的工作流涉及飞书、Slack、Discord等多个平台的深度集成,需要这些平台之间的数据流转和联动——OpenClaw的生态支持是强大的。

QcloudCommunity的博客 1218

一文讲透:Harness Engineering即控制论!

而研发模式的升级我认为将会是一个飞跃的过程,之所以现在我们仍然需要需要参与编码,一个非常大的原因就是缺乏传感器和基建,仍然需要人来串流程,比如需要人来验证UI是否正确、需要人来告诉AI代码不符合代码规范,因此在有些场景我们仍然感觉 AI 完成的很吃力,但这不是 AI 能力不行,而是我们并没有为 AI 提供友好的环境……控制论中的突变理论介绍了矫枉过正和飞跃现象之间的矛盾,如果质变中经历的中间过渡态是不稳定的,那么他就是一个飞跃的过程,如果中间过渡态是稳定的,那么他就是一个渐变的过程。但是这些阶段要解决的。

QcloudCommunity的博客 1204

神级开源插件!一句话让QClaw变3D小镇,Agent工作可视化,赛博云监工

这个架构是翻了几次车才想通的—原有AI的实现机制是用 setTimeout 猜动画时长导致了幽灵 NPC、工位撞车、越改越崩,后面我停下来换了思路,推翻原有的架构,按照“意图+回传”的架构进行重构,之前的问题一次性全部解决。15 天,我和 AI 吵了 185 次架, 4.5 万行代码,开发了一款 QClaw / OpenClaw 的UGC游戏插件,这可能是人类跟 Agents 交互的新范式,插件已完全开源,有需要的欢迎自取~我天天用,用着用着我就在思考,Agent 产品现在的交互体验,基本都一个样。

QcloudCommunity的博客 1198

一文搞懂Hermes:新顶流Agent如何从经验中自我进化

Voyager 是一个能在 Minecraft 中自主探索、学习技能、无限积累能力的 AI Agent,它提出了 "Skill Library"(技能库)的概念——Agent 将成功的行为序列编码为可复用的技能函数,存储在一个持续增长的代码库中。如果 Skill 的名称和描述不够精准,或者用户的任务描述与 Skill 的触发条件有语义差距,Agent 可能会错过相关的 Skill。如果进程在写入过程中崩溃,目标文件要么是旧内容(还没被替换),要么是新内容(替换已完成),绝不会出现写了一半的损坏文件。

QcloudCommunity的博客 2637

自掏腰包一万元,拥抱AI这一年,我的工具、实践和思考

其实也很好理解,过往的每个领域(比如前端、后端、设计、测试等等)都主要是这个领域的从业者在为它添砖加瓦,但是大模型时代的 AI 应用领域却几乎是所有使用 AI 的人类一起在迭代,无分领域,无分文理,无分老少。因为每个时期的 AI 都有着不同的特点,很多时候当我费尽心思去钻研,自以为有点弄明白 AI 应该怎么玩的时候,基座模型和行业范式常常就会迎来颠覆式的变革,很多过往的经验都会倾覆,然后只能从头再来。过去一年多,被热议的 AI 范式大概是沿着四个阶段递进演化,每一个阶段其实都在解决前一个阶段的核心问题。

QcloudCommunity的博客 627

办公Agent的CI/CD时刻到来了

核心观点是:企业给员工配了一堆 AI 工具,试点跑了几百个,但真正拖慢 AI 转型速度的瓶颈不在模型能力,在"最后一公里":AI 输出和实际工作流之间的那道鸿沟。代码写完,打个 tar 包,开 FTP 传到服务器上,SSH 进去解压,改配置文件,重启服务,刷一下页面祈祷别 500。你复制,切窗口,粘贴到腾讯文档里,发现 Markdown 格式全乱了,手动调标题层级,代码块重新标记语言类型,表格散架了重排一遍。模型是越来越聪明了,但"生成"到"落地"之间那段路,还是你自己在走,一步一步,手动搬运。

QcloudCommunity的博客 608

4亿token买来5个教训:让6个AI Agent连写4天代码发生了什么?

Watchdog 检测到崩溃 → 启动诊断 Agent 分析原因 → 诊断 Agent 跑满 20 轮没搞定 → Watchdog 判定“已修复”,重启系统 → 重启的系统因为诊断 Agent 留下的环境变量被继承,连续 3 次拒绝启动 → 触发连续失败保护退出 → Watchdog 第 3 次巡检,发现进程和记录文件都没了,尝试手动重启,自己也停了。启动前我翻了论文、做了架构设计、写了监控+修复异常的脚本。这个发现让我的情绪从沮丧变成了兴奋——不是那种"终于修好了"的释然,是"我找到根因了"的快感。

QcloudCommunity的博客 584

赛博斗蛐蛐:9大模型决战三国志,天命在谁?

我猜是这样的,当Gemini面临决策的时候,一系列关键词比如 守城,劣势,粮草,三国等等,在语义层面的关联性中LLM发现了竖壁清野这个关键词概率非常高,所以以此为策略,然后再根据这个策略完美执行操作。MiMo 的外交是三方中最精明的。Kimi作为国产模型,也同样颠覆了我对他的看法,最后的比赛他甚至一度是优势者,存在很多夺冠的可能性,要知道他的对手可是claude和gemini,而他经常出兵慢,回过头来想想或许正是他的策略,毕竟中后期他的优势都来自于稳健的发展和较少的战斗频率(和claude比).

QcloudCommunity的博客 875

Claude Code是怎么知道你在骂他的?这 12 条发现值得关注

确实存在——5,500+ 行,集成了消息队列、工具装配、MCP 编排、会话状态、权限、分析、文件持久化和优雅关闭,基本上一个文件干了所有事。对抗虚假声明——"不要在输出显示失败时声称所有测试通过,不要压缩或简化失败的检查来制造绿色结果"。完整的 KAIROS 是一个持续驻留的守护进程,能感知你在不在电脑前、主动寻找有用的工作做,更像是住在终端里的全职同事。源码里藏着一个叫 "Buddy" 的电子宠物系统,完整度令人惊讶——这不是一个 TODO,而是一个从数值系统到 ASCII 动画都实现了的完整功能。

QcloudCommunity的博客 702

逆向深扒Claude Code源码,我发现了什么!?

Anthropic 内部用户获得更严格的质量控制 prompt、更好的验证机制(独立 Verification Agent)、以及针对 model 弱点的专门对策(如 Capybara v8 的 29-30% 错误声明率对策)。这不是代码混乱的标志——它是整个 Agent Loop 的心脏,所有的流式处理、工具调度、上下文压缩、子代理管理都在这个文件中协调。这种"胖核心"设计是刻意的:保持核心循环的原子性,避免分散到多个模块导致的协调复杂度。核心价值:Fork 代理的工具输出不会回到主代理的上下文窗口。

QcloudCommunity的博客 893

一文讲透如何构建Harness——六大组件全解析

本文将从"裸模型的四个硬伤"出发,逐一拆解 Harness 的六大组件——文件系统、Bash + 沙箱、记忆(AGENTS.md)、Web Search + MCP、上下文工程、编排 + Hooks——带你看清 AI Agent 真正的竞争壁垒,不在模型层,而在 Harness 层。如果你用过 Agent 做复杂任务,你一定有过这样的体验:一开始 Agent 的表现很好,但随着对话变长,它开始"变笨"——遗忘之前的约定,重复之前犯过的错误,甚至对同一个问题给出前后矛盾的回答。对于简单的问答场景,这无所谓。

QcloudCommunity的博客 761

Harness Engineering 来了,SDD 还有意义吗?

他们的解法是把「品味」编码进规则,然后用一个定期运行的「doc-gardening」Agent 自动扫描漂移、发起修复 PR——「技术债务就像一笔高息贷款,不断地以小额贷款的方式偿还,总比让债务不断累积要好」。代码仓库本地的、已版本化的工件,才是 Agent 所能看到的全部。在 Vibe Coding 模式下(即不做规划、随意向 AI 提需求的开发方式),大量设计决策、跨服务约定、「为什么不选另一个方案」的讨论,全部停留在一次性的 AI 对话里——下一个人,或者下一次 AI 会话,完全无从获取。

QcloudCommunity的博客 419

零废话!一文讲透从0构建AI Agent

每个工具都要写一套"定义→解析→执行"的胶水代码。上下文管理就是在"记住足够多"和"别超标"之间找平衡,常见策略包括滑动窗口、摘要压缩、RAG 检索增强。上下文窗口是 Agent 的"工作记忆",但它有硬性限制。LLM 负责"动脑"决策,代码负责"动手"执行。这是从"聊天机器人"进化到"Agent"的关键一步。每次调 API 都把完整对话历史发过去,LLM 本身是无状态的,"记忆"完全靠客户端的数组模拟。这样 Agent 一开始就知道自己"在哪里"、"手头有什么",不需要先花一轮工具调用去探索环境。

QcloudCommunity的博客 712

距离AI把小编我裁掉还有72小时

这是一个基于 OpenClaw 开源生态打造的本地化 AI Agent 助手,已于上周开启全量公测,无需复杂配置,三步即可上手,自带安全防护,支持微信直连绑定,内置多款优质国产大模型,现阶段也是完全免费使用,基本上前面提到过的痛点都可以靠它解决。对了,这里特别强调一点,上面的截图让产品同事汗流浃背,再三找我确认 QClaw 思考过程中优美的“草”字说法,不会是默认出现的吧?AI 好,AI 得学,但更重要的是,在你的工作和生活里,哪些东西是能结构化地被 AI 所接入的,不要死守着那些脏活累活不放。

QcloudCommunity的博客 674
上一篇: 我,前端,不想卷技术了……卷下整洁架构
下一篇: 腾讯工作13年之所思所想,那些优秀程序员的共性特征
腾讯云开发者
腾讯云开发者 企业官方账号 企业官方账号
博客等级 码龄10年 6291粉丝 1962原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值