Tiny8051 Code (git)

Brought to you by: thedmd
[f0b455]: / Mcu8051 / Dasm8051.cs Maximize Restore History

1346 lines (1246 with data), 68.8 kB

// Copyright (c) 2008, Michał Cichoń
// All rights reserved.
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace Tiny8051.Mcu8051
{
  // Opcje rozkazu
  public enum OpcodeFlags : ushort
  {
    // Instrukcja 1-bajtowa
    None = 0,

    // Rodzaj transferu
    TransferMask = 0x780,
    // Skok warunkowy
    ConditionalTransfer = 0x400,
    // Skok
    JumpTransfer = 0x200,
    // Powrót
    ReturnTransfer = 0x100,
    // Skok do podprogramu
    CallTransfer = 0x80,

    // Maska opcji
    AddressMask = 0x7C,
    // Adresowanie 11-bitowe
    ShortRelativeAddress = 0x40,
    // Adresowanie względne
    RelativeAddress = 0x20,
    // Adresowanie bitowe
    BitAddress = 0x10,
    // Adresowanie bezpośrednie
    DirectAddress = 0x08,
    // Adresowanie natychmiastowe
    ImmediateAddress = 0x04,

    // Liczba dodatkowych bitów
    SizeMask = TwoBytes | ThreeBytes,
    // Instrukcja 3-bajtowa
    ThreeBytes = 0x02,
    // Instrukcja 2-bajtowa
    TwoBytes = 0x01,
    // Instrukcja 1-bajtowa
    OneByte = 0x00,

    // Maska opcji
    OptionsMask = 0x7F,
    // Adres 16-bitowy
    Immediate3 = ImmediateAddress | ThreeBytes,
    // Dana natychmiastowa w 2 bajcie
    Immediate2 = ImmediateAddress | TwoBytes,
    // Adres bezpośredni w 2 bajcie
    Direct2 = DirectAddress | TwoBytes,
    // Adres bezpośredni w 3 bajcie
    Direct3 = DirectAddress | ThreeBytes,
    // Adres bezpośredni w 2 bajcie i dana natychmiastowa w 3 bajcie
    DirectImmediate3 = DirectAddress | ImmediateAddress | ThreeBytes,
    // Adres bitowy w 2 bajcie
    Bit2 = BitAddress | TwoBytes,
    // Adres względny w 2 bajcie
    Relative2 = RelativeAddress | TwoBytes,
    // Adres względny w 2 bajcie i dana natychmiastowa w 3 bajcie
    RelativeImediate3 = RelativeAddress | ImmediateAddress | ThreeBytes,
    // Adres względny w 2 bajcie i adres bezpośredni w 3 bajcie
    RelativeDirect3 = RelativeAddress | DirectAddress | ThreeBytes,
    // Adres względny w 2 bajcie i adres bitowy w 3 bajcie
    RelativeBit3 = RelativeAddress | BitAddress | ThreeBytes,
    // Adres 11-bitowy w 2 bajcie
    ShortRelative2 = ShortRelativeAddress | TwoBytes
  }

  // Rodzaj pamięci
  public enum MemoryType
  {
    // Pamięć kodu
    Code,
    // Pamięć wewnętrzna RAM
    IData,
    // Pamięć zewnętrzna RAM
    XData
  }

  // Rodzaj argumentu
  public enum AdressingType
  {
    // Dana natychmiastowa
    ImmediateAddressing,
    // Adresowanie bitowe
    BitAddressing,
    // Adresowanie bezpośrednie
    DirectAddressing,
    // Adrsowanie pośrednie
    IndirectAddressing,
    // Adrsowanie względne
    RelativeAddressing
  }

  // Opis argumentu
  public class ArgumentDescription
  {
    // Nazwa
    private string m_name;
    // Rodzaj pamięci
    private MemoryType m_memory_type;
    // Rodzaj argumentu
    private AdressingType m_argument_type;
    // Wartość (adres lub stała)
    private ushort m_value;
    // Argument pomocniczy
    private bool m_is_fake_argument = false;

    // Nazwa
    public string Name
    {
      get { return m_name; }
      set { m_name = value; }
    }
    // Rodzaj pamięci
    public MemoryType MemoryType
    {
      get { return m_memory_type; }
      set { m_memory_type = value; }
    }
    // Rodzaj argumentu
    public AdressingType AdressingType
    {
      get { return m_argument_type; }
      set { m_argument_type = value; }
    }
    // Wartość (adres lub stała)
    public ushort Value
    {
      get { return m_value; }
      set { m_value = value; }
    }
    // Argument pomocniczy (niewidoczny)
    public bool IsFakeArgument
    {
      get { return m_is_fake_argument; }
      set { m_is_fake_argument = value; }
    }
  }

  // Opis instrukcji
  public class InstructionDescription
  {
    private string m_token = "";
    private ushort m_address;
    private byte[] m_code;
    private OpcodeFlags m_flags = OpcodeFlags.None;
    private ArgumentDescription[] m_arguments = null;

    // Nazwa
    public string Token
    {
      set { m_token = value; }
      get { return m_token; }
    }
    // Adres
    public ushort Address
    {
      get { return m_address; }
      set { m_address = value; }
    }
    // Kod
    public byte[] Code
    {
      get { return m_code; }
      set { m_code = value; }
    }    
    // Opcje
    public OpcodeFlags Flags
    {
      set { m_flags = value; }
      get { return m_flags; }
    }
    // Argumenty
    public ArgumentDescription[] Arguments
    {
      set { m_arguments = value; }
      get { return m_arguments; }
    }

    // Sprawdza, czy adres występuje w jakiejśc instrukcji
    public bool Affect(
      ushort address,
      MemoryType memory,
      Mcu8051 procesor)
    {
      foreach (ArgumentDescription arg in m_arguments)
      {
        if (arg.MemoryType != memory)
          continue;

        // TODO: fix it! this is very buggy!
        if (arg.Value == address)
          return true;

        //switch (arg.AdressingType)
        //{
        //  case AdressingType.BitAddressing:
        //    break;

        //  case AdressingType.DirectAddressing:
        //    if (address == arg.Value)
        //      return true;
        //    break;

        //  case AdressingType.ImmediateAddressing:
        //    break;

        //  case AdressingType.IndirectAddressing:
        //    break;

        //  case AdressingType.RelativeAddressing:
        //    break;
        //}
      }

      return false;
    }
  }

  class Dasm8051
  {
    // Tablica opcji
    static public OpcodeFlags[] Flags
    {
      get
      {
        return m_option_table;
      }
    }

    // Rozmiar rozkazu
    static public byte GetOpcodeSize(
      byte opcode)
    {
      return (byte)(1 + (m_option_table[opcode] & OpcodeFlags.SizeMask));
    }

    // Prosta deasemblacja
    static public string SimpleDeassemble(
      ushort address,
      byte[] code)
    {
      // Rozpoczynamy deasemblację
      StringBuilder str = new StringBuilder(m_mnemonic_table[code[0]]);

      // Generujemy parametry
      switch ((OpcodeFlags)(m_option_table[code[0]] & OpcodeFlags.OptionsMask))
      {
        case OpcodeFlags.None:
          break;

        case OpcodeFlags.Immediate3:
          str.AppendFormat("{0:X4}", (ushort)((code[1] << 8) | code[2]));
          break;

        case OpcodeFlags.Immediate2:
          str.Append(GetHex(code[1]));
          break;

        case OpcodeFlags.Direct2:
          str.Append(GetDir(code[1]));
          if ((code[0] & 0xF) == 2 || code[0] == 0xF5)
            str.Append(", a");
          else if ((code[0] & 0xF0) == 0x80)
            if (code[0] < 0x88)
              str.AppendFormat(", @r{0:d}", code[0] & 1);
            else
              str.AppendFormat(", R{0:d}", code[0] & 7);
          break;

        case OpcodeFlags.Direct3:
          str.Append(GetDir(code[2]));
          str.Append(", ");
          str.Append(GetDir(code[1]));
          break;

        case OpcodeFlags.DirectImmediate3:
          str.Append(GetDir(code[1]));
          str.Append(", #");
          str.Append(GetHex(code[2]));
          break;

        case OpcodeFlags.Bit2:
          str.Append(GetBit(code[1]));
          if (code[0] == 0x92)
            str.Append(", c");
          break;

        case OpcodeFlags.Relative2:
          str.AppendFormat("{0:X4}", (ushort)(address + 2 + (sbyte)code[1]));
          break;

        case OpcodeFlags.RelativeImediate3:
          str.Append(GetHex(code[1]));
          str.AppendFormat(", {0:X4}", (ushort)(address + 3 + (sbyte)code[2]));
          break;

        case OpcodeFlags.RelativeDirect3:
          str.Append(GetDir(code[1]));
          str.AppendFormat(", {0:X4}", (ushort)(address + 3 + (sbyte)code[2]));
          break;

        case OpcodeFlags.RelativeBit3:
          str.Append(GetBit(code[1]));
          str.AppendFormat(", {0:X4}", (ushort)(address + 3 + (sbyte)code[2]));
          break;

        case OpcodeFlags.ShortRelative2:
          str.AppendFormat("{0:X4}", (ushort)(((code[0] & 0xE0) << 3) | code[1]));
          break;
      }

      return str.ToString().ToLower();
    }

    // Deasemblacja z analizą
    static public InstructionDescription Deassemble(
      ushort address,
      Mcu8051 mcu)
    {
      InstructionDescription desc = new InstructionDescription();

      byte[] code = new byte[GetOpcodeSize(mcu.Code[address % mcu.Code.Size])];

      for (int i = 0; i < code.Length; i++)
        code[i] = mcu.Code[(address + i) % mcu.Code.Size];

      // Kod
      desc.Code = code;

      // Adres
      desc.Address = address;

      // Token
      desc.Token = m_mnemonic_table[code[0]].Substring(0, m_mnemonic_table[code[0]].IndexOf(' ')).ToLower();

      // Flagi
      desc.Flags = m_option_table[code[0]];

      // Liczymy arguemnty
      int arguments_count = 0;
      if (m_arguments_usage[code[0], 2] != ArgumentUsage.None)
        arguments_count = 3;
      else if (m_arguments_usage[code[0], 1] != ArgumentUsage.None)
        arguments_count = 2;
      else if (m_arguments_usage[code[0], 0] != ArgumentUsage.None)
        arguments_count = 1;

      desc.Arguments = new ArgumentDescription[arguments_count];

      // Budujemy argumenty
      if (arguments_count > 0)
      {
        for (int i = 0; i < arguments_count; i++)
        {
          ArgumentDescription arg = new ArgumentDescription();

          desc.Arguments[i] = arg;

          switch (m_arguments_usage[code[0], i])
          {
            case ArgumentUsage.CarryFlag:
              arg.Name = "C";
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.BitAddressing;
              arg.Value = 0xD7;
              break;

            case ArgumentUsage.Accumulator:
              arg.Name = "A";
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.DirectAddressing;
              arg.Value = 0xE0;
              break;

            case ArgumentUsage.AccumulatorWithB:
              if (i == 0)
              {
                arg.Name = "AB";
                arg.MemoryType = MemoryType.IData;
                arg.AdressingType = AdressingType.DirectAddressing;
                arg.Value = 0xE0;
              }
              else
              {
                arg.Name = "";
                arg.MemoryType = MemoryType.IData;
                arg.AdressingType = AdressingType.DirectAddressing;
                arg.Value = 0xF0;
                arg.IsFakeArgument = true;
              }
              break;

            case ArgumentUsage.BankRegister:
              arg.Value = (ushort)(code[0] & 0x07);
              arg.Name = "R" + arg.Value.ToString();
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.DirectAddressing;
              break;

            case ArgumentUsage.DPTRRegister:
              arg.Value = mcu.DPTR;
              arg.Name = "DPTR";
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.DirectAddressing;
              break;

            case ArgumentUsage.BitAddress:
              if (code[1] < 0x80)
                arg.Name = String.Format("{0:X2}h.{1:d}", (code[1] >> 3) + 0x20, code[1] & 0x7);
              else
                arg.Name = m_sfr_bit_names[code[1] & 0x7F];
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.BitAddressing;
              arg.Value = code[1];
              break;

            case ArgumentUsage.BitAddressInverse:
              if (code[1] < 0x80)
                arg.Name = String.Format("/{0:X2}h.{1:d}", (code[1] >> 3) + 0x20, code[1] & 0x7);
              else
                arg.Name = m_sfr_bit_names[code[1] & 0x7F];
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.BitAddressing;
              arg.Value = code[1];
              break;

            case ArgumentUsage.ShortAddress:
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.ImmediateAddressing;
              arg.Value = (ushort)(code[1] | ((code[0] & 0xE0) << 3));
              arg.Name = arg.Value.ToString("X4");
              break;

            case ArgumentUsage.LongAddress:
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.ImmediateAddressing;
              arg.Value = (ushort)((code[1] << 8) | code[2]);
              arg.Name = arg.Value.ToString("X4");
              break;

            case ArgumentUsage.SmallImmediateData:
              if ((m_option_table[code[0]] & OpcodeFlags.DirectImmediate3) == OpcodeFlags.DirectImmediate3)
                arg.Value = code[2];
              else
                arg.Value = code[1];
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.ImmediateAddressing;
              arg.Name = "#" + GetHex(arg.Value);
              break;

            case ArgumentUsage.LargeImmediateData:
              arg.Value = (ushort)((code[1] << 8) | code[2]);
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.ImmediateAddressing;
              arg.Name = "#" + GetHex(arg.Value);
              break;

            case ArgumentUsage.RelativeAddress:
              if ((m_option_table[code[0]] & OpcodeFlags.TwoBytes) != 0)
                arg.Value = (ushort)(address + 2 + (sbyte)code[1]);
              else
                arg.Value = (ushort)(address + 3 + (sbyte)code[2]);
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.RelativeAddressing;
              arg.Name = arg.Value.ToString("X4");
              break;

            case ArgumentUsage.DirectAddress:
              if ((m_option_table[code[0]] & OpcodeFlags.Direct3) == OpcodeFlags.Direct3)
                arg.Value = code[1 + i];
              else
                arg.Value = code[1];
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.DirectAddressing;
              arg.Name = GetDir((byte)arg.Value);
              break;

            case ArgumentUsage.IndirectRiAddress:
              arg.Value = mcu.Bank[(code[0] & 0x01)];
              arg.Name = "@R" + (code[0] & 0x01).ToString();
              arg.MemoryType = MemoryType.IData;
              arg.AdressingType = AdressingType.IndirectAddressing;
              break;

            case ArgumentUsage.IndirectDPTRAddress:
              arg.Value = mcu.DPTR;
              arg.Name = "@DPTR";
              arg.MemoryType = MemoryType.XData;
              arg.AdressingType = AdressingType.IndirectAddressing;
              break;

            case ArgumentUsage.IndirectDPTRAddressWithOffset:
              arg.Value = (ushort)(mcu.DPTR + mcu.ACC);
              arg.Name = "@A + DPTR";
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.IndirectAddressing;
              break;

            case ArgumentUsage.IndirectPCAddressWithOffset:
              arg.Value = (ushort)(mcu.PC + mcu.ACC);
              arg.Name = "@A + PC";
              arg.MemoryType = MemoryType.Code;
              arg.AdressingType = AdressingType.IndirectAddressing;
              break;
          }

          //arg.Name = arg.Name.ToLower();
        }
      }

      return desc;
    }

    static public void Work()
    {
      /*
      string file = File.ReadAllText("data.txt");
      string[] splitter = { "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\t", "\r\n" };
      string[] args = file.Split(splitter, StringSplitOptions.None);

      StreamWriter result = new StreamWriter(File.OpenWrite("result.cs"));

      for (int i = 0; i < 256; i++)
      {
        string token = m_mnemonic_table[i].Substring(0, m_mnemonic_table[i].IndexOf(' '));

        string[] local = new string[] { args[i + 0 * 256], args[i + 1 * 256], args[i + 2 * 256] };
        ArgumentUsage[] types = new ArgumentUsage[3];

        result.Write("  { new ArgumentUsage { ");

        for (int j = 0; j < 3; j++)
        {
          string cmp = local[j].ToUpper();

          if ((cmp.Length == 0) || (cmp.CompareTo("-") == 0))
            types[j] = ArgumentUsage.None;
          else if (cmp.CompareTo("C") == 0)
            types[j] = ArgumentUsage.CarryFlag;
          else if (cmp.CompareTo("A") == 0)
            types[j] = ArgumentUsage.Accumulator;
          else if (cmp.CompareTo("AB") == 0)
            types[j] = ArgumentUsage.AccumulatorWithB;
          else if (cmp.Substring(0, 1).CompareTo("R") == 0 && cmp.Length == 2)
            types[j] = ArgumentUsage.BankRegister;
          else if (cmp.CompareTo("DPTR") == 0)
            types[j] = ArgumentUsage.DPTRRegister;
          else if (cmp.CompareTo("BIT") == 0)
            types[j] = ArgumentUsage.BitAddress;
          else if (cmp.CompareTo("/BIT") == 0)
            types[j] = ArgumentUsage.BitAddressInverse;
          else if (cmp.CompareTo("ADDR11") == 0)
            types[j] = ArgumentUsage.ShortAddress;
          else if (cmp.CompareTo("ADDR16") == 0)
            types[j] = ArgumentUsage.LongAddress;
          else if (cmp.CompareTo("#DATA") == 0)
            types[j] = ArgumentUsage.SmallImmediateData;
          else if (cmp.CompareTo("#DATA16") == 0)
            types[j] = ArgumentUsage.LargeImmediateData;
          else if (cmp.CompareTo("REL") == 0)
            types[j] = ArgumentUsage.RelativeAddress;
          else if (cmp.CompareTo("DIRECT") == 0)
            types[j] = ArgumentUsage.DirectAddress;
          else if (cmp.Substring(0, 2).CompareTo("@R") == 0)
            types[j] = ArgumentUsage.IndirectRiAddress;
          else if (cmp.CompareTo("@DPTR") == 0)
            types[j] = ArgumentUsage.IndirectDPTRAddress;
          else if (cmp.CompareTo("@A + DPTR") == 0)
            types[j] = ArgumentUsage.IndirectDPTRAddressWithOffset;
          else if (cmp.CompareTo("@A + PC") == 0)
            types[j] = ArgumentUsage.IndirectPCAddressWithOffset;
          else
            types[j] = ArgumentUsage.None;

          result.Write("ArgumentUsage.");
          result.Write(types[j].ToString());

          if (j < 2)
            result.Write(", ");
        }

        result.WriteLine(" } },");
        

      }

      result.Close();
      */
    }

    # region Funkcje pomocnicze

    // Sposób użycia argumentu
    private enum ArgumentUsage
    {
      None,

      CarryFlag,

      Accumulator,
      AccumulatorWithB,
      BankRegister,
      DPTRRegister,

      BitAddress,
      BitAddressInverse,

      ShortAddress,
      LongAddress,

      SmallImmediateData,
      LargeImmediateData,

      RelativeAddress,

      DirectAddress,

      IndirectRiAddress,
      IndirectDPTRAddress,
      IndirectDPTRAddressWithOffset,
      IndirectPCAddressWithOffset
    }

    // Wypisuje liczbę szestnastkową
    static private string GetHex(
      ushort value)
    {
      if (value < 10)
        return value.ToString();
      else if (value < 16)
        return String.Format("0{0:X}h", value);
      else if (value < 0xa0)
        return String.Format("{0:X}h", value);
      else if (value < 0x100)
        return String.Format("0{0:X}h", value);
      else if (value < 0xa00)
        return String.Format("{0:X}h", value);
      else if (value < 0x1000)
        return String.Format("0{0:X}h", value);
      else if (value < 0xa000)
        return String.Format("{0:X}h", value);
      else
        return String.Format("0{0:X}h", value);
    }

    // Wypisuje adres bezpośredni
    static private string GetDir(
      byte value)
    {
      if (value < 0x80)
        return String.Format("{0:X2}h", value);
      else
        return m_sfr_names[value & 0x7F];
    }

    // Wypisuje adres bitowy
    static private string GetBit(
      byte value)
    {
      if (value < 0x80)
        return String.Format("{0:X2}h.{1:d}", (value >> 3) + 0x20, value & 0x7);
      else
        return m_sfr_bit_names[value & 0x7F];
    }

    # endregion

    # region Tabele niezbędne do deasemblacji

    // Tablica mnemoników
    private static string[] m_mnemonic_table =
    {
      "nop ",           "ajmp ",      "ljmp ",        "rr a",               // 00 - 03
      "inc a",          "inc ",       "inc @r0",      "inc @r1",            // 04 - 07
      "inc r0",         "inc r1",     "inc r2",       "inc r3",             // 08 - 0b
      "inc r4",         "inc r5",     "inc r6",       "inc r7",             // 0c - 0f
      "jbc ",           "acall ",     "lcall ",       "rrc a",              // 10 - 13
      "dec a",          "dec ",       "dec @r0",      "dec @r1",            // 14 - 17
      "dec r0",         "dec r1",     "dec r2",       "dec r3",             // 18 - 1b
      "dec r4",         "dec r5",     "dec r6",       "dec r7",             // 1c - 1f
      "jb ",            "ajmp ",      "ret ",         "rl a",               // 20 - 23
      "add a, #",       "add a, ",    "add a, @r0",   "add a, @r1",         // 24 - 27
      "add a, r0",      "add a, r1",  "add a, r2",    "add a, r3",          // 28 - 2b
      "add a, r4",      "add a, r5",  "add a, r6",    "add a, r7",          // 2c - 2f
      "jnb ",           "acall ",     "reti ",        "rlc a",              // 30 - 33
      "addc a, #",      "addc a, ",   "addc a, @r0",  "addc a, @r1",        // 34 - 37
      "addc a, r0",     "addc a, r1", "addc a, r2",   "addc a, r3",         // 38 - 3b
      "addc a, r4",     "addc a, r5", "addc a, r6",   "addc a, r7",         // 3c - 3f
      "jc ",            "ajmp ",      "orl ",         "orl ",               // 40 - 43
      "orl a, #",       "orl a, ",    "orl a, @r0",   "orl a, @r1",         // 44 - 47
      "orl a, r0",      "orl a, r1",  "orl a, r2",    "orl a, r3",          // 48 - 4b
      "orl a, r4",      "orl a, r5",  "orl a, r6",    "orl a, r7",          // 4c - 4f
      "jnc ",           "acall ",     "anl ",         "anl ",               // 50 - 53
      "anl a, #",       "anl a, ",    "anl a, @r0",   "anl a, @r1",         // 54 - 57
      "anl a, r0",      "anl a, r1",  "anl a, r2",    "anl a, r3",          // 58 - 5b
      "anl a, r4",      "anl a, r5",  "anl a, r6",    "anl a, r7",          // 5c - 5f
      "jz ",            "ajmp ",      "xrl ",         "xrl ",               // 60 - 63
      "xrl a, #",       "xrl a, ",    "xrl a, @r0",   "xrl a, @r1",         // 64 - 67
      "xrl a, r0",      "xrl a, r1",  "xrl a, r2",    "xrl a, r3",          // 68 - 6b
      "xrl a, r4",      "xrl a, r5",  "xrl a, r6",    "xrl a, r7",          // 6c - 6f
      "jnz ",           "acall ",     "orl c, ",      "jmp @a + dptr",      // 70 - 73
      "mov a, #",       "mov ",       "mov @r0, #",   "mov @r1, #",         // 74 - 77
      "mov r0, #",      "mov r1, #",  "mov r2, #",    "mov r3, #",          // 78 - 7b
      "mov r4, #",      "mov r5, #",  "mov r6, #",    "mov r7, #",          // 7c - 7f
      "sjmp ",          "ajmp ",      "anl c, ",      "movc a, @a + pc",    // 80 - 83
      "div ab",         "mov ",       "mov ",         "mov ",               // 84 - 87
      "mov ",           "mov ",       "mov ",         "mov ",               // 88 - 8b
      "mov ",           "mov ",       "mov ",         "mov ",               // 8c - 8f
      "mov dptr, #",    "acall ",     "mov ",         "movc a, @a + dptr",  // 90 - 93
      "subb a, #",      "subb a, ",   "subb a, @r0",  "subb a, @r1",        // 94 - 97
      "subb a, r0",     "subb a, r1", "subb a, r2",   "subb a, r3",         // 98 - 9b
      "subb a, r4",     "subb a, r5", "subb a, r6",   "subb a, r7",         // 9c - 9f
      "orl c, /",       "ajmp ",      "mov c, ",      "inc dptr",           // a0 - a3
      "mul ab",         "db ",        "mov @r0, ",    "mov @r1, ",          // a4 - a7
      "mov r0, ",       "mov r1, ",   "mov r2, ",     "mov r3, ",           // a8 - ab
      "mov r4, ",       "mov r5, ",   "mov r6, ",     "mov r7, ",           // ac - af
      "anl c, /",       "acall ",     "cpl ",         "cpl c",              // b0 - b3
      "cjne a, #",      "cjne a, ",   "cjne @r0, #",  "cjne @r1, #",        // b4 - b7
      "cjne r0, #",     "cjne r1, #", "cjne r2, #",   "cjne r3, #",         // b8 - bb
      "cjne r4, #",     "cjne r5, #", "cjne r6, #",   "cjne r7, #",         // bc - bf
      "push ",          "ajmp ",      "clr ",         "clr c",              // c0 - c3
      "swap a",         "xch a, ",    "xch a, @r0",   "xch a, @r1",         // c4 - c7
      "xch a, r0",      "xch a, r1",  "xch a, r2",    "xch a, r3",          // c8 - cb
      "xch a, r4",      "xch a, r5",  "xch a, r6",    "xch a, r7",          // cc - cf
      "pop ",           "acall ",     "setb ",        "setb c",             // d0 - d3
      "da a",           "djnz ",      "xchd a, @r0",  "xchd a, @r1",        // d4 - d7
      "djnz r0, ",      "djnz r1, ",  "djnz r2, ",    "djnz r3, ",          // d8 - db
      "djnz r4, ",      "djnz r5, ",  "djnz r6, ",    "djnz r7, ",          // dc - df
      "movx a, @dptr",  "ajmp ",      "movx a, @r0",  "movx a, @r1",        // e0 - e3
      "clr a",          "mov a, ",    "mov a, @r0",   "mov a, @r1",         // e4 - e7
      "mov a, r0",      "mov a, r1",  "mov a, r2",    "mov a, r3",          // e8 - eb
      "mov a, r4",      "mov a, r5",  "mov a, r6",    "mov a, r7",          // ec - ef
      "movx @dptr, a",  "acall ",     "movx @r0, a",  "movx @r1, a",        // f0 - f3
      "cpl a",          "mov ",       "mov @r0, a",   "mov @r1, a",         // f4 - f7
      "mov r0, a",      "mov r1, a",  "mov r2, a",    "mov r3, a",          // f8 - fb
      "mov r4, a",      "/mov r5, a",  "mov r6, a",    "mov r7, a"           // fc - ff
    };

    // Tablica nazw rejestrów SFR
    private static string[] m_sfr_names =
    {
      "P0",     "SP",     "DPL",    "DPh",    // 80 - 83
      "84h",    "85h",    "86h",    "PCON",   // 84 - 87
      "TCON",   "TMOD",   "TL0",    "TL1",    // 88 - 8B
      "Th0",    "Th1",    "8Eh",    "8Fh",    // 8C - 8F
      "P1",     "91h",    "92h",    "93h",    // 90 - 93
      "94h",    "95h",    "96h",    "97h",    // 94 - 97
      "SCON",   "SBUF",   "9Ah",    "9Bh",    // 98 - 9B
      "9Ch",    "9Dh",    "9Eh",    "9Fh",    // 9C - 9F
      "P2",     "0A1h",   "0A2h",   "0A3h",   // A0 - A3
      "0A4h",   "0A5h",   "0A6h",   "0A7h",   // A4 - A7
      "IE",     "0A9h",   "0AAh",   "0ABh",   // A8 - AB
      "0ACh",   "0ADh",   "0AEh",   "0AFh",   // AC - AF
      "P3",     "0B1h",   "0B2h",   "0B3h",   // B0 - B3
      "0B4h",   "0B5h",   "0B6h",   "0B7h",   // B4 - B7
      "IP",     "0B9h",   "0BAh",   "0BBh",   // B8 - BB
      "0BCh",   "0BDh",   "0BEh",   "0BFh",   // BC - BF
      "0C0h",   "0C1h",   "0C2h",   "0C3h",   // C0 - C3
      "0C4h",   "0C5h",   "0C6h",   "0C7h",   // C4 - C7
      "0C8h",   "0C9h",   "0CAh",   "0CBh",   // C8 - CB
      "0CCh",   "0CDh",   "0CEh",   "0CFh",   // CC - CF
      "PSW",    "0D1h",   "0D2h",   "0D3h",   // D0 - D3
      "0D4h",   "0D5h",   "0D6h",   "0D7h",   // D4 - D7
      "0D8h",   "0D9h",   "0DAh",   "0DBh",   // D8 - DB
      "0DCh",   "0DDh",   "0DEh",   "0DFh",   // DC - DF
      "ACC",    "0E1h",   "0E2h",   "0E3h",   // E0 - E3
      "0E4h",   "0E5h",   "0E6h",   "0E7h",   // E4 - E7
      "0E8h",   "0E9h",   "0EAh",   "0EBh",   // E8 - EB
      "0ECh",   "0EDh",   "0EEh",   "0EFh",   // EC - EF
      "B",      "0F1h",   "0F2h",   "0F3h",   // F0 - F3
      "0F4h",   "0F5h",   "0F6h",   "0F7h",   // F4 - F7
      "0F8h",   "0F9h",   "0FAh",   "0FBh",   // F8 - FB
      "0FCh",   "0FDh",   "0FEh",   "0FFh",   // FC - FF
    };

    // Tablica nazw bitów SFR
    private static string[] m_sfr_bit_names =
    {
      "P0.0",   "P0.1",   "P0.2",   "P0.3",   // 80 - 83
      "P0.4",   "P0.5",   "P0.6",   "P0.7",   // 84 - 87
      "IT0",    "IE0",    "IT1",    "IE1",    // 88 - 8B
      "TR0",    "TF0",    "TR1",    "TF1",    // 8C - 8F
      "P1.0",   "P1.1",   "P1.2",   "P1.3",   // 90 - 93
      "P1.4",   "P1.5",   "P1.6",   "P1.7",   // 94 - 97
      "RI",     "TI",     "RB8",    "TB8",    // 98 - 9B
      "REN",    "SM2",    "SM1",    "SM0",    // 9C - 9F
      "P2.0",   "P2.1",   "P2.2",   "P2.3",   // A0 - A3
      "P2.4",   "P2.5",   "P2.6",   "P2.7",   // A4 - A7
      "EX0",    "ET0",    "EX1",    "ET1",    // A8 - AB
      "ES",     "IE.5",   "IE.6",   "EA",     // AC - AF
      "RXD",    "TXD",    "INT0",   "INT1",   // B0 - B3
      "T0",     "T1",     "WR",     "RD",     // B4 - B7
      "PX0",    "PT0",    "PX1",    "PT1",    // B8 - BB
      "PS",     "IP.5",   "IP.6",   "IP.7",   // BC - BF
      "0C0h.0", "0C0h.1", "0C0h.2", "0C0h.3", // C0 - C3
      "0C0h.4", "0C0h.5", "0C0h.6", "0C0h.7", // C4 - C7
      "0C8h.0", "0C8h.1", "0C8h.2", "0C8h.3", // C8 - CB
      "0C8h.4", "0C8h.5", "0C8h.6", "0C8h.7", // CC - CF
      "P",      "PSW.1",  "OV",     "RS0",    // D0 - D3
      "RS1",    "F0",     "AC",     "CY",     // D4 - D7
      "0D8h.0", "0D8h.1", "0D8h.2", "0D8h.3", // D8 - DB
      "0D8h.4", "0D8h.5", "0D8h.6", "0D8h.7", // DC - DF
      "ACC.0",  "ACC.1",  "ACC.2",  "ACC.3",  // E0 - E3
      "ACC.4",  "ACC.5",  "ACC.6",  "ACC.7",  // E4 - E7
      "0E8h.0", "0E8h.1", "0E8h.2", "0E8h.3", // E8 - EB
      "0E8h.4", "0E8h.5", "0E8h.6", "0E8h.7", // EC - EF
      "B.0",    "B.1",    "B.2",    "B.3",    // F0 - F3
      "B.4",    "B.5",    "B.6",    "B.7",    // F4 - F7
      "0F8h.0", "0F8h.1", "0F8h.2", "0F8h.3", // F8 - FB
      "0F8h.4", "0F8h.5", "0F8h.6", "0F8h.7", // FC - FF
    };

    // Tablica opcji
    private static OpcodeFlags[] m_option_table =
    {
      /* nop   */  OpcodeFlags.OneByte,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* ljmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* rr    */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* inc   */  OpcodeFlags.OneByte,
      /* jbc   */  OpcodeFlags.RelativeAddress | OpcodeFlags.BitAddress | OpcodeFlags.ThreeBytes,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* lcall */  OpcodeFlags.CallTransfer | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* rrc   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* dec   */  OpcodeFlags.OneByte,
      /* jb    */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.BitAddress | OpcodeFlags.ThreeBytes,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* ret   */  OpcodeFlags.ReturnTransfer,
      /* rl    */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* add   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* add   */  OpcodeFlags.OneByte,
      /* jnb   */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.BitAddress | OpcodeFlags.ThreeBytes,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* reti  */  OpcodeFlags.ReturnTransfer,
      /* rlc   */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* addc  */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* addc  */  OpcodeFlags.OneByte,
      /* jc    */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* orl   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* orl   */  OpcodeFlags.DirectAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* orl   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* orl   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.OneByte,
      /* jnc   */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* anl   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* anl   */  OpcodeFlags.DirectAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* anl   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* anl   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* anl   */  OpcodeFlags.OneByte,
      /* jz    */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* xrl   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* xrl   */  OpcodeFlags.DirectAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* xrl   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* xrl   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* xrl   */  OpcodeFlags.OneByte,
      /* jnz   */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* acall */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* orl   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* jmp   */  OpcodeFlags.JumpTransfer,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* sjmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* anl   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* movc  */  OpcodeFlags.OneByte,
      /* div   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.ThreeBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* movc  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.ImmediateAddress | OpcodeFlags.TwoBytes,
      /* subb  */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* subb  */  OpcodeFlags.OneByte,
      /* orl   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* inc   */  OpcodeFlags.OneByte,
      /* mul   */  OpcodeFlags.OneByte,
      /* db    */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* anl   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* cpl   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* cpl   */  OpcodeFlags.OneByte,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.DirectAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* cjne  */  OpcodeFlags.RelativeAddress | OpcodeFlags.ImmediateAddress | OpcodeFlags.ThreeBytes,
      /* push  */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* clr   */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* clr   */  OpcodeFlags.OneByte,
      /* swap  */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* xch   */  OpcodeFlags.OneByte,
      /* pop   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* setb  */  OpcodeFlags.BitAddress | OpcodeFlags.TwoBytes,
      /* setb  */  OpcodeFlags.OneByte,
      /* da    */  OpcodeFlags.OneByte,
      /* djnz  */  OpcodeFlags.RelativeAddress | OpcodeFlags.DirectAddress | OpcodeFlags.ThreeBytes,
      /* xchd  */  OpcodeFlags.OneByte,
      /* xchd  */  OpcodeFlags.OneByte,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* djnz  */  OpcodeFlags.ConditionalTransfer | OpcodeFlags.RelativeAddress | OpcodeFlags.TwoBytes,
      /* movx  */  OpcodeFlags.OneByte,
      /* ajmp  */  OpcodeFlags.JumpTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* movx  */  OpcodeFlags.OneByte,
      /* movx  */  OpcodeFlags.OneByte,
      /* clr   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* movx  */  OpcodeFlags.OneByte,
      /* acall */  OpcodeFlags.CallTransfer | OpcodeFlags.ShortRelativeAddress | OpcodeFlags.TwoBytes,
      /* movx  */  OpcodeFlags.OneByte,
      /* movx  */  OpcodeFlags.OneByte,
      /* cpl   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.DirectAddress | OpcodeFlags.TwoBytes,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
      /* mov   */  OpcodeFlags.OneByte,
    };

    // Opis typów argumentów
    private static ArgumentUsage[,] m_arguments_usage =
    {
      { ArgumentUsage.None, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.LongAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.LongAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.None, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.None, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.RelativeAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.RelativeAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.RelativeAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.RelativeAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.BitAddress, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectDPTRAddressWithOffset, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.RelativeAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.BitAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectPCAddressWithOffset, ArgumentUsage.None }, 
      { ArgumentUsage.AccumulatorWithB, ArgumentUsage.AccumulatorWithB, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DPTRRegister, ArgumentUsage.LargeImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.CarryFlag, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectDPTRAddressWithOffset, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.BitAddressInverse, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.BitAddress, ArgumentUsage.None }, 
      { ArgumentUsage.DPTRRegister, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.AccumulatorWithB, ArgumentUsage.AccumulatorWithB, ArgumentUsage.None }, 
      { ArgumentUsage.None, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.BitAddressInverse, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.SmallImmediateData, ArgumentUsage.RelativeAddress }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.BitAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.CarryFlag, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.RelativeAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectDPTRAddress, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.DirectAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.IndirectRiAddress, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.BankRegister, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectDPTRAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.ShortAddress, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.Accumulator, ArgumentUsage.None, ArgumentUsage.None }, 
      { ArgumentUsage.DirectAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.IndirectRiAddress, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }, 
      { ArgumentUsage.BankRegister, ArgumentUsage.Accumulator, ArgumentUsage.None }
    };

    # endregion
  }
}
Tiny8051 Code (git)

Branches

Tags

[f0b455]: / Mcu8051 / Dasm8051.cs Maximize Restore History

1346 lines (1246 with data), 68.8 kB
