Scanning

任何编译器或解释器的第一步都是扫描。扫描器将原始源代码作为一系列字符输入,并将其分组为一系列我们称之为标记的块。这些是构成语言语法的有意义的“单词”和“标点符号”。

这一阶段的重点是把字符数组转换成token序列,通过“双指针”的方式逐步消耗字符。

Token类:

1
2
3
4
5
6
class Token {
final TokenType type;
final String lexeme;
final Object literal;
final int line;
}

TokenType:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
enum TokenType {
// Single-character tokens.
LEFT_PAREN, RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE,
COMMA, DOT, MINUS, PLUS, SEMICOLON, SLASH, STAR,

// One or two character tokens.
BANG, BANG_EQUAL,
EQUAL, EQUAL_EQUAL,
GREATER, GREATER_EQUAL,
LESS, LESS_EQUAL,

// Literals.
IDENTIFIER, STRING, NUMBER,

// Keywords.
AND, CLASS, ELSE, FALSE, FUN, FOR, IF, NIL, OR,
PRINT, RETURN, SUPER, THIS, TRUE, VAR, WHILE,

EOF
}

处理方式:

1
2
3
4
5
6
7
8
9
private void scanToken() {
char c = advance();
switch (c) {
case '(': addToken(LEFT_PAREN); break;
case '!':
addToken(match('=') ? BANG_EQUAL : BANG);
break;
}
}

Representing Code

在上一章中,我们将原始源代码作为字符串,并将其转换为稍微更高级的表示形式:一系列标记。我们将在下一章中编写的解析器将获取这些标记,并再次将它们转换为更丰富、更复杂的表示形式。

在我们能够生成该表示之前,我们需要定义它。

我们需要一把更大的锤子,而那把锤子就是上下文无关文法(CFG)。它是形式文法工具箱中的下一个最重要的工具。形式文法使用一组称为“字母表”的原子片段。然后它定义了一组通常是无限的“字符串”,这些字符串“属于”文法。每个字符串都是字母表中的“字母”序列。

语言语法的BNF表示:

1
2
3
4
5
6
7
8
9
10
11
expression     → literal
| unary
| binary
| grouping ;

literal → NUMBER | STRING | "true" | "false" | "nil" ;
grouping → "(" expression ")" ;
unary → ( "-" | "!" ) expression ;
binary → expression operator expression ;
operator → "==" | "!=" | "<" | "<=" | ">" | ">="
| "+" | "-" | "*" | "/" ;

Parsing Expressions

在解析之前除了语法规则还需要确定关键字的运算优先级和结合性(左结合、右结合)。

将优先级加入语法规则之后变成下面的形式:

1
2
3
4
5
6
7
8
9
expression     → equality ;
equality → comparison ( ( "!=" | "==" ) comparison )* ;
comparison → term ( ( ">" | ">=" | "<" | "<=" ) term )* ;
term → factor ( ( "-" | "+" ) factor )* ;
factor → unary ( ( "/" | "*" ) unary )* ;
unary → ( "!" | "-" ) unary
| primary ;
primary → NUMBER | STRING | "true" | "false" | "nil"
| "(" expression ")" ;

Recursive Descent Parsing

