adding last implementations

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

@@ -60,4 +60,14 @@ public class ADC extends AbstractMnemonic implements Mnemonic {
     return 0x69 + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * AEQB: skip next command if A = B
+ * 
  * @author wklaa_000
  *
  */

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * AGTB: skip next command if A > B
+ * 
  * @author wklaa_000
  *
  */

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * ALTB: skip next command if A < B
+ * 
  * @author wklaa_000
  *
  */

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

@@ -60,4 +60,14 @@ public class ARC extends AbstractMnemonic implements Mnemonic {
     return 0x6B + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -1,42 +0,0 @@
-/**
- * MCS Media Computer Software
- * Copyright 2018 by Wilfried Klaas
- * Project: SPSEmulator
- * File: Not.java
- * EMail: W.Klaas@gmx.de
- * Created: 25.11.2018 wklaa_000
- * 
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- */
-package de.mcs.tools.sps.mnemonic;
-
-import de.mcs.tools.sps.exceptions.SyntaxError;
-
-/**
- * @author wklaa_000
- *
- */
-public class BAAD extends AbstractMnemonic implements Mnemonic {
-
-  public BAAD(String line) throws SyntaxError {
-    super(line);
-  }
-
-  @Override
-  public int getByte() {
-    // TODO modifier x (1,2)
-    return 0xF0;
-  }
-
-}

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

@@ -0,0 +1,73 @@
+/**
+ * MCS Media Computer Software
+ * Copyright 2018 by Wilfried Klaas
+ * Project: SPSEmulator
+ * File: Not.java
+ * EMail: W.Klaas@gmx.de
+ * Created: 25.11.2018 wklaa_000
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ */
+package de.mcs.tools.sps.mnemonic;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+/**
+ * BADC #x: byte analog input #x to register A. x should be 1 or 2
+ * 
+ * @author wklaa_000
+ *
+ */
+public class BADC extends AbstractMnemonic implements Mnemonic {
+
+  byte value;
+
+  public BADC(String line) throws SyntaxError {
+    super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 1) || (myValue > 2)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 1..2 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) ((myValue - 1) & 0xFF);
+  }
+
+  @Override
+  public int getByte() {
+    return 0xF0 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
+}

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

@@ -21,22 +21,53 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * BARC #x: rc byte input #x to register A. x should be 1 or 2
+ * 
  * @author wklaa_000
  *
  */
 public class BARC extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+
   public BARC(String line) throws SyntaxError {
     super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 1) || (myValue > 2)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 1..2 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) ((myValue - 1) & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1,2)
-    return 0xF2;
+    return 0xF2 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
   }
 
 }

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

@@ -21,22 +21,53 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * BPWM #x: output byte register A to PWM #x. x should be 1 or 2
+ * 
  * @author wklaa_000
  *
  */
 public class BPWM extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+
   public BPWM(String line) throws SyntaxError {
     super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 1) || (myValue > 2)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 1..2 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) ((myValue - 1) & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1,2)
-    return 0xF4;
+    return 0xF4 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
   }
 
 }

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

@@ -21,22 +21,53 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * BSRV #x: output byte register A to servo #x. x should be 1 or 2
+ * 
  * @author wklaa_000
  *
  */
 public class BSRV extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+
   public BSRV(String line) throws SyntaxError {
     super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 1) || (myValue > 2)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 1..2 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) ((myValue - 1) & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1,2)
-    return 0xF6;
+    return 0xF6 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
   }
 
 }

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

@@ -21,26 +21,64 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * CALL #x: Jump to address #x + 16 * PAGE and return on RTR
+ * 
  * @author wklaa_000
  *
  */
 public class CALL extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+  private boolean isLabel;
+
   public CALL(String line) throws SyntaxError {
     super(line);
+    value = 0;
+    isLabel = false;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    String argument = getArgument().trim();
+    if (argument.startsWith(":")) {
+      isLabel = true;
+      return;
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 0) || (myValue > 15)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) (myValue & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (0..15)
-    return 0xD0;
+    return 0xD0 + value;
+  }
+
+  @Override
+  public boolean isLabel() {
+    return isLabel;
   }
 
   @Override
   public boolean isUsingPage() {
     return true;
   }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
 }

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

@@ -21,22 +21,59 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * CASB #x: call to subroutine #x, #x in range 1..6
+ * 
  * @author wklaa_000
  *
  */
 public class CASB extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+  private boolean isLabel;
+
   public CASB(String line) throws SyntaxError {
     super(line);
+    value = 0;
+    isLabel = false;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    String argument = getArgument().trim();
+    if (argument.startsWith(":")) {
+      isLabel = true;
+      return;
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 1) || (myValue > 6)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) ((myValue - 1) & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1..6)
-    return 0xE1;
+    return 0xE1 + value;
   }
 
