Moved some instructions around

src/shardware.adb

@@ -77,6 +77,14 @@ package body Shardware is
     return Unsigned_32(Shift_Left(Unsigned_128(Value), Amount));
   end MyShiftU;
 
+  function BytesToU (TheBytes : ByteArr) return Unsigned_32 is
+  begin
+    return Unsigned_32(MyShiftU(TheBytes (1), 24) 
+    + MyShiftU(TheBytes (2), 16)
+    + MyShiftU(TheBytes (3), 8) 
+    + Unsigned_32(TheBytes (4)));
+  end BytesToU;
+
   function BytesToI (TheBytes : ByteArr) return Integer is
   begin
     return UnToSignedInt(BytesToU(TheBytes));
@@ -88,7 +96,6 @@ package body Shardware is
     TheBits : BitArr (1 .. 32);
     BitBuff : BitArr (1 .. 32);
     Mantissa : Float := 0.0;
-    PowerOfTen : Integer := 0;
     Exponent : Natural := 0;
     Sign : Float := 1.0;
   begin
@@ -134,43 +141,95 @@ package body Shardware is
     return Result;
   end BytesToF;
 
-  function BytesToU (TheBytes : ByteArr) return Unsigned_32 is
+  procedure MovU (Register : in out Unsigned_32; Value : Unsigned_32) is 
   begin
-    return Unsigned_32(MyShiftU(TheBytes (1), 24) 
+    Register := Value;
-    + MyShiftU(TheBytes (2), 16)
+  end MovU;
-    + MyShiftU(TheBytes (3), 8) 
-    + Unsigned_32(TheBytes (4)));
-  end BytesToU;
 
   procedure MovI (Register : in out Integer; Value : Integer) is
   begin
     Register := Value;
   end MovI;
 
-  procedure AddI (Register : in out Integer; Value : Integer) is
-  begin
-    Register := Register + Value;
-  end AddI;
-
   procedure MovF (Register : in out Float; Value : Float) is 
   begin
     Register := Value;
   end MovF;
 
-  procedure AddF (Register : in out Float; Value : Float) is 
-  begin
-    Register := Register + Value;
-  end AddF;
-
-  procedure MovU (Register : in out Unsigned_32; Value : Unsigned_32) is 
-  begin
-    Register := Value;
-  end MovU;
-
   procedure AddU (Register : in out Unsigned_32; Value : Unsigned_32) is 
   begin
     Register := Register + Value;
   end AddU;
 
+  procedure AddI (Register : in out Integer; Value : Integer) is
+  begin
+    Register := Register + Value;
+  end AddI;
+
+  procedure AddF (Register : in out Float; Value : Float) is 
+  begin
+    Register := Register + Value;
+  end AddF;
+
+  procedure SubU (Register : in out Unsigned_32; Value : Unsigned_32) is 
+  begin
+    if Value > Register then
+      raise Constraint_Error with "Unsigned value can't be lower than 0.";
+    else
+      Register := Register - Value;
+    end if;
+  end SubU;
+
+  procedure SubI (Register : in out Integer; Value : Integer) is
+  begin
+    Register := Register - Value;
+  end SubI;
+
+  procedure SubF (Register : in out Float; Value : Float) is 
+  begin
+    Register := Register - Value;
+  end SubF;
+
+  procedure MulU (Register : in out Unsigned_32; Value : Unsigned_32) is 
+  begin
+    Register := Register * Value;
+  end MulU;
+
+  procedure MulI (Register : in out Integer; Value : Integer) is
+  begin
+    Register := Register * Value;
+  end MulI;
+
+  procedure MulF (Register : in out Float; Value : Float) is 
+  begin
+    Register := Register * Value;
+  end MulF;
+
+  procedure DivU (Register : in out Unsigned_32; Value : Unsigned_32) is 
+  begin
+    if Value = 0 then
+      raise Constraint_Error with "Please do not divide by 0.";
+    else
+      Register := Register / Value;
+    end if;
+  end DivU;
+
+  procedure DivI (Register : in out Integer; Value : Integer) is
+  begin
+    if Value = 0 then
+      raise Constraint_Error with "Please do not divide by 0.";
+    else
+      Register := Register / Value;
+    end if;
+  end DivI;
+
+  procedure DivF (Register : in out Float; Value : Float) is 
+  begin
+    if Value = 0.0 then
+      raise Constraint_Error with "Please do not divide by 0.";
+    else
+      Register := Register / Value;
+    end if;
+  end DivF;
 
 end Shardware;