递归下降核心步骤:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  private Stmt declaration() {
try {
//> Classes match-class
if (match(CLASS)) return classDeclaration();
//< Classes match-class
//> Functions match-fun
if (match(FUN)) return function("function");
//< Functions match-fun
if (match(VAR)) return varDeclaration();

return statement();
} catch (ParseError error) {
synchronize();
return null;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
  private Stmt classDeclaration() {
Token name = consume(IDENTIFIER, "Expect class name.");
//> Inheritance parse-superclass

Expr.Variable superclass = null;
if (match(LESS)) {
consume(IDENTIFIER, "Expect superclass name.");
superclass = new Expr.Variable(previous());
}

//< Inheritance parse-superclass
consume(LEFT_BRACE, "Expect '{' before class body.");

List<Stmt.Function> methods = new ArrayList<>();
while (!check(RIGHT_BRACE) && !isAtEnd()) {
methods.add(function("method"));
}

consume(RIGHT_BRACE, "Expect '}' after class body.");

/* Classes parse-class-declaration < Inheritance construct-class-ast
return new Stmt.Class(name, methods);
*/
//> Inheritance construct-class-ast
return new Stmt.Class(name, superclass, methods);
//< Inheritance construct-class-ast
}

解析的结果是返回一个语句列表:

1
List<Stmt> statements = parser.parse();

stmt类是一个抽象类,被各个具体的语法声明实现,class的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static class Class extends Stmt {
Class(Token name,
Expr.Variable superclass,
List<Stmt.Function> methods) {
this.name = name;
this.superclass = superclass;
this.methods = methods;
}

@Override
<R> R accept(Visitor<R> visitor) {
return visitor.visitClassStmt(this);
}

final Token name;
final Expr.Variable superclass;
final List<Stmt.Function> methods;
}

Evaluating Expressions

语言实现有各种方式让计算机执行用户源代码的命令。它们可以将其编译成机器码,翻译成另一种高级语言,或将其简化为某种字节码格式,以便虚拟机运行。然而,对于我们的第一个解释器,我们将选择最简单、最直接的路径,直接执行语法树。

使用访问者模式来遍历上面产生的stmt列表直接进行求值,一个操作符遍历的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
public Object visitBinaryExpr(Expr.Binary expr) {
Object left = evaluate(expr.left);
Object right = evaluate(expr.right);

switch (expr.operator.type) {
case MINUS:
return (double)left - (double)right;
case SLASH:
return (double)left / (double)right;
case STAR:
return (double)left * (double)right;
}

// Unreachable.
return null;
}

Statements and State

为了支持绑定,我们的解释器需要内部状态。当你在程序开头定义一个变量并在结尾处使用它时,解释器必须在此期间保留该变量的值。因此,在本章中,我们将赋予我们的解释器一个不仅能处理,还能记住的大脑。

状态和语句是相辅相成的。由于语句根据定义不会评估为一个值,它们需要做一些其他的事情才能发挥作用。这个事情被称为副作用。它可能意味着产生用户可见的输出或修改解释器中的一些状态,以便以后可以检测到。后者使它们非常适合定义变量或其他命名实体。

Environments

将变量与值关联的绑定需要存储在某个地方。自从Lisp的发明者发明了括号以来,这种数据结构就被称为环境。

1
2
3
class Environment {
private final Map<String, Object> values = new HashMap<>();
}

Scope

作用域定义了一个区域,其中一个名称映射到某个实体。多个作用域使得同一个名称可以在不同的上下文中指代不同的事物。

词法作用域(或较少听到的静态作用域)是一种特定的作用域风格,程序文本本身显示了作用域的开始和结束位置。

通过对求值环境增加嵌套来实现作用域的效果:

1
2
3
4
class Environment {
final Environment enclosing; // 求值环境嵌套
private final Map<String, Object> values = new HashMap<>();
}

Control Flow

目前,我们的解释器只不过是一个计算器。Lox程序只能在完成之前做固定数量的工作。要使其运行时间加倍,必须使源代码长度加倍。我们即将解决这个问题。在本章中,我们的解释器迈出了向编程语言主要联赛迈进的重要一步:图灵完备性。

IF

1
2
3
4
5
6
7
8
9
10
11
12
13
private Stmt ifStatement() {
consume(LEFT_PAREN, "Expect '(' after 'if'.");
Expr condition = expression();
consume(RIGHT_PAREN, "Expect ')' after if condition.");

Stmt thenBranch = statement();
Stmt elseBranch = null;
if (match(ELSE)) {
elseBranch = statement();
}

return new Stmt.If(condition, thenBranch, elseBranch);
}

如何对IF求值:

1
2
3
4
5
6
7
8
9
@Override
public Void visitIfStmt(Stmt.If stmt) {
if (isTruthy(evaluate(stmt.condition))) {
execute(stmt.thenBranch);
} else if (stmt.elseBranch != null) {
execute(stmt.elseBranch);
}
return null;
}

Functions

一旦我们准备好被调用者和参数,剩下的就是执行调用。我们通过将被调用者转换为LoxCallable,然后在其上调用一个 call() 方法来实现这一点。任何可以像函数一样被调用的Lox对象的Java表示都将实现这个接口。这包括自定义函数,当然也包括类对象,因为类被“调用”来构造新实例。

1
2
3
interface LoxCallable {
Object call(Interpreter interpreter, List<Object> arguments);
}

Function Objects

这基本上就是 Stmt.Function 类的作用。我们能不能直接使用它?几乎可以,但还不够。我们还需要一个实现 LoxCallable 接口的类,这样我们才能调用它。我们不希望解释器的运行时阶段渗入前端的语法类,所以我们不希望 Stmt.Function 本身实现这一点。相反,我们将其包装在一个新的类中。

1
2
3
4
5
6
class LoxFunction implements LoxCallable {
private final Stmt.Function declaration;
LoxFunction(Stmt.Function declaration) {
this.declaration = declaration;
}
}

call的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
@Override
public Object call(Interpreter interpreter,
List<Object> arguments) {
Environment environment = new Environment(interpreter.globals);
for (int i = 0; i < declaration.params.size(); i++) {
environment.define(declaration.params.get(i).lexeme,
arguments.get(i));
}

interpreter.executeBlock(declaration.body, environment);
return null;
}

我们在每次调用时创建一个新的环境,而不是在函数声明时。我们之前看到的方法就是这样做的。在调用开始时,它创建一个新的环境。然后它以步调一致地遍历参数和参数列表。对于每一对,它都会使用参数的名称创建一个新的变量,并将其绑定到参数的值。

Classes

类的解析方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
private Stmt classDeclaration() {
Token name = consume(IDENTIFIER, "Expect class name.");
consume(LEFT_BRACE, "Expect '{' before class body.");

List<Stmt.Function> methods = new ArrayList<>();
while (!check(RIGHT_BRACE) && !isAtEnd()) {
methods.add(function("method"));
}

consume(RIGHT_BRACE, "Expect '}' after class body.");

return new Stmt.Class(name, methods);
}

Creating Instances

使用callable来实现类的初始化:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class LoxClass implements LoxCallable {
final String name;
final LoxClass superclass; // 类的继承
private final Map<String, LoxFunction> methods; // 类方法

@Override
public Object call(Interpreter interpreter,
List<Object> arguments) {
LoxInstance instance = new LoxInstance(this);
// 构造器约定为特殊的函数 名为init
LoxFunction initializer = findMethod("init");
if (initializer != null) {
initializer.bind(instance).call(interpreter, arguments);
}
}

类的实例包含:

1
2
3
4
5
6
class LoxInstance {

private LoxClass klass;

private final Map<String, Object> fields = new HashMap<>(); // 类属性
}

开始

随着年龄的增长,似乎也到了要写日记的年纪了(正经人谁口口口)。况且今年算是一个特殊的年份,呐,就来回顾一下今年的种种罢。

健康

从健康来回顾是一个不错的开始。今年的生活节奏也有了很大的变化,虽然离年初的目标仍有一段距离,但是也值得记录一下。

起源

经过去年一年在奋斗逼之都的摧残之后,已经意识到了健康生活的重要性。在健康学习到150岁 - 人体系统调优不完全指南程序员延寿指南 | A programmer’s guide to live longer的契机下,决定好好调整今年的生活作息。

作息

最重要的当然是日常作息了,主要的优化方式就是从12点之后睡觉改为11点入睡,7点起床(当然也和工作时间调整有关)。

喝水

虽然看上去是一个不起眼的优化,但是回过头来看应该是本年度最有性价比的改动了。在下载了喝水app并严格执行每日喝水目标之后确实能感觉到身体的变化。

减肥&&锻炼

从奋斗逼之都被赶回来的时候已经接近90kg了,上称的时候确实有点不能接受。所以今年最大的目标就是减肥。然而作为一个没有毅力的人(不然也不会到达这个体重),自然是要选择easy path了。在经过仔细调研之后决定第一步就是先喝水,于是就有了用app强制喝水的故事。一开始确实非常的难受,需要一直跑厕所,但是还好那段时间在家里蹲所以也没有什么大碍。在大概经过1个月之后身体就已经可以适应正常的饮水量了。而喝水的另一个好处,作为民科的我的想法是:饭前喝水可以一定程度稀释胰岛素水平(加上占据胃容量),可以在更少饮食的情况下不那么饥饿。

减肥最重要的当然是饮食了,对此我的策略一开始是:早饭正常吃,中午一个板烧鸡腿堡,晚上一口饭+吃菜。由于前置了一个月的喝水计划,所以在执行到这里的时候并没有非常的折磨,当然晚上也是会饿的,所以也买了一堆牛肉干来尝试,最后的选择是下面这款:

由于提早了睡眠时间,所以晚上饥饿的程度也不会那么严重,总体来说减少摄入在早睡和多喝水的优化下比较轻松就达成了。而目前我的策略是所谓的8+16进食法:早饭不吃一杯牛奶,中午正常吃,晚饭不吃饭光吃菜。

锻炼的部分,一开始只是在家里做简单的深蹲。后面改为了骑车上班(15km)+动感单车的形式,夏秋两季的运动量是最多的。感觉最好的还是省了两个月的油钱,还是在油价的最高点(不是。


在运动之于最大的收获就是发现了屌丝神器迪卡侬,已经成为忠实用户了。

所以在达成了75kg目标的今天还是非常满意的(虽然年初的目标是70kg)。

游戏

今年在搬进新家之后买了太差了电视和ps5,终于可以好好的玩游戏了~ 而今年最多的游戏时光也是在ps5上面。但是我还是要说ps5会员你就是个寄吧。纯纯的垃圾(特别是大镖客出会免)

异度之刃3

在过年的时候作为出门做客消遣的游戏算是狠狠的玩了一阵,非常的沉迷非常的好玩,今年过年玩xb2。

个人评价:系统、地图非常不错,吊打国内开放世界手游。但是受限于ns的垃圾机能,人物大部分时间马赛克严重,非常影响游玩。剧本方面主角太多,非常菜市场,没有能够完美塑造全部的角色或者重点塑造一对男女主,少点味。

而且感觉xb2,3的系统都非常适合手游化甚至可以达到好玩的程度,不知道为什么日厂不做。

死亡搁浅

作为ps5会免的第一个体验的游戏,只能说画质非常的不错。但是放下之后就很难再拿起来玩了。

战神5

画质非常炫酷,作为ps5的扛鼎之作,虽然战斗系统方面还是4的那一套做了迭代。但是总体流程玩下来很爽快,不亏。好评。

对马岛之魂

ps5会免游戏,在多年不吃育碧罐头之后再来品味甚至别有一番风味。战斗之后的振刀收刀非常的帅气,很有剑戟片的感觉。风景也很不错。好评。

FF16

年度答辩之作,对rpg的最大侮辱,吉田还是滚回去做ff14吧。

美末1

在另一篇文章中已经品鉴过了,好评。

荒野大镖客

好玩,但是后期有点没耐心了。而且剧本走向悲剧,在不那么快乐的2023年玩起来有点压抑。

十三机兵防卫圈

自己买了盘刚要玩就进入会免。。二刷,希望哪天又失忆了可以再玩一遍。 好好评。

王国之泪

对旷野之息的迭代,感觉其实王泪才是老任一开始想要做到的样子。好玩,但是机能太垃圾了,玩到一半搁置。等ns2再玩。

阅读

Crafting Interpreters

写编译器和解释器的书,从0开始。非常适合新手,而且有免费的HTML版本,搭配双语翻译效果绝佳。今年最值得推荐的书。

可能性的艺术 比较政治学

适合作为政治学入门书籍观看,还不错(看的原因是据说被ban了,逆反)。

计算 吴瀚清

新书,第一部分感觉可以和《什么是数学》《数学 它的内容方法和意义》一起观看,属于数学简史类型的科普。

刘擎西方现代思想讲义

科普哲学思想的书,图一乐之外也能大致了解各个思想学派和发展路径。

工作、消费主义和新穷人

没什么印象,简单来说工作只是资本主义对人的一种规训,不努力工作,薅资本家羊毛才是正途。

置身之内

知道了地方和中央也不是铁板一块,地方只会在拿着上面的要求一顿排列组合之后选择电阻最低的路径(easy path)来实现上面的KPI和自己的目标。

天朝的崩溃

在绝对的科技优势面前任何的努力或者忠诚都是无用的,无论你是文官还是将军,在看到英军战斗的那一刻就能知道,时代已经变了而你无能为力。你能做的只有一路瞒到国务院或者议和止损保住自己的狗命。

购物

石头G10S

搬了新家之后购入了扫地机器人,总体来说非常不错,很省心。

PS5

值得,就是夏天过热自动关机有点绷不住。

群晖+Apple TV

看蓝光原盘的电影很爽。

Apple Watch SE

为了记录运动买的,总体不错,就是一天一充还是有点接受不了。

升降桌

买了电机和桌面自己组装的,现在已经习惯了站立工作。

工作

今年最值得说的可能就是工作吧,但是现在的我来说,觉得还是要将其放到更低的位置(生活更重要)。

虽然一想起来可能有很多话要讲,但是最后写出来的可能也就那样:

从去年10月被奋斗逼公司卸磨杀驴之后在杭州并找不到工作,然后灰溜溜回家过年。年前机缘巧合面了现在这家老家的公司,干到现在也快一年了。虽然薪资对半砍了,但是获得了8:30上班,5:30下班的清闲日子,也才有了健康生活还能锻炼的一年。

作为一个三年三家公司,四年四家的loser,今年也来到了工作的第四个年头。个人感觉自己还是挺幸运的,赶上了互联网的末班车蹭到了几年经验,现在也还没有失业在家。也有时间做自己喜欢的事。

起源

这个事故来源于某个PHPer转职Javaer时发生的灵异事件,在云原生应用脚手架中选择了应用架构为MVC架构之后生成的脚手架打包的jar包启动之后无法访问Controller中配置的路径。

现象

据某PHPer所说,在IDEA中直接启动项目没有问题但是打包成jar之后就访问不到controller中定义的请求路径了。

第一次排障

面对这个bug的第一直觉就是maven打包有问题,应该是代码没有打包进去。但是在解压jar包之后发现代码确实已经在lib文件夹里,而且解压之后也能找到对应的class文件。

这时候怀疑对象就转到了spring bean装配有问题上,于是便使用ApplicationContext的getBean方法尝试在spring启动完成之后获取basicController的bean,然后发现果然是bean并没有成功装载。

于是死马当活马医的给启动类加上了@ComponentScan注解尝试抢救一下,结果抢救失败仍然没有装载。

这时候已经是万策尽放弃治疗了,直接劝退了PHPer。

第二次排障

一天之后这个bug迎来了专家会诊,某Java领域大神准备对其进行一番操作,但是失败了。于是又将项目clone下来看了一看,因为病因是IDEA启动时可以正确加载而maven打包之后有问题,于是又将嫌疑人锁定到了maven上,但是根据本人浅薄的maven知识并没有发现配置有任何有问题的地方。

于是又开始死马当活马医,准备使用SPI机制给spring强制注入bean试试。在spring.factories文件中配置 org.springframework.boot.autoconfigure.EnableAutoConfiguration 为controller之后发现IDEA正常启动。但是maven打包时springboot启动直接报错:找不到该class文件。

嗯,有错误是好事,说明并不是spring装配的时候有问题而是项目启动时根本没有这个class的文件。这时候随便找了一个自己项目里的SDK jar包解压看了一下目录,又看了一下多模块中web模块的jar包:BOOT-INF。凶手已经找到了。

破案

按照配置给web模块和service模块增加了<skip>true</skip>配置,跳过了springboot打包插件,项目正常启动并可以访问请求路径。

很明显,在创建模板的时候pom.xml直接被复制了三份放到了三个模块当中,导致了spring-boot-maven-plugin插件把三个子项目都打包成了可部署的jar包。

一开始解压jar包的时候并没有关注到这个细节导致多次抢救无效。

令人疑惑的是 https://github.com/alibaba/cloud-native-app-initializer/issues/65 官方仓库里竟然有这种issue,但是<skip>true</skip>在最外层完全是反作用导致打包失败,而内部web模块明明需要这个配置却没有填写。属实神秘。

0%