Guest User

Untitled

a guest
Jul 8th, 2012
235
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