Added Branching and Clear Instructions

jnosek · Aug 7, 2014 · c51b2c4 · c51b2c4
1 parent d2125d3
commit c51b2c4
Show file tree

Hide file tree

Showing 16 changed files with 430 additions and 25 deletions.
diff --git a/AGC/AGC.csproj b/AGC/AGC.csproj
@@ -40,6 +40,8 @@
     <Compile Include="Base\FixedMemory.cs" />
     <Compile Include="Base\IRegister.cs" />
     <Compile Include="Base\SinglePrecision.cs" />
+    <Compile Include="Instructions\BranchZeroOrMinusToFixed.cs" />
+    <Compile Include="Instructions\ClearAndAdd.cs" />
     <Compile Include="Registers\FullRegister.cs" />
     <Compile Include="Base\IWord.cs" />
     <Compile Include="Base\MemoryAddress.cs" />

diff --git a/AGC/Base/FixedMemory.cs b/AGC/Base/FixedMemory.cs
@@ -16,7 +16,7 @@ public FixedMemory(MemoryAddress memory)
 
         public void Write(ushort value)
         {
-            throw new InvalidOperationException("Cannot write to a fixed memory location");
+            //throw new InvalidOperationException("Cannot write to a fixed memory location");
         }
 
         public ushort Address

diff --git a/AGC/ExtraCodeInstructionSet.cs b/AGC/ExtraCodeInstructionSet.cs
@@ -18,6 +18,7 @@ public ExtraCodeInstructionSet(Processor cpu)
 
             Add(new BranchZeroToFixed { CPU = CPU });
             Add(new ExtraQuarterCode(CPU));
+            Add(new BranchZeroOrMinusToFixed { CPU = CPU });
         }
 
         public new IInstruction this[ushort code]

diff --git a/AGC/InstructionSet.cs b/AGC/InstructionSet.cs
@@ -17,7 +17,8 @@ public InstructionSet(Processor cpu)
             CPU = cpu;
 
             Add(new TransferControl { CPU = CPU });
-            Add(new QuarterCode { CPU = CPU });
+            Add(new QuarterCode(CPU));
+            Add(new ClearAndAdd { CPU = CPU });
             Add(new Add { CPU = CPU });
         }
 

diff --git a/AGC/Instructions/BranchZeroOrMinusToFixed.cs b/AGC/Instructions/BranchZeroOrMinusToFixed.cs
@@ -0,0 +1,32 @@
+using Apollo.Virtual.AGC.Base;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Apollo.Virtual.AGC.Instructions
+{
+    /// <summary>
+    /// BZMF - EX 0110
+    /// 
+    /// Jumps to a fixed memory location if the accumulator is 0 or negative
+    /// </summary>
+    class BranchZeroOrMinusToFixed : IInstruction
+    {
+        public ushort Code
+        {
+            get { return 0x06; }
+        }
+
+        public Processor CPU { get; set; }
+
+        public void Execute(ushort K)
+        {
+            var value = CPU.A.Read();
+
+            // if +0 or negative, jump
+            if (value == 0 || (value & 0x8000) > 0)
+                CPU.Z.Write(K);
+        }
+    }
+}
diff --git a/AGC/Instructions/BranchZeroToFixed.cs b/AGC/Instructions/BranchZeroToFixed.cs
@@ -9,7 +9,7 @@ namespace Apollo.Virtual.AGC.Instructions
     /// <summary>
     /// BZF - EX 0001
     /// 
-    /// Jumps to a memory location in the fixed bank if the accumulator is 0
+    /// Jumps to a fixed memory location if the accumulator is 0
     /// </summary>
     class BranchZeroToFixed : IInstruction
     {
@@ -22,7 +22,14 @@ public ushort Code
 
         public void Execute(ushort K)
         {
-            if (CPU.A.Read() == 0)
+            // if in overflow, no jump
+            if(CPU.A.IsOverflow)
+                return;
+
+            var value = CPU.A.Read();
+
+            // if +0 or -0, then jump
+            if (value == 0 || value == SinglePrecision.NegativeZero)
                 CPU.Z.Write(K);
         }
     }

diff --git a/AGC/Instructions/ClearAndAdd.cs b/AGC/Instructions/ClearAndAdd.cs
@@ -0,0 +1,34 @@
+using Apollo.Virtual.AGC.Base;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Apollo.Virtual.AGC.Instructions
+{
+    /// <summary>
+    /// CA - 0011
+    /// 
+    /// Moves the contents of memory at location K into the accumulator
+    /// </summary>
+    class ClearAndAdd : IInstruction
+    {
+        public ushort Code
+        {
+            get { return 0x3; }
+        }
+
+        public Processor CPU { get; set; }
+
+        public void Execute(ushort K)
+        {
+            var value = CPU.Memory[K];
+
+            // set value in accumulator
+            CPU.A.Write(value);
+
+            // value in K is re-written
+            CPU.Memory[K] = value;
+        }
+    }
+}
diff --git a/AGC/Instructions/QuarterCode.cs b/AGC/Instructions/QuarterCode.cs
@@ -14,8 +14,10 @@ namespace Apollo.Virtual.AGC.Instructions
     /// </summary>
     class QuarterCode : InstructionList, IInstruction
     {
-        public QuarterCode() : base(3)
+        public QuarterCode(Processor CPU) : base(3)
         {
+            this.CPU = CPU;
+
             Add(new AddToStorage { CPU = this.CPU });
         }
 

diff --git a/AGC/Registers/FullRegister.cs b/AGC/Registers/FullRegister.cs
@@ -28,6 +28,17 @@ public ushort Read()
             return memory.Read();
         }
 