+  @Override
+  public boolean isLabel() {
+    return isLabel;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
 }

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

@@ -21,22 +21,57 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * DEQ0 #x: Skip next command if digital input #x = 0. #x in range 1..4
+ * 
  * @author wklaa_000
  *
  */
 public class DEQ0 extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+
   public DEQ0(String line) throws SyntaxError {
     super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    if (StringUtils.isEmpty(getArgument())) {
+      value = 0;
+    } 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()));
+      }
+      value = (byte) ((myValue - 1) & 0xFF);
+    }
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1..4)
-    return 0xC8;
+    return 0xC8 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
   }
 
 }

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

@@ -21,22 +21,57 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * DEQ1 #x: Skip next command if digital input #x = 0. #x in range 1..4
+ * 
  * @author wklaa_000
  *
  */
 public class DEQ1 extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+
   public DEQ1(String line) throws SyntaxError {
     super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    if (StringUtils.isEmpty(getArgument())) {
+      value = 0;
+    } 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()));
+      }
+      value = (byte) ((myValue - 1) & 0xFF);
+    }
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1..4)
-    return 0xC4;
+    return 0xC4 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
   }
 
 }

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

@@ -21,22 +21,59 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * DFSB #x: define subroutine #x, #x in range 1..6
+ * 
  * @author wklaa_000
  *
  */
 public class DFSB extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+  private boolean isLabel;
+
   public DFSB(String line) throws SyntaxError {
     super(line);
+    value = 0;
+    isLabel = false;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    String argument = getArgument().trim();
+    if (argument.startsWith(":")) {
+      isLabel = true;
+      return;
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 1) || (myValue > 6)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) ((myValue - 1) & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (1..6)
-    return 0xE8;
+    return 0xE8 + value;
   }
 
+  @Override
+  public boolean isLabel() {
+    return isLabel;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
 }

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

