Value FlagExpr::Evaluate(SymbolTable* scope, EvalContext& context, bool asbool)
{
// When evaluating as a boolean, we want to use the "load flag" command, 07.
// This is so an expression "flag <x>" can be used in normal expressions as
// a flag number (e.g., set(myflag)) and in boolean conditions (e.g.,
// if myflag { }). Just sugar, really.
// Thus, if statements and "and", "or", "not" expressions pass asbool=true.
// All other nodes ignore this parameter, using the default value of false.
//
// Honestly, this feels like a hack, and it comes at the cost of some possibly
// unintuitive behavior. However, it seems useful to allow the use of flags
// in conditionals this way... Maybe there's a better alternative.
String* value = new String();
if(asbool) value->Code("07");
Value flagval = expr->Evaluate(scope, context, false);
String flagstr = flagval.ToCodeString();
value->Append(flagstr.Substring(0,2));
return Value(value);
}
Value OrExpr::Evaluate(SymbolTable *scope, EvalContext& context, bool asbool)
{
// Scope override; must do this for every expression that might contain an identifier
if(this->scope != NULL)
scope = this->scope;
// Lowering of A or B:
// [A]
// [iftrue goto end]
// [B]
// label end:
String* value = new String();
string labelbase = context.GetUniqueLabelName();
Anchor* endanchor = new Anchor(labelbase + ".end");
// a
value->Append( a->Evaluate(scope, context, true).ToCodeString() );
// iftrue goto end:
value->Code("1B 03 FF FF FF FF");
value->AddReference(value->GetPos()-4, endanchor);
// b
value->Append( b->Evaluate(scope, context, true).ToCodeString() );
// end:
value->AddAnchor(endanchor);
return Value(value);
}
Value NotExpr::Evaluate(SymbolTable *scope, EvalContext& context, bool asbool)
{
// Scope override; must do this for every expression that might contain an identifier
if(this->scope != NULL)
scope = this->scope;
// Lowering of not A:
// [A] ; assumes A modifies the W register
// [0B 00] ; set W = (W == 0)
String* value = new String();
value->Append( a->Evaluate(scope, context, true).ToCodeString() );
value->Code("0B 00");
return Value(value);
}
Value AndExpr::Evaluate(SymbolTable *scope, EvalContext& context, bool asbool)
{
// Scope override; must do this for every expression that might contain an identifier
if(this->scope != NULL)
scope = this->scope;
// Lowering A and B:
// [A]
// [iffalse goto end]
// [B]
// label end:
String* value = new String();
// Create internal label
string labelbase = context.GetUniqueLabelName();
Anchor* endanchor = new Anchor(labelbase + ".end");
// Evaluate the first operand
value->Append( a->Evaluate(scope, context, true).ToCodeString() );
// Add a jump to the end if the first operand is false
value->Code("1B 02 FF FF FF FF");
value->AddReference(value->GetPos()-4, endanchor);
// TODO:
// Hm. I just realized that some boolean expressions (and and or) rely on reference
// resolution to operate correctly. Thus, it doesn't make sense to use them in ROM
// write statements at the moment, because ROM write statements occur after normal
// resolution, but without doing any resolution themselves. Perhaps ROM write statements
// should have a special resolution step to take care of stuff like this. (Perhaps
// the ROM data itself should be represented as a ByteChunk, with refs?)
// Anyway, don't worry about this for now, since using boolean expressions in a ROM
// write statement is not a very likely usage scenario.
// UPDATE: 11/11/2008
// This issue has been fixed by moving the evaluation of ROM write subexpressions
// back to the evaluation pass of the compiler, and simply caching the results and
// resolving references in a later pass. However, it still might be worthwhile to
// consider alternative solutions; whole-ROM resolution seems interesting for example.
// Evaluate the second operand
value->Append( b->Evaluate(scope, context, true).ToCodeString() );
// Set the position of the end label
value->AddAnchor(endanchor);
return Value(value);
}
Value MenuExpr::Evaluate(SymbolTable* scope, EvalContext& context, bool asbool)
{
if(this->scope != NULL)
scope = this->scope;
// Lowering a menu statement:
// [19 02][option][02] - for each option
// [1C 0C $cols][11][12]
// [09 $num (statementjmps)]
// [goto end]
// [statement][goto end] - for each statement
// label end:
String* value = new String();
// Create internal labels
vector<Anchor*> anchors;
string labelbase = context.GetUniqueLabelName();
for(unsigned int i = 0; i < options.size(); ++i) {
std::stringstream ss;
ss << ".opt" << i;
Anchor* a = new Anchor(labelbase + ss.str());
anchors.push_back(a);
}
Anchor* endanchor = new Anchor(labelbase + ".end");
// First, append the options between [19 02] and [02] codes
for(unsigned int i = 0; i < options.size(); ++i) {
value->Code("19 02");
value->Append( options[i]->Evaluate(scope, context).ToCodeString() );
value->Code("02");
}
// Next, append the option display commands
// If we're only using two options, and no number of columns was specified,
// use "1C 07", otherwise, use "1C 0C".
if(options.size() == 2 && defcolumns)
value->Code("1C 07");
else
value->Code("1C 0C");
value->Byte(columns);// write exactly one byte for the column count
value->Code("11 12");
// Next, the multi-jump code
value->Code("09");
value->Byte(results.size());// write exactly one byte for the option count
for(unsigned int i = 0; i < results.size(); ++i) {
value->Code("FF FF FF FF");
value->AddReference(value->GetPos() - 4, anchors[i]);
}
// Add a jump to the "default" option after the multi-jump, or end if no default
value->Code("0A FF FF FF FF");
if(defaultopt != -1)
value->AddReference(value->GetPos() - 4, anchors[defaultopt]);
else
value->AddReference(value->GetPos() - 4, endanchor);
// Finally, write out all the options, with a "goto end" after each
// At each point we set the position of the relevant label.
for(unsigned int i = 0; i < results.size(); ++i)
{
value->AddAnchor(anchors[i]);
value->Append( results[i]->Evaluate(scope, context).ToCodeString() );
// Add a "goto end" after every statement, in case it falls through
value->Code("0A FF FF FF FF");
value->AddReference(value->GetPos() - 4, endanchor);
}
// Last step: set position of the "end" label
value->AddAnchor(endanchor);
return Value(value);
}
Value IfExpr::Evaluate(SymbolTable *env, EvalContext& context, bool asbool)
{
if(this->scope != NULL)
env = this->scope;
/*
* Lowering an if statement:
*
* [condition]
* [iffalse goto falselbl]
* [thenstmt]
* [goto endlbl]
* falselbl:
* [elsestmt]
* endlbl:
*/
String* value = new String();
// Create internal labels
string labelbase = context.GetUniqueLabelName();
Anchor* endanchor = new Anchor(labelbase + ".end");
Anchor* falseanchor = new Anchor(labelbase + ".false");
// First, we evaluate the condition
Value cond_val = condition->Evaluate(env, context, true);
// TODO: this might be an opportunity to do some typechecking on the returned value,
// instead of just converting it to a string. Maybe some warnings would be appropriate?
// (i.e., conditioning on a number value, which is almost always meaningless)
// append cond_val to the output:
value->Append(cond_val.ToCodeString());
// Then, we output an "iffalse goto false" instruction, and register a jump reference
value->Code("1B 02 FF FF FF FF");
value->AddReference(value->GetSize() - 4, falseanchor);
// Evaluate the "then" statement
Value then_val = thenexpr->Evaluate(env, context);
value->Append(then_val.ToCodeString());
// Add a "goto end"
// TODO: strictly speaking, we can dispense with this last goto when
// there is no 'else' clause. We'll leave it here for now until we
// get the first round of regression tests in place, and then we'll
// update it along with the other evaluation refactoring.
value->Code("0A FF FF FF FF");
value->AddReference(value->GetPos() - 4, endanchor);
// Set the position of the false anchor within the string
value->AddAnchor(falseanchor);
// Evaluate the "else" statement
if(elseexpr) {
Value else_val = elseexpr->Evaluate(env, context);
value->Append(else_val.ToCodeString());
}
// Set the position of the "end" label
value->AddAnchor(endanchor);
return Value(value);
}