Renaming LDI -> LDA, merging PORT -> DOUT #

src/main/java/de/mcs/tools/sps/mnemonic/AbstractMnemonic.java

@@ -88,9 +88,13 @@ public abstract class AbstractMnemonic implements Mnemonic {
   }
 
   public int getArgumentAsNumber() throws IllegalArgument {
+    return getArgumentAsNumber(getArgument());
+  };
+
+  public int getArgumentAsNumber(String arg) throws IllegalArgument {
     int value = 0;
     try {
-      String argument = getArgument().toLowerCase();
+      String argument = arg.toLowerCase();
       if (argument.startsWith("0b")) {
         value = Integer.parseInt(argument.substring(2), 2);
       } else {
@@ -98,7 +102,7 @@ public abstract class AbstractMnemonic implements Mnemonic {
       }
     } catch (Exception e) {
       throw new IllegalArgument(getLineNumber(),
-          String.format("argument %s is not valid for %s.", getArgument(), this.getClass().getSimpleName()));
+          String.format("argument %s is not valid for %s.", arg, this.getClass().getSimpleName()));
     }
     return value;
   };

src/main/java/de/mcs/tools/sps/mnemonic/DOUT.java

@@ -36,22 +36,36 @@ import de.mcs.tools.sps.exceptions.SyntaxError;
  */
 public class DOUT extends AbstractMnemonic implements Mnemonic {
 
+  static int PORT = 0x10;
+  static int DOUT = 0x54;
   byte value;
+  boolean isPort;
 
   public DOUT(String line) throws SyntaxError {
     super(line);
     value = 0;
+    isPort = false;
   }
 
   @Override
   public void checkArgument() throws SyntaxError {
-    if (StringUtils.isEmpty(getArgument())) {
+    String argument = getArgument();
+    if (StringUtils.isEmpty(argument)) {
       value = 0;
+    } else if (argument.startsWith("#")) {
+      isPort = true;
+      String myArgument = argument.substring(1);
+      int myValue = getArgumentAsNumber(myArgument);
+      if ((myValue < 0) || (myValue > 15)) {
+        throw new IllegalArgument(getLineNumber(),
+            String.format("argument %s is not in range 1..4 for %s.", argument, this.getClass().getSimpleName()));
+      }
+      value = (byte) (myValue & 0xFF);
     } else {
       int myValue = getArgumentAsNumber();
       if ((myValue < 1) || (myValue > 4)) {
         throw new IllegalArgument(getLineNumber(),
-            String.format("argument %s is not in range 1..4 for %s.", getArgument(), this.getClass().getSimpleName()));
+            String.format("argument %s is not in range 1..4 for %s.", argument, this.getClass().getSimpleName()));
       }
       value = (byte) (myValue & 0xFF);
     }
@@ -59,7 +73,10 @@ public class DOUT extends AbstractMnemonic implements Mnemonic {
 
   @Override
   public int getByte() {
-    return 0x54 + value;
+    if (isPort) {
+      return PORT + value;
+    }
+    return DOUT + value;
   }
 
   @Override

src/main/java/de/mcs/tools/sps/mnemonic/LDI.java → src/main/java/de/mcs/tools/sps/mnemonic/LDA.java

@@ -33,11 +33,11 @@ import de.mcs.tools.sps.exceptions.SyntaxError;
  * @author wklaa_000
  *
  */
-public class LDI extends AbstractMnemonic implements Mnemonic {
+public class LDA extends AbstractMnemonic implements Mnemonic {
 
   byte value;
 
-  public LDI(String line) throws SyntaxError {
+  public LDA(String line) throws SyntaxError {
     super(line);
     value = 0;
   }

src/test/java/de/mcs/tools/sps/mnemonic/TestDOUT.java

@@ -13,6 +13,7 @@ import de.mcs.tools.sps.exceptions.SyntaxError;
 class TestDOUT {
 
   private static final int BYTE_VALUE = 0x54;
+  private static final int PORT_BYTE_VALUE = 0x10;
   private final String MNEMONIC = "DOUT";
 
   @Test
@@ -31,6 +32,18 @@ class TestDOUT {
     mnemonic.checkArgument();
     assertEquals(BYTE_VALUE + 0x04, mnemonic.getByte());
 
+    mnemonic = new DOUT(MNEMONIC + " #0x04");
+    mnemonic.checkArgument();
+    assertEquals(PORT_BYTE_VALUE + 0x04, mnemonic.getByte());
+
+    mnemonic = new DOUT(MNEMONIC + " #0x00");
+    mnemonic.checkArgument();
+    assertEquals(PORT_BYTE_VALUE + 0x00, mnemonic.getByte());
+
+    mnemonic = new DOUT(MNEMONIC + " #0x0f");
+    mnemonic.checkArgument();
+    assertEquals(PORT_BYTE_VALUE + 0x0f, mnemonic.getByte());
+
     Assertions.assertThrows(SyntaxError.class, () -> {
       DOUT mno1 = new DOUT(MNEMONIC + " 0x05");
       mno1.checkArgument();
@@ -40,6 +53,11 @@ class TestDOUT {
       DOUT mno1 = new DOUT(MNEMONIC + " 0x10");
       mno1.checkArgument();
     });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      DOUT mno1 = new DOUT(MNEMONIC + " #0x10");
+      mno1.checkArgument();
+    });
   }
 
   @Test
@@ -47,6 +65,9 @@ class TestDOUT {
     Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC, 0);
     assertEquals(DOUT.class, mnemonic.getClass());
 
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " #0x04", 0);
+    assertEquals(DOUT.class, mnemonic.getClass());
+
     Assertions.assertThrows(SyntaxError.class, () -> {
       MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
     });
@@ -58,8 +79,8 @@ class TestDOUT {
     mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
     assertEquals(BYTE_VALUE + 0x02, mnemonic.getByte());
 
-    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 3", 0);
-    assertEquals(BYTE_VALUE + 3, mnemonic.getByte());
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " #3", 0);
+    assertEquals(PORT_BYTE_VALUE + 3, mnemonic.getByte());
 
     mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00000100", 0);
     assertEquals(BYTE_VALUE + 4, mnemonic.getByte());

src/test/java/de/mcs/tools/sps/mnemonic/TestLDI.java → src/test/java/de/mcs/tools/sps/mnemonic/TestLDA.java

@@ -10,34 +10,34 @@ import org.junit.jupiter.api.Test;
 import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
-class TestLDI {
+class TestLDA {
 
   private static final int BYTE_VALUE = 0x40;
-  private final String MNEMONIC = "LDI";
+  private final String MNEMONIC = "LDA";
 
   @Test
   void testMnemonic() throws SyntaxError {
-    LDI mnemonic = new LDI(MNEMONIC + " 0x00");
+    LDA mnemonic = new LDA(MNEMONIC + " 0x00");
     mnemonic.checkArgument();
     assertEquals(BYTE_VALUE, mnemonic.getByte());
     assertTrue(mnemonic.hasArgument());
     assertFalse(mnemonic.isUsingPage());
 
-    mnemonic = new LDI(MNEMONIC + " 0x01");
+    mnemonic = new LDA(MNEMONIC + " 0x01");
     mnemonic.checkArgument();
     assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
 
-    mnemonic = new LDI(MNEMONIC + " 0x0f");
+    mnemonic = new LDA(MNEMONIC + " 0x0f");
     mnemonic.checkArgument();
     assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
-      LDI mnemonic1 = new LDI(MNEMONIC);
+      LDA mnemonic1 = new LDA(MNEMONIC);
       mnemonic1.checkArgument();
     });
 
     Assertions.assertThrows(IllegalArgument.class, () -> {
-      LDI mnemonic1 = new LDI(MNEMONIC + " 0x10");
+      LDA mnemonic1 = new LDA(MNEMONIC + " 0x10");
       mnemonic1.checkArgument();
     });
   }
@@ -45,7 +45,7 @@ class TestLDI {
   @Test
   void testMnemonicFactory() throws SyntaxError {
     Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
-    assertEquals(LDI.class, mnemonic.getClass());
+    assertEquals(LDA.class, mnemonic.getClass());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       MnemonicFactory.getMnemonic(MNEMONIC, 0);