daily pastebin goal
58%
SHARE
TWEET

Untitled

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