{

public:

virtual ~Expression() {}

virtual double evaluate() = 0;

{

public:

NumberExpression(double value)

: value_(value)

{}

virtual double evaluate()

{

return value_;

}

private:

double value_;

{

public:

AdditionExpression(Expression* left, Expression* right)

: left_(left),

right_(right)

{}

virtual double evaluate()

{

// 计算操作数

double left = left_->evaluate();

double right = right_->evaluate();

// 把它们加起来

return left + right;

}

private:

Expression* left_;

Expression* right_;

{

//^increase-health

setHealth(0, getHealth(0) +

(getAgility(0) + getWisdom(0)) / 2);

//^increase-health

{

INST_SET_HEALTH = 0x00,

INST_SET_WISDOM = 0x01,

INST_SET_AGILITY = 0x02,

INST_PLAY_SOUND = 0x03,

INST_SPAWN_PARTICLES = 0x04

//^omit

,INST_LITERAL,

INST_GET_HEALTH,

INST_GET_WISDOM,

INST_GET_AGILITY,

INST_ADD,

//^omit

{

Instruction instruction = INST_SET_AGILITY;

//^interpret-instruction

switch (instruction)

{

case INST_SET_HEALTH:

setHealth(0, 100);

break;

case INST_SET_WISDOM:

setWisdom(0, 100);

break;

case INST_SET_AGILITY:

setAgility(0, 100);

break;

case INST_PLAY_SOUND:

playSound(SOUND_BANG);

break;

case INST_SPAWN_PARTICLES:

spawnParticles(PARTICLE_FLAME);

break;

//^omit

case INST_LITERAL:

case INST_GET_HEALTH:

case INST_GET_WISDOM:

case INST_GET_AGILITY:

case INST_ADD:

break;

//^omit

}

//^interpret-instruction

{

public:

void interpret(char bytecode[], int size)

{

for (int i = 0; i < size; i++)

{

char instruction = bytecode[i];

switch (instruction)

{

// 每条指令的跳转分支……

//^omit

case INST_SPAWN_PARTICLES:

break;

default:

break;

//^omit

}

}

}

{

public:

VM()

: stackSize_(0)

{}

// 其他代码……

private:

static const int MAX_STACK = 128;

int stackSize_;

int stack_[MAX_STACK];

{

private:

void push(int value)

{

// 检查栈溢出

assert(stackSize_ < MAX_STACK);

stack_[stackSize_++] = value;

}

int pop()

{

// 保证栈不是空的

assert(stackSize_ > 0);

return stack_[--stackSize_];

}

// 其余的代码

//^omit

void interpret();

static const int MAX_STACK = 128;

int stackSize_;

int stack_[MAX_STACK];

//^omit

{

int instruction = INST_SET_AGILITY;

//^pop-instructions

switch (instruction)

{

case INST_SET_HEALTH:

{

int amount = pop();

int wizard = pop();

setHealth(wizard, amount);

break;

}

case INST_SET_WISDOM:

case INST_SET_AGILITY:

// 像上面一样……

case INST_PLAY_SOUND:

playSound(pop());

break;

case INST_SPAWN_PARTICLES:

spawnParticles(pop());

break;

}

//^pop-instructions

char bytecode[123];

int i = 0;

switch (INST_LITERAL)

{

//^interpret-literal

case INST_LITERAL:

{

// 从字节码中读取下一个字节

int value = bytecode[++i];

push(value);

break;

}

//^interpret-literal

//^read-stats

case INST_GET_HEALTH:

{

int wizard = pop();

push(getHealth(wizard));

break;

}

case INST_GET_WISDOM:

case INST_GET_AGILITY:

// 你知道思路了吧……

//^read-stats

//^add

case INST_ADD:

{

int b = pop();

int a = pop();

push(a + b);

break;

}

//^add

}

{

TYPE_INT,

TYPE_DOUBLE,

TYPE_STRING

{

ValueType type;

union

{

int intValue;

double doubleValue;

char* stringValue;

};

{

TYPE_INT,

TYPE_DOUBLE,

TYPE_STRING

{

public:

virtual ~Value() {}

virtual ValueType type() = 0;

virtual int asInt() {

// 只能在int上调用

assert(false);

return 0;

}

// 其他转换方法……

{

public:

IntValue(int value)

: value_(value)

{}

virtual ValueType type() { return TYPE_INT; }

virtual int asInt() { return value_; }

private:

int value_;