// Gens op codes for if statement, and following block.
//
// Returns: Number of bytes generated.
public override int GenOpCodes(OpCodeGenParam param)
{
// Inits
int bytes = 0;
int bytes2 = 0;
VarTableEntry varEntry = null;
try
{
// Gen op codes for boolean exp ( results in accum )
bytes += expr.GenOpCodes(param);
// Create new temp var
varEntry = param.tables.CreateTempVarTableEntry();
// Set in use flag
varEntry.InUse = true;
// Increment in use count
param.tables.IncVarIsUseCount();
// Move results into temp memory
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Load 1 into accum
param.AddBytes(0xA2, 0x01);
// Compare temp (res of expr) to true (1)
param.AddBytes(0xEC);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Branch to end of block (using curBlockID, as gen op
// will use this id and incremement it. The current
// block at any time is really curBlockID - 1 ).
param.AddBytes(0xD0);
param.AddByteForUpdate('B', param.curBlockID);
// Incrmeent bytes
bytes += 10;
// Set temp var not in use
varEntry.InUse = false;
// Decremeent in use count
param.tables.DecVarInUseCount();
// Gen op codes for block
bytes += block.GenOpCodes(param);
}
// Catch over 256 byte error,
// and throw up
catch (IndexOutOfRangeException ex)
{
throw ex;
}
// Return bytes added
return(bytes);
}
// Gens opp codes for int operation add.
// Results are in the accum.
//
// Returns: Number of bytes generated.
public override int GenOpCodes(OpCodeGenParam param)
{
// Inits
VarTableEntry varEntry = null;
int bytes = 0;
int bytes2 = 0;
try
{
// Load accummulator with constant
param.AddBytes(0xA9, (byte)intVal.Value);
// Get avaialbe stack location
varEntry = param.tables.CreateTempVarTableEntry();
// Set in use flag
varEntry.InUse = true;
// Increment var in use flag
param.tables.IncVarIsUseCount();
// Store accumulator in stack location
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Increment bytes
bytes += 5;
// Check if expr is not null
if (expr != null)
{
// Gen op codes for expr
bytes2 += expr.GenOpCodes(param);
}
// Else expr is null
else
{
// Move 0 to accumulator
param.AddBytes(0xA9, 0x00);
// Increment bytes
bytes2 += 2;
}
// Add temp var to accumulator
param.AddBytes(0x6D);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Increment bytes
bytes2 += 3;
// Set temp var not in use
varEntry.InUse = false;
// Decrement counter
param.tables.DecVarInUseCount();
}
// Catch over 256 byte error,
// and throw up
catch (IndexOutOfRangeException ex)
{
throw ex;
}
// Return bytes added
return(bytes + bytes2);
}
// Gens op codes for while loop.
//
// Returns: Number of bytes generated.
public override int GenOpCodes(OpCodeGenParam param)
{
// Inits
int bytes = 0;
int bytes2 = 0;
int jumpByte = 0;
int startByte = param.curByte;
VarTableEntry varEntry = null;
VarTableEntry varEntry2 = null;
try
{
// Gen op codes for boolean exp ( results in accum )
bytes += expr.GenOpCodes(param);
// Create new temp var
varEntry = param.tables.CreateTempVarTableEntry();
// Set in use flag
varEntry.InUse = true;
// Increment in use count
param.tables.IncVarIsUseCount();
// Move results into temp memory
//param.opCodes.AppendFormat("8D V{0} 00 ", varEntry.VarID);
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Incrmeent bytes
bytes += 3;
// Capture current byte (where to jump to at end of loop)
jumpByte = param.curByte + bytes;
// Load 1 into accum
//param.opCodes.Append("A2 01 ");
param.AddBytes(0xA2, 0x01);
// Compare temp (res of expr) to true (1)
//param.opCodes.AppendFormat("EC V{0} 00 ", varEntry.VarID);
param.AddBytes(0xEC);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Branch to end of block, and 12 more to skip
// forced jump to begining of while
//param.opCodes.AppendFormat("D0 B{0}S{1} ", param.curBlockID, 12);
param.AddBytes(0xD0);
param.AddByteForUpdate('B', param.curBlockID, 12);
// Incrmeent bytes
bytes += 7;
// Set current byte (for calling gen op)
//param.curByte += 10;
// Set temp var not in use
varEntry.InUse = false;
// Decremeent in use count
param.tables.DecVarInUseCount();
// Gen op codes for block
bytes2 += block.GenOpCodes(param);
// ### Force NE Jump ### //
// Create another new temp var
varEntry2 = param.tables.CreateTempVarTableEntry();
// Set in use
varEntry2.InUse = true;
// Inc var in use count
param.tables.IncVarIsUseCount();
// Load 0 into acc
//param.opCodes.Append("A9 00 ");
param.AddBytes(0xA9, 0x00);
// Load acc to temp var
//param.opCodes.AppendFormat("8D V{0} 00 ", varEntry2.VarID);
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntry2.VarID);
param.AddBytes(0x00);
// Load 1 into x reg
//param.opCodes.Append("A2 01 ");
param.AddBytes(0xA2, 0x01);
// Compare temp to x (which will always be not equal )
//param.opCodes.AppendFormat("EC V{0} 00 ", varEntry2.VarID);
param.AddBytes(0xEC);
param.AddByteForUpdate('V', varEntry2.VarID);
param.AddBytes(0x00);
// Incremeent bytes
bytes2 += 12;
// Update bytes ( I do it before next statmement for
// caculation of accurate curByte )
//param.curByte += 12;
// Branch to top of while loop ( note these two bytes already
// added to curByte )
//param.opCodes.AppendFormat("D0 {0} ",(256 - param.curByte + startByte + 1).ToString("X2"));
param.AddBytes(0xD0, (byte)(255 - (param.curByte - startByte + 1)));
// Set temp var not in use
varEntry2.InUse = false;
// Decremeent in use count
param.tables.DecVarInUseCount();
}
// Catch over 256 byte error,
// and throw up
catch (IndexOutOfRangeException ex)
{
throw ex;
}
// Return bytes added
return(bytes + bytes2);
}
// Gens op codes for print statment.
// Calls system to print based on type of expr.
//
// Returns: Number of bytes generated.
public override int GenOpCodes(OpCodeGenParam param)
{
// Inits
int bytes = 0;
VarTableEntry varEntry = null;
VarTableEntry varEntryTrue = null;
VarTableEntry varEntryFalse = null;
HeapTableEntry heapEntryTrue = null;
HeapTableEntry heapEntryFalse = null;
IDASTNode idASTNode = null;
try
{
// Gen op codes for expr. Results in accum
bytes += expr.GenOpCodes(param);
// Create temp var on stack
varEntry = param.tables.CreateTempVarTableEntry();
varEntry.InUse = true;
param.tables.IncVarIsUseCount();
// Load accumlator to memory (results from expr )
//param.opCodes.AppendFormat("8D V{0} 00 ", varEntry.VarID);
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
bytes += 3;
// Inc cur bytes
//param.curByte += 3;
// Check if int expr, or var dec of type int
if ((expr is IntExprASTNode) ||
((expr is IDASTNode) && (((IDASTNode)expr).SymbolTableEntry.DataType == DataType.DT_INT)))
{
// Load 1 int x reg
//param.opCodes.Append("A2 01 ");
param.AddBytes(0xA2, 0x01);
// Load into y register
//param.opCodes.AppendFormat("AC V{0} 00 ",varEntry.VarID);
param.AddBytes(0xAC);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Make system call
//param.opCodes.Append("FF ");
param.AddBytes(0xFF);
// Inc bytes
bytes += 6;
// Inc cur bytes
// param.curByte += 6;
}
// Else check if bool expr, or var dec with boolean type
else if ((expr is BooleanExprASTNode) ||
((expr is IDASTNode) && (((IDASTNode)expr).SymbolTableEntry.DataType == DataType.DT_BOOLEAN)))
{
// Create strings for true and false on heap.
// If already on their it wont allocate new
// ones, but use the same.
heapEntryTrue = param.tables.AddHeapTableEntry(param, "true");
heapEntryFalse = param.tables.AddHeapTableEntry(param, "false");
// Create temp vars on stack for true
varEntryTrue = param.tables.CreateTempVarTableEntry();
varEntryTrue.InUse = true;
param.tables.IncVarIsUseCount();
// Create temp var on stack for false
varEntryFalse = param.tables.CreateTempVarTableEntry();
varEntryFalse.InUse = true;
param.tables.IncVarIsUseCount();
// Load true string address in acc
//param.opCodes.AppendFormat("A9 H{0} ", heapEntryTrue.HeapID);
param.AddBytes(0xA9);
param.AddByteForUpdate('H', heapEntryTrue.HeapID);
// Move to temp var
//param.opCodes.AppendFormat("8D V{0} 00 ", varEntryTrue.VarID);
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntryTrue.VarID);
param.AddBytes(0x00);
// Load true add in acc
//param.opCodes.AppendFormat("A9 H{0} ", heapEntryFalse.HeapID);
param.AddBytes(0xA9);
param.AddByteForUpdate('H', heapEntryFalse.HeapID);
// Move to temp var
//param.opCodes.AppendFormat("8D V{0} 00 ", varEntryFalse.VarID);
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntryFalse.VarID);
param.AddBytes(0x00);
// Load false into y reg
//param.opCodes.AppendFormat("AC V{0} 00 ", varEntryFalse.VarID);
param.AddBytes(0xAC);
param.AddByteForUpdate('V', varEntryFalse.VarID);
param.AddBytes(0x00);
// Load 01 int x reg
//param.opCodes.Append("A2 01 ");
param.AddBytes(0xA2, 0x01);
// Compare results with results from acc
//param.opCodes.AppendFormat("EC V{0} 00 ", varEntry.VarID);
param.AddBytes(0xEC);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Branch on not equal x bytes
//param.opCodes.Append("D0 04 ");
param.AddBytes(0xD0, 0x03);
// Load true into y reg
//param.opCodes.AppendFormat("AC V{0} 00 ", varEntryTrue.VarID);
param.AddBytes(0xAC);
param.AddByteForUpdate('V', varEntryTrue.VarID);
param.AddBytes(0x00);
// Load 2 int x reg
//param.opCodes.Append("A2 02 ");
param.AddBytes(0xA2, 0x02);
// Make system call
//param.opCodes.Append("FF ");
param.AddBytes(0xFF);
// Inc bytes
bytes += 26;
// Inc cur bytes
//param.curByte += 26;
/*
* // Set temp vars not in use
* varEntryTrue.InUse = false;
* varEntryFalse.InUse = false;
* param.tables.DecVarInUseCount();
* param.tables.DecVarInUseCount();
* */
}
// Else check if string expr or var of string type
else if ((expr is StringExprASTNode) ||
((expr is IDASTNode) && (((IDASTNode)expr).SymbolTableEntry.DataType == DataType.DT_STRING)))
{
// Load into temp var
//param.opCodes.AppendFormat("8D
// Load expr res into y reg
//param.opCodes.AppendFormat("AC V{0} 00 ", varEntry.VarID);
param.AddBytes(0xAC);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Load 2 int x reg
//param.opCodes.Append("A2 02 ");
param.AddBytes(0xA2, 0x02);
// Make system call
//param.opCodes.Append("FF ");
param.AddBytes(0xFF);
// Increment bytes
bytes += 6;
// Inc cur bytes
//param.curByte += 6;
}
// Reset temp var
varEntry.InUse = false;
param.tables.DecVarInUseCount();
}
// Catch over 256 byte error,
// and throw up
catch (IndexOutOfRangeException ex)
{
throw ex;
}
// Return bytes added
return(bytes);
}
// Gens op codes for comparision of boolean expr == or !=,
// and puts results in accum. 1 for true, 0 for false.
//
// Returns: Number of bytes generated.
public override int GenOpCodes(OpCodeGenParam param)
{
// Inits
VarTableEntry varEntryTemp = null;
int bytes = 0;
int index = 0;
// ### Checking Expr 1 ### //
// try for error
try
{
// Gen op codes for expr one
bytes += exprOne.GenOpCodes(param);
// ### Check if not only bool val, as if it was ### //
// ### the value is just left in the accumulator ### //
// Check if expr 2 is not null
if (exprTwo != null)
{
// ### Add acc results from expr 1 ### //
// Add temp var for expr one results
varEntryTemp = param.tables.CreateTempVarTableEntry();
// Set in use
varEntryTemp.InUse = true;
// Increment var in use
param.tables.IncVarIsUseCount();
// Move value of accumulator to temp var
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntryTemp.VarID);
param.AddBytes(0x00);
// ### Generate expr 2 value and put in accumm ### //
// Gen op codes for expr two
bytes += exprTwo.GenOpCodes(param);
// ### Compare values of temp var (expr 1), and accum (expr2) ### //
// ### Put results in accumulator. ### //
// Load temp value from first expr into reg x
param.AddBytes(0xAE);
param.AddByteForUpdate('V', varEntryTemp.VarID);
param.AddBytes(0x00);
// Move accum into same temp val
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntryTemp.VarID);
param.AddBytes(0x00);
// Increment bytes
bytes += 9;
// Check if equals
if (value == BOOLOP_TYPE.BOOLOP_EQUALS)
{
// Set false in accum "A9 00 "
param.AddBytes(0xA9, 0x00);
}
else
{
// Set true in accum
param.AddBytes(0xA9, 0x01);
}
// Compare x to temp var
param.AddBytes(0xEC);
param.AddByteForUpdate('V', varEntryTemp.VarID);
param.AddBytes(0x00);
// Branch 2 bytes if equl
param.AddBytes(0xD0, 0x02);
// Check if equals
if (value == BOOLOP_TYPE.BOOLOP_EQUALS)
{
// Set true in accum (skip in nnot equal)
param.AddBytes(0xA9, 0x01);
}
else
{
// Set false in accum (skip in nnot equal)
param.AddBytes(0xA9, 0x00);
}
// Increment bytes
bytes += 9;
// Reset in use flag for temp var
varEntryTemp.InUse = false;
// Decremeent in use flag
param.tables.DecVarInUseCount();
}
}
// Throw error up
catch (IndexOutOfRangeException ex)
{
throw ex;
}
// Return number of bytes
return(bytes);
}
// Generates op codes for expr, which is put in accum.
// This value is then loaded into var's value.
//
// Returns: Number of op code bytes added.
public override int GenOpCodes(OpCodeGenParam param)
{
// Inits
VarTableEntry varEntry = null;
InitValueEntry initEntry = null;
int bytes = 0;
int curByte = param.curByte;
bool value = false;
StringExprASTNode stringNode = null;
HeapTableEntry heapEntry = null;
bool initVar = false;
// Try for over 256 bytes
try
{
// Get init value entry
initEntry = param.tables.GetLastInitValueEntry(id.Value, id.SymbolTableEntry.DataType);
// Check if value was already init
if (initEntry != null)
{
// Set init var
initVar = true;
// Check if int value
if (expr is IntValASTNode)
{
// Set byte with value
param.SetByte(initEntry.Index, (byte)((IntValASTNode)expr).Value);
// Set inital value in symbol table
id.SymbolTableEntry.IntValue = ((IntValASTNode)expr).Value;
}
else if (expr is BoolValASTNode)
{
// Get bool value
if (((BoolValASTNode)expr).Value == BOOLVAL_TYPE.BOOLVAL_TRUE)
{
value = true;
}
else
{
value = false;
}
// Set byte with value
param.SetByte(initEntry.Index, (byte)(value == true ? 1 : 0));
// Set inital value in symbol table
id.SymbolTableEntry.IntValue = (value == true ? 1 : 0);
}
else if (expr is StringExprASTNode)
{
stringNode = ((StringExprASTNode)expr);
heapEntry = param.tables.AddHeapTableEntry(param, stringNode.Value);
param.AddInsertByte(initEntry.Index, 'H', heapEntry.HeapID, 0);
id.SymbolTableEntry.StringValue = stringNode.Value;
}
else
{
initVar = false;
}
// Remove from table if iniitalized
if (initVar)
{
param.tables.RemoveLastInitValueEntry(initEntry);
param.initVars++;
}
}
// Check if initialized optimization
if (!initVar)
{
// Gen op codes for expr , value in accum
bytes += expr.GenOpCodes(param);
// Retreive temp placehold from var table
varEntry = param.tables.GetVarTableEntry(id.SymbolTableEntry.EntryID);
// Move accumlator to memory "8D V{0} 00 "
param.AddBytes(0x8D);
param.AddByteForUpdate('V', varEntry.VarID);
param.AddBytes(0x00);
// Increment bytes
bytes += 3;
}
}
// Catch over 256 bytes
catch (IndexOutOfRangeException ex)
{
throw ex;
}
// Return bytesa added
return(bytes);
}