daily pastebin goal
29%
SHARE
TWEET

Untitled

a guest Jul 8th, 2012 202 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using GBHL;
  5.  
  6. namespace GameBoy_Assembler_Plus
  7. {
  8.         public class Assembler
  9.         {
  10.                 char[] splits = { '\n', ',', ' ', '.', '/', ';', '{', '}', '\t' };
  11.                 private byte[] ERR_SYNTAX = new byte[4];
  12.                 private byte[] ERR_OPCODE = new byte[5];
  13.                 private byte[] ERR_LABEL = new byte[7];
  14.                 private byte[] ERR_OUTOFSCOPE = new byte[8];
  15.  
  16.                 public byte[] CompileLine(string s, List<CodeLabel> labels, int thisOffset)
  17.                 {
  18.                         GBFile gb = new GBFile(new byte[3]);
  19.  
  20.                         string[] parts = s.ToLower().Split(splits);
  21.                         if (parts.Length == 0)
  22.                                 return null;
  23.                         try
  24.                         {
  25.                                 switch (parts[0])
  26.                                 {
  27.  
  28.                                         //8-BIT VALUE LOADS
  29.                                         case "ld":
  30.                                                 if (IsSingleRegister(parts[1]) || parts[1] == "(hl)" || parts[1] == "(de)" || parts[1] == "(bc)") //LD R,n
  31.                                                 {
  32.                                                         int value = GetByte(parts[2]);
  33.                                                         if (value != -1 && (value > 0xF || parts[2].StartsWith("0") || value < 0xA))
  34.                                                         {
  35.                                                                 switch (parts[1])
  36.                                                                 {
  37.                                                                         case "a":
  38.                                                                                 WriteOpcode(ref gb, 0x3E, value);
  39.                                                                                 break;
  40.                                                                         case "b":
  41.                                                                                 WriteOpcode(ref gb, 0x06, value);
  42.                                                                                 break;
  43.                                                                         case "c":
  44.                                                                                 WriteOpcode(ref gb, 0x0E, value);
  45.                                                                                 break;
  46.                                                                         case "d":
  47.                                                                                 WriteOpcode(ref gb, 0x16, value);
  48.                                                                                 break;
  49.                                                                         case "e":
  50.                                                                                 WriteOpcode(ref gb, 0x1E, value);
  51.                                                                                 break;
  52.                                                                         case "h":
  53.                                                                                 WriteOpcode(ref gb, 0x26, value);
  54.                                                                                 break;
  55.                                                                         case "l":
  56.                                                                                 WriteOpcode(ref gb, 0x2E, value);
  57.                                                                                 break;
  58.                                                                         case "(hl)":
  59.                                                                                 WriteOpcode(ref gb, 0x36, value);
  60.                                                                                 break;
  61.                                                                 }
  62.                                                                 if (gb.BufferLocation > 0)
  63.                                                                         break;
  64.                                                         }
  65.                                                         else if ((IsSingleRegister(parts[2]) && IsSingleRegister(parts[1])) || (parts[2] == "(hl)" && IsSingleRegister(parts[1])) || (parts[1] == "a" && (parts[2] == "(bc)" || parts[2] == "(de)"))) //LD REGISTER,REGISTER and LD REGISTER,(HL)
  66.                                                         {
  67.                                                                 switch (parts[1]) //LD R,R and LD R,(HL) and LD A,(BC) and LD A,(DE)
  68.                                                                 {
  69.                                                                         case "a":
  70.                                                                                 switch (parts[2])
  71.                                                                                 {
  72.                                                                                         case "a":
  73.                                                                                                 WriteOpcode(ref gb, 0x7F);
  74.                                                                                                 break;
  75.                                                                                         case "b":
  76.                                                                                                 WriteOpcode(ref gb, 0x78);
  77.                                                                                                 break;
  78.                                                                                         case "c":
  79.                                                                                                 WriteOpcode(ref gb, 0x79);
  80.                                                                                                 break;
  81.                                                                                         case "d":
  82.                                                                                                 WriteOpcode(ref gb, 0x7A);
  83.                                                                                                 break;
  84.                                                                                         case "e":
  85.                                                                                                 WriteOpcode(ref gb, 0x7B);
  86.                                                                                                 break;
  87.                                                                                         case "h":
  88.                                                                                                 WriteOpcode(ref gb, 0x7C);
  89.                                                                                                 break;
  90.                                                                                         case "l":
  91.                                                                                                 WriteOpcode(ref gb, 0x7D);
  92.                                                                                                 break;
  93.                                                                                         case "(hl)":
  94.                                                                                                 WriteOpcode(ref gb, 0x7E);
  95.                                                                                                 break;
  96.                                                                                         case "(bc)":
  97.                                                                                                 WriteOpcode(ref gb, 0x0A);
  98.                                                                                                 break;
  99.                                                                                         case "(de)":
  100.                                                                                                 WriteOpcode(ref gb, 0x1A);
  101.                                                                                                 break;
  102.                                                                                 }
  103.                                                                                 break;
  104.                                                                         case "b":
  105.                                                                                 switch (parts[2])
  106.                                                                                 {
  107.                                                                                         case "a":
  108.                                                                                                 WriteOpcode(ref gb, 0x47);
  109.                                                                                                 break;
  110.                                                                                         case "b":
  111.                                                                                                 WriteOpcode(ref gb, 0x40);
  112.                                                                                                 break;
  113.                                                                                         case "c":
  114.                                                                                                 WriteOpcode(ref gb, 0x41);
  115.                                                                                                 break;
  116.                                                                                         case "d":
  117.                                                                                                 WriteOpcode(ref gb, 0x42);
  118.                                                                                                 break;
  119.                                                                                         case "e":
  120.                                                                                                 WriteOpcode(ref gb, 0x43);
  121.                                                                                                 break;
  122.                                                                                         case "h":
  123.                                                                                                 WriteOpcode(ref gb, 0x44);
  124.                                                                                                 break;
  125.                                                                                         case "l":
  126.                                                                                                 WriteOpcode(ref gb, 0x45);
  127.                                                                                                 break;
  128.                                                                                         case "(hl)":
  129.                                                                                                 WriteOpcode(ref gb, 0x46);
  130.                                                                                                 break;
  131.                                                                                         default:
  132.                                                                                                 return ERR_OPCODE;
  133.                                                                                 }
  134.                                                                                 break;
  135.                                                                         case "c":
  136.                                                                                 switch (parts[2])
  137.                                                                                 {
  138.                                                                                         case "a":
  139.                                                                                                 WriteOpcode(ref gb, 0x4F);
  140.                                                                                                 break;
  141.                                                                                         case "b":
  142.                                                                                                 WriteOpcode(ref gb, 0x48);
  143.                                                                                                 break;
  144.                                                                                         case "c":
  145.                                                                                                 WriteOpcode(ref gb, 0x49);
  146.                                                                                                 break;
  147.                                                                                         case "d":
  148.                                                                                                 WriteOpcode(ref gb, 0x4A);
  149.                                                                                                 break;
  150.                                                                                         case "e":
  151.                                                                                                 WriteOpcode(ref gb, 0x4B);
  152.                                                                                                 break;
  153.                                                                                         case "h":
  154.                                                                                                 WriteOpcode(ref gb, 0x4C);
  155.                                                                                                 break;
  156.                                                                                         case "l":
  157.                                                                                                 WriteOpcode(ref gb, 0x4D);
  158.                                                                                                 break;
  159.                                                                                         case "(hl)":
  160.                                                                                                 WriteOpcode(ref gb, 0x4E);
  161.                                                                                                 break;
  162.                                                                                         default:
  163.                                                                                                 return ERR_OPCODE;
  164.                                                                                 }
  165.                                                                                 break;
  166.                                                                         case "d":
  167.                                                                                 switch (parts[2])
  168.                                                                                 {
  169.                                                                                         case "a":
  170.                                                                                                 WriteOpcode(ref gb, 0x57);
  171.                                                                                                 break;
  172.                                                                                         case "b":
  173.                                                                                                 WriteOpcode(ref gb, 0x50);
  174.                                                                                                 break;
  175.                                                                                         case "c":
  176.                                                                                                 WriteOpcode(ref gb, 0x51);
  177.                                                                                                 break;
  178.                                                                                         case "d":
  179.                                                                                                 WriteOpcode(ref gb, 0x52);
  180.                                                                                                 break;
  181.                                                                                         case "e":
  182.                                                                                                 WriteOpcode(ref gb, 0x53);
  183.                                                                                                 break;
  184.                                                                                         case "h":
  185.                                                                                                 WriteOpcode(ref gb, 0x54);
  186.                                                                                                 break;
  187.                                                                                         case "l":
  188.                                                                                                 WriteOpcode(ref gb, 0x55);
  189.                                                                                                 break;
  190.                                                                                         case "(hl)":
  191.                                                                                                 WriteOpcode(ref gb, 0x56);
  192.                                                                                                 break;
  193.                                                                                         default:
  194.                                                                                                 return ERR_OPCODE;
  195.                                                                                 }
  196.                                                                                 break;
  197.                                                                         case "e":
  198.                                                                                 switch (parts[2])
  199.                                                                                 {
  200.                                                                                         case "a":
  201.                                                                                                 WriteOpcode(ref gb, 0x5F);
  202.                                                                                                 break;
  203.                                                                                         case "b":
  204.                                                                                                 WriteOpcode(ref gb, 0x58);
  205.                                                                                                 break;
  206.                                                                                         case "c":
  207.                                                                                                 WriteOpcode(ref gb, 0x59);
  208.                                                                                                 break;
  209.                                                                                         case "d":
  210.                                                                                                 WriteOpcode(ref gb, 0x5A);
  211.                                                                                                 break;
  212.                                                                                         case "e":
  213.                                                                                                 WriteOpcode(ref gb, 0x5B);
  214.                                                                                                 break;
  215.                                                                                         case "h":
  216.                                                                                                 WriteOpcode(ref gb, 0x5C);
  217.                                                                                                 break;
  218.                                                                                         case "l":
  219.                                                                                                 WriteOpcode(ref gb, 0x5D);
  220.                                                                                                 break;
  221.                                                                                         case "(hl)":
  222.                                                                                                 WriteOpcode(ref gb, 0x5E);
  223.                                                                                                 break;
  224.                                                                                         default:
  225.                                                                                                 return ERR_OPCODE;
  226.                                                                                 }
  227.                                                                                 break;
  228.                                                                         case "h":
  229.                                                                                 switch (parts[2])
  230.                                                                                 {
  231.                                                                                         case "a":
  232.                                                                                                 WriteOpcode(ref gb, 0x67);
  233.                                                                                                 break;
  234.                                                                                         case "b":
  235.                                                                                                 WriteOpcode(ref gb, 0x60);
  236.                                                                                                 break;
  237.                                                                                         case "c":
  238.                                                                                                 WriteOpcode(ref gb, 0x61);
  239.                                                                                                 break;
  240.                                                                                         case "d":
  241.                                                                                                 WriteOpcode(ref gb, 0x62);
  242.                                                                                                 break;
  243.                                                                                         case "e":
  244.                                                                                                 WriteOpcode(ref gb, 0x63);
  245.                                                                                                 break;
  246.                                                                                         case "h":
  247.                                                                                                 WriteOpcode(ref gb, 0x64);
  248.                                                                                                 break;
  249.                                                                                         case "l":
  250.                                                                                                 WriteOpcode(ref gb, 0x65);
  251.                                                                                                 break;
  252.                                                                                         case "(hl)":
  253.                                                                                                 WriteOpcode(ref gb, 0x66);
  254.                                                                                                 break;
  255.                                                                                         default:
  256.                                                                                                 return ERR_OPCODE;
  257.                                                                                 }
  258.                                                                                 break;
  259.                                                                         case "l":
  260.                                                                                 switch (parts[2])
  261.                                                                                 {
  262.                                                                                         case "a":
  263.                                                                                                 WriteOpcode(ref gb, 0x6F);
  264.                                                                                                 break;
  265.                                                                                         case "b":
  266.                                                                                                 WriteOpcode(ref gb, 0x68);
  267.                                                                                                 break;
  268.                                                                                         case "c":
  269.                                                                                                 WriteOpcode(ref gb, 0x69);
  270.                                                                                                 break;
  271.                                                                                         case "d":
  272.                                                                                                 WriteOpcode(ref gb, 0x6A);
  273.                                                                                                 break;
  274.                                                                                         case "e":
  275.                                                                                                 WriteOpcode(ref gb, 0x6B);
  276.                                                                                                 break;
  277.                                                                                         case "h":
  278.                                                                                                 WriteOpcode(ref gb, 0x6C);
  279.                                                                                                 break;
  280.                                                                                         case "l":
  281.                                                                                                 WriteOpcode(ref gb, 0x6D);
  282.                                                                                                 break;
  283.                                                                                         case "(hl)":
  284.                                                                                                 WriteOpcode(ref gb, 0x6E);
  285.                                                                                                 break;
  286.                                                                                         default:
  287.                                                                                                 return ERR_OPCODE;
  288.                                                                                 }
  289.                                                                                 break;
  290.                                                                 }
  291.                                                         }
  292.                                                         else if (s.ToLower().StartsWith("ld a,(ff00+c)"))
  293.                                                         {
  294.                                                                 WriteOpcode(ref gb, 0xF2);
  295.                                                         }
  296.                                                         else if (s.ToLower().StartsWith("ld a,(ff00 + c)"))
  297.                                                         {
  298.                                                                 WriteOpcode(ref gb, 0xF2);
  299.                                                         }
  300.                                                         else if (s.ToLower().StartsWith("ld a,(ff00+"))
  301.                                                         {
  302.                                                                 value = GetByte(parts[2].Substring(6, parts[2].IndexOf(")") - 6));
  303.                                                                 if (value == -1)
  304.                                                                         return ERR_SYNTAX;
  305.                                                                 WriteOpcode(ref gb, 0xF0, value);
  306.                                                         }
  307.                                                         else if (s.ToLower().StartsWith("ld a,(ff00 + "))
  308.                                                         {
  309.                                                                 value = GetByte(s.Substring(13, s.IndexOf(")") - 13));
  310.                                                                 if (value == -1)
  311.                                                                         return ERR_SYNTAX;
  312.                                                                 WriteOpcode(ref gb, 0xF0, value);
  313.                                                         }
  314.                                                         else if (parts[1] == "a" && parts[2].StartsWith("(") && parts[2].EndsWith(")"))
  315.                                                         {
  316.                                                                 value = GetByte(parts[2].Substring(1, parts[2].IndexOf(")") - 1));
  317.                                                                 if (value == -1)
  318.                                                                         return ERR_SYNTAX;
  319.                                                                 WriteOpcode(ref gb, 0xFA, (value & 0xFF), (value >> 8));
  320.                                                         }
  321.                                                         else if (parts[1] == "(hl)" && IsSingleRegister(parts[2]))
  322.                                                         {
  323.                                                                 switch (parts[2])
  324.                                                                 {
  325.                                                                         case "a":
  326.                                                                                 WriteOpcode(ref gb, 0x77);
  327.                                                                                 break;
  328.                                                                         case "b":
  329.                                                                                 WriteOpcode(ref gb, 0x70);
  330.                                                                                 break;
  331.                                                                         case "c":
  332.                                                                                 WriteOpcode(ref gb, 0x71);
  333.                                                                                 break;
  334.                                                                         case "d":
  335.                                                                                 WriteOpcode(ref gb, 0x72);
  336.                                                                                 break;
  337.                                                                         case "e":
  338.                                                                                 WriteOpcode(ref gb, 0x73);
  339.                                                                                 break;
  340.                                                                         case "h":
  341.                                                                                 WriteOpcode(ref gb, 0x74);
  342.                                                                                 break;
  343.                                                                         case "l":
  344.                                                                                 WriteOpcode(ref gb, 0x75);
  345.                                                                                 break;
  346.                                                                         default:
  347.                                                                                 return ERR_OPCODE;
  348.                                                                 }
  349.                                                         }
  350.                                                         else if (parts[1] == "(bc)" && parts[2] == "a")
  351.                                                         {
  352.                                                                 WriteOpcode(ref gb, 0x02);
  353.                                                         }
  354.                                                         else if (parts[1] == "(de)" && parts[2] == "a")
  355.                                                         {
  356.                                                                 WriteOpcode(ref gb, 0x12);
  357.                                                         }
  358.                                                         else
  359.                                                         {
  360.                                                                 return ERR_OPCODE;
  361.                                                         }
  362.                                                 }
  363.                                                 else if (IsRegisterPair(parts[1]) || parts[1] == "sp") //"LD RR,nn"
  364.                                                 {
  365.                                                         if (parts[1] == "sp" && parts[2] == "hl")
  366.                                                         {
  367.                                                                 WriteOpcode(ref gb, 0xF9);
  368.                                                                 break;
  369.                                                         }
  370.                                                         int value;
  371.                                                         if (s.StartsWith("ld hl,sp+"))
  372.                                                         {
  373.                                                                 value = GetByte(parts[2].Substring(3));
  374.                                                                 if (value == -1)
  375.                                                                         return ERR_SYNTAX;
  376.                                                                 WriteOpcode(ref gb, 0xF8, (value & 0xFF));
  377.                                                                 break;
  378.                                                         }
  379.                                                         if (s.StartsWith("ld hl,sp + "))
  380.                                                         {
  381.                                                                 value = GetByte(s.Substring(11));
  382.                                                                 if (value == -1)
  383.                                                                         return ERR_SYNTAX;
  384.                                                                 WriteOpcode(ref gb, 0xF8, (value & 0xFF));
  385.                                                                 break;
  386.                                                         }
  387.                                                         value = GetByte(parts[2]);
  388.                                                         if (value == -1)
  389.                                                                 return ERR_SYNTAX;
  390.                                                         switch (parts[1])
  391.                                                         {
  392.                                                                 case "bc":
  393.                                                                         WriteOpcode(ref gb, 0x01, (value & 0xFF), ((value >> 8) & 0xFF));
  394.                                                                         break;
  395.                                                                 case "de":
  396.                                                                         WriteOpcode(ref gb, 0x11, (value & 0xFF), ((value >> 8) & 0xFF));
  397.                                                                         break;
  398.                                                                 case "hl":
  399.                                                                         WriteOpcode(ref gb, 0x21, (value & 0xFF), ((value >> 8) & 0xFF));
  400.                                                                         break;
  401.                                                                 case "sp":
  402.                                                                         WriteOpcode(ref gb, 0x31, (value & 0xFF), ((value >> 8) & 0xFF));
  403.                                                                         break;
  404.                                                         }
  405.                                                 }
  406.                                                 else if (s.ToLower().StartsWith("ld (ff00+c),a"))
  407.                                                 {
  408.                                                         WriteOpcode(ref gb, 0xE2);
  409.                                                 }
  410.                                                 else if (s.ToLower().StartsWith("ld (ff00 + c),a"))
  411.                                                 {
  412.                                                         WriteOpcode(ref gb, 0xE2);
  413.                                                 }
  414.                                                 else if (s.ToLower().StartsWith("ld (ff00+"))
  415.                                                 {
  416.                                                         int value = GetByte(parts[1].Substring(6, parts[1].IndexOf(")") - 6));
  417.                                                         if (value == -1)
  418.                                                                 return ERR_SYNTAX;
  419.                                                         if (parts[2] != "a")
  420.                                                                 return ERR_OPCODE;
  421.                                                         WriteOpcode(ref gb, 0xE0, value);
  422.                                                 }
  423.                                                 else if (s.ToLower().StartsWith("ld (ff00 + "))
  424.                                                 {
  425.                                                         int value = GetByte(s.Substring(11, s.IndexOf(")") - 11));
  426.                                                         if (value == -1)
  427.                                                                 return ERR_SYNTAX;
  428.                                                         if (parts[4] != "a")
  429.                                                                 return ERR_OPCODE;
  430.                                                         WriteOpcode(ref gb, 0xE0, value);
  431.                                                 }
  432.                                                 else if (parts[1].StartsWith("(") && parts[1].EndsWith(")")) //LD (nn),A
  433.                                                 {
  434.                                                         if (parts[2] == "a")
  435.                                                         {
  436.                                                                 int value = GetByte(parts[1].Substring(1, parts[1].IndexOf(")") - 1));
  437.                                                                 if (value == -1)
  438.                                                                         return ERR_SYNTAX;
  439.                                                                 WriteOpcode(ref gb, 0xEA, (value & 0xFF), (value >> 8));
  440.                                                         }
  441.                                                         else if (parts[2] == "sp")
  442.                                                         {
  443.                                                                 int value = GetByte(parts[1].Substring(1, parts[1].IndexOf(")") - 1));
  444.                                                                 if (value == -1)
  445.                                                                         return ERR_SYNTAX;
  446.                                                                 WriteOpcode(ref gb, 0x08, (value & 0xFF), (value >> 8));
  447.                                                         }
  448.                                                         else
  449.                                                                 return ERR_OPCODE;
  450.                                                 }
  451.                                                 else
  452.                                                 {
  453.                                                         return ERR_OPCODE;
  454.                                                 }
  455.                                                 break;
  456.  
  457.                                         case "ldi":
  458.                                                 if (parts[1] == "a" && parts[2] == "(hl)")
  459.                                                 {
  460.                                                         WriteOpcode(ref gb, 0x2A);
  461.                                                 }
  462.                                                 else if (parts[1] == "(hl)" && parts[2] == "a")
  463.                                                 {
  464.                                                         WriteOpcode(ref gb, 0x22);
  465.                                                 }
  466.                                                 else
  467.                                                 {
  468.                                                         return ERR_OPCODE;
  469.                                                 }
  470.                                                 break;
  471.  
  472.                                         case "ldd":
  473.                                                 if (parts[1] == "a" && parts[2] == "(hl)")
  474.                                                 {
  475.                                                         WriteOpcode(ref gb, 0x3A);
  476.                                                 }
  477.                                                 else if (parts[1] == "(hl)" && parts[2] == "a")
  478.                                                 {
  479.                                                         WriteOpcode(ref gb, 0x32);
  480.                                                 }
  481.                                                 else
  482.                                                 {
  483.                                                         return ERR_OPCODE;
  484.                                                 }
  485.                                                 break;
  486.  
  487.                                         case "push":
  488.                                                 if (IsRegisterPair(parts[1]))
  489.                                                 {
  490.                                                         if (parts[1] == "af")
  491.                                                                 WriteOpcode(ref gb, 0xF5);
  492.                                                         else if (parts[1] == "bc")
  493.                                                                 WriteOpcode(ref gb, 0xC5);
  494.                                                         else if (parts[1] == "de")
  495.                                                                 WriteOpcode(ref gb, 0xD5);
  496.                                                         else if (parts[1] == "hl")
  497.                                                                 WriteOpcode(ref gb, 0xE5);
  498.                                                 }
  499.                                                 else
  500.                                                         return ERR_OPCODE;
  501.                                                 break;
  502.  
  503.                                         case "pop":
  504.                                                 if (IsRegisterPair(parts[1]))
  505.                                                 {
  506.                                                         if (parts[1] == "af")
  507.                                                                 WriteOpcode(ref gb, 0xF1);
  508.                                                         else if (parts[1] == "bc")
  509.                                                                 WriteOpcode(ref gb, 0xC1);
  510.                                                         else if (parts[1] == "de")
  511.                                                                 WriteOpcode(ref gb, 0xD1);
  512.                                                         else if (parts[1] == "hl")
  513.                                                                 WriteOpcode(ref gb, 0xE1);
  514.                                                 }
  515.                                                 else
  516.                                                         return ERR_OPCODE;
  517.                                                 break;
  518.  
  519.                                         case "add":
  520.                                                 if (parts[1] == "a")
  521.                                                 {
  522.                                                         switch (parts[2])
  523.                                                         {
  524.                                                                 case "a":
  525.                                                                         WriteOpcode(ref gb, 0x87);
  526.                                                                         break;
  527.                                                                 case "b":
  528.                                                                         WriteOpcode(ref gb, 0x80);
  529.                                                                         break;
  530.                                                                 case "c":
  531.                                                                         WriteOpcode(ref gb, 0x81);
  532.                                                                         break;
  533.                                                                 case "d":
  534.                                                                         WriteOpcode(ref gb, 0x82);
  535.                                                                         break;
  536.                                                                 case "e":
  537.                                                                         WriteOpcode(ref gb, 0x83);
  538.                                                                         break;
  539.                                                                 case "h":
  540.                                                                         WriteOpcode(ref gb, 0x84);
  541.                                                                         break;
  542.                                                                 case "l":
  543.                                                                         WriteOpcode(ref gb, 0x85);
  544.                                                                         break;
  545.                                                                 case "(hl)":
  546.                                                                         WriteOpcode(ref gb, 0x86);
  547.                                                                         break;
  548.                                                                 default:
  549.                                                                         int value = GetByte(parts[2]);
  550.                                                                         if (value == -1)
  551.                                                                                 return ERR_SYNTAX;
  552.                                                                         WriteOpcode(ref gb, 0xC6, (value & 0xFF));
  553.                                                                         break;
  554.                                                         }
  555.                                                 }
  556.                                                 else if (parts[1] == "hl")
  557.                                                 {
  558.                                                         switch (parts[2])
  559.                                                         {
  560.                                                                 case "bc":
  561.                                                                         WriteOpcode(ref gb, 0x09);
  562.                                                                         break;
  563.                                                                 case "de":
  564.                                                                         WriteOpcode(ref gb, 0x19);
  565.                                                                         break;
  566.                                                                 case "hl":
  567.                                                                         WriteOpcode(ref gb, 0x29);
  568.                                                                         break;
  569.                                                                 case "sp":
  570.                                                                         WriteOpcode(ref gb, 0x39);
  571.                                                                         break;
  572.                                                                 default:
  573.                                                                         return ERR_OPCODE;
  574.                                                         }
  575.                                                 }
  576.                                                 else if (parts[1] == "sp")
  577.                                                 {
  578.                                                         int value = GetByte(parts[2]);
  579.                                                         if (value == -1)
  580.                                                                 return ERR_SYNTAX;
  581.                                                         WriteOpcode(ref gb, 0xE8, (value & 0xFF));
  582.                                                 }
  583.                                                 else
  584.                                                 {
  585.                                                         return ERR_OPCODE;
  586.                                                 }
  587.                                                 break;
  588.  
  589.                                         case "adc":
  590.                                                 if (parts[1] == "a")
  591.                                                 {
  592.                                                         switch (parts[2])
  593.                                                         {
  594.                                                                 case "a":
  595.                                                                         WriteOpcode(ref gb, 0x8F);
  596.                                                                         break;
  597.                                                                 case "b":
  598.                                                                         WriteOpcode(ref gb, 0x88);
  599.                                                                         break;
  600.                                                                 case "c":
  601.                                                                         WriteOpcode(ref gb, 0x89);
  602.                                                                         break;
  603.                                                                 case "d":
  604.                                                                         WriteOpcode(ref gb, 0x8A);
  605.                                                                         break;
  606.                                                                 case "e":
  607.                                                                         WriteOpcode(ref gb, 0x8B);
  608.                                                                         break;
  609.                                                                 case "h":
  610.                                                                         WriteOpcode(ref gb, 0x8C);
  611.                                                                         break;
  612.                                                                 case "l":
  613.                                                                         WriteOpcode(ref gb, 0x8D);
  614.                                                                         break;
  615.                                                                 case "(hl)":
  616.                                                                         WriteOpcode(ref gb, 0x8E);
  617.                                                                         break;
  618.                                                                 default:
  619.                                                                         int value = GetByte(parts[2]);
  620.                                                                         if (value == -1)
  621.                                                                                 return ERR_SYNTAX;
  622.                                                                         WriteOpcode(ref gb, 0xCE, (value & 0xFF));
  623.                                                                         break;
  624.                                                         }
  625.                                                 }
  626.                                                 break;
  627.  
  628.                                         case "sub":
  629.                                                 if (parts[1] == "a")
  630.                                                 {
  631.                                                         switch (parts[2])
  632.                                                         {
  633.                                                                 case "a":
  634.                                                                         WriteOpcode(ref gb, 0x97);
  635.                                                                         break;
  636.                                                                 case "b":
  637.                                                                         WriteOpcode(ref gb, 0x90);
  638.                                                                         break;
  639.                                                                 case "c":
  640.                                                                         WriteOpcode(ref gb, 0x91);
  641.                                                                         break;
  642.                                                                 case "d":
  643.                                                                         WriteOpcode(ref gb, 0x92);
  644.                                                                         break;
  645.                                                                 case "e":
  646.                                                                         WriteOpcode(ref gb, 0x93);
  647.                                                                         break;
  648.                                                                 case "h":
  649.                                                                         WriteOpcode(ref gb, 0x94);
  650.                                                                         break;
  651.                                                                 case "l":
  652.                                                                         WriteOpcode(ref gb, 0x95);
  653.                                                                         break;
  654.                                                                 case "(hl)":
  655.                                                                         WriteOpcode(ref gb, 0x96);
  656.                                                                         break;
  657.                                                                 default:
  658.                                                                         int value = GetByte(parts[2]);
  659.                                                                         if (value == -1)
  660.                                                                                 return ERR_SYNTAX;
  661.                                                                         WriteOpcode(ref gb, 0xD6, (value & 0xFF));
  662.                                                                         break;
  663.                                                         }
  664.                                                 }
  665.                                                 break;
  666.  
  667.                                         case "sbc":
  668.                                                 if (parts[1] == "a")
  669.                                                 {
  670.                                                         switch (parts[2])
  671.                                                         {
  672.                                                                 case "a":
  673.                                                                         WriteOpcode(ref gb, 0x9F);
  674.                                                                         break;
  675.                                                                 case "b":
  676.                                                                         WriteOpcode(ref gb, 0x98);
  677.                                                                         break;
  678.                                                                 case "c":
  679.                                                                         WriteOpcode(ref gb, 0x99);
  680.                                                                         break;
  681.                                                                 case "d":
  682.                                                                         WriteOpcode(ref gb, 0x9A);
  683.                                                                         break;
  684.                                                                 case "e":
  685.                                                                         WriteOpcode(ref gb, 0x9B);
  686.                                                                         break;
  687.                                                                 case "h":
  688.                                                                         WriteOpcode(ref gb, 0x9C);
  689.                                                                         break;
  690.                                                                 case "l":
  691.                                                                         WriteOpcode(ref gb, 0x9D);
  692.                                                                         break;
  693.                                                                 case "(hl)":
  694.                                                                         WriteOpcode(ref gb, 0x9E);
  695.                                                                         break;
  696.                                                                 default:
  697.                                                                         return ERR_SYNTAX;
  698.                                                         }
  699.                                                 }
  700.                                                 break;
  701.  
  702.                                         case "and":
  703.                                                 if (parts[1] == "a")
  704.                                                 {
  705.                                                         switch (parts[2])
  706.                                                         {
  707.                                                                 case "a":
  708.                                                                         WriteOpcode(ref gb, 0xA7);
  709.                                                                         break;
  710.                                                                 case "b":
  711.                                                                         WriteOpcode(ref gb, 0xA0);
  712.                                                                         break;
  713.                                                                 case "c":
  714.                                                                         WriteOpcode(ref gb, 0xA1);
  715.                                                                         break;
  716.                                                                 case "d":
  717.                                                                         WriteOpcode(ref gb, 0xA2);
  718.                                                                         break;
  719.                                                                 case "e":
  720.                                                                         WriteOpcode(ref gb, 0xA3);
  721.                                                                         break;
  722.                                                                 case "h":
  723.                                                                         WriteOpcode(ref gb, 0xA4);
  724.                                                                         break;
  725.                                                                 case "l":
  726.                                                                         WriteOpcode(ref gb, 0xA5);
  727.                                                                         break;
  728.                                                                 case "(hl)":
  729.                                                                         WriteOpcode(ref gb, 0xA6);
  730.                                                                         break;
  731.                                                                 default:
  732.                                                                         int value = GetByte(parts[2]);
  733.                                                                         if (value == -1)
  734.                                                                                 return ERR_SYNTAX;
  735.                                                                         WriteOpcode(ref gb, 0xE6, (value & 0xFF));
  736.                                                                         break;
  737.                                                         }
  738.                                                 }
  739.                                                 break;
  740.  
  741.                                         case "or":
  742.                                                 if (parts[1] == "a")
  743.                                                 {
  744.                                                         switch (parts[2])
  745.                                                         {
  746.                                                                 case "a":
  747.                                                                         WriteOpcode(ref gb, 0xB7);
  748.                                                                         break;
  749.                                                                 case "b":
  750.                                                                         WriteOpcode(ref gb, 0xB0);
  751.                                                                         break;
  752.                                                                 case "c":
  753.                                                                         WriteOpcode(ref gb, 0xB1);
  754.                                                                         break;
  755.                                                                 case "d":
  756.                                                                         WriteOpcode(ref gb, 0xB2);
  757.                                                                         break;
  758.                                                                 case "e":
  759.                                                                         WriteOpcode(ref gb, 0xB3);
  760.                                                                         break;
  761.                                                                 case "h":
  762.                                                                         WriteOpcode(ref gb, 0xB4);
  763.                                                                         break;
  764.                                                                 case "l":
  765.                                                                         WriteOpcode(ref gb, 0xB5);
  766.                                                                         break;
  767.                                                                 case "(hl)":
  768.                                                                         WriteOpcode(ref gb, 0xB6);
  769.                                                                         break;
  770.                                                                 default:
  771.                                                                         int value = GetByte(parts[2]);
  772.                                                                         if (value == -1)
  773.                                                                                 return ERR_SYNTAX;
  774.                                                                         WriteOpcode(ref gb, 0xF6, (value & 0xFF));
  775.                                                                         break;
  776.                                                         }
  777.                                                 }
  778.                                                 break;
  779.  
  780.                                         case "xor":
  781.                                                 if (parts[1] == "a")
  782.                                                 {
  783.                                                         switch (parts[2])
  784.                                                         {
  785.                                                                 case "a":
  786.                                                                         WriteOpcode(ref gb, 0xAF);
  787.                                                                         break;
  788.                                                                 case "b":
  789.                                                                         WriteOpcode(ref gb, 0xA8);
  790.                                                                         break;
  791.                                                                 case "c":
  792.                                                                         WriteOpcode(ref gb, 0xA9);
  793.                                                                         break;
  794.                                                                 case "d":
  795.                                                                         WriteOpcode(ref gb, 0xAA);
  796.                                                                         break;
  797.                                                                 case "e":
  798.                                                                         WriteOpcode(ref gb, 0xAB);
  799.                                                                         break;
  800.                                                                 case "h":
  801.                                                                         WriteOpcode(ref gb, 0xAC);
  802.                                                                         break;
  803.                                                                 case "l":
  804.                                                                         WriteOpcode(ref gb, 0xAD);
  805.                                                                         break;
  806.                                                                 case "(hl)":
  807.                                                                         WriteOpcode(ref gb, 0xAE);
  808.                                                                         break;
  809.                                                                 default:
  810.                                                                         int value = GetByte(parts[2]);
  811.                                                                         if (value == -1)
  812.                                                                                 return ERR_SYNTAX;
  813.                                                                         WriteOpcode(ref gb, 0xEE, (value & 0xFF));
  814.                                                                         break;
  815.                                                         }
  816.                                                 }
  817.                                                 break;
  818.  
  819.                                         case "cp":
  820.                                                 if (parts[1] == "a")
  821.                                                 {
  822.                                                         switch (parts[2])
  823.                                                         {
  824.                                                                 case "a":
  825.                                                                         WriteOpcode(ref gb, 0xBF);
  826.                                                                         break;
  827.                                                                 case "b":
  828.                                                                         WriteOpcode(ref gb, 0xB8);
  829.                                                                         break;
  830.                                                                 case "c":
  831.                                                                         WriteOpcode(ref gb, 0xB9);
  832.                                                                         break;
  833.                                                                 case "d":
  834.                                                                         WriteOpcode(ref gb, 0xBA);
  835.                                                                         break;
  836.                                                                 case "e":
  837.                                                                         WriteOpcode(ref gb, 0xBB);
  838.                                                                         break;
  839.                                                                 case "h":
  840.                                                                         WriteOpcode(ref gb, 0xBC);
  841.                                                                         break;
  842.                                                                 case "l":
  843.                                                                         WriteOpcode(ref gb, 0xBD);
  844.                                                                         break;
  845.                                                                 case "(hl)":
  846.                                                                         WriteOpcode(ref gb, 0xBE);
  847.                                                                         break;
  848.                                                                 default:
  849.                                                                         int value = GetByte(parts[2]);
  850.                                                                         if (value == -1)
  851.                                                                                 return ERR_SYNTAX;
  852.                                                                         WriteOpcode(ref gb, 0xFE, (value & 0xFF));
  853.                                                                         break;
  854.                                                         }
  855.                                                 }
  856.                                                 break;
  857.  
  858.                                         case "inc":
  859.                                                 switch (parts[1])
  860.                                                 {
  861.                                                         case "a":
  862.                                                                 WriteOpcode(ref gb, 0x3C);
  863.                                                                 break;
  864.                                                         case "b":
  865.                                                                 WriteOpcode(ref gb, 0x04);
  866.                                                                 break;
  867.                                                         case "c":
  868.                                                                 WriteOpcode(ref gb, 0x0C);
  869.                                                                 break;
  870.                                                         case "d":
  871.                                                                 WriteOpcode(ref gb, 0x14);
  872.                                                                 break;
  873.                                                         case "e":
  874.                                                                 WriteOpcode(ref gb, 0x1C);
  875.                                                                 break;
  876.                                                         case "h":
  877.                                                                 WriteOpcode(ref gb, 0x24);
  878.                                                                 break;
  879.                                                         case "l":
  880.                                                                 WriteOpcode(ref gb, 0x2C);
  881.                                                                 break;
  882.                                                         case "(hl)":
  883.                                                                 WriteOpcode(ref gb, 0x34);
  884.                                                                 break;
  885.  
  886.                                                         //16-Bit
  887.                                                         case "bc":
  888.                                                                 WriteOpcode(ref gb, 0x03);
  889.                                                                 break;
  890.                                                         case "de":
  891.                                                                 WriteOpcode(ref gb, 0x13);
  892.                                                                 break;
  893.                                                         case "hl":
  894.                                                                 WriteOpcode(ref gb, 0x23);
  895.                                                                 break;
  896.                                                         case "sp":
  897.                                                                 WriteOpcode(ref gb, 0x33);
  898.                                                                 break;
  899.  
  900.                                                         default:
  901.                                                                 return ERR_OPCODE;
  902.                                                 }
  903.                                                 break;
  904.  
  905.                                         case "dec":
  906.                                                 switch (parts[1])
  907.                                                 {
  908.                                                         case "a":
  909.                                                                 WriteOpcode(ref gb, 0x3D);
  910.                                                                 break;
  911.                                                         case "b":
  912.                                                                 WriteOpcode(ref gb, 0x05);
  913.                                                                 break;
  914.                                                         case "c":
  915.                                                                 WriteOpcode(ref gb, 0x0D);
  916.                                                                 break;
  917.                                                         case "d":
  918.                                                                 WriteOpcode(ref gb, 0x15);
  919.                                                                 break;
  920.                                                         case "e":
  921.                                                                 WriteOpcode(ref gb, 0x1D);
  922.                                                                 break;
  923.                                                         case "h":
  924.                                                                 WriteOpcode(ref gb, 0x25);
  925.                                                                 break;
  926.                                                         case "l":
  927.                                                                 WriteOpcode(ref gb, 0x2D);
  928.                                                                 break;
  929.                                                         case "(hl)":
  930.                                                                 WriteOpcode(ref gb, 0x35);
  931.                                                                 break;
  932.  
  933.                                                         //16-Bit
  934.                                                         case "bc":
  935.                                                                 WriteOpcode(ref gb, 0x0B);
  936.                                                                 break;
  937.                                                         case "de":
  938.                                                                 WriteOpcode(ref gb, 0x1B);
  939.                                                                 break;
  940.                                                         case "hl":
  941.                                                                 WriteOpcode(ref gb, 0x2B);
  942.                                                                 break;
  943.                                                         case "sp":
  944.                                                                 WriteOpcode(ref gb, 0x3B);
  945.                                                                 break;
  946.  
  947.                                                         default:
  948.                                                                 return ERR_OPCODE;
  949.                                                 }
  950.                                                 break;
  951.  
  952.                                         case "swap":
  953.                                                 switch (parts[1])
  954.                                                 {
  955.                                                         case "a":
  956.                                                                 WriteOpcode(ref gb, 0xCB, 0x37);
  957.                                                                 break;
  958.                                                         case "b":
  959.                                                                 WriteOpcode(ref gb, 0xCB, 0x30);
  960.                                                                 break;
  961.                                                         case "c":
  962.                                                                 WriteOpcode(ref gb, 0xCB, 0x31);
  963.                                                                 break;
  964.                                                         case "d":
  965.                                                                 WriteOpcode(ref gb, 0xCB, 0x32);
  966.                                                                 break;
  967.                                                         case "e":
  968.                                                                 WriteOpcode(ref gb, 0xCB, 0x33);
  969.                                                                 break;
  970.                                                         case "h":
  971.                                                                 WriteOpcode(ref gb, 0xCB, 0x34);
  972.                                                                 break;
  973.                                                         case "l":
  974.                                                                 WriteOpcode(ref gb, 0xCB, 0x35);
  975.                                                                 break;
  976.                                                         case "(hl)":
  977.                                                                 WriteOpcode(ref gb, 0xCB, 0x36);
  978.                                                                 break;
  979.                                                 }
  980.                                                 break;
  981.  
  982.                                         case "daa":
  983.                                                 WriteOpcode(ref gb, 0x27);
  984.                                                 break;
  985.  
  986.                                         case "cpl":
  987.                                                 WriteOpcode(ref gb, 0x2F);
  988.                                                 break;
  989.  
  990.                                         case "ccf":
  991.                                                 WriteOpcode(ref gb, 0x3F);
  992.                                                 break;
  993.  
  994.                                         case "scf":
  995.                                                 WriteOpcode(ref gb, 0x37);
  996.                                                 break;
  997.  
  998.                                         case "nop":
  999.                                                 WriteOpcode(ref gb, 0x00);
  1000.                                                 break;
  1001.  
  1002.                                         case "halt":
  1003.                                                 WriteOpcode(ref gb, 0x76);
  1004.                                                 break;
  1005.  
  1006.                                         case "stop":
  1007.                                                 WriteOpcode(ref gb, 0x10, 0x00);
  1008.                                                 break;
  1009.  
  1010.                                         case "di":
  1011.                                                 WriteOpcode(ref gb, 0xF3);
  1012.                                                 break;
  1013.  
  1014.                                         case "ei":
  1015.                                                 WriteOpcode(ref gb, 0xFB);
  1016.                                                 break;
  1017.  
  1018.                                         case "rlca":
  1019.                                                 WriteOpcode(ref gb, 0x07);
  1020.                                                 break;
  1021.  
  1022.                                         case "rla":
  1023.                                                 WriteOpcode(ref gb, 0x17);
  1024.                                                 break;
  1025.  
  1026.                                         case "rrca":
  1027.                                                 WriteOpcode(ref gb, 0x0F);
  1028.                                                 break;
  1029.  
  1030.                                         case "rra":
  1031.                                                 WriteOpcode(ref gb, 0x1F);
  1032.                                                 break;
  1033.  
  1034.                                         case "rlc":
  1035.                                                 switch (parts[1])
  1036.                                                 {
  1037.                                                         case "a":
  1038.                                                                 WriteOpcode(ref gb, 0xCB, 0x07);
  1039.                                                                 break;
  1040.                                                         case "b":
  1041.                                                                 WriteOpcode(ref gb, 0xCB, 0x00);
  1042.                                                                 break;
  1043.                                                         case "c":
  1044.                                                                 WriteOpcode(ref gb, 0xCB, 0x01);
  1045.                                                                 break;
  1046.                                                         case "d":
  1047.                                                                 WriteOpcode(ref gb, 0xCB, 0x02);
  1048.                                                                 break;
  1049.                                                         case "e":
  1050.                                                                 WriteOpcode(ref gb, 0xCB, 0x03);
  1051.                                                                 break;
  1052.                                                         case "h":
  1053.                                                                 WriteOpcode(ref gb, 0xCB, 0x04);
  1054.                                                                 break;
  1055.                                                         case "l":
  1056.                                                                 WriteOpcode(ref gb, 0xCB, 0x05);
  1057.                                                                 break;
  1058.                                                         case "(hl)":
  1059.                                                                 WriteOpcode(ref gb, 0xCB, 0x06);
  1060.                                                                 break;
  1061.                                                 }
  1062.                                                 break;
  1063.  
  1064.                                         case "rl":
  1065.                                                 switch (parts[1])
  1066.                                                 {
  1067.                                                         case "a":
  1068.                                                                 WriteOpcode(ref gb, 0xCB, 0x17);
  1069.                                                                 break;
  1070.                                                         case "b":
  1071.                                                                 WriteOpcode(ref gb, 0xCB, 0x10);
  1072.                                                                 break;
  1073.                                                         case "c":
  1074.                                                                 WriteOpcode(ref gb, 0xCB, 0x11);
  1075.                                                                 break;
  1076.                                                         case "d":
  1077.                                                                 WriteOpcode(ref gb, 0xCB, 0x12);
  1078.                                                                 break;
  1079.                                                         case "e":
  1080.                                                                 WriteOpcode(ref gb, 0xCB, 0x13);
  1081.                                                                 break;
  1082.                                                         case "h":
  1083.                                                                 WriteOpcode(ref gb, 0xCB, 0x14);
  1084.                                                                 break;
  1085.                                                         case "l":
  1086.                                                                 WriteOpcode(ref gb, 0xCB, 0x15);
  1087.                                                                 break;
  1088.                                                         case "(hl)":
  1089.                                                                 WriteOpcode(ref gb, 0xCB, 0x16);
  1090.                                                                 break;
  1091.                                                 }
  1092.                                                 break;
  1093.  
  1094.                                         case "rrc":
  1095.                                                 switch (parts[1])
  1096.                                                 {
  1097.                                                         case "a":
  1098.                                                                 WriteOpcode(ref gb, 0xCB, 0x0F);
  1099.                                                                 break;
  1100.                                                         case "b":
  1101.                                                                 WriteOpcode(ref gb, 0xCB, 0x08);
  1102.                                                                 break;
  1103.                                                         case "c":
  1104.                                                                 WriteOpcode(ref gb, 0xCB, 0x09);
  1105.                                                                 break;
  1106.                                                         case "d":
  1107.                                                                 WriteOpcode(ref gb, 0xCB, 0x0A);
  1108.                                                                 break;
  1109.                                                         case "e":
  1110.                                                                 WriteOpcode(ref gb, 0xCB, 0x0B);
  1111.                                                                 break;
  1112.                                                         case "h":
  1113.                                                                 WriteOpcode(ref gb, 0xCB, 0x0C);
  1114.                                                                 break;
  1115.                                                         case "l":
  1116.                                                                 WriteOpcode(ref gb, 0xCB, 0x0D);
  1117.                                                                 break;
  1118.                                                         case "(hl)":
  1119.                                                                 WriteOpcode(ref gb, 0xCB, 0x0E);
  1120.                                                                 break;
  1121.                                                 }
  1122.                                                 break;
  1123.  
  1124.                                         case "rr":
  1125.                                                 switch (parts[1])
  1126.                                                 {
  1127.                                                         case "a":
  1128.                                                                 WriteOpcode(ref gb, 0xCB, 0x1F);
  1129.                                                                 break;
  1130.                                                         case "b":
  1131.                                                                 WriteOpcode(ref gb, 0xCB, 0x18);
  1132.                                                                 break;
  1133.                                                         case "c":
  1134.                                                                 WriteOpcode(ref gb, 0xCB, 0x19);
  1135.                                                                 break;
  1136.                                                         case "d":
  1137.                                                                 WriteOpcode(ref gb, 0xCB, 0x1A);
  1138.                                                                 break;
  1139.                                                         case "e":
  1140.                                                                 WriteOpcode(ref gb, 0xCB, 0x1B);
  1141.                                                                 break;
  1142.                                                         case "h":
  1143.                                                                 WriteOpcode(ref gb, 0xCB, 0x1C);
  1144.                                                                 break;
  1145.                                                         case "l":
  1146.                                                                 WriteOpcode(ref gb, 0xCB, 0x1D);
  1147.                                                                 break;
  1148.                                                         case "(hl)":
  1149.                                                                 WriteOpcode(ref gb, 0xCB, 0x1E);
  1150.                                                                 break;
  1151.                                                 }
  1152.                                                 break;
  1153.  
  1154.                                         case "sla":
  1155.                                                 switch (parts[1])
  1156.                                                 {
  1157.                                                         case "a":
  1158.                                                                 WriteOpcode(ref gb, 0xCB, 0x27);
  1159.                                                                 break;
  1160.                                                         case "b":
  1161.                                                                 WriteOpcode(ref gb, 0xCB, 0x20);
  1162.                                                                 break;
  1163.                                                         case "c":
  1164.                                                                 WriteOpcode(ref gb, 0xCB, 0x21);
  1165.                                                                 break;
  1166.                                                         case "d":
  1167.                                                                 WriteOpcode(ref gb, 0xCB, 0x22);
  1168.                                                                 break;
  1169.                                                         case "e":
  1170.                                                                 WriteOpcode(ref gb, 0xCB, 0x23);
  1171.                                                                 break;
  1172.                                                         case "h":
  1173.                                                                 WriteOpcode(ref gb, 0xCB, 0x24);
  1174.                                                                 break;
  1175.                                                         case "l":
  1176.                                                                 WriteOpcode(ref gb, 0xCB, 0x25);
  1177.                                                                 break;
  1178.                                                         case "(hl)":
  1179.                                                                 WriteOpcode(ref gb, 0xCB, 0x26);
  1180.                                                                 break;
  1181.                                                 }
  1182.                                                 break;
  1183.  
  1184.                                         case "sra":
  1185.                                                 switch (parts[1])
  1186.                                                 {
  1187.                                                         case "a":
  1188.                                                                 WriteOpcode(ref gb, 0xCB, 0x2F);
  1189.                                                                 break;
  1190.                                                         case "b":
  1191.                                                                 WriteOpcode(ref gb, 0xCB, 0x28);
  1192.                                                                 break;
  1193.                                                         case "c":
  1194.                                                                 WriteOpcode(ref gb, 0xCB, 0x29);
  1195.                                                                 break;
  1196.                                                         case "d":
  1197.                                                                 WriteOpcode(ref gb, 0xCB, 0x2A);
  1198.                                                                 break;
  1199.                                                         case "e":
  1200.                                                                 WriteOpcode(ref gb, 0xCB, 0x2B);
  1201.                                                                 break;
  1202.                                                         case "h":
  1203.                                                                 WriteOpcode(ref gb, 0xCB, 0x2C);
  1204.                                                                 break;
  1205.                                                         case "l":
  1206.                                                                 WriteOpcode(ref gb, 0xCB, 0x2D);
  1207.                                                                 break;
  1208.                                                         case "(hl)":
  1209.                                                                 WriteOpcode(ref gb, 0xCB, 0x2E);
  1210.                                                                 break;
  1211.                                                 }
  1212.                                                 break;
  1213.  
  1214.                                         case "slr":
  1215.                                                 switch (parts[1])
  1216.                                                 {
  1217.                                                         case "a":
  1218.                                                                 WriteOpcode(ref gb, 0xCB, 0x3F);
  1219.                                                                 break;
  1220.                                                         case "b":
  1221.                                                                 WriteOpcode(ref gb, 0xCB, 0x38);
  1222.                                                                 break;
  1223.                                                         case "c":
  1224.                                                                 WriteOpcode(ref gb, 0xCB, 0x39);
  1225.                                                                 break;
  1226.                                                         case "d":
  1227.                                                                 WriteOpcode(ref gb, 0xCB, 0x3A);
  1228.                                                                 break;
  1229.                                                         case "e":
  1230.                                                                 WriteOpcode(ref gb, 0xCB, 0x3B);
  1231.                                                                 break;
  1232.                                                         case "h":
  1233.                                                                 WriteOpcode(ref gb, 0xCB, 0x3C);
  1234.                                                                 break;
  1235.                                                         case "l":
  1236.                                                                 WriteOpcode(ref gb, 0xCB, 0x3D);
  1237.                                                                 break;
  1238.                                                         case "(hl)":
  1239.                                                                 WriteOpcode(ref gb, 0xCB, 0x3E);
  1240.                                                                 break;
  1241.                                                 }
  1242.                                                 break;
  1243.  
  1244.                                         case "bit":
  1245.                                                 int bas = GetByte(parts[1]);
  1246.                                                 if (bas < 0 || bas > 7)
  1247.                                                         return ERR_SYNTAX;
  1248.                                                 bas *= 8;
  1249.                                                 switch (parts[2])
  1250.                                                 {
  1251.                                                         case "a":
  1252.                                                                 WriteOpcode(ref gb, 0xCB, 0x47 + bas);
  1253.                                                                 break;
  1254.                                                         case "b":
  1255.                                                                 WriteOpcode(ref gb, 0xCB, 0x40 + bas);
  1256.                                                                 break;
  1257.                                                         case "c":
  1258.                                                                 WriteOpcode(ref gb, 0xCB, 0x41 + bas);
  1259.                                                                 break;
  1260.                                                         case "d":
  1261.                                                                 WriteOpcode(ref gb, 0xCB, 0x42 + bas);
  1262.                                                                 break;
  1263.                                                         case "e":
  1264.                                                                 WriteOpcode(ref gb, 0xCB, 0x43 + bas);
  1265.                                                                 break;
  1266.                                                         case "h":
  1267.                                                                 WriteOpcode(ref gb, 0xCB, 0x44 + bas);
  1268.                                                                 break;
  1269.                                                         case "l":
  1270.                                                                 WriteOpcode(ref gb, 0xCB, 0x45 + bas);
  1271.                                                                 break;
  1272.                                                         case "(hl)":
  1273.                                                                 WriteOpcode(ref gb, 0xCB, 0x46 + bas);
  1274.                                                                 break;
  1275.                                                 }
  1276.                                                 break;
  1277.  
  1278.                                         case "set":
  1279.                                                 bas = GetByte(parts[1]);
  1280.                                                 if (bas < 0 || bas > 7)
  1281.                                                         return ERR_SYNTAX;
  1282.                                                 bas *= 8;
  1283.                                                 switch (parts[2])
  1284.                                                 {
  1285.                                                         case "a":
  1286.                                                                 WriteOpcode(ref gb, 0xCB, 0xC7 + bas);
  1287.                                                                 break;
  1288.                                                         case "b":
  1289.                                                                 WriteOpcode(ref gb, 0xCB, 0xC0 + bas);
  1290.                                                                 break;
  1291.                                                         case "c":
  1292.                                                                 WriteOpcode(ref gb, 0xCB, 0xC1 + bas);
  1293.                                                                 break;
  1294.                                                         case "d":
  1295.                                                                 WriteOpcode(ref gb, 0xCB, 0xC2 + bas);
  1296.                                                                 break;
  1297.                                                         case "e":
  1298.                                                                 WriteOpcode(ref gb, 0xCB, 0xC3 + bas);
  1299.                                                                 break;
  1300.                                                         case "h":
  1301.                                                                 WriteOpcode(ref gb, 0xCB, 0xC4 + bas);
  1302.                                                                 break;
  1303.                                                         case "l":
  1304.                                                                 WriteOpcode(ref gb, 0xCB, 0xC5 + bas);
  1305.                                                                 break;
  1306.                                                         case "(hl)":
  1307.                                                                 WriteOpcode(ref gb, 0xCB, 0xC6 + bas);
  1308.                                                                 break;
  1309.                                                 }
  1310.                                                 break;
  1311.  
  1312.                                         case "res":
  1313.                                                 bas = GetByte(parts[1]);
  1314.                                                 if (bas < 0 || bas > 7)
  1315.                                                         return ERR_SYNTAX;
  1316.                                                 bas *= 8;
  1317.                                                 switch (parts[2])
  1318.                                                 {
  1319.                                                         case "a":
  1320.                                                                 WriteOpcode(ref gb, 0xCB, 0x87 + bas);
  1321.                                                                 break;
  1322.                                                         case "b":
  1323.                                                                 WriteOpcode(ref gb, 0xCB, 0x80 + bas);
  1324.                                                                 break;
  1325.                                                         case "c":
  1326.                                                                 WriteOpcode(ref gb, 0xCB, 0x81 + bas);
  1327.                                                                 break;
  1328.                                                         case "d":
  1329.                                                                 WriteOpcode(ref gb, 0xCB, 0x82 + bas);
  1330.                                                                 break;
  1331.                                                         case "e":
  1332.                                                                 WriteOpcode(ref gb, 0xCB, 0x83 + bas);
  1333.                                                                 break;
  1334.                                                         case "h":
  1335.                                                                 WriteOpcode(ref gb, 0xCB, 0x84 + bas);
  1336.                                                                 break;
  1337.                                                         case "l":
  1338.                                                                 WriteOpcode(ref gb, 0xCB, 0x85 + bas);
  1339.                                                                 break;
  1340.                                                         case "(hl)":
  1341.                                                                 WriteOpcode(ref gb, 0xCB, 0x86 + bas);
  1342.                                                                 break;
  1343.                                                 }
  1344.                                                 break;
  1345.  
  1346.                                         case "jp":
  1347.                                                 if (parts[1] == "(hl)")
  1348.                                                 {
  1349.                                                         WriteOpcode(ref gb, 0xE9);
  1350.                                                 }
  1351.                                                 else if (parts[1] != "nz" && parts[1] != "z" && parts[1] != "nc" && parts[1] != "c")
  1352.                                                 {
  1353.                                                         if (parts[1] == "")
  1354.                                                                 return ERR_SYNTAX;
  1355.                                                         int jumpto = GetByte(parts[1]);
  1356.                                                         if (jumpto == -1)
  1357.                                                         {
  1358.                                                                 string label = parts[1];
  1359.                                                                 foreach (CodeLabel c in labels)
  1360.                                                                 {
  1361.                                                                         if (c.Label == label)
  1362.                                                                         {
  1363.                                                                                 int jp = c.Offset;
  1364.                                                                                 WriteOpcode(ref gb, 0xC3, (jp & 0xFF), ((jp >> 8) & 0xFF));
  1365.                                                                                 break;
  1366.                                                                         }
  1367.                                                                 }
  1368.                                                                 if (gb.BufferLocation == 0)
  1369.                                                                         return ERR_LABEL;
  1370.                                                         }
  1371.                                                         else
  1372.                                                         {
  1373.                                                                 WriteOpcode(ref gb, 0xC3, (jumpto & 0xFF), ((jumpto >> 8) & 0xFF));
  1374.                                                         }
  1375.                                                 }
  1376.                                                 else
  1377.                                                 {
  1378.                                                         if (parts[2] == "")
  1379.                                                                 return ERR_SYNTAX;
  1380.                                                         int jumpto = GetByte(parts[2]);
  1381.                                                         byte opcode = 0xC2;
  1382.                                                         if (parts[1] == "z")
  1383.                                                                 opcode = 0xCA;
  1384.                                                         else if (parts[1] == "nc")
  1385.                                                                 opcode = 0xD2;
  1386.                                                         else if (parts[1] == "c")
  1387.                                                                 opcode = 0xDA;
  1388.                                                         if (jumpto == -1)
  1389.                                                         {
  1390.                                                                 string label = parts[2];
  1391.                                                                 foreach (CodeLabel c in labels)
  1392.                                                                 {
  1393.                                                                         if (c.Label == label)
  1394.                                                                         {
  1395.                                                                                 int jp = c.Offset;
  1396.                                                                                 WriteOpcode(ref gb, opcode, (jp & 0xFF), ((jp >> 8) & 0xFF));
  1397.                                                                                 break;
  1398.                                                                         }
  1399.                                                                 }
  1400.                                                                 if (gb.BufferLocation == 0)
  1401.                                                                         return ERR_LABEL;
  1402.                                                         }
  1403.                                                         else
  1404.                                                         {
  1405.                                                                 WriteOpcode(ref gb, opcode, (jumpto & 0xFF), ((jumpto >> 8) & 0xFF));
  1406.                                                         }
  1407.                                                 }
  1408.                                                 break;
  1409.  
  1410.                                         case "jr":
  1411.                                                 if (parts[1] != "nz" && parts[1] != "z" && parts[1] != "nc" && parts[1] != "c")
  1412.                                                 {
  1413.                                                         if (parts[1] == "")
  1414.                                                                 return ERR_SYNTAX;
  1415.                                                         int jumpto = GetByte(parts[1]);
  1416.                                                         if (jumpto == -1)
  1417.                                                         {
  1418.                                                                 string label = parts[1];
  1419.                                                                 foreach (CodeLabel c in labels)
  1420.                                                                 {
  1421.                                                                         if (c.Label == label)
  1422.                                                                         {
  1423.                                                                                 int jp = 0;
  1424.                                                                                 if (c.Offset < thisOffset)
  1425.                                                                                 {
  1426.                                                                                         if ((byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2)) < 0x80)
  1427.                                                                                         {
  1428.                                                                                                 return ERR_OUTOFSCOPE;
  1429.                                                                                         }
  1430.                                                                                         jp = (byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2));
  1431.                                                                                 }
  1432.                                                                                 else
  1433.                                                                                 {
  1434.                                                                                         if ((byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2)) > 0x7F)
  1435.                                                                                         {
  1436.                                                                                                 return ERR_OUTOFSCOPE;
  1437.                                                                                         }
  1438.                                                                                         jp = (byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2));
  1439.                                                                                         if (jp > 0x7F)
  1440.                                                                                                 return ERR_OUTOFSCOPE;
  1441.                                                                                 }
  1442.                                                                                 WriteOpcode(ref gb, 0x18, (jp & 0xFF));
  1443.                                                                                 break;
  1444.                                                                         }
  1445.                                                                 }
  1446.                                                                 if (gb.BufferLocation == 0)
  1447.                                                                         return ERR_LABEL;
  1448.                                                         }
  1449.                                                         else
  1450.                                                         {
  1451.                                                                 WriteOpcode(ref gb, 0x18, (jumpto & 0xFF));
  1452.                                                         }
  1453.                                                 }
  1454.                                                 else
  1455.                                                 {
  1456.                                                         if (parts[2] == "")
  1457.                                                                 return ERR_SYNTAX;
  1458.                                                         int jumpto = GetByte(parts[2]);
  1459.                                                         byte opcode = 0x20;
  1460.                                                         if (parts[1] == "z")
  1461.                                                                 opcode = 0x28;
  1462.                                                         else if (parts[1] == "nc")
  1463.                                                                 opcode = 0x30;
  1464.                                                         else if (parts[1] == "c")
  1465.                                                                 opcode = 0x38;
  1466.                                                         if (jumpto == -1)
  1467.                                                         {
  1468.                                                                 string label = parts[2];
  1469.                                                                 foreach (CodeLabel c in labels)
  1470.                                                                 {
  1471.                                                                         if (c.Label == label)
  1472.                                                                         {
  1473.                                                                                 int jp = 0;
  1474.                                                                                 if (c.Offset < thisOffset)
  1475.                                                                                 {
  1476.                                                                                         if ((byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2)) < 0x80)
  1477.                                                                                         {
  1478.                                                                                                 return ERR_OUTOFSCOPE;
  1479.                                                                                         }
  1480.                                                                                         jp = (byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2));
  1481.                                                                                 }
  1482.                                                                                 else
  1483.                                                                                 {
  1484.                                                                                         if ((byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2)) > 0x7F)
  1485.                                                                                         {
  1486.                                                                                                 return ERR_OUTOFSCOPE;
  1487.                                                                                         }
  1488.                                                                                         jp = (byte)(c.StartOffset + (c.Offset - c.StartOffset) - (thisOffset + 2));
  1489.                                                                                 }
  1490.                                                                                 WriteOpcode(ref gb, opcode, (jp & 0xFF));
  1491.                                                                                 break;
  1492.                                                                         }
  1493.                                                                 }
  1494.                                                                 if (gb.BufferLocation == 0)
  1495.                                                                         return ERR_LABEL;
  1496.                                                         }
  1497.                                                         else
  1498.                                                         {
  1499.                                                                 WriteOpcode(ref gb, opcode, (jumpto & 0xFF));
  1500.                                                         }
  1501.                                                 }
  1502.                                                 break;
  1503.  
  1504.                                         case "call":
  1505.                                                 if (parts[1] != "nz" && parts[1] != "z" && parts[1] != "nc" && parts[1] != "c")
  1506.                                                 {
  1507.                                                         int call = GetByte(parts[1]);
  1508.                                                         if (call == -1)
  1509.                                                         {
  1510.                                                                 foreach (CodeLabel c in labels)
  1511.                                                                 {
  1512.                                                                         if (c.Label == parts[1])
  1513.                                                                         {
  1514.                                                                                 WriteOpcode(ref gb, 0xCD, (c.Offset & 0xFF), ((c.Offset >> 8) & 0xFF));
  1515.                                                                         }
  1516.                                                                 }
  1517.                                                                 if (gb.BufferLocation == 0)
  1518.                                                                         return ERR_LABEL;
  1519.                                                         }
  1520.                                                         else
  1521.                                                         {
  1522.                                                                 WriteOpcode(ref gb, 0xCD, (call & 0xFF), ((call >> 8) & 0xFF));
  1523.                                                         }
  1524.                                                 }
  1525.                                                 else
  1526.                                                 {
  1527.                                                         int call = GetByte(parts[2]);
  1528.                                                         byte opcode = 0xC4;
  1529.                                                         if (parts[1] == "z")
  1530.                                                                 opcode = 0xCC;
  1531.                                                         else if (parts[1] == "nc")
  1532.                                                                 opcode = 0xD4;
  1533.                                                         else if (parts[1] == "c")
  1534.                                                                 opcode = 0xDC;
  1535.                                                         if (call == -1)
  1536.                                                         {
  1537.                                                                 foreach (CodeLabel c in labels)
  1538.                                                                 {
  1539.                                                                         if (c.Label == parts[2])
  1540.                                                                         {
  1541.                                                                                 WriteOpcode(ref gb, opcode, (c.Offset & 0xFF), ((c.Offset >> 8) & 0xFF));
  1542.                                                                         }
  1543.                                                                 }
  1544.                                                                 if (gb.BufferLocation == 0)
  1545.                                                                         return ERR_LABEL;
  1546.                                                         }
  1547.                                                         else
  1548.                                                         {
  1549.                                                                 WriteOpcode(ref gb, opcode, (call & 0xFF), ((call >> 8) & 0xFF));
  1550.                                                         }
  1551.                                                 }
  1552.                                                 break;
  1553.  
  1554.                                         case "rst":
  1555.                                                 int rst = GetByte(parts[1]);
  1556.                                                 switch (rst)
  1557.                                                 {
  1558.                                                         case 0x00:
  1559.                                                                 WriteOpcode(ref gb, 0xC7);
  1560.                                                                 break;
  1561.                                                         case 0x08:
  1562.                                                                 WriteOpcode(ref gb, 0xCF);
  1563.                                                                 break;
  1564.                                                         case 0x10:
  1565.                                                                 WriteOpcode(ref gb, 0xD7);
  1566.                                                                 break;
  1567.                                                         case 0x18:
  1568.                                                                 WriteOpcode(ref gb, 0xDF);
  1569.                                                                 break;
  1570.                                                         case 0x20:
  1571.                                                                 WriteOpcode(ref gb, 0xE7);
  1572.                                                                 break;
  1573.                                                         case 0x28:
  1574.                                                                 WriteOpcode(ref gb, 0xEF);
  1575.                                                                 break;
  1576.                                                         case 0x30:
  1577.                                                                 WriteOpcode(ref gb, 0xF7);
  1578.                                                                 break;
  1579.                                                         case 0x38:
  1580.                                                                 WriteOpcode(ref gb, 0xFF);
  1581.                                                                 break;
  1582.                                                 }
  1583.                                                 break;
  1584.  
  1585.                                         case "ret":
  1586.                                                 if (parts.Length < 2)
  1587.                                                 {
  1588.                                                         WriteOpcode(ref gb, 0xC9);
  1589.                                                 }
  1590.                                                 else if (parts[1] == "nz")
  1591.                                                 {
  1592.                                                         WriteOpcode(ref gb, 0xC0);
  1593.                                                 }
  1594.                                                 else if (parts[1] == "z")
  1595.                                                 {
  1596.                                                         WriteOpcode(ref gb, 0xC8);
  1597.                                                 }
  1598.                                                 else if (parts[1] == "nc")
  1599.                                                 {
  1600.                                                         WriteOpcode(ref gb, 0xD0);
  1601.                                                 }
  1602.                                                 else if (parts[1] == "c")
  1603.                                                 {
  1604.                                                         WriteOpcode(ref gb, 0xD8);
  1605.                                                 }
  1606.                                                 break;
  1607.  
  1608.                                         case "reti":
  1609.                                                 WriteOpcode(ref gb, 0xD9);
  1610.                                                 break;
  1611.  
  1612.                                         case "raw":
  1613.                                                 for (int i = 1; i < parts.Length; i++)
  1614.                                                 {
  1615.                                                         int b = GetByte(parts[i]);
  1616.                                                         if (b != -1)
  1617.                                                                 WriteOpcode(ref gb, (byte)b);
  1618.                                                 }
  1619.                                                 break;
  1620.  
  1621.                                         default:
  1622.                                                 return ERR_OPCODE;
  1623.                                 }
  1624.  
  1625.                         }
  1626.                         catch (Exception)
  1627.                         {
  1628.                                 return ERR_SYNTAX;
  1629.                         }
  1630.  
  1631.                         if (gb.BufferLocation == 0)
  1632.                                 return ERR_OPCODE;
  1633.  
  1634.                         byte[] output = new byte[gb.BufferLocation];
  1635.                         Array.Copy(gb.Buffer, output, gb.BufferLocation);
  1636.                         return output;
  1637.                 }
  1638.  
  1639.                 private bool IsRegister(string s)
  1640.                 {
  1641.                         switch (s)
  1642.                         {
  1643.                                 case "a":
  1644.                                 case "b":
  1645.                                 case "c":
  1646.                                 case "d":
  1647.                                 case "e":
  1648.                                 case "f":
  1649.                                 case "h":
  1650.                                 case "l":
  1651.                                 case "af":
  1652.                                 case "bc":
  1653.                                 case "de":
  1654.                                 case "hl":
  1655.                                         return true;
  1656.                         }
  1657.  
  1658.                         return false;
  1659.                 }
  1660.  
  1661.                 private bool IsSingleRegister(string s)
  1662.                 {
  1663.                         switch (s)
  1664.                         {
  1665.                                 case "a":
  1666.                                 case "b":
  1667.                                 case "c":
  1668.                                 case "d":
  1669.                                 case "e":
  1670.                                 case "f":
  1671.                                 case "h":
  1672.                                 case "l":
  1673.                                         return true;
  1674.                         }
  1675.  
  1676.                         return false;
  1677.                 }
  1678.  
  1679.                 private bool IsRegisterPair(string s)
  1680.                 {
  1681.                         switch (s)
  1682.                         {
  1683.                                 //SP is excluded because it doesn't usually appear with common register pair opcodes
  1684.                                 case "af":
  1685.                                 case "bc":
  1686.                                 case "de":
  1687.                                 case "hl":
  1688.                                         return true;
  1689.                         }
  1690.                         return false;
  1691.                 }
  1692.  
  1693.                 public int GetByte(string s)
  1694.                 {
  1695.                         int o;
  1696.                         if (!int.TryParse(s, System.Globalization.NumberStyles.HexNumber, null, out o))
  1697.                                 return -1;
  1698.                         return o;
  1699.                 }
  1700.  
  1701.                 public void WriteOpcode(ref GBFile g, byte opcode)
  1702.                 {
  1703.                         g.WriteByte(opcode);
  1704.                 }
  1705.  
  1706.                 public void WriteOpcode(ref GBFile g, byte opcode, int value)
  1707.                 {
  1708.                         g.WriteByte(opcode);
  1709.                         g.WriteByte((byte)value);
  1710.                 }
  1711.  
  1712.                 public void WriteOpcode(ref GBFile g, byte opcode, int value, int value2)
  1713.                 {
  1714.                         g.WriteByte(opcode);
  1715.                         g.WriteByte((byte)value);
  1716.                         g.WriteByte((byte)value2);
  1717.                 }
  1718.         }
  1719. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top