+        public bool IsOverflow
+        {
+            get
+            {
+                // look at bits 16 and 15 to see if they are different
+                var value = (ushort)(Read() & 0xC000);
+
+                return value == 0x8000 || value == 0x4000;
+            }
+        }
+
         MemoryAddress IRegister.Memory
         {
             set { this.memory = value; }

diff --git a/Tests/AGC.Tests/AGC.Tests.csproj b/Tests/AGC.Tests/AGC.Tests.csproj
@@ -52,7 +52,11 @@
   <ItemGroup>
     <Compile Include="BaseTest.cs" />
     <Compile Include="Instructions\Add.cs" />
+    <Compile Include="Instructions\AddToStorage.cs" />
     <Compile Include="Instructions\Augment.cs" />
+    <Compile Include="Instructions\BranchZeroOrMinusToFixed.cs" />
+    <Compile Include="Instructions\BranchZeroToFixed.cs" />
+    <Compile Include="Instructions\UnitTest1.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

diff --git a/Tests/AGC.Tests/Instructions/Add.cs b/Tests/AGC.Tests/Instructions/Add.cs
@@ -18,13 +18,13 @@ public void AddTwoPositiveNumbers()
             Memory[0x200] = 10;
             Memory[0x201] = 15;
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -39,13 +39,13 @@ public void AddTwoNegativeNumbers()
             Memory[0x200] = SinglePrecision.To(-10);
             Memory[0x201] = SinglePrecision.To(-15);
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -60,13 +60,13 @@ public void AddPostive1AndNegative1()
             Memory[0x200] = SinglePrecision.To(-10);
             Memory[0x201] = 15;
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -81,13 +81,13 @@ public void AddTwoNumbersThatEqualNegativeZero()
             Memory[0x200] = 0xC000; // most negative number 15 bit number
             Memory[0x201] = SinglePrecision.To(-1);
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -105,13 +105,13 @@ public void AddTwoNumbersThatEqualPositiveZero()
             Memory[0x200] = 0x3FFF; // most positive number 15 bit number
             Memory[0x201] = 1;
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -129,13 +129,13 @@ public void AddTwoNegativeNumbersThatCauseUnderflow()
             Memory[0x200] = 0xC000; // most negative number 15 bit number
             Memory[0x201] = SinglePrecision.To(-3);
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -153,13 +153,13 @@ public void AddTwoPositiveNumbersThatCauseOverflow()
             Memory[0x200] = 0x3FFF; // most positive number 15 bit number
             Memory[0x201] = 3;
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -177,13 +177,13 @@ public void AddNegativeZeroAndPositiveNumber()
             Memory[0x200] = SinglePrecision.NegativeZero;
             Memory[0x201] = 4;
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -201,13 +201,13 @@ public void AddNegativeZeroAndNegativeNumber()
             Memory[0x200] = SinglePrecision.NegativeZero;
             Memory[0x201] = SinglePrecision.To(-4);
 
-            // insert add instructions
+            // insert instructions
             Memory.LoadFixedRom(new ushort[] {
                 0x06000 | 0x200,
                 0x06000 | 0x201
             });
 
-            // act - run the additions
+            // act - run the instructions
             CPU.Execute();
             CPU.Execute();
 
@@ -217,5 +217,29 @@ public void AddNegativeZeroAndNegativeNumber()
             // assert
             Assert.AreEqual(SinglePrecision.To(-4), Memory[0x202]);
         }
+
+        [TestMethod]
+        public void Add1AndNegative1EqualsNegative0()
+        {
+            // arrange
+            Memory[0x200] = 0x01;
+            Memory[0x201] = SinglePrecision.To(-1);
+
+            // insert instructions
+            Memory.LoadFixedRom(new ushort[] {
+                0x06000 | 0x200,
+                0x06000 | 0x201
+            });
+
+            // act - run the instructions
+            CPU.Execute();
+            CPU.Execute();
+
+            //save acumulator value to a place in memory so we can view the overflow corrected value, for now
+            Memory[0x202] = Memory[0x0];
+
+            // assert
+            Assert.AreEqual(SinglePrecision.NegativeZero, Memory[0x202]);
+        }
     }
 }