// For all CodeGen variations on a CompoundStatement, we want to
// first generate the StmtExp list to get the sideffects, and
// then fall through to the last expression and use that
// as the real CodeGen target.
// Code generation as an expression
public override void GenerateAsRight(CodeGen.EmitCodeGen gen)
{
// Generate the StmtExp to get their sideffects
foreach(StatementExp e in m_eList)
e.GenerateAsStatement(gen);
m_eLast.GenerateAsRight(gen);
}
// We can only generate as a Statement if the last thing is also
// a StatementeExp
public override void GenerateAsStatement(CodeGen.EmitCodeGen gen)
{
// Generate the StmtExp to get their sideffects
foreach(StatementExp e in m_eList)
e.GenerateAsStatement(gen);
Debug.Assert(m_eLast is StatementExp);
StatementExp se = (StatementExp) m_eLast;
se.GenerateAsStatement(gen);
}
// Code generation
public override void GenerateAsRight(CodeGen.EmitCodeGen gen)
{
Debug.Assert(false);
}
// Statement expressions can be generated as a statement or expression.
// As an expression, they must leave a value on the top of the stack
// As a statement, they don't leave a value on top (and hence may
// be able to have a more efficient impl).
// Normal Generate() will generate as a RHS expression.
public virtual void GenerateAsStatement(CodeGen.EmitCodeGen gen)
{
// Default impl generates as a RHS exp and just pops the value off
gen.GenerateAsStatement(this);
}
public override void GenerateAsLeftPost(CodeGen.EmitCodeGen gen)
{
gen.GenerateAsLeftPost(this);
}
public override void GenerateAsRight(CodeGen.EmitCodeGen gen)
{
/*
if (Flow == EArgFlow.cIn)
m_exp.GenerateAsRight(gen);
else
m_exp.GenerateAddrOf(gen);
*/
gen.GenerateArg(this);
}
public override void Generate(CodeGen.EmitCodeGen gen)
{
// @todo - should we emit a nop?
}
public override void GenerateAsStatement(CodeGen.EmitCodeGen gen)
{
gen.GenerateAsStatement(this);
}
// Code generation
public override void Generate(CodeGen.EmitCodeGen gen)
{
foreach(Statement stmt in Statements)
{
stmt.Generate(gen);
}
}
// Code generation public abstract void Generate(CodeGen.EmitCodeGen gen);
// Code generation
public override void Generate(CodeGen.EmitCodeGen gen)
{
Debug.Assert(m_nodeCtor != null);
gen.Generate(this);
}
// Code generation
public override void Generate(CodeGen.EmitCodeGen gen)
{
m_sexp.GenerateAsStatement(gen);
}
// Code generation, just pass on to our resolved statement
public override void Generate(CodeGen.EmitCodeGen gen)
{
m_stmtResolved.Generate(gen);
}
// Generate the address
public override void GenerateAddrOf(CodeGen.EmitCodeGen gen)
{
// Still generate all the StmtExp normally because we
// need their side-effects
foreach(StatementExp e in m_eList)
e.GenerateAsStatement(gen);
// Use the address of the last expression.
m_eLast.GenerateAddrOf(gen);
}
//.........................................................................
// Code Generation - Generate the address of this expression
//.........................................................................
public virtual void GenerateAddrOf(CodeGen.EmitCodeGen gen)
{
// Can't get the addr of most expressions
//Debug.Assert(false, "Didn't implemented GenerateAddrOf");
// Default impl, evaluate as RHS, store in temp, gen addr of that.
gen.GenerateAddrOf(this);
}
// Code generation as an expression
public override void GenerateAsRight(CodeGen.EmitCodeGen gen)
{
gen.Generate(this);
}
// Generating the address of a literal is ok. We just have to
// create a temporary local to provide backing storage
public override void GenerateAddrOf(CodeGen.EmitCodeGen gen)
{
gen.GenerateAddrOf(this);
}
public virtual void GenerateAsRight(CodeGen.EmitCodeGen gen)
{
Debug.Assert(false, "Didn't implement GenerateAsRight");
}
public override void GenerateAddrOf(CodeGen.EmitCodeGen gen)
{
Debug.Assert(!IsIndexer, "Don't codegen Indexers as Array Access");
gen.GenerateAddrOf(this);
}
