Chatper 11 字节码

通过将行为编码成虚拟机指令，而使其具备数据的灵活性。

 

解释器模式（慢）：

class Expression
{

public:
  virtual ~Expression() {}
  virtual double eva luate() = 0;

};

class NumberExpression : public Expression
{

public:
  NumberExpression(double value)
  : value_(value)
  {}
 
  virtual double eva luate()
  {
    return value_;
  }

private:
  double value_;

};

class AdditionExpression : public Expression
{

public:
  AdditionExpression(Expression* left, Expression* right)
  : left_(left),
    right_(right)
  {}

  virtual double eva luate()
  {
    // eva luate the operands.
    double left = left_->eva luate();
    double right = right_->eva luate();
 
    // Add them.
    return left + right;
  } 

private:
  Expression* left_;
  Expression* right_;

};

 

字节码模式：

当你的游戏需要定义大量行为，可以指定一套指令集，虚拟机逐条执行指令栈上的这些指令。通过组合指令，即可完成很多高级指令。

enum Instruction
{
  INST_SET_HEALTH = 0x00,
  INST_SET_WISDOM = 0x01,
  INST_SET_AGILITY = 0x02,
  INST_GET_HEALTH = 0x03,
  INST_GET_WISDOM = 0x04,
  INST_GET_AGILITY = 0x05,
  INST_PLAY_SOUND = 0x06,
  INST_SPAWN_PARTICLES = 0x07,
  INST_LITERAL = 0x08,
  INST_ADD = 0X09,
};

class VM
{

public:
  VM()
  : stackSize_(0)
  {}
 
  void interpret(char bytecode[], int size)
  {
    for (int i = 0; i < size; i++)
    {
      char instruction = bytecode[i];
      switch (instruction)
      {
         case INST_SET_HEALTH:
         {
              int amount = pop();
              int wizard = pop();
              setHealth(wizard, amount);
              break;
         } 

         case INST_SET_WISDOM:
         case INST_SET_AGILITY:
         // Same as above... 

         case INST_GET_HEALTH:
         {
              int wizard = pop();
              push(getHealth(wizard));
              break;
         } 

         case INST_GET_WISDOM:
         case INST_GET_AGILITY:
         // You get the idea...

         case INST_PLAY_SOUND:
              playSound(SOUND_BANG);
              break;

         case INST_SPAWN_PARTICLES:
              spawnParticles(PARTICLE_FLAME);
              break;

         case INST_LITERAL:
         {
              // Read the next byte from the bytecode.
              int value = bytecode[++i];
              push(value);
              break;
         }
 
         case INST_ADD:
         {
              int b = pop();
              int a = pop();
              push(a + b);
              break;
         }
    }
  } 

private:
     void push(int value)
     {
         // Check for stack overflow.
         assert(stackSize_ < MAX_STACK);
         stack_[stackSize_++] = value;
     }

     int pop()
     {
         // Make sure the stack isn't empty.
         assert(stackSize_ > 0);
         return stack_[--stackSize_];
     }

     static const int MAX_STACK = 128;
     int stackSize_;
     int stack_[MAX_STACK]; 

};

 

指令的组合：

setHealth(0, getHealth(0) + (getAgility(0) + getWisdom(0)) / 2);

翻译为：

LITERAL 0    [0]            # Wizard index
LITERAL 0    [0, 0]         # Wizard index
GET_HEALTH   [0, 45]        # getHealth()
LITERAL 0    [0, 45, 0]     # Wizard index
GET_AGILITY  [0, 45, 7]     # getAgility()
LITERAL 0    [0, 45, 7, 0]  # Wizard index
GET_WISDOM   [0, 45, 7, 11] # getWisdom()
ADD          [0, 45, 18]    # Add agility and wisdom
LITERAL 2    [0, 45, 18, 2] # Divisor
DIVIDE       [0, 45, 9]     # Average agility and wisdom
ADD          [0, 54]        # Add average to current health
SET_HEALTH   []             # Set health to result

 

基于栈的虚拟机：

1．  指令小（通常一字节）；

2．  指令数多

基于寄存器的虚拟机：

1. 指令大（Lua虚拟机每个指令占用32位，6位存储指令类型，剩下的存储参数）；
2. 指令数少

值的表示：

1. 坚持使用单一数据类型 or
2. 使用带标签的联合体

enum ValueType
{
  TYPE_INT,
  TYPE_DOUBLE,
  TYPE_STRING
}; 

struct Value
{
  ValueType type;

  union
  {