@@ -62,4 +62,14 @@ public class DIN extends AbstractMnemonic implements Mnemonic {
     return 0x64 + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -62,4 +62,14 @@ public class DOUT extends AbstractMnemonic implements Mnemonic {
     return 0x54 + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -23,31 +23,53 @@ package de.mcs.tools.sps.mnemonic;
 
 import org.apache.commons.lang3.StringUtils;
 
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * JMP #x: Jump to address #x + 16 * PAGE
  * 
  * @author wklaa_000
  *
  */
 public class JMP extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+  private boolean isLabel;
+
   public JMP(String line) throws SyntaxError {
     super(line);
+    value = 0;
+    isLabel = false;
   }
 
   @Override
   public void checkArgument() throws SyntaxError {
-    String arg = getArgument();
-    if (StringUtils.isEmpty(arg)) {
-      throw new SyntaxError(getLineNumber(), "Missing argument. JMP should have an argument.");
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    String argument = getArgument().trim();
+    if (argument.startsWith(":")) {
+      isLabel = true;
+      return;
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 0) || (myValue > 15)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
     }
+    value = (byte) (myValue & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (0..15)
-    return 0x90;
+    return 0x90 + value;
+  }
+
+  @Override
+  public boolean isLabel() {
+    return isLabel;
   }
 
   @Override

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

@@ -61,4 +61,14 @@ public class LDI extends AbstractMnemonic implements Mnemonic {
     return 0x40 + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -21,22 +21,55 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * LOOPC #x: if C > 0, C = C - 1 and JMP #x + 16 * PAGE
+ * 
  * @author wklaa_000
  *
  */
 public class LOOPC extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+  private boolean isLabel;
+
   public LOOPC(String line) throws SyntaxError {
     super(line);
+    value = 0;
+    isLabel = false;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    String argument = getArgument().trim();
+    if (argument.startsWith(":")) {
+      isLabel = true;
+      return;
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 0) || (myValue > 15)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) (myValue & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (0..15)
-    return 0xA0;
+    return 0xA0 + value;
+  }
+
+  @Override
+  public boolean isLabel() {
+    return isLabel;
   }
 
   @Override
@@ -44,4 +77,8 @@ public class LOOPC extends AbstractMnemonic implements Mnemonic {
     return true;
   }
 
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
 }

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

@@ -21,22 +21,55 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * LOOPD #x: if D > 0, D = D - 1 and JMP #x + 16 * PAGE
+ * 
  * @author wklaa_000
  *
  */
 public class LOOPD extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+  private boolean isLabel;
+
   public LOOPD(String line) throws SyntaxError {
     super(line);
+    value = 0;
+    isLabel = false;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    String argument = getArgument().trim();
+    if (argument.startsWith(":")) {
+      isLabel = true;
+      return;
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 0) || (myValue > 15)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) (myValue & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (0..15)
-    return 0xB0;
+    return 0xB0 + value;
+  }
+
+  @Override
+  public boolean isLabel() {
+    return isLabel;
   }
 
   @Override
@@ -44,4 +77,8 @@ public class LOOPD extends AbstractMnemonic implements Mnemonic {
     return true;
   }
 
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
 }

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

@@ -100,4 +100,14 @@ public class MOV extends AbstractMnemonic implements Mnemonic {
     return output;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -21,22 +21,53 @@
  */
 package de.mcs.tools.sps.mnemonic;
 
+import org.apache.commons.lang3.StringUtils;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * PAGE #x: setting register PAGE #x, #x in range 0..15
+ * 
  * @author wklaa_000
  *
  */
 public class PAGE extends AbstractMnemonic implements Mnemonic {
 
+  byte value;
+
   public PAGE(String line) throws SyntaxError {
     super(line);
+    value = 0;
+  }
+
+  @Override
+  public void checkArgument() throws SyntaxError {
+    if (StringUtils.isEmpty(getArgument())) {
+      throw new SyntaxError(getLineNumber(),
+          String.format("missing argument for %s.", this.getClass().getSimpleName()));
+    }
+    int myValue = getArgumentAsNumber();
+    if ((myValue < 0) || (myValue > 15)) {
+      throw new IllegalArgument(getLineNumber(),
+          String.format("argument %s is not in range 0..15 for %s.", getArgument(), this.getClass().getSimpleName()));
+    }
+    value = (byte) (myValue & 0xFF);
   }
 
   @Override
   public int getByte() {
-    // TODO modifier x (0..15)
-    return 0x80;
+    return 0x80 + value;
+  }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
   }
 
 }

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * PEND: program end
+ * 
  * @author wklaa_000
  *
  */

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

@@ -60,4 +60,14 @@ public class PORT extends AbstractMnemonic implements Mnemonic {
     return 0x10 + output;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * PRG0: skip if PRG is 0
+ * 
  * @author wklaa_000
  *
  */

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * PRG1: skip if PRG is 1
+ * 
  * @author wklaa_000
  *
  */

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

@@ -60,4 +60,14 @@ public class PWM extends AbstractMnemonic implements Mnemonic {
     return 0x59 + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * REST: restart controller
+ * 
  * @author wklaa_000
  *
  */

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

@@ -40,6 +40,7 @@ public class RJMP extends AbstractMnemonic implements Mnemonic {
   public RJMP(String line) throws SyntaxError {
     super(line);
     value = 0;
+    isLabel = false;
   }
 
   @Override
@@ -74,4 +75,15 @@ public class RJMP extends AbstractMnemonic implements Mnemonic {
   public void setValue(int value) {
     this.value = value;
   }
+
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

src/main/java/de/mcs/tools/sps/mnemonic/RET.java → src/main/java/de/mcs/tools/sps/mnemonic/RTR.java

@@ -24,12 +24,14 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * RTR: Return from sub routine.
+ * 
  * @author wklaa_000
  *
  */
-public class RET extends AbstractMnemonic implements Mnemonic {
+public class RTR extends AbstractMnemonic implements Mnemonic {
 
-  public RET(String line) throws SyntaxError {
+  public RTR(String line) throws SyntaxError {
     super(line);
   }
 

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * SEL0: skip if SEL is 0
+ * 
  * @author wklaa_000
  *
  */

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * SEL1: skip if SEL is 1
+ * 
  * @author wklaa_000
  *
  */

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * SKIP0: skip next command if A = 0
+ * 
  * @author wklaa_000
  *
  */

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

@@ -60,4 +60,14 @@ public class SRV extends AbstractMnemonic implements Mnemonic {
     return 0x5B + value;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * SUB: A = A - B
+ * 
  * @author wklaa_000
  *
  */

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

@@ -24,6 +24,8 @@ package de.mcs.tools.sps.mnemonic;
 import de.mcs.tools.sps.exceptions.SyntaxError;
 
 /**
+ * TONE: output tone with value from register A, A in range 36..108
+ * 
  * @author wklaa_000
  *
  */

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

@@ -105,4 +105,14 @@ public class WAIT extends AbstractMnemonic implements Mnemonic {
     return 0x20 + output;
   }
 
+  @Override
+  public boolean isUsingPage() {
+    return false;
+  }
+
+  @Override
+  public boolean hasArgument() {
+    return true;
+  }
+
 }

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,13 +17,15 @@ class TestADC {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    ADC mno = new ADC(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
+    ADC mnemonic = new ADC(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
 
-    mno = new ADC(MNEMONIC + " 0x02");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
+    mnemonic = new ADC(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       ADC mno1 = new ADC(MNEMONIC + " 0x03");

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,13 +17,15 @@ class TestARC {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    ARC mno = new ARC(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
+    ARC mnemonic = new ARC(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
 
-    mno = new ARC(MNEMONIC + " 0x02");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
+    mnemonic = new ARC(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       ARC mno1 = new ARC(MNEMONIC + " 0x03");

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestBADC {
+
+  private static final int BYTE_VALUE = 0xf0;
+  private final String MNEMONIC = "BADC";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    BADC mnemonic = new BADC(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new BADC(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      BADC mno1 = new BADC(MNEMONIC + " 0x03");
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      BADC mno1 = new BADC(MNEMONIC + " 0");
+      mno1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BADC.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 5", 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00000010", 0);
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+  }
+}

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestBARC {
+
+  private static final int BYTE_VALUE = 0xf2;
+  private final String MNEMONIC = "BARC";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    BARC mnemonic = new BARC(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new BARC(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      BARC mno1 = new BARC(MNEMONIC + " 0x03");
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      BARC mno1 = new BARC(MNEMONIC + " 0");
+      mno1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BARC.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 5", 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00000010", 0);
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+  }
+}

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestBPWM {
+
+  private static final int BYTE_VALUE = 0xf4;
+  private final String MNEMONIC = "BPWM";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    BPWM mnemonic = new BPWM(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new BPWM(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      BPWM mno1 = new BPWM(MNEMONIC + " 0x03");
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      BPWM mno1 = new BPWM(MNEMONIC + " 0");
+      mno1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BPWM.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 5", 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00000010", 0);
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+  }
+}

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestBSRV {
+
+  private static final int BYTE_VALUE = 0x5b;
+  private final String MNEMONIC = "SRV";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    SRV mnemonic = new SRV(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new SRV(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      SRV mno1 = new SRV(MNEMONIC + " 0x03");
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      SRV mno1 = new SRV(MNEMONIC + " 0");
+      mno1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(SRV.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC + " 5", 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 1", 0);
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00000010", 0);
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+  }
+}

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestCALL {
+
+  private static final int BYTE_VALUE = 0xD0;
+  private final String MNEMONIC = "CALL";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    CALL mnemonic = new CALL(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertTrue(mnemonic.isUsingPage());
+
+    mnemonic = new CALL(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = new CALL(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    mnemonic = new CALL(MNEMONIC + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      CALL mnemonic1 = new CALL(MNEMONIC);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      CALL mnemonic1 = new CALL(MNEMONIC + " 0x10");
+      mnemonic1.checkArgument();
+    });
+
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    assertEquals(CALL.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x02, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 12", 0);
+    assertEquals(BYTE_VALUE + 12, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00001010", 0);
+    assertEquals(BYTE_VALUE + 10, mnemonic.getByte());
+
+  }
+}

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

@@ -0,0 +1,123 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestDEQ {
+
+  private static final int BYTE_VALUE_0 = 0xc8;
+  private final String MNEMONIC_0 = "DEQ0";
+  private static final int BYTE_VALUE_1 = 0xc4;
+  private final String MNEMONIC_1 = "DEQ1";
+
+  @Test
+  void testMnemonic0() throws SyntaxError {
+    DEQ0 mnemonic = new DEQ0(MNEMONIC_0 + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_0, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new DEQ0(MNEMONIC_0 + " 0x04");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_0 + 0x03, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      DEQ0 mno1 = new DEQ0(MNEMONIC_0);
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      DEQ0 mno1 = new DEQ0(MNEMONIC_0 + " 0x05");
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      DEQ0 mno1 = new DEQ0(MNEMONIC_0 + " 0x10");
+      mno1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonic1() throws SyntaxError {
+    DEQ1 mnemonic = new DEQ1(MNEMONIC_1 + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_1, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new DEQ1(MNEMONIC_1 + " 0x04");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_1 + 0x03, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      DEQ1 mno1 = new DEQ1(MNEMONIC_1);
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      DEQ1 mno1 = new DEQ1(MNEMONIC_1 + " 0x05");
+      mno1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      DEQ1 mno1 = new DEQ1(MNEMONIC_1 + " 0x10");
+      mno1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonic0Factory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_0 + " 1", 0);
+    assertEquals(DEQ0.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC_0 + " 0x00", 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC_0 + " 5", 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_0 + " 0x02", 0);
+    assertEquals(BYTE_VALUE_0 + 1, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_0 + " 3", 0);
+    assertEquals(BYTE_VALUE_0 + 2, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_0 + " 0b00000100", 0);
+    assertEquals(BYTE_VALUE_0 + 3, mnemonic.getByte());
+
+  }
+
+  @Test
+  void testMnemonic1Factory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_1 + " 1", 0);
+    assertEquals(DEQ1.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC_1 + " 0x00", 0);
+    });
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC_1 + " 5", 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_1 + " 0x02", 0);
+    assertEquals(BYTE_VALUE_1 + 1, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_1 + " 3", 0);
+    assertEquals(BYTE_VALUE_1 + 2, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_1 + " 0b00000100", 0);
+    assertEquals(BYTE_VALUE_1 + 3, mnemonic.getByte());
+
+  }
+}

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,17 +17,19 @@ class TestDIN {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    DIN mno = new DIN(MNEMONIC);
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
-
-    mno = new DIN(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
-
-    mno = new DIN(MNEMONIC + " 0x04");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 0x04, mno.getByte());
+    DIN mnemonic = new DIN(MNEMONIC);
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new DIN(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    mnemonic = new DIN(MNEMONIC + " 0x04");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x04, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       DIN mno1 = new DIN(MNEMONIC + " 0x05");

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,17 +17,19 @@ class TestDOUT {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    DOUT mno = new DOUT(MNEMONIC);
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
-
-    mno = new DOUT(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
-
-    mno = new DOUT(MNEMONIC + " 0x04");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 0x04, mno.getByte());
+    DOUT mnemonic = new DOUT(MNEMONIC);
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new DOUT(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    mnemonic = new DOUT(MNEMONIC + " 0x04");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x04, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       DOUT mno1 = new DOUT(MNEMONIC + " 0x05");

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestJMP {
+
+  private static final int BYTE_VALUE = 0x90;
+  private final String MNEMONIC = "JMP";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    JMP mnemonic = new JMP(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertTrue(mnemonic.isUsingPage());
+
+    mnemonic = new JMP(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = new JMP(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    mnemonic = new JMP(MNEMONIC + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      JMP mnemonic1 = new JMP(MNEMONIC);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      JMP mnemonic1 = new JMP(MNEMONIC + " 0x10");
+      mnemonic1.checkArgument();
+    });
+
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    assertEquals(JMP.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x02, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 12", 0);
+    assertEquals(BYTE_VALUE + 12, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00001010", 0);
+    assertEquals(BYTE_VALUE + 10, mnemonic.getByte());
+
+  }
+}

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -18,6 +20,8 @@ class TestLDI {
     LDI mnemonic = new LDI(MNEMONIC + " 0x00");
     mnemonic.checkArgument();
     assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
 
     mnemonic = new LDI(MNEMONIC + " 0x01");
     mnemonic.checkArgument();

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestLOOPC {
+
+  private static final int BYTE_VALUE = 0xA0;
+  private final String MNEMONIC = "LOOPC";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    LOOPC mnemonic = new LOOPC(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertTrue(mnemonic.isUsingPage());
+
+    mnemonic = new LOOPC(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = new LOOPC(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    mnemonic = new LOOPC(MNEMONIC + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      LOOPC mnemonic1 = new LOOPC(MNEMONIC);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      LOOPC mnemonic1 = new LOOPC(MNEMONIC + " 0x10");
+      mnemonic1.checkArgument();
+    });
+
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    assertEquals(LOOPC.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x02, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 12", 0);
+    assertEquals(BYTE_VALUE + 12, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00001010", 0);
+    assertEquals(BYTE_VALUE + 10, mnemonic.getByte());
+
+  }
+}

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

@@ -0,0 +1,68 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestLOOPD {
+
+  private static final int BYTE_VALUE = 0xB0;
+  private final String MNEMONIC = "LOOPD";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    LOOPD mnemonic = new LOOPD(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertTrue(mnemonic.isUsingPage());
+
+    mnemonic = new LOOPD(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = new LOOPD(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    mnemonic = new LOOPD(MNEMONIC + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      LOOPD mnemonic1 = new LOOPD(MNEMONIC);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      LOOPD mnemonic1 = new LOOPD(MNEMONIC + " 0x10");
+      mnemonic1.checkArgument();
+    });
+
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    assertEquals(LOOPD.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x02, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 12", 0);
+    assertEquals(BYTE_VALUE + 12, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00001010", 0);
+    assertEquals(BYTE_VALUE + 10, mnemonic.getByte());
+
+  }
+}

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -25,45 +27,47 @@ class TestMOV {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    MOV mno = new MOV(MNEMONIC + " A, B");
-    mno.checkArgument();
-    assertEquals(AB, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " A, C");
-    mno.checkArgument();
-    assertEquals(AC, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " A, D");
-    mno.checkArgument();
-    assertEquals(AD, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " A, E");
-    mno.checkArgument();
-    assertEquals(AE, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " A, F");
-    mno.checkArgument();
-    assertEquals(AF, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " B, A");
-    mno.checkArgument();
-    assertEquals(BA, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " C, A");
-    mno.checkArgument();
-    assertEquals(CA, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " D, A");
-    mno.checkArgument();
-    assertEquals(DA, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " E, A");
-    mno.checkArgument();
-    assertEquals(EA, mno.getByte());
-
-    mno = new MOV(MNEMONIC + " F, A");
-    mno.checkArgument();
-    assertEquals(FA, mno.getByte());
+    MOV mnemonic = new MOV(MNEMONIC + " A, B");
+    mnemonic.checkArgument();
+    assertEquals(AB, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new MOV(MNEMONIC + " A, C");
+    mnemonic.checkArgument();
+    assertEquals(AC, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " A, D");
+    mnemonic.checkArgument();
+    assertEquals(AD, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " A, E");
+    mnemonic.checkArgument();
+    assertEquals(AE, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " A, F");
+    mnemonic.checkArgument();
+    assertEquals(AF, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " B, A");
+    mnemonic.checkArgument();
+    assertEquals(BA, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " C, A");
+    mnemonic.checkArgument();
+    assertEquals(CA, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " D, A");
+    mnemonic.checkArgument();
+    assertEquals(DA, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " E, A");
+    mnemonic.checkArgument();
+    assertEquals(EA, mnemonic.getByte());
+
+    mnemonic = new MOV(MNEMONIC + " F, A");
+    mnemonic.checkArgument();
+    assertEquals(FA, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       DIN mno1 = new DIN(MNEMONIC + " 0x05");

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

@@ -0,0 +1,64 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestPAGE {
+
+  private static final int BYTE_VALUE = 0x80;
+  private final String MNEMONIC = "PAGE";
+
+  @Test
+  void testMnemonic() throws SyntaxError {
+    PAGE mnemonic = new PAGE(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new PAGE(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x01, mnemonic.getByte());
+
+    mnemonic = new PAGE(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      PAGE mnemonic1 = new PAGE(MNEMONIC);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      PAGE mnemonic1 = new PAGE(MNEMONIC + " 0x10");
+      mnemonic1.checkArgument();
+    });
+  }
+
+  @Test
+  void testMnemonicFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x00", 0);
+    assertEquals(PAGE.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0x02", 0);
+    assertEquals(BYTE_VALUE + 0x02, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 12", 0);
+    assertEquals(BYTE_VALUE + 12, mnemonic.getByte());
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC + " 0b00001010", 0);
+    assertEquals(BYTE_VALUE + 10, mnemonic.getByte());
+
+  }
+}

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,17 +17,19 @@ class TestPORT {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    PORT mno = new PORT(MNEMONIC + " 0x00");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
+    PORT mnemonic = new PORT(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
 
-    mno = new PORT(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
+    mnemonic = new PORT(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
 
-    mno = new PORT(MNEMONIC + " 0x0f");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 0x0f, mno.getByte());
+    mnemonic = new PORT(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       PORT mno1 = new PORT(MNEMONIC);
@@ -57,4 +61,5 @@ class TestPORT {
     assertEquals(BYTE_VALUE + 10, mnemonic.getByte());
 
   }
+
 }

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,13 +17,15 @@ class TestPWM {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    PWM mno = new PWM(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
+    PWM mnemonic = new PWM(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
 
-    mno = new PWM(MNEMONIC + " 0x02");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
+    mnemonic = new PWM(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       PWM mno1 = new PWM(MNEMONIC + " 0x03");

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

@@ -1,5 +1,6 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -16,21 +17,23 @@ class TestRJMP {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    RJMP rjmp = new RJMP(MNEMONIC + " 0x00");
-    rjmp.checkArgument();
-    assertEquals(BYTE_VALUE, rjmp.getByte());
-
-    rjmp = new RJMP(MNEMONIC + " 0x01");
-    rjmp.checkArgument();
-    assertEquals(BYTE_VALUE + 1, rjmp.getByte());
-
-    rjmp = new RJMP(MNEMONIC + " 0x0f");
-    rjmp.checkArgument();
-    assertEquals(BYTE_VALUE + 0x0f, rjmp.getByte());
-
-    rjmp = new RJMP(MNEMONIC + " :test");
-    rjmp.checkArgument();
-    assertTrue(rjmp.isLabel());
+    RJMP mnemonic = new RJMP(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new RJMP(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    mnemonic = new RJMP(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    mnemonic = new RJMP(MNEMONIC + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       RJMP rjmp1 = new RJMP(MNEMONIC);

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,13 +17,15 @@ class TestSRV {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    SRV mno = new SRV(MNEMONIC + " 0x01");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE, mno.getByte());
+    SRV mnemonic = new SRV(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
 
-    mno = new SRV(MNEMONIC + " 0x02");
-    mno.checkArgument();
-    assertEquals(BYTE_VALUE + 1, mno.getByte());
+    mnemonic = new SRV(MNEMONIC + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       SRV mno1 = new SRV(MNEMONIC + " 0x03");

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

@@ -0,0 +1,121 @@
+package de.mcs.tools.sps.mnemonic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.mcs.tools.sps.exceptions.IllegalArgument;
+import de.mcs.tools.sps.exceptions.SyntaxError;
+
+class TestSUBROUTINE {
+
+  private static final int BYTE_VALUE_CASB = 0xE1;
+  private final String MNEMONIC_CASB = "CASB";
+  private static final int BYTE_VALUE_DFSB = 0xE8;
+  private final String MNEMONIC_DFSB = "DFSB";
+
+  @Test
+  void testMnemonicCASB() throws SyntaxError {
+    CASB mnemonic = new CASB(MNEMONIC_CASB + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_CASB, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new CASB(MNEMONIC_CASB + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_CASB + 0x01, mnemonic.getByte());
+
+    mnemonic = new CASB(MNEMONIC_CASB + " 0x06");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_CASB + 0x05, mnemonic.getByte());
+
+    mnemonic = new CASB(MNEMONIC_CASB + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      CASB mnemonic1 = new CASB(MNEMONIC_CASB);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      CASB mnemonic1 = new CASB(MNEMONIC_CASB + " 0x00");
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      CASB mnemonic1 = new CASB(MNEMONIC_CASB + " 0x07");
+      mnemonic1.checkArgument();
+    });
+
+  }
+
+  @Test
+  void testMnemonicDFSB() throws SyntaxError {
+    DFSB mnemonic = new DFSB(MNEMONIC_DFSB + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_DFSB, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new DFSB(MNEMONIC_DFSB + " 0x02");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_DFSB + 0x01, mnemonic.getByte());
+
+    mnemonic = new DFSB(MNEMONIC_DFSB + " 0x06");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE_DFSB + 0x05, mnemonic.getByte());
+
+    mnemonic = new DFSB(MNEMONIC_DFSB + " :test");
+    mnemonic.checkArgument();
+    assertTrue(mnemonic.isLabel());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      DFSB mnemonic1 = new DFSB(MNEMONIC_DFSB);
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      DFSB mnemonic1 = new DFSB(MNEMONIC_DFSB + " 0x00");
+      mnemonic1.checkArgument();
+    });
+
+    Assertions.assertThrows(IllegalArgument.class, () -> {
+      DFSB mnemonic1 = new DFSB(MNEMONIC_DFSB + " 0x07");
+      mnemonic1.checkArgument();
+    });
+
+  }
+
+  @Test
+  void testMnemonicCASBFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_CASB + " 0x01", 0);
+    assertEquals(CASB.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC_CASB, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_CASB + " 0x02", 0);
+    assertEquals(BYTE_VALUE_CASB + 0x01, mnemonic.getByte());
+
+  }
+
+  @Test
+  void testMnemonicDFSBFactory() throws SyntaxError {
+    Mnemonic mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_DFSB + " 0x01", 0);
+    assertEquals(DFSB.class, mnemonic.getClass());
+
+    Assertions.assertThrows(SyntaxError.class, () -> {
+      MnemonicFactory.getMnemonic(MNEMONIC_DFSB, 0);
+    });
+
+    mnemonic = MnemonicFactory.getMnemonic(MNEMONIC_DFSB + " 0x02", 0);
+    assertEquals(BYTE_VALUE_DFSB + 0x01, mnemonic.getByte());
+
+  }
+}

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

@@ -195,6 +195,78 @@ class TestSingleMnemonics {
     assertEquals(0x7d, mno.getByte());
   }
 
+  @Test
+  void testSKIP0() throws SyntaxError {
+    SKIP0 mno = new SKIP0("SKIP0");
+    assertEquals(0xc0, mno.getByte());
+  }
+
+  @Test
+  void testAGTB() throws SyntaxError {
+    AGTB mno = new AGTB("AGTB");
+    assertEquals(0xc1, mno.getByte());
+  }
+
+  @Test
+  void testALTB() throws SyntaxError {
+    ALTB mno = new ALTB("ALTB");
+    assertEquals(0xc2, mno.getByte());
+  }
+
+  @Test
+  void testAEQB() throws SyntaxError {
+    AEQB mno = new AEQB("AEQB");
+    assertEquals(0xc3, mno.getByte());
+  }
+
+  @Test
+  void testPRG0() throws SyntaxError {
+    PRG0 mno = new PRG0("PRG0");
+    assertEquals(0xcc, mno.getByte());
+  }
+
+  @Test
+  void testPRG1() throws SyntaxError {
+    PRG1 mno = new PRG1("PRG1");
+    assertEquals(0xce, mno.getByte());
+  }
+
+  @Test
+  void testSEL0() throws SyntaxError {
+    SEL0 mno = new SEL0("SEL0");
+    assertEquals(0xcd, mno.getByte());
+  }
+
+  @Test
+  void testSEL1() throws SyntaxError {
+    SEL1 mno = new SEL1("SEL1");
+    assertEquals(0xcf, mno.getByte());
+  }
+
+  @Test
+  void testRTR() throws SyntaxError {
+    RTR mno = new RTR("RTR");
+    assertEquals(0xe0, mno.getByte());
+  }
+
+  @Test
+  void testREST() throws SyntaxError {
+    REST mno = new REST("REST");
+    assertEquals(0xef, mno.getByte());
+  }
+
+  @Test
+  void testTONE() throws SyntaxError {
+    TONE mno = new TONE("TONE");
+    assertEquals(0xf8, mno.getByte());
+  }
+
+  @Test
+  void testPEND() throws SyntaxError {
+    PEND mno = new PEND("PEND");
+    assertEquals(0xff, mno.getByte());
+  }
+
   @Test
   void testMnemonicFactory() throws SyntaxError {
     Mnemonic mnemonic = MnemonicFactory.getMnemonic("SWAP", 0);
@@ -241,5 +313,41 @@ class TestSingleMnemonics {
 
     mnemonic = MnemonicFactory.getMnemonic("BSUBA", 0);
     assertEquals(BSUBA.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("SKIP0", 0);
+    assertEquals(SKIP0.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("AGTB", 0);
+    assertEquals(AGTB.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("ALTB", 0);
+    assertEquals(ALTB.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("AEQB", 0);
+    assertEquals(AEQB.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("PRG0", 0);
+    assertEquals(PRG0.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("PRG1", 0);
+    assertEquals(PRG1.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("SEL0", 0);
+    assertEquals(SEL0.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("SEL1", 0);
+    assertEquals(SEL1.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("RTR", 0);
+    assertEquals(RTR.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("REST", 0);
+    assertEquals(REST.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("TONE", 0);
+    assertEquals(TONE.class, mnemonic.getClass());
+
+    mnemonic = MnemonicFactory.getMnemonic("PEND", 0);
+    assertEquals(PEND.class, mnemonic.getClass());
   }
 }

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

@@ -1,6 +1,8 @@
 package de.mcs.tools.sps.mnemonic;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -15,29 +17,31 @@ class TestWAIT {
 
   @Test
   void testMnemonic() throws SyntaxError {
-    WAIT wait = new WAIT(MNEMONIC + " 0x00");
-    wait.checkArgument();
-    assertEquals(BYTE_VALUE, wait.getByte());
-
-    wait = new WAIT(MNEMONIC + " 0x01");
-    wait.checkArgument();
-    assertEquals(BYTE_VALUE + 1, wait.getByte());
-
-    wait = new WAIT(MNEMONIC + " 0x0f");
-    wait.checkArgument();
-    assertEquals(BYTE_VALUE + 0x0f, wait.getByte());
-
-    wait = new WAIT(MNEMONIC + " 1ms");
-    wait.checkArgument();
-    assertEquals(BYTE_VALUE, wait.getByte());
-
-    wait = new WAIT(MNEMONIC + " 10ms");
-    wait.checkArgument();
-    assertEquals(BYTE_VALUE + 0x03, wait.getByte());
-
-    wait = new WAIT(MNEMONIC + " 60s");
-    wait.checkArgument();
-    assertEquals(BYTE_VALUE + 0x0f, wait.getByte());
+    WAIT mnemonic = new WAIT(MNEMONIC + " 0x00");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+    assertTrue(mnemonic.hasArgument());
+    assertFalse(mnemonic.isUsingPage());
+
+    mnemonic = new WAIT(MNEMONIC + " 0x01");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 1, mnemonic.getByte());
+
+    mnemonic = new WAIT(MNEMONIC + " 0x0f");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
+
+    mnemonic = new WAIT(MNEMONIC + " 1ms");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE, mnemonic.getByte());
+
+    mnemonic = new WAIT(MNEMONIC + " 10ms");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x03, mnemonic.getByte());
+
+    mnemonic = new WAIT(MNEMONIC + " 60s");
+    mnemonic.checkArgument();
+    assertEquals(BYTE_VALUE + 0x0f, mnemonic.getByte());
 
     Assertions.assertThrows(SyntaxError.class, () -> {
       WAIT wait1 = new WAIT(MNEMONIC);