MisakaTang's Blog

Scanning

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

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

Token类：

class Token {
  final TokenType type;
  final String lexeme;
  final Object literal;
  final int line; 
}

TokenType:

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
}

处理方式：

private void scanToken() {
  char c = advance();
  switch (c) {
    case '(': addToken(LEFT_PAREN); break;      
    case '!':
      addToken(match('=') ? BANG_EQUAL : BANG);
      break;
  }
}

Representing Code

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

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

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

语言语法的BNF表示：

expression     → literal
               | unary
               | binary
               | grouping ;

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

Parsing Expressions

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

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

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

递归下降核心步骤：

  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;
    }
  }

  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的实现如下：

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列表直接进行求值，一个操作符遍历的例子：

@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

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

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

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

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

Control Flow

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

IF

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求值：

@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 本身实现这一点。相反，我们将其包装在一个新的类中。

class LoxFunction implements LoxCallable {
  private final Stmt.Function declaration;
  LoxFunction(Stmt.Function declaration) {
    this.declaration = declaration;
  }
}

call的实现如下：

@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

类的解析方式：

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来实现类的初始化：

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);
    }
}

类的实例包含：

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，今年也来到了工作的第四个年头。个人感觉自己还是挺幸运的，赶上了互联网的末班车蹭到了几年经验，现在也还没有失业在家。也有时间做自己喜欢的事。

阿里云原生应用脚手架攀爬事故小记

发表于 2023-12-15 更新于 2025-01-04 分类于技术

起源

这个事故来源于某个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模块明明需要这个配置却没有填写。属实神秘。