src/shardware.ads

@@ -22,15 +22,28 @@ package Shardware is
 
   function MyShiftU (Value : Byte; Amount : Integer) return Unsigned_32;
 
+  function BytesToU (TheBytes : ByteArr) return Unsigned_32;
   function BytesToI (TheBytes : ByteArr) return Integer;
   function BytesToF (TheBytes : ByteArr) return Float;
-  function BytesToU (TheBytes : ByteArr) return Unsigned_32;
 
-  procedure MovI (Register : in out Integer; Value : Integer);
-  procedure AddI (Register : in out Integer; Value : Integer);
-  procedure MovF (Register : in out Float; Value : Float);
-  procedure AddF (Register : in out Float; Value : Float);
   procedure MovU (Register : in out Unsigned_32; Value : Unsigned_32);
+  procedure MovI (Register : in out Integer; Value : Integer);
+  procedure MovF (Register : in out Float; Value : Float);
+
   procedure AddU (Register : in out Unsigned_32; Value : Unsigned_32);
+  procedure AddI (Register : in out Integer; Value : Integer);
+  procedure AddF (Register : in out Float; Value : Float);
+
+  procedure SubU (Register : in out Unsigned_32; Value : Unsigned_32);
+  procedure SubI (Register : in out Integer; Value : Integer);
+  procedure SubF (Register : in out Float; Value : Float);
+
+  procedure MulU (Register : in out Unsigned_32; Value : Unsigned_32);
+  procedure MulI (Register : in out Integer; Value : Integer);
+  procedure MulF (Register : in out Float; Value : Float);
+
+  procedure DivU (Register : in out Unsigned_32; Value : Unsigned_32);
+  procedure DivI (Register : in out Integer; Value : Integer);
+  procedure DivF (Register : in out Float; Value : Float);
 
 end Shardware;

src/sillymachine.adb

@@ -17,14 +17,14 @@ procedure sillymachine is
   Value : Byte;
 
   ExecSize : Integer := 0;
-  MemorySize : Integer := 1048576; -- default memory is 1 mb (TODO: figure out why 8 mb produces STORAGE_ERROR)
+  MemorySize : Integer := 0;
 
   PC : Integer := 0; -- Program Counter
   Instruction : ByteArr (0 .. 15);
 
+  RegisterU : RegArrU (0 .. 27);
   RegisterI : RegArrI (0 .. 27);
   RegisterF : RegArrF (0 .. 27);
-  RegisterU : RegArrU (0 .. 27);
 
 begin
 
@@ -48,7 +48,7 @@ begin
 
   if Argument_Count = 0 then
     New_Line(1);
-    Put_Line("Usage: sillymachine <sm binary file> <number of megabytes for wanted memory (optional)>");
+    Put_Line("Usage: sillymachine <sm binary file>");
     New_Line(1);
     goto THE_END;
   end if;
@@ -78,12 +78,8 @@ begin
   Bin_IO.Close(F);
   Put_Line("Header passed");
 
-  if Argument_Count > 1 then
-    MemorySize := 1048576 * Integer'Value(Argument (2));
-  end if;
-
   ExecSize := Integer(Ada.Directories.Size(FileName));
-  MemorySize := MemorySize + ExecSize;
+  MemorySize := ExecSize;
 
   declare
     MemoryArr : ByteArr (0 .. MemorySize);
@@ -116,43 +112,43 @@ begin
       case MyShiftU(Instruction (0), 8) + Unsigned_32(Instruction (1)) is -- execute the instruction
         when 0 => null;                                               -- NOP
         when 1 => null;                                               -- TODO: TRAP
-        when 2 => MovU(RegisterU(Integer(Instruction (2))),
+        when 2 => MovU(RegisterU(Integer(Instruction (2))),             -- Move Unsigned_32 to Register
-          BytesToU(TempBytes(Instruction)));                                     -- Move Unsigned_32 to Register
+          BytesToU(TempBytes(Instruction)));
         when 3 => MovU(RegisterU(Integer(Instruction (2))),             -- Move Register to Register (Unsigned_32)
           RegisterU(Integer(Instruction (3))));
