// Gens op codes to find address from var table, // and store value in accumulator. // // Returns: Number of bytes generated. public override int GenOpCodes(OpCodeGenParam param) { // Inits VarTableEntry varEntry = null; // Find var in var table varEntry = param.tables.GetVarTableEntry(SymbolTableEntry.EntryID); // Verify var entry exists if (varEntry != null) { try { // Load value into accumlator param.opCodes.AppendFormat("AD V{0} 00 ", varEntry.VarID); param.AddBytes(0xAD); param.AddByteForUpdate('V', varEntry.VarID); param.AddBytes(0x00); } // Catch over 256 byte error, // and throw up catch (IndexOutOfRangeException ex) { throw ex; } } // Return number of bytes return(3); }
// Loads accum with 1 on true, 0 on false. // // Returns: Number of bytes generated. public override int GenOpCodes(OpCodeGenParam param) { try { // Check if true if (Value == BOOLVAL_TYPE.BOOLVAL_TRUE) { // Load accumulator with 1 param.AddBytes(0xA9, 0x01); } // Else false else { // Load accumulator with 0 param.AddBytes(0xA9, 0x00); } } // Catch over 256 byte error, // and throw up catch (IndexOutOfRangeException ex) { throw ex; } // Return current number of bytes return(2); }
// Gens op codes to create string on heap, // and load address in accumulator. // // Returns: Number of bytes generated. public override int GenOpCodes(OpCodeGenParam param) { // Inits HeapTableEntry heapEntry = null; // Check if heap entry exists heapEntry = param.tables.AddHeapTableEntry(param, Value); try { // Load accumulator with heap address //param.opCodes.AppendFormat("A9 H{0} ", heapEntry.HeapID); param.AddBytes(0xA9); param.AddByteForUpdate('H', heapEntry.HeapID); } // Catch over 256 byte error, // and throw up catch (IndexOutOfRangeException ex) { throw ex; } // Increment bytes //param.curByte += 2; // Return cur num bytes return(2); }
// Gens code that allocates 00 to a location in memory, // tracked in var table. // // Returns: Number of bytes generated. public override int GenOpCodes(OpCodeGenParam param) { // Inits VarTableEntry varEntry = null; // Create var table entry for this varEntry = param.tables.CreateVarTableEntry(id.SymbolTableEntry); // Increment current vars in use param.tables.IncVarIsUseCount(); // Check if entry found incase of some wierd error if (varEntry != null) { try { // Load accumlator with 0 //param.opCodes.Append("A9 00 "); param.AddBytes(0xA9, 0x00); // Add var entry to init value table // for optimization param.tables.AddInitValueEntry(id.Value, param.curByte - 1, param.curBlockID - 1, id.SymbolTableEntry.DataType); // Copy to temp location in memory //param.opCodes.AppendFormat("8D V{0} 00 ",varEntry.VarID); param.AddBytes(0x8D); param.AddByteForUpdate('V', varEntry.VarID); param.AddBytes(0x00); } // Catch over 256 byte error, // and throw up catch (IndexOutOfRangeException ex) { throw ex; } // Add number of bytes // param.curByte += 5; } // Return cur bytes return(5); }
// Puts int value into accum. // // Returns: Number of bytes generated. public override int GenOpCodes(OpCodeGenParam param) { try { // Load value into accum param.AddBytes(0xA9, (byte)Value); } // Catch over 256 byte error, // and throw up catch (IndexOutOfRangeException ex) { throw ex; } // Return number of bytes return(2); }
// 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); }
// Fills in variable locations, heap locations, and jump size for // blocks in one pase. Collected some meta data about program. // // Returns: OpCodeData describing memory of program. private OpCodeData FillInTempOpCodeValues(OpCodeGenParam param) { // Inits int zeros = 0; int num = 0; int localOffSet = 0; int curByte = 0; String[] strings = null; String s = null; String[] offStrings = null; String o = null; int len = 0; VarTableEntry varEntry = null; HeapTableEntry heapEntry = null; BlockSizeTableEntry blockEntry = null; OpCodeData programData = new OpCodeData(); TempByteData byteData = null; int location = 0; // Determin stack size programData.stackSize = param.tables.MaxVarUsage; programData.stackStart = param.curByte; // Determine heap size programData.heapSize = param.tables.TotalHeapSize(); programData.heapStart = param.curByte + programData.stackSize; // Write 00 over stack zeros = programData.stackSize; for (int i = 0; i < zeros; i++) { //param.opCodes.Append("00 "); param.AddBytes(0x00); } // Update size of file //param.curByte += zeros; // Send message SendGeneralMessage("Creating strings in memory..."); // Fill in memory locations for heap for (int i = 0; i < param.tables.HeapTableCount(); i++) { heapEntry = param.tables.GetHeapTableEntryByIndex(i); heapEntry.MemoryLocation = programData.heapStart + curByte; // Write char for (int n = 0; n < heapEntry.StringValue.Length; n++) { //param.opCodes.AppendFormat("{0} ", ((int)heapEntry.StringValue[n]).ToString("X2")); param.AddBytes((byte)heapEntry.StringValue[n]); } //param.opCodes.Append("00 "); param.AddBytes(0x00); //param.curByte += heapEntry.Length + 1; curByte += heapEntry.Length; } // Send message SendGeneralMessage("String creation complete."); // Set program data size programData.totalBytes = param.curByte; // Cycle through codes for (int i = 0; i < param.insertBytes.Count; i++) { // Get byte data byteData = (TempByteData)param.insertBytes[i]; // Get place holder string s = byteData.VarSymbol; // Check for V (var table if (s[0] == 'V') { // Get number off string num = int.Parse(s.Substring(1, s.Length - 1)); // Find entry varEntry = param.tables.GetVarTableEntry(num); // Replace entry with address if (varEntry != null) { // Set location location = programData.stackStart + varEntry.Offset; param.SetByte(byteData.Index, (byte)(location)); if (varEntry.VarEntry != null) { varEntry.VarEntry.MemoryLocation = location; } } } // Check for H (heap) else if (s[0] == 'H') { // Find length to s or end len = s.Length; for (int n = 1; n < s.Length; n++) { if (s[n] == 'S') { len = n; } } // Get number off string num = int.Parse(s.Substring(1, len - 1)); // Find entry heapEntry = param.tables.GetHeapTableEntry(num); // Split of F offStrings = s.Split('S'); // Get offf num if valid if (offStrings.Length > 1) { o = offStrings[1]; localOffSet = int.Parse(o.Substring(0, o.Length)); } else { localOffSet = 0; } // Replace entry with address if (heapEntry != null) { // strings[i] = String.Format("{0}", (heapEntry.MemoryLocation + localOffSet).ToString("X2")); param.SetByte(byteData.Index, (byte)(heapEntry.MemoryLocation + localOffSet)); } } // Else if block parse flag else if (s[0] == 'B') { // Find length to s or end len = s.Length; for (int n = 1; n < s.Length; n++) { if (s[n] == 'S') { len = n; } } // Get number off string num = int.Parse(s.Substring(1, len - 1)); // Find entry ( happens to work out that block id = index ) blockEntry = param.tables.GetBlockSizeTableEntry(num); // Split of F offStrings = s.Split('S'); // Get offf num if valid if (offStrings.Length > 1) { o = offStrings[1]; localOffSet = int.Parse(o.Substring(0, o.Length)); } else { localOffSet = 0; } // Replace entry with address if (blockEntry != null) { //strings[i] = String.Format("{0}", (blockEntry.BlockSize + localOffSet).ToString("X2")); param.SetByte(byteData.Index, (byte)(blockEntry.BlockSize + localOffSet)); } } } // Return program data return(programData); }
// Generates op codes from ast. public ProcessReturnValue GenerateOpCodes(ASTNode rootASTNode, DynamicBranchTreeNode <SymbolHashTable> rootSymbolTableNode) { // Inits ProcessReturnValue ret = ProcessReturnValue.PRV_NONE; OpCodeGenParam param; bool error = false; // Create temp tables tempTables = new OpCodeGenTempTables(); tempOpCodeData = new StringBuilder(250); // Create new byte array opCodeDataBytes = new byte[256]; // Reset error and warning count errorCount = 0; warningCount = 0; // Create op code gen param param = new OpCodeGenParam(tempOpCodeData, opCodeDataBytes, rootSymbolTableNode, tempTables); // Send message SendGeneralMessage("Starting code generation phase..."); // Send message SendGeneralMessage("Generating op codes..."); // Gen op codes try { rootASTNode.GenOpCodes(param); // Add final 00 param.AddBytes(0x00); } // Catch index out of range exption // on over 256 byte error catch (IndexOutOfRangeException ex) { SendError("Program ran over 256 bytes."); // Send message SendGeneralMessage("Op code generation complete."); error = true; } // Send message SendGeneralMessage("Op code generation complete."); // If not errors if (!error) { // Send message SendGeneralMessage("Inserting memory locations..."); // Fill in memory locations and jump sizes programData = FillInTempOpCodeValues(param); // Send message SendGeneralMessage("Completed inserting memory locations."); // Send message SendGeneralMessage("Code generation phase complete."); // Send message SendGeneralMessage("Compilation complete."); // Set op code total bytes opCodeBytes = programData.totalBytes; } // Else send error message else { // Send message SendGeneralMessage("Compilation completed with errors."); } //Determine return value if (ErrorCount > 0) { ret = ProcessReturnValue.PRV_ERRORS; } else if (WarningCount > 0) { ret = ProcessReturnValue.PRV_WARNINGS; } else { ret = ProcessReturnValue.PRV_OK; } //Return code return(ret); }
// 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); }