Add ability to shift multiple steps in one instruction

assembler.pas

@@ -331,17 +331,22 @@ begin
                     else if Elem [3] <> '' then ArgError
                     else if Elem [4] <> '' then ArgError;
                 end
-                else if Bin [BP] <= $50 then begin
-                    if Elem [3] <> '' then ArgError
-                    else if Elem [4] <> '' then ArgError;
-                end
                 else if Bin [BP] <= $b0 then begin
                     if Elem [4] <> '' then ArgError;
                 end;
 
                 //Assemble the arguments
                 //Shifts
-                if Bin [BP] >= $20 then if Bin [BP] <= $50 then OneArgReg (2);
+                if Bin [BP] >= $20 then if Bin [BP] <= $50 then begin
+                    //First argument
+                    OneArgReg (2);
+                    //Second argument
+                    if CompareText (Elem [3], '1') = 0 then Bin [BP] := Bin [BP] + 1
+                    else if CompareText (Elem [3], '2') = 0 then Bin [BP] := Bin [BP] + 2
+                    else if CompareText (Elem [3], '3') = 0 then Bin [BP] := Bin [BP] + 3
+                    else if CompareText (Elem [3], '4') = 0 then Bin [BP] := Bin [BP] + 0
+                    else ArgError;
+                end;
                 //Logical operations
                 if Bin [BP] >= $60 then if Bin [BP] <= $90 then TwoArgRegs;
                 //Load

disassembler.pas

@@ -111,7 +111,13 @@ begin
         write (Opcodes [Op]);
         if Op = $b then writeln (IntToHex (Addr, 1), ', R', X)
         else begin
-            if Op >= 2 then write ('R', X);
+            if Op >= 2 then begin
+                write ('R', X);
+                if Op <= 5 then begin
+                    if Y = 0 then write (', 4')
+                    else write (', ', Y);
+                end;
+            end;
             if Op >= 6 then if Op <= 9 then write (', R', Y);
             if OP >= $c then write (', R', Y);
             if Op >= $a then begin

emulator.pas

@@ -374,13 +374,25 @@ begin
             RP := RP + 1;
         end
         //Shl
-        else if Op = 2 then R [X] := R [X] shl 1
+        else if Op = 2 then begin
+            if Y = 0 then R [X] := R [X] shl 4
+            else R [X] := R [X] shl Y;
+        end
         //Shr
-        else if Op = 3 then R [X] := R [X] shr 1
+        else if Op = 3 then begin
+            if Y = 0 then R [X] := R [X] shr 4
+            else R [X] := R [X] shr Y;
+        end
         //Rol
-        else if Op = 4 then R [X] := RolByte (R [X])
+        else if Op = 4 then begin
+            if Y = 0 then R [X] := RolByte (R [X], 4)
+            else R [X] := RolByte (R [X], Y);
+        end
         //Ror
-        else if Op = 5 then R [X] := RorByte (R [X])
+        else if Op = 5 then begin
+            if Y = 0 then R [X] := RorByte (R [X], 4)
+            else R [X] := RorByte (R [X], Y);
+        end
         //Nand
         else if Op = 6 then R [X] := not (R [X] and R [Y])
         //And

examples/ascii.asm

@@ -16,10 +16,7 @@
 
         ;Convert and print the high nibble
         ;Convert
-        ror     r0
-        ror     r0
-        ror     r0
-        ror     r0
+        ror     r0, 4
         cleq    r0, r0, n2hex
         ;Print
         store   ffff, r0

examples/echo.asm

@@ -228,11 +228,11 @@ sumlop: xor     r1, r1
         xor     r1, r1
         xor     r1, r2
         ;Shift the carry
-        shl     r2
+        shl     r2, 1
 
         ;Check for and store overflow if any
         ;Check
-        rol     r1
+        rol     r1, 1
         breq    r1, r2, nvrflw
         ;Store
         load    r1, #1

readme.md

@@ -1,5 +1,5 @@
-Thingamajig v1.0
-================
+Thingamajig v1.1-dev
+====================
 
 Thingamajig is a RISC/MISC homebrew computer architecture. Its git
 repository can be found at
@@ -37,10 +37,10 @@ instruction pointer is incremented before being accessed or modified.
 0   HALT
 1   RET                    IP = *RP; RP += 2
 
-2   SHL     RX             RX <<= 1    Logical shifts
-3   SHR     RX             RX >>= 1
-4   ROL     RX             RX <<= 1    Rotating shifts
-5   ROR     RX             RX >>= 1
+2   SHL     RX, N          RX <<= N (logical)     Shifts of 1-4 steps,
+3   SHR     RX, N          RX >>= N (logical)     with 4 encoded as 0
+4   ROL     RX, N          RX <<= N (rotating)    in machine code.
+5   ROR     RX, N          RX >>= N (rotating)
 
 6   NAND    RX, RY         RX = ~(RX & RY)
 7   AND     RX, RY         RX &= RY