-        when 4 => null;                                               -- TODO: Move Memory to Register
+        when 4 => null;                                               -- TODO: Move Memory to Register (Unsigned_32)
-        when 5 => AddU(RegisterU(Integer(Instruction (2))),             -- Add Unsigned_32 to Register (Only positive values for now)
+        when 5 => MovI(RegisterI(Integer(Instruction (2))),             -- Move Int to Register
-          BytesToU(TempBytes(Instruction)));
-        when 6 => AddU(RegisterU(Integer(Instruction (2))),             -- Add Register to Register (Unsigned_32) 
-          RegisterU(Integer(Instruction (3))));
-        when 7 => MovI(RegisterI(Integer(Instruction (2))),             -- Move Int to Register
           BytesToI(TempBytes(Instruction)));
-        when 8 => MovI(RegisterI(Integer(Instruction (2))),             -- Move Register to Register (Int)
+        when 6 => MovI(RegisterI(Integer(Instruction (2))),             -- Move Register to Register (Int)
           RegisterI(Integer(Instruction (3))));
-        when 9 => null;                                               -- TODO: Move Memory to Register
+        when 7 => null;                                               -- TODO: Move Memory to Register
-        when 10 => AddI(RegisterI(Integer(Instruction (2))),             -- Add Int to Register 
+        when 8 => MovF(RegisterF(Integer(Instruction (2))),            -- Move Float to Register
-          BytesToI(TempBytes(Instruction)));
-        when 11 => AddI(RegisterI(Integer(Instruction (2))),             -- Add Register to Register (Int) 
-          RegisterI(Integer(Instruction (3))));
-        when 12 => MovF(RegisterF(Integer(Instruction (2))),            -- Move Float to Register
           BytesToF(TempBytes(Instruction)));
-        when 14 => MovF(RegisterF(Integer(Instruction (2))),             -- Move Register to Register (Float)
+        when 9 => MovF(RegisterF(Integer(Instruction (2))),             -- Move Register to Register (Float)
           RegisterF(Integer(Instruction (3))));
-        when 15 => null;                                                -- TODO: Move Memory to Register (Float)
+        when 10 => null;                                                -- TODO: Move Memory to Register (Float)
-        when 16 => AddF(RegisterF(Integer(Instruction (2))),             -- Add Float to Register 
+        when 11 => AddU(RegisterU(Integer(Instruction (2))),             -- Add Unsigned_32 to Register
+          BytesToU(TempBytes(Instruction)));
+        when 12 => AddU(RegisterU(Integer(Instruction (2))),             -- Add Register to Register (Unsigned_32) 
+          RegisterU(Integer(Instruction (3))));
+        when 13 => AddI(RegisterI(Integer(Instruction (2))),             -- Add Int to Register 
+          BytesToI(TempBytes(Instruction)));
+        when 14 => AddI(RegisterI(Integer(Instruction (2))),             -- Add Register to Register (Int) 
+          RegisterI(Integer(Instruction (3))));
+        when 15 => AddF(RegisterF(Integer(Instruction (2))),             -- Add Float to Register 
           BytesToF(TempBytes(Instruction)));
-        when 17 => AddF(RegisterF(Integer(Instruction (2))),             -- Add Register to Register (Float) 
+        when 16 => AddF(RegisterF(Integer(Instruction (2))),             -- Add Register to Register (Float) 
           RegisterF(Integer(Instruction (3))));
         when 65535 => goto THE_END; -- exit opcode
         when others => null;
       end case;
 
-      --Put_Line(Unsigned_32'Image(RegisterU(0)));
+      Put_Line(Unsigned_32'Image(RegisterU(0)));
-      --Put_Line(Unsigned_32'Image(RegisterU(1)));
+      Put_Line(Unsigned_32'Image(RegisterU(1)));
       --Put_Line(Integer'Image(RegisterI(0)));
       --Put_Line(Integer'Image(RegisterI(1)));
-      Put_Line(Float'Image(RegisterF(0)));
+      --Put_Line(Float'Image(RegisterF(0)));
-      Put_Line(Float'Image(RegisterF(1)));
+      --Put_Line(Float'Image(RegisterF(1)));
 
       PC := PC + 16; -- increment program counter to next instruction
     end loop;