public void go() {

    try {
      vm.play(program);

      result = program.getResult();

      // 如果存在 Exception 或 Revert
      // 重要提示：
      // Exception 是在 program 的设置中抛出的。 
      // Revert 是由虚拟机编译器提前写入字节码中的，通过跳转（jump）触发。 
      if (result.getException() != null || result.isRevert()) {

        if (result.getException() != null) {
          // 如果是 Exception，将消耗所有的 Energy
          program.spendAllEnergy();
          // 设置 runtimeError 字段以指示错误内容
          runtimeError = result.getException().getMessage();
          // 抛出异常
          throw result.getException();
        } else {
          // 如果是 Revert 且没有 Exception，只需设置 runtimeError 字段来指示错误内容。 
          runtimeError = "REVERT opcode executed";
        }

        // 只要发生 Exception 或 Revert，就不会执行 commit。虚拟机执行过程中的所有状态变更都不会落盘（保存）。 

      } else {
        // 如果没有 Exception 和 Revert，则执行 commit，虚拟机执行期间的所有状态变更都会落盘。 
        deposit.commit();
      }
    }
    catch (JVMStackOverFlowException e) {
        // TVM 或 JVM 发生 JVMStackOverFlowException，标记异常。 
        // JVMStackOverFlowException 只会在 go() 中被捕获，这通常发生在通过 call 调用的合约中，或者被循环调用的 JVMStackOverFlowException。它不会在 play() 中被捕获，只能在这里被捕获。 
        result.setException(e);
        runtimeError = result.getException().getMessage();
    }
    // 捕获所有可能抛出的内容 (Throwable)
    catch (Throwable e) {
      // 如果异常未知，则进行标记。 
      if (Objects.isNull(result.getException())) {
        result.setException(new RuntimeException("Unknown Throwable"));
      }
      // 确保 runtimeError 字段有值
      if (StringUtils.isEmpty(runtimeError)) {
        runtimeError = result.getException().getMessage();
      }

    }
  }
  // 执行完 go() 函数后，将不再使用 result.getException()，而是将 runtimeError 填充到 transactionInfo 中。

// play() 会捕获所有的 RuntimeException，并抛出 JVMStackOverFlowException（包括 StackOverflowError）
  public void play(Program program) {
    try {
      // 虚拟机的逐指令（op）执行循环
      while (!program.isStopped()) {
        // step() 会先捕获 RuntimeException，扣除 Energy，然后再抛出异常。 
        // 此时，它会停止 step()，先捕获 RuntimeException，然后扣除 Energy。 
        this.step(program);
      }
    }
    catch (JVMStackOverFlowException e) {
      // 抛出 JVMStackOverFlowException 异常
      throw new JVMStackOverFlowException();
    } catch (RuntimeException e) {
      if (StringUtils.isEmpty(e.getMessage())) {
        // 将 step() 函数抛出的 RuntimeException 放入 program.result.exception 中，而不是向外抛出。 
        program.setRuntimeFailure(new RuntimeException("Unknown Exception"));
      } else {
        program.setRuntimeFailure(e);
      }
    } catch (StackOverflowError soe) {
      // 抛出 JVMStackOverFlowException 异常
      throw new JVMStackOverFlowException();
    } finally {
    }
  }

// step() 会先捕获 RuntimeException，扣除 Energy，然后再向外抛出
// 注意，这里抛出的异常全是 RuntimeException
public void step(Program program) {
  try {
    // 如果 op 非法，则抛出 IllegalOperationException。实际上，Invalid 是提前写入字节码中的，assert 类型的操作会跳转（jump）到 invalid。 
    OpCode op = OpCode.code(program.getCurrentOp());
    if (op == null) {
      throw Program.Exception.invalidOpCode(program.getCurrentOp());
    }
    switch (op) {
      // 1. 计算该 op 所需的 Energy

      // 2. 如果扣除时余额不足，则抛出 OutOfEnergyException
      program.spendEnergy(energyCost, op.name());
 
      // 3. 检测 CPU 时间，若超时则抛出 OutOfResourceException
      program.checkCPUTimeLimit(op.name());

      // 4. OP 的实际执行
      // 这里的重点是 CREATE 指令和 CALL 指令。 
      // 内部的执行步骤都非常相似： 
      // 4.1 当调用深度（depth）达到上限时，会将 0 压入栈（push 0 to stack），然后返回
      // 4.2 如果携带了 value 但余额不足，则将 0 压入栈，然后返回
      // 4.3 如果携带了 value 且转账失败，则抛出 RuntimeException 类型的异常。 
      // 4.4 （需要执行时）执行虚拟机
      // 4.5 若虚拟机执行结果发生异常：不会向外抛出异常，只会扣除所有的 Energy，并将 0 压入栈。 
      // 4.6 若虚拟机执行结果发生 revert：会退还 Energy，并将 0 压入栈。 
      // 4.7 执行成功：会退还 Energy，并将 1 压入栈。

      // 注意：
      // 发生异常后，到底是执行 Revert 操作还是其他处理，是由虚拟机的字节码决定的。有些会触发 revert，有些会触发 invalid。 
      // callToPrecompile 失败时，会直接抛出 RuntimeException 类型的异常
   }
 } catch (RuntimeException e) {
   // step() 会先捕获 RuntimeException，扣除所有的 Energy，然后再抛出
   program.spendAllEnergy();
   // 停止循环
   program.stop();
    // 抛出异常
    throw e;
  } finally {
  }
}