Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "memory.h"
  6. #include "dbglabls.h"
  7. #include "z80asm.h"
  8.  
  9. #include "util.h"
  10.  
  11. char asmbuf[0x40];
  12.  
  13. #define _iw     9
  14. #define _ib     10
  15. #define _shrt   27
  16. #define _ld     0x89
  17. #define _zr16   0x8A
  18. #define _zr8    0x8B
  19. #define _cb     0x8C
  20. #define _zjr    0x8D
  21. #define _hl     0x8E
  22. #define _zr81   0x8F
  23. #define _zop    0x90
  24. #define _zf     0x91
  25. #define _zr16a  0x92
  26. #define _zr8_   0x9D
  27. #define _zr81_  0x9E
  28.  
  29. //=============================================================================
  30. static unsigned char asm_tab_z80[] =
  31. {
  32.  
  33. /*
  34. #if 0
  35.     2,0xED,0xFF,0xFF,0xFF, // call unreal api
  36.     'u','a','p','i',0,
  37. #endif
  38. */
  39.  
  40.     // fix bug out (c),a => out (0C),a
  41.     //-------------------------------------------------------------------------
  42.     2, 0xED, 0x70, 0xFF, 0xFF,                                  // in (c)
  43.     'i','n',' ','(','c',')',0,
  44.     //-------------------------------------------------------------------------
  45.     2, 0xED, 0x71, 0xFF, 0xFF,                                  // out (c),0
  46.     'o','u','t',' ','(','c',')',',','0',0,
  47.     //-------------------------------------------------------------------------
  48.     2, 0xED, 0x40, 0xFF, 0xC7,                                  // in r8,(c)
  49.     'i','n',' ',_zr8,',','(','c',')',0,
  50.     //-------------------------------------------------------------------------
  51.     2, 0xED, 0x41, 0xFF, 0xC7,                                  // out (c),r8
  52.     'o','u','t',' ','(','c',')',',',_zr8,0,
  53.     //-------------------------------------------------------------------------
  54.  
  55.     //-------------------------------------------------------------------------
  56.     1,0xCB,0xFF,                                                // all cb-opcodes
  57.     _cb,0,
  58.     //-------------------------------------------------------------------------
  59.     1, 0x00, 0xFF,                                               // nop
  60.     'n','o','p',0,
  61.     //-------------------------------------------------------------------------
  62.     1, 0x08, 0xFF,                                              // ex af,af'
  63.     'e','x',' ','a','f',',','a','f','\'',0,
  64.     1, 0x08, 0xFF,                                              // exa          //[NS]
  65.     'e','x','a', 0 ,
  66.     //-------------------------------------------------------------------------
  67.     1,0x02, 0xFF,                                               // ld (bc),a
  68.     _ld, '(','b','c',')',',','a',0,
  69.     //-------------------------------------------------------------------------
  70.     1,0x12, 0xFF,                                               // ld (de),a
  71.     _ld, '(','d','e',')',',','a',0,
  72.     //-------------------------------------------------------------------------
  73.     1,0x0A, 0xFF,                                               // ld a,(bc)
  74.     _ld, 'a',',','(','b','c',')',0,
  75.     //-------------------------------------------------------------------------
  76.     1,0x1A, 0xFF,                                               // ld a,(de)
  77.     _ld, 'a',',','(','d','e',')',0,
  78.     //-------------------------------------------------------------------------
  79.     1,0x03,0xCF,                                                // inc r16
  80.     'i','n','c',' ',_zr16,0,
  81.     //-------------------------------------------------------------------------
  82.     1,0x0B,0xCF,                                                // dec r16
  83.     'd','e','c',' ',_zr16,0,
  84.     //-------------------------------------------------------------------------
  85.     1,0x04,0xC7,                                                // inc r8
  86.     'i','n','c',' ', _zr8,0,
  87.     //-------------------------------------------------------------------------
  88.     1, 0x05, 0xC7,                                              // dec r8
  89.     'd','e','c',' ', _zr8,0,
  90.     //-------------------------------------------------------------------------
  91.     1, 0x07, 0xFF,                                              // rlca
  92.     'r','l','c','a',0,
  93.     //-------------------------------------------------------------------------
  94.     1, 0x17, 0xFF,                                              // rla
  95.     'r','l','a',0,
  96.     //-------------------------------------------------------------------------
  97.     1, 0x27, 0xFF,                                              // daa
  98.     'd','a','a',0,
  99.     //-------------------------------------------------------------------------
  100.     1, 0x37, 0xFF,                                              // scf
  101.     's','c','f',0,
  102.     //-------------------------------------------------------------------------
  103.     1, 0x0F, 0xFF,                                              // rrca
  104.     'r','r','c','a',0,
  105.     //-------------------------------------------------------------------------
  106.     1, 0x1F, 0xFF,                                              // rra
  107.     'r','r','a',0,
  108.     //-------------------------------------------------------------------------
  109.     1, 0x2F, 0xFF,                                              // cpl
  110.     'c','p','l',0,
  111.     //-------------------------------------------------------------------------
  112.     1, 0x3F, 0xFF,                                              // ccf
  113.     'c','c','f',0,
  114.     //-------------------------------------------------------------------------
  115.     1, 0x00, 0xC7,                                              // relative jumps
  116.     _zjr, _shrt, 0,
  117.     //-------------------------------------------------------------------------
  118.     1, 0x09, 0xCF,                                              // add hl, r16
  119.     'a','d','d',' ',_hl,',',_zr16,0,
  120.     //-------------------------------------------------------------------------
  121.     1, 0x32, 0xFF,                                              // ld (nnnn),a
  122.     _ld,'(',_iw,')',',','a',0,
  123.     //-------------------------------------------------------------------------
  124.     1, 0x3A, 0xFF,                                              // ld a,(nnnn)
  125.     _ld,'a',',','(',_iw,')',0,
  126.     //-------------------------------------------------------------------------
  127.     1, 0x22, 0xFF,                                              // ld (nnnn),hl
  128.     _ld,'(',_iw,')',',',_hl,0,
  129.     //-------------------------------------------------------------------------
  130.     1, 0x2A, 0xFF,                                              // ld hl,(nnnn)
  131.     _ld,_hl,',','(',_iw,')',0,
  132.     //-------------------------------------------------------------------------
  133.     1, 0x76, 0xFF,                                              // halt
  134.     'h','a','l','t',0,
  135.     //-------------------------------------------------------------------------
  136.     1, 0x40, 0xC0,                                              // ld r8,r8
  137.     _ld, _zr8_, ',', _zr81_, 0,
  138.     //-------------------------------------------------------------------------
  139.     1, 0x80, 0xC0,                                              // op r8
  140.     _zop/*, ' '*/, _zr81, 0,
  141.     //-------------------------------------------------------------------------
  142.     1, 0xC0, 0xC7,                                              // ret cc
  143.     'r','e','t',' ',_zf,0,
  144.     //-------------------------------------------------------------------------
  145.     1, 0xC2, 0xC7,                                              // jp cc, nnnn
  146.     'j','p',' ',_zf,',',_iw,0,
  147.     //-------------------------------------------------------------------------
  148.     1, 0xC4, 0xC7,                                              // call cc, nnnn
  149.     'c','a','l','l',' ',_zf,',',_iw,0,
  150.     //-------------------------------------------------------------------------
  151.     1, 0xC6, 0xC7,                                              // op immb
  152.     _zop/*, ' '*/, _ib, 0,
  153.     //-------------------------------------------------------------------------
  154.     1, 0xC1, 0xCF,                                              // pop r16a
  155.     'p','o','p',' ',_zr16a,0,
  156.     //-------------------------------------------------------------------------
  157.     1, 0xC5, 0xCF,                                              // push r16a
  158.     'p','u','s','h',' ',_zr16a,0,
  159.     //-------------------------------------------------------------------------
  160.     1, 0xC3, 0xFF,                                              // jp nnnn
  161.     'j','p', ' ', _iw,0,
  162.     //-------------------------------------------------------------------------
  163.     1, 0xD3, 0xFF,                                              // out (nn),a
  164.     'o','u','t',' ','(',_ib,')',',','a',0,
  165.     //-------------------------------------------------------------------------
  166.     1, 0xE3, 0xFF,                                              // ex (sp),hl
  167.     'e','x',' ','(','s','p',')',',',_hl,0,
  168.     //-------------------------------------------------------------------------
  169.     1, 0xF3, 0xFF,                                              // di
  170.     'd','i',0,
  171.     //-------------------------------------------------------------------------
  172.     1, 0xC9, 0xFF,                                              // ret
  173.     'r','e','t',0,
  174.     //-------------------------------------------------------------------------
  175.     1, 0xD9, 0xFF,                                              // exx
  176.     'e','x','x',0,
  177.     //-------------------------------------------------------------------------
  178.     1, 0xE9, 0xFF,                                              // jp (hl)
  179.     'j','p',' ','(',_hl,')',0,
  180.     //-------------------------------------------------------------------------
  181.     1, 0xF9, 0xFF,                                              // ld sp, hl
  182.     _ld, 's','p',',',_hl,0,
  183.     //-------------------------------------------------------------------------
  184.     1, 0xDB, 0xFF,                                              // in a,(nn)
  185.     'i','n',' ','a',',','(',_ib,')',0,
  186.     //-------------------------------------------------------------------------
  187.     1, 0xEB, 0xFF,                                              // ex de,hl  - no 'ex de,ix' !
  188.     'e','x',' ','d','e',',','h','l',0,
  189.     1, 0xEB, 0xFF,                                              // exd          [NS]
  190.     'e','x','d', 0 ,
  191.     //-------------------------------------------------------------------------
  192.     1, 0xFB, 0xFF,                                              // ei
  193.     'e','i',0,
  194.     //-------------------------------------------------------------------------
  195.     1, 0xCD, 0xFF,                                              // call nnnn
  196.     'c','a','l','l',' ',_iw,0,
  197.     //-------------------------------------------------------------------------
  198.     1, 0xC7, 0xFF,                                              // rst 0
  199.     'r','s','t',' ','0',0,
  200.     //-------------------------------------------------------------------------
  201.     1, 0xCF, 0xFF,                                              // rst 8
  202.     'r','s','t',' ','8',0,
  203.     //-------------------------------------------------------------------------
  204.     1, 0xD7, 0xFF,                                              // rst 10
  205.     'r','s','t',' ','1','0',0,
  206.     //-------------------------------------------------------------------------
  207.     1, 0xDF, 0xFF,                                              // rst 18
  208.     'r','s','t',' ','1','8',0,
  209.     //-------------------------------------------------------------------------
  210.     1, 0xE7, 0xFF,                                              // rst 20
  211.     'r','s','t',' ','2','0',0,
  212.     //-------------------------------------------------------------------------
  213.     1, 0xEF, 0xFF,                                              // rst 28
  214.     'r','s','t',' ','2','8',0,
  215.     //-------------------------------------------------------------------------
  216.     1, 0xF7, 0xFF,                                              // rst 30
  217.     'r','s','t',' ','3','0',0,
  218.     //-------------------------------------------------------------------------
  219.     1, 0xFF, 0xFF,                                              // rst 38
  220.     'r','s','t',' ','3','8',0,
  221.     //-------------------------------------------------------------------------
  222.  
  223. /*
  224.    // ED opcodes
  225. #if 0 // moved above
  226.    2, 0xED, 0x70, 0xFF, 0xFF, // in (c)
  227.    'i','n',' ','(','c',')',0,
  228.    2, 0xED, 0x71, 0xFF, 0xFF, // out (c),0
  229.    'o','u','t',' ','(','c',')',',','0',0,
  230.    2, 0xED, 0x40, 0xFF, 0xC7, // in r8,(c)
  231.    'i','n',' ',_zr8,',','(','c',')',0,
  232.    2, 0xED, 0x41, 0xFF, 0xC7, // out (c),r8
  233.    'o','u','t',' ','(','c',')',',',_zr8,0,
  234. #endif
  235. */
  236.    
  237.     //-------------------------------------------------------------------------
  238.     2, 0xED, 0x42, 0xFF, 0xCF,                                  // sbc hl,r16
  239.     's','b','c',' ','h','l',',',_zr16,0,
  240.     //-------------------------------------------------------------------------
  241.     2, 0xED, 0x4A, 0xFF, 0xCF,                                  // adc hl,r16
  242.     'a','d','c',' ','h','l',',',_zr16,0,
  243.     //-------------------------------------------------------------------------
  244.     2, 0xED, 0x43, 0xFF, 0xCF,                                  // ld (nnnn), r16
  245.     _ld, '(',_iw,')',',',_zr16, 0,
  246.     //-------------------------------------------------------------------------
  247.     2, 0xED, 0x4B, 0xFF, 0xCF,                                  // ld r16, (nnnn)
  248.     _ld, _zr16, ',', '(',_iw,')', 0,
  249.     //-------------------------------------------------------------------------
  250.     2, 0xED, 0x44, 0xFF, 0xC7,                                  // neg
  251.     'n','e','g',0,
  252.     //-------------------------------------------------------------------------
  253.     2, 0xED, 0x45, 0xFF, 0xCF,                                  // retn
  254.     'r','e','t','n',0,
  255.     //-------------------------------------------------------------------------
  256.     2, 0xED, 0x4D, 0xFF, 0xCF,                                  // reti
  257.     'r','e','t','i',0,
  258.     //-------------------------------------------------------------------------
  259.     2, 0xED, 0x46, 0xFF, 0xDF,                                  // im 0
  260.     'i','m',' ','0',0,
  261.     //-------------------------------------------------------------------------
  262.     2, 0xED, 0x56, 0xFF, 0xDF,                                  // im 1
  263.     'i','m',' ','1',0,
  264.     //-------------------------------------------------------------------------
  265.     2, 0xED, 0x5E, 0xFF, 0xDF,                                  // im 2
  266.     'i','m',' ','2',0,
  267.     //-------------------------------------------------------------------------
  268.     2, 0xED, 0x4E, 0xFF, 0xDF,                                  // im 0/1
  269.     'i','m',' ','0','/','1',0,
  270.     //-------------------------------------------------------------------------
  271.     2, 0xED, 0x47, 0xFF, 0xFF,                                  // ld i,a
  272.     _ld, 'i',',','a',0,
  273.     //-------------------------------------------------------------------------
  274.     2, 0xED, 0x57, 0xFF, 0xFF,                                  // ld a,i
  275.     _ld, 'a',',','i',0,
  276.     //-------------------------------------------------------------------------
  277.     2, 0xED, 0x67, 0xFF, 0xFF,                                  // rrd
  278.     'r','r','d',0,
  279.     //-------------------------------------------------------------------------
  280.     2, 0xED, 0x4F, 0xFF, 0xFF,                                  // ld r,a
  281.     _ld, 'r',',','a',0,
  282.     //-------------------------------------------------------------------------
  283.     2, 0xED, 0x5F, 0xFF, 0xFF,                                  // ld a,r
  284.     _ld, 'a',',','r',0,
  285.     //-------------------------------------------------------------------------
  286.     2, 0xED, 0x6F, 0xFF, 0xFF,                                  // rld
  287.     'r','l','d',0,
  288.     //-------------------------------------------------------------------------
  289.  
  290.     //-------------------------------------------------------------------------
  291.     2, 0xED, 0xA0, 0xFF, 0xFF,                                  // ldi
  292.     'l','d','i',0,
  293.     //-------------------------------------------------------------------------
  294.     2, 0xED, 0xA1, 0xFF, 0xFF,                                  // cpi
  295.     'c','p','i',0,
  296.     //-------------------------------------------------------------------------
  297.     2, 0xED, 0xA2, 0xFF, 0xFF,                                  // ini
  298.     'i','n','i',0,
  299.     //-------------------------------------------------------------------------
  300.     2, 0xED, 0xA3, 0xFF, 0xFF,                                  // outi
  301.     'o','u','t','i',0,
  302.     //-------------------------------------------------------------------------
  303.     2, 0xED, 0xA8, 0xFF, 0xFF,                                  // ldd
  304.     'l','d','d',0,
  305.     //-------------------------------------------------------------------------
  306.     2, 0xED, 0xA9, 0xFF, 0xFF,                                  // cpd
  307.     'c','p','d',0,
  308.     //-------------------------------------------------------------------------
  309.     2, 0xED, 0xAA, 0xFF, 0xFF,                                  // ind
  310.     'i','n','d',0,
  311.     //-------------------------------------------------------------------------
  312.     2, 0xED, 0xAB, 0xFF, 0xFF,                                  // outd
  313.     'o','u','t','d',0,
  314.     //-------------------------------------------------------------------------
  315.  
  316.     //-------------------------------------------------------------------------
  317.     2, 0xED, 0xB0, 0xFF, 0xFF,                                  // ldir
  318.     'l','d','i','r',0,
  319.     //-------------------------------------------------------------------------
  320.     2, 0xED, 0xB1, 0xFF, 0xFF,                                  // cpir
  321.     'c','p','i','r',0,
  322.     //-------------------------------------------------------------------------
  323.     2, 0xED, 0xB2, 0xFF, 0xFF,                                  // inir
  324.     'i','n','i','r',0,
  325.     //-------------------------------------------------------------------------
  326.     2, 0xED, 0xB3, 0xFF, 0xFF,                                  // otir
  327.     'o','t','i','r',0,
  328.     //-------------------------------------------------------------------------
  329.     2, 0xED, 0xB8, 0xFF, 0xFF,                                  // lddr
  330.     'l','d','d','r',0,
  331.     //-------------------------------------------------------------------------
  332.     2, 0xED, 0xB9, 0xFF, 0xFF,                                  // cpdr
  333.     'c','p','d','r',0,
  334.     //-------------------------------------------------------------------------
  335.     2, 0xED, 0xBA, 0xFF, 0xFF,                                  // indr
  336.     'i','n','d','r',0,
  337.     //-------------------------------------------------------------------------
  338.     2, 0xED, 0xBB, 0xFF, 0xFF,                                  // otdr
  339.     'o','t','d','r',0,
  340.     //-------------------------------------------------------------------------
  341.  
  342.     //-------------------------------------------------------------------------
  343.     2, 0xED, 0x00, 0xFF, 0x00,                                  // all others 'ED'
  344.     'n','o','p','*',0,
  345.     //-------------------------------------------------------------------------
  346.  
  347.     //-------------------------------------------------------------------------
  348.     // place immediates after all - 'ld a,b' is not 'ld a,0B'
  349.     1, 0x01, 0xCF,                                      // ld r16,imm16
  350.     _ld, _zr16, ',', _iw, 0,
  351.     //-------------------------------------------------------------------------
  352.     1, 0x06, 0xC7,                                      // ld r8, imm8
  353.     _ld, _zr8, ',', _ib, 0,
  354.     //-------------------------------------------------------------------------
  355.  
  356.     0 // end
  357. };
  358. //=============================================================================
  359.  
  360. #define abs(x) ((x)>0 ? (x) : (-(x)))
  361.  
  362. //=============================================================================
  363. // по 3
  364. //static char z80r16_1[] = "bc\0de\0hl\0sp";
  365. static char z80r16_1[] =        "bc\0"
  366.                                 "de\0"
  367.                                 "hl\0"
  368.                                 "sp";
  369. //static char z80r16_2[] = "bc\0de\0ix\0sp";
  370. static char z80r16_2[] =        "bc\0"
  371.                                 "de\0"
  372.                                 "ix\0"
  373.                                 "sp";
  374. //static char z80r16_3[] = "bc\0de\0iy\0sp";
  375. static char z80r16_3[] =        "bc\0"
  376.                                 "de\0"
  377.                                 "iy\0"
  378.                                 "sp";
  379.  
  380. //=============================================================================
  381. // по 5 остаток набираетсо \0
  382.  
  383. #define Z80R8_WIDTH     5
  384. #define Z80R8_COUNT     16      //8 + 8 альтернативных (результат & 7)
  385.  
  386.  
  387. //-----------------------------------------------------------------------------
  388. //static char z80r8_1[] = "b\0\0\0\0c\0\0\0\0d\0\0\0\0e\0\0\0\0h\0\0\0\0l\0\0\0\0(hl)\0a";
  389. static char z80r8_1[] =         "b\0\0\0\0"     //0
  390.                                 "c\0\0\0\0"     //1
  391.                                 "d\0\0\0\0"     //2
  392.                                 "e\0\0\0\0"     //3
  393.                                 "h\0\0\0\0"     //4
  394.                                 "l\0\0\0\0"     //5
  395.                                 "(hl)\0"        //6
  396.                                 "a\0\0\0\0"     //7
  397.                                 "b\0\0\0\0"     //0 ALT naming
  398.                                 "c\0\0\0\0"     //1
  399.                                 "d\0\0\0\0"     //2
  400.                                 "e\0\0\0\0"     //3
  401.                                 "h\0\0\0\0"     //4
  402.                                 "l\0\0\0\0"     //5
  403.                                 "(hl)\0"        //6
  404.                                 "a\0\0\0\0";    //7
  405.  
  406.  
  407. //=============================================================================
  408. //static char z80r8_2[] = "b\0\0\0\0c\0\0\0\0d\0\0\0\0e\0\0\0\0xh\0\0\0xl\0\0\0(1x)\0a";
  409.  
  410. // только буфер (будет перезаписан!!!)
  411. static char z80r8_2[] =         "b\0\0\0\0"     //0
  412.                                 "c\0\0\0\0"     //1
  413.                                 "d\0\0\0\0"     //2
  414.                                 "e\0\0\0\0"     //3
  415.                                 "ixh\0\0"       //4
  416.                                 "ixl\0\0"       //5
  417.                                 "(1x)\0"        //6
  418.                                 "a\0\0\0\0"     //7
  419.                                 "b\0\0\0\0"     //0 ALT naming
  420.                                 "c\0\0\0\0"     //1
  421.                                 "d\0\0\0\0"     //2
  422.                                 "e\0\0\0\0"     //3
  423.                                 "xh\0\0\0"      //4
  424.                                 "xl\0\0\0"      //5
  425.                                 "(1x)\0"        //6
  426.                                 "a\0\0\0\0";    //7
  427.  
  428. //-----------------------------------------------------------------------------
  429. // IXH IXL Style
  430. const char z80r8_2_style_0[] =          "b\0\0\0\0"     //0
  431.                                         "c\0\0\0\0"     //1
  432.                                         "d\0\0\0\0"     //2
  433.                                         "e\0\0\0\0"     //3
  434.                                         "ixh\0\0"       //4     ixh main
  435.                                         "ixl\0\0"       //5     ixl main
  436.                                         "(1x)\0"        //6
  437.                                         "a\0\0\0\0"     //7
  438.                                         "b\0\0\0\0"     //0 ALT naming
  439.                                         "c\0\0\0\0"     //1
  440.                                         "d\0\0\0\0"     //2
  441.                                         "e\0\0\0\0"     //3
  442.                                         "xh\0\0\0"      //4     xh main
  443.                                         "xl\0\0\0"      //5     xl main
  444.                                         "(1x)\0"        //6
  445.                                         "a\0\0\0\0";    //7
  446.  
  447. //-----------------------------------------------------------------------------
  448. // XH XL Style                 
  449. const char z80r8_2_style_1[] =          "b\0\0\0\0"     //0
  450.                                         "c\0\0\0\0"     //1
  451.                                         "d\0\0\0\0"     //2
  452.                                         "e\0\0\0\0"     //3
  453.                                         "xh\0\0\0"      //4     xh main
  454.                                         "xl\0\0\0"      //5     xl main
  455.                                         "(1x)\0"        //6
  456.                                         "a\0\0\0\0"     //7
  457.                                         "b\0\0\0\0"     //0 ALT naming
  458.                                         "c\0\0\0\0"     //1
  459.                                         "d\0\0\0\0"     //2
  460.                                         "e\0\0\0\0"     //3
  461.                                         "ixh\0\0"       //4     ixh alt
  462.                                         "ixl\0\0"       //5     ixl alt
  463.                                         "(1x)\0"        //6
  464.                                         "a\0\0\0\0";    //7
  465.  
  466. //=============================================================================
  467.  
  468.  
  469. //=============================================================================
  470. //static char z80r8_3[] = "b\0\0\0\0c\0\0\0\0d\0\0\0\0e\0\0\0\0yh\0\0\0yl\0\0\0(1y)\0a";
  471. static char z80r8_3[] =         "b\0\0\0\0"     //0
  472.                                 "c\0\0\0\0"     //1
  473.                                 "d\0\0\0\0"     //2
  474.                                 "e\0\0\0\0"     //3
  475.                                 "iyh\0\0"       //4
  476.                                 "iyl\0\0"       //5
  477.                                 "(1y)\0"        //6
  478.                                 "a\0\0\0\0"     //7
  479.                                 "b\0\0\0\0"     //0 ALT naming
  480.                                 "c\0\0\0\0"     //1
  481.                                 "d\0\0\0\0"     //2
  482.                                 "e\0\0\0\0"     //3
  483.                                 "yh\0\0\0"      //4
  484.                                 "yl\0\0\0"      //5
  485.                                 "(1y)\0"        //6
  486.                                 "a\0\0\0\0";    //7
  487. //-----------------------------------------------------------------------------
  488. // IYH IYL Style
  489. const char z80r8_3_style_0[] =          "b\0\0\0\0"     //0
  490.                                         "c\0\0\0\0"     //1
  491.                                         "d\0\0\0\0"     //2
  492.                                         "e\0\0\0\0"     //3
  493.                                         "iyh\0\0"       //4     iyh main
  494.                                         "iyl\0\0"       //5     iyl main
  495.                                         "(1y)\0"        //6
  496.                                         "a\0\0\0\0"     //7
  497.                                         "b\0\0\0\0"     //0 ALT naming
  498.                                         "c\0\0\0\0"     //1
  499.                                         "d\0\0\0\0"     //2
  500.                                         "e\0\0\0\0"     //3
  501.                                         "yh\0\0\0"      //4     yh alt
  502.                                         "yl\0\0\0"      //5     yl alt
  503.                                         "(1y)\0"        //6
  504.                                         "a\0\0\0\0";    //7
  505. //-----------------------------------------------------------------------------
  506. // YH YL Style
  507. const char z80r8_3_style_1[] =          "b\0\0\0\0"     //0 ALT naming
  508.                                         "c\0\0\0\0"     //1
  509.                                         "d\0\0\0\0"     //2
  510.                                         "e\0\0\0\0"     //3
  511.                                         "yh\0\0\0"      //4     yh main
  512.                                         "yl\0\0\0"      //5     yl main
  513.                                         "(1y)\0"        //6
  514.                                         "a\0\0\0\0"     //7
  515.                                         "b\0\0\0\0"     //0
  516.                                         "c\0\0\0\0"     //1
  517.                                         "d\0\0\0\0"     //2
  518.                                         "e\0\0\0\0"     //3
  519.                                         "iyh\0\0"       //4     iyh alt
  520.                                         "iyl\0\0"       //5     iyl alt
  521.                                         "(1y)\0"        //6
  522.                                         "a\0\0\0\0";    //7
  523.        
  524. //-----------------------------------------------------------------------------
  525.  
  526.  
  527.  
  528. //=============================================================================
  529.  
  530. // по 7
  531. //static char cbtab[] =  "rlc \0\0\0rrc \0\0\0rl \0\0\0\0rr \0\0\0\0sla \0\0\0sra \0\0\0sli \0\0\0srl \0\0\0"
  532. //                       "bit 0,\0bit 1,\0bit 2,\0bit 3,\0bit 4,\0bit 5,\0bit 6,\0bit 7,\0"
  533. //                       "res 0,\0res 1,\0res 2,\0res 3,\0res 4,\0res 5,\0res 6,\0res 7,\0"
  534. //                       "set 0,\0set 1,\0set 2,\0set 3,\0set 4,\0set 5,\0set 6,\0set 7,\0";
  535.  
  536. static char cbtab[] =   "rlc \0\0\0"
  537.                         "rrc \0\0\0"
  538.                         "rl \0\0\0\0"
  539.                         "rr \0\0\0\0"
  540.                         "sla \0\0\0"
  541.                         "sra \0\0\0"
  542.                         "sli \0\0\0"
  543.                         "srl \0\0\0"
  544.                         "bit 0,\0"
  545.                         "bit 1,\0"
  546.                         "bit 2,\0"
  547.                         "bit 3,\0"
  548.                         "bit 4,\0"
  549.                         "bit 5,\0"
  550.                         "bit 6,\0"
  551.                         "bit 7,\0"
  552.                         "res 0,\0"
  553.                         "res 1,\0"
  554.                         "res 2,\0"
  555.                         "res 3,\0"
  556.                         "res 4,\0"
  557.                         "res 5,\0"
  558.                         "res 6,\0"
  559.                         "res 7,\0"
  560.                         "set 0,\0"
  561.                         "set 1,\0"
  562.                         "set 2,\0"
  563.                         "set 3,\0"
  564.                         "set 4,\0"
  565.                         "set 5,\0"
  566.                         "set 6,\0"
  567.                         "set 7,\0";
  568.                
  569. //=============================================================================
  570.                
  571. //static char zjr[] =    "xxxxxx\0xxxxxx\0djnz \0\0jr \0\0\0\0jr nz,\0jr z,\0\0jr nc,\0jr c,\0";                         
  572. static char zjr[] =     "xxxxxx\0"
  573.                         "xxxxxx\0"
  574.                         "djnz \0\0"
  575.                         "jr \0\0\0\0"
  576.                         "jr nz,\0"
  577.                         "jr z,\0\0"
  578.                         "jr nc,\0"
  579.                         "jr c,\0";
  580.  
  581. //=============================================================================
  582. // по 8
  583. #define ZOP_WIDTH       8
  584. #define ZOP_COUNT       16      //8 + 8 альтернативных (результат & 7)
  585.  
  586. //-----------------------------------------------------------------------------
  587. //char zop[] = "add\0adc\0sub\0sbc\0and\0xor\0or\0\0cp"; lvd    OLD
  588. //static char zop[] =    "add a,\0\0adc a,\0\0sub \0\0\0\0sbc a,\0\0and \0\0\0\0xor \0\0\0\0or \0\0\0\0\0cp \0\0\0\0\0";
  589.  
  590. //-----------------------------------------------------------------------------
  591. // буфер будет перезаписан! при входе в дебагер согласно конфигу
  592. static char zop[] =     "add a,\0\0"            //0 add a,a
  593.                         "adc a,\0\0"            //1 adc a,a
  594.                         "sub \0\0\0\0"          //2 sub a
  595.                         "sbc a,\0\0"            //3 sbc a,a
  596.                         "and \0\0\0\0"          //4 and a
  597.                         "xor \0\0\0\0"          //5 xor a
  598.                         "or \0\0\0\0\0"         //6 or a
  599.                         "cp \0\0\0\0\0"         //7 cp a
  600.                         "add \0\0\0\0"          //0 add a               ALT
  601.                         "adc \0\0\0\0"          //1 adc a
  602.                         "sub a,\0\0"            //2 sub a,a             "sub \0\0\0\0"
  603.                         "sbc \0\0\0\0"          //3 sbc a
  604.                         "and a,\0\0"            //4 and a,a             "and \0\0\0\0"
  605.                         "xor a,\0\0"            //5 xor a,a             "xor \0\0\0\0"
  606.                         "or a,\0\0\0"           //6 or a,a              "or \0\0\0\0\0"
  607.                         "cp a,\0\0\0";          //7 cp a,a              "cp \0\0\0\0\0"
  608.  
  609. //-----------------------------------------------------------------------------
  610. // Full
  611. const char zop_style_0[] =      "add a,\0\0"            //0 add a,a
  612.                                 "adc a,\0\0"            //1 adc a,a
  613.                                 "sub a,\0\0"            //2 sub a,a
  614.                                 "sbc a,\0\0"            //3 sbc a,a
  615.                                 "and a,\0\0"            //4 and a,a
  616.                                 "xor a,\0\0"            //5 xor a,a
  617.                                 "or a,\0\0\0"           //6 or a,a
  618.                                 "cp a,\0\0\0"           //7 cp a,a
  619.                                 "add \0\0\0\0"          //0 add a - ALT
  620.                                 "adc \0\0\0\0"          //1 adc a
  621.                                 "sub \0\0\0\0"          //2 sub a
  622.                                 "sbc \0\0\0\0"          //3 sbc a
  623.                                 "and \0\0\0\0"          //4 and a
  624.                                 "xor \0\0\0\0"          //5 xor a
  625.                                 "or \0\0\0\0\0"         //6 or a
  626.                                 "cp \0\0\0\0\0";        //7 cp a
  627. //-----------------------------------------------------------------------------
  628. // Short
  629. const char zop_style_1[] =      "add \0\0\0\0"          //0 add a
  630.                                 "adc \0\0\0\0"          //1 adc a
  631.                                 "sub \0\0\0\0"          //2 sub a
  632.                                 "sbc \0\0\0\0"          //3 sbc a
  633.                                 "and \0\0\0\0"          //4 and a
  634.                                 "xor \0\0\0\0"          //5 xor a
  635.                                 "or \0\0\0\0\0"         //6 or a
  636.                                 "cp \0\0\0\0\0"         //7 cp a
  637.                                 "add a,\0\0"            //0 add a,a - ALT
  638.                                 "adc a,\0\0"            //1 adc a,a
  639.                                 "sub a,\0\0"            //2 sub a,a
  640.                                 "sbc a,\0\0"            //3 sbc a,a
  641.                                 "and a,\0\0"            //4 and a,a
  642.                                 "xor a,\0\0"            //5 xor a,a
  643.                                 "or a,\0\0\0"           //6 or a,a
  644.                                 "cp a,\0\0\0";          //7 cp a,a                     
  645. //-----------------------------------------------------------------------------
  646. // Classic
  647. static char zop_style_2[] =     "add a,\0\0"            //0 add a,a
  648.                                 "adc a,\0\0"            //1 adc a,a
  649.                                 "sub \0\0\0\0"          //2 sub a
  650.                                 "sbc a,\0\0"            //3 sbc a,a
  651.                                 "and \0\0\0\0"          //4 and a
  652.                                 "xor \0\0\0\0"          //5 xor a
  653.                                 "or \0\0\0\0\0"         //6 or a
  654.                                 "cp \0\0\0\0\0"         //7 cp a
  655.                                 "add \0\0\0\0"          //0 add a               ALT
  656.                                 "adc \0\0\0\0"          //1 adc a
  657.                                 "sub a,\0\0"            //2 sub a,a             "sub \0\0\0\0"
  658.                                 "sbc \0\0\0\0"          //3 sbc a
  659.                                 "and a,\0\0"            //4 and a,a             "and \0\0\0\0"
  660.                                 "xor a,\0\0"            //5 xor a,a             "xor \0\0\0\0"
  661.                                 "or a,\0\0\0"           //6 or a,a              "or \0\0\0\0\0"
  662.                                 "cp a,\0\0\0";          //7 cp a,a              "cp \0\0\0\0\0"
  663.  
  664. //=============================================================================
  665.  
  666. //static char zf[] =     "nz\0z\0\0nc\0c\0\0po\0pe\0p\0\0m";
  667. static char zf[] =      "nz\0"
  668.                         "z\0\0"
  669.                         "nc\0"
  670.                         "c\0\0"
  671.                         "po\0"
  672.                         "pe\0"
  673.                         "p\0\0"
  674.                         "m";
  675. //=============================================================================
  676.  
  677.  
  678. //=============================================================================
  679. void update_disasm_style()
  680. {
  681.  
  682.     //-------------------------------------------------------------------------
  683.     switch (conf.Disasm_A_Mnemonics_Style)
  684.     {
  685.         case 0: memcpy( zop, zop_style_0, sizeof(zop_style_0)); break;  // Full form  (xxx a,a)
  686.         case 1: memcpy( zop, zop_style_1, sizeof(zop_style_1)); break;  // Short form (xxx a)
  687.         case 2: memcpy( zop, zop_style_2, sizeof(zop_style_2)); break;  // Classic form
  688.     }
  689.     //-------------------------------------------------------------------------
  690.     switch (conf.Disasm_Index_H_L_Style)
  691.     {
  692.         //IXH IXL IYH IYL
  693.         case 0: memcpy( z80r8_2, z80r8_2_style_0, sizeof(z80r8_2_style_0));    
  694.                 memcpy( z80r8_3, z80r8_3_style_0, sizeof(z80r8_3_style_0));     break;
  695.         //XH XL YH YL
  696.         case 1: memcpy( z80r8_2, z80r8_2_style_1, sizeof(z80r8_2_style_1));
  697.                 memcpy( z80r8_3, z80r8_3_style_1, sizeof(z80r8_3_style_1));     break;
  698.     }
  699.     //-------------------------------------------------------------------------    
  700.  
  701.  
  702.     return;                    
  703. }
  704.  
  705.  
  706.  
  707. //=============================================================================
  708. static void disasm_address( char *line, unsigned addr, char labels)
  709. {
  710.     char *label = nullptr;
  711.    
  712. //   if (labels&&addr) label = mon_labels.find(am_r(addr));     //0.39.0
  713.  
  714.     char *virtlabel = nullptr;  //NEDOREPO
  715.     //-------------------------------------------------------------------------
  716.     if (labels && addr)
  717.     {
  718.         label = mon_labels.find( am_r( addr));
  719.         virtlabel = mon_labels.find( ((unsigned char *)NULL)+addr);
  720.     }
  721.     //-------------------------------------------------------------------------
  722.     if (virtlabel)              // NEDOREPO
  723.         label = virtlabel;     
  724.     //-------------------------------------------------------------------------
  725.     if (label)
  726.     {
  727.         //strcpy(line, label);
  728.         int i;
  729.         //---------------------------------------------------------------------
  730.         for (i = 0;    (i < 20) && label[i];    i++)
  731.             line[i] = label[i];
  732.         //---------------------------------------------------------------------
  733.         line[i] = label[i];
  734.     } //Alone Coder 0.36.6
  735.     //-------------------------------------------------------------------------
  736.     else
  737.     {
  738.         sprintf( line, "%04X", addr & 0xFFFF);
  739.     }
  740.     //-------------------------------------------------------------------------
  741. }
  742. //=============================================================================
  743.  
  744.  
  745. //=============================================================================
  746. const unsigned char *disasm( const unsigned char *cmd, unsigned current, char labels)
  747. {
  748.     const unsigned char *st = cmd;
  749.     unsigned char z80p;
  750.     char *z80r16;
  751.     char *z80r8;
  752.  
  753.     z80r16 = z80r16_1;
  754.     z80r8 = z80r8_1;
  755.     z80p = 0;
  756.     //-------------------------------------------------------------------------
  757.     for (    ;    ;    )
  758.     { // z80 prefixes
  759.         //---------------------------------------------------------------------
  760.         if (*cmd == 0xDD)
  761.         {
  762.             z80r16 = z80r16_2;
  763.             z80r8 = z80r8_2;
  764.             z80p = 0xDD;
  765.         }
  766.         //---------------------------------------------------------------------
  767.         else if (*cmd == 0xFD)
  768.         {
  769.             z80r16 = z80r16_3;
  770.             z80r8 = z80r8_3;
  771.             z80p = 0xFD;
  772.         }
  773.         //---------------------------------------------------------------------
  774.         else
  775.         {
  776.             break;
  777.         }
  778.         //---------------------------------------------------------------------
  779.         cmd++;
  780.     }
  781.     //-------------------------------------------------------------------------
  782.     for (unsigned char *ptr = asm_tab_z80;    *ptr;    )
  783.     {
  784.         // cmd - start of command, c1 - mod/rm, cm - current pointer
  785.         const unsigned char *rcmd = cmd;
  786.         //---------------------------------------------------------------------
  787.         if (*cmd == 0xED)
  788.         {
  789.             rcmd++;
  790.             z80r16 = z80r16_1;
  791.             z80r8 = z80r8_1;
  792.             z80p = 0;
  793.         }
  794.         //---------------------------------------------------------------------
  795.         const unsigned char *cm = rcmd + 1;
  796.         //---------------------------------------------------------------------
  797.         for (int j = 0;    j < *ptr;    j++)    // match mask
  798.             if ((cmd[j] & ptr[j + *ptr + 1]) != ptr[j + 1])
  799.                 goto nextcmd;
  800.         //---------------------------------------------------------------------
  801.         *asmbuf = 0;
  802.         unsigned char *pt;
  803.         //---------------------------------------------------------------------
  804.         for (pt = ptr + (2 * *ptr) + 1;    *pt;    pt++)
  805.         { // scan all commands
  806.             char ln[/*32*/64];
  807.             const char *l1 = ln;
  808.             ln[0] = 0; //Alone Coder 0.36.6
  809.             //-----------------------------------------------------------------
  810.             switch (*pt)
  811.             {
  812.                 //-------------------------------------------------------------
  813.                 case _zr16:                                     // in rcmd & 0x30
  814.                     l1 = z80r16 + 3 * ((*rcmd >> 4) & 3);
  815.                     break;
  816.                 //-------------------------------------------------------------
  817.                 case _zr16a:                                    // in rcmd & 0x30
  818.                     if (((*rcmd >> 4) & 3) == 3)
  819.                     {
  820.                         l1 = "af";
  821.                     }
  822.                     else
  823.                     {
  824.                         l1 = z80r16 + 3 * ((*rcmd >> 4) & 3);
  825.                     }
  826.                     break;
  827.                 //-------------------------------------------------------------
  828.                 case _hl:                                       // hl/ix/iy
  829.                     l1 = z80r16 + 3 * 2;
  830.                     break;
  831.                 //-------------------------------------------------------------
  832.                 case _zjr:                                      // relative jumps
  833.                     l1 = zjr + 7 * ((*rcmd >> 3) & 7);
  834.                     break;
  835.                 //-------------------------------------------------------------
  836.                 case _zop:                                      // z80 operations at rcmd & 0x38
  837.                   //l1 = zop + 4 * ((*rcmd >> 3) & 7); lvd OLD
  838.                   //l1 = zop + 8 * ((*rcmd >> 3) & 7);
  839.                     l1 = zop + ZOP_WIDTH * ((*rcmd >> 3) & 7);
  840.                     break;
  841.                 //-------------------------------------------------------------
  842.                 case _zf:                                       // z80 flags at rcmd & 0x38
  843.                     l1 = zf + 3 * ((*rcmd >> 3) & 7);
  844.                     break;
  845.                 //-------------------------------------------------------------
  846.                 case _cb:                                       // all CB-opcodes
  847.                 {
  848.                     //---------------------------------------------------------
  849.                     if (!z80p)
  850.                     {
  851.                         sprintf(  ln,
  852.                                     "%s%s",
  853.                                       cbtab + (*cm >> 3) * 7,
  854.                                         z80r8_1 + (*cm & 7) * 5);
  855.                         cm++;
  856.                     }
  857.                     //---------------------------------------------------------
  858.                     else
  859.                     {
  860.                         //---------------------------------------------------------
  861.                         if ((cm[1] & 7) != 6 && ((cm[1] & 0xC0) != 0x40)) // operand is reg,(ix+nn)
  862.                         {
  863.                             sprintf(  ln,
  864.                                         "%s%s,(i%c%c%02X)",
  865.                                           cbtab + (cm[1] >> 3) * 7,
  866.                                             z80r8_1 + (cm[1] & 7) * 5,
  867.                                               z80p == 0xDD  ?  'x' :
  868.                                                                'y',
  869.                                                   *(char*)cm >= 0  ?  '+' :
  870.                                                                       '-',
  871.                                                       abs(*(char*)cm)
  872.                                     );
  873.                         }
  874.                         //---------------------------------------------------------
  875.                         else // only (ix+nn)
  876.                         {
  877.                             sprintf(  ln,
  878.                                         "%s(i%c%c%02X)",
  879.                                           cbtab + (cm[1] >> 3) * 7,
  880.                                             z80p == 0xDD  ?  'x' :
  881.                                                              'y',
  882.                                                 *(char*)cm >= 0  ?  '+' :
  883.                                                                     '-',
  884.                                                     abs(*(char*)cm)
  885.                                     );
  886.                         }
  887.                         //---------------------------------------------------------
  888.                         cm += 2;
  889.                     }
  890.                     //---------------------------------------------------------
  891.                     break;
  892.                 }
  893.                 //-------------------------------------------------------------
  894.                 case _zr8:                                      // in rcmd & 0x38
  895.                     //---------------------------------------------------------
  896.                     if (z80p && ((*rcmd & 0x38) == 0x30))
  897.                     {
  898.                         sprintf(  ln,
  899.                                     "(i%c%c%02X)",
  900.                                       z80p == 0xDD  ?  'x' :
  901.                                                        'y',
  902.                                           *(char*)cm >= 0  ?  '+' :
  903.                                                               '-',
  904.                                               abs(*(char*)cm)
  905.                                 );
  906.                         cm++;
  907.                     }
  908.                     //---------------------------------------------------------
  909.                     else
  910.                     {
  911.                         l1 = z80r8 + 5 * ((*rcmd >> 3) & 7);
  912.                     }
  913.                     //---------------------------------------------------------
  914.                     break;
  915.                 //-------------------------------------------------------------
  916.                 case _zr8_:                     // in rcmd & 0x38, in ld r8,r8
  917.                     //---------------------------------------------------------
  918.                     if (!z80p || (*rcmd & 7) == 6)
  919.                     {
  920.                         l1 = z80r8_1 + 5 * ((*rcmd >> 3) & 7);
  921.                         break;
  922.                     }
  923.                     //---------------------------------------------------------
  924.                     if ((*rcmd & 0x38) == 0x30)
  925.                     {
  926.                         sprintf(  ln,
  927.                                     "(i%c%c%02X)",
  928.                                       z80p == 0xDD  ?  'x' :
  929.                                                        'y',
  930.                                           *(char*)cm >= 0  ?  '+' :
  931.                                                               '-',
  932.                                               abs(*(char*)cm)
  933.                                 );
  934.                         cm++;
  935.                     }
  936.                     //---------------------------------------------------------
  937.                     else
  938.                     {
  939.                         l1 = z80r8 + 5 * ((*rcmd >> 3) & 7);
  940.                     }//--------------------------------------------------------
  941.                     break;
  942.                 //-------------------------------------------------------------
  943.                 case _zr81:                                     // in rcmd & 7
  944.                     //---------------------------------------------------------
  945.                     if (z80p && (*rcmd & 7) == 6)
  946.                     {
  947.                         sprintf(  ln,
  948.                                     "(i%c%c%02X)",
  949.                                       z80p == 0xDD  ?  'x' :
  950.                                                        'y',
  951.                                           *(char*)cm >= 0  ?  '+' :
  952.                                                               '-',
  953.                                               abs(*(char*)cm)
  954.                                 );
  955.                         cm++;
  956.                     }
  957.                     //---------------------------------------------------------
  958.                     else
  959.                     {
  960.                         l1 = z80r8 + 5 * (*rcmd & 7);
  961.                     }
  962.                     //---------------------------------------------------------
  963.                     break;
  964.                 //-------------------------------------------------------------
  965.                 case _zr81_:                    // in rcmd & 7, in ld r8,r8
  966.                     //---------------------------------------------------------
  967.                     if (!z80p || ((*rcmd & 0x38) == 0x30))
  968.                     {
  969.                         l1 = z80r8_1 + 5 * (*rcmd & 7);
  970.                         break;
  971.                     }
  972.                     //---------------------------------------------------------
  973.                     if ((*rcmd & 7) == 6)
  974.                     {
  975.                         sprintf(  ln,
  976.                                     "(i%c%c%02X)",
  977.                                       z80p == 0xDD  ?  'x' :
  978.                                                        'y',
  979.                                           *(char*)cm >= 0  ?  '+' :
  980.                                                               '-',
  981.                                               abs(*(char*)cm)
  982.                                 );
  983.                         cm++;
  984.                     }
  985.                     //---------------------------------------------------------
  986.                     else
  987.                     {
  988.                         l1 = z80r8 + 5 * (*rcmd & 7);
  989.                     }
  990.                     //---------------------------------------------------------
  991.                     break;
  992.                 //-------------------------------------------------------------
  993.                 case _ld:
  994.                     l1 = "ld ";
  995.                     break;
  996.                 //-------------------------------------------------------------
  997.                 case _shrt:                                     // short jump
  998.                     disasm_address( ln, unsigned( current + cm - st + *(signed char*) cm + 1), labels);
  999.                     cm++;
  1000.                     break;
  1001.                 //-------------------------------------------------------------
  1002.                 case _ib:                               // immediate byte at cm
  1003.                     sprintf(ln, "%02X", *cm++);
  1004.                     break;
  1005.                 //-------------------------------------------------------------
  1006.                 case _iw:                               // immediate word at cm
  1007.                     disasm_address(ln, *(unsigned short*)cm, labels);
  1008.                     cm += 2;
  1009.                     break;
  1010.                 //-------------------------------------------------------------
  1011.                 default:
  1012.                     *(short*)ln = *pt;
  1013.                 //-------------------------------------------------------------
  1014.             }
  1015.             //-----------------------------------------------------------------
  1016.             strcat(asmbuf, l1);
  1017.         }
  1018.         //---------------------------------------------------------------------
  1019.         // make tabulation between instruction and operands
  1020.         {
  1021.             //                        if( !cpu.logena ) //LVD
  1022.             {
  1023.                 char b1[0x40];
  1024.                 char *p = asmbuf;
  1025.                 char *q = b1;
  1026.                 //-------------------------------------------------------------
  1027.                 while (*p != ' ' && *p)
  1028.                     *q++ = *p++;
  1029.                 //-------------------------------------------------------------
  1030.                 *q++ = *p;
  1031.                 //-------------------------------------------------------------
  1032.                 if (*p)
  1033.                 {
  1034.                     //---------------------------------------------------------
  1035.                     if (conf.Disasm_Tabulation)
  1036.                     {
  1037.                         while (q < b1 + 5)
  1038.                         {
  1039.                             *q++ = ' '; // +5 - tab size=5, was 4
  1040.                         }
  1041.                     }
  1042.                     //---------------------------------------------------------
  1043.                     while(*++p)
  1044.                         *q++ = *p;
  1045.                     //---------------------------------------------------------
  1046.                 }
  1047.                 *q = 0;
  1048.                 strcpy(asmbuf, b1);
  1049.             }
  1050.             return max(cm, cmd + *ptr);
  1051.         }
  1052. nextcmd:
  1053.         ptr += (2 * *ptr) + 1;
  1054.         //---------------------------------------------------------------------
  1055.         while(*ptr++); // skip mask,code and instruction
  1056.         //---------------------------------------------------------------------
  1057.     }
  1058.     strcpy(asmbuf, "???"); return cmd + 1;
  1059. }
  1060. //=============================================================================
  1061.  
  1062.  
  1063. //=============================================================================
  1064. static int getindex(unsigned char **ptr, char *table, unsigned width, int size)
  1065. {
  1066. // find max match - fdiv and fdivr must be found as fdivr
  1067.     unsigned max = 0;
  1068.     unsigned imax;
  1069.     //-------------------------------------------------------------------------
  1070.     for (unsigned i = 0;    i < unsigned(size);    i++)
  1071.     {
  1072.         size_t ln = strlen(table + i * width);
  1073.         //---------------------------------------------------------------------
  1074.         if (!strncmp((char*)*ptr, table + i * width, ln))
  1075.         {
  1076.             if (ln > max)
  1077.             {
  1078.                 max = unsigned(ln);
  1079.                 imax = i;
  1080.             }
  1081.         }
  1082.         //---------------------------------------------------------------------
  1083.     }
  1084.     if (max)
  1085.     {
  1086.         (*ptr) += strlen(table + imax*width);
  1087.         return int(imax);
  1088.     }
  1089.     return -1;
  1090. }
  1091. //=============================================================================
  1092.  
  1093.  
  1094.  
  1095. //=============================================================================
  1096. static int scanhex(unsigned char **ptr)
  1097. {
  1098.     int r = 0;
  1099.     int s = 1;
  1100.     //-------------------------------------------------------------------------
  1101.     if (**ptr == '-')
  1102.     {
  1103.         (*ptr)++;
  1104.         s = -1;
  1105.     }
  1106.     //-------------------------------------------------------------------------
  1107.     if (**ptr == '+')
  1108.         (*ptr)++;
  1109.     //-------------------------------------------------------------------------
  1110.     while (isdigit(**ptr) || (**ptr >= 'a' && **ptr <= 'f'))
  1111.     {
  1112.         r = 16 * r + hexdigit(**ptr);
  1113.         (*ptr)++;
  1114.     }
  1115.     //-------------------------------------------------------------------------
  1116.     return r*s;
  1117. }
  1118. //=============================================================================
  1119.  
  1120. static unsigned char cmdb[16];
  1121. unsigned char asmresult[24];
  1122. static unsigned char z80p;
  1123. static unsigned char a_command[0x40];
  1124.  
  1125. //=============================================================================
  1126. static int z80scanr8(unsigned char **ptr, unsigned char **cm)
  1127. {
  1128. //  int in = getindex(ptr, z80r8_1, 5, 8);
  1129.     int in = (getindex(ptr, z80r8_1, Z80R8_WIDTH, Z80R8_COUNT)) ;       //+alt набор [NS]
  1130.     if (in >= 0) in &= 0x07;    //обрезка alt набора
  1131.     //printf("in %d\n",in);
  1132.     //-------------------------------------------------------------------------
  1133.     if (in >= 0)
  1134.         return in;
  1135.     //-------------------------------------------------------------------------
  1136.     char *r8 = z80r8_1;
  1137.     //-------------------------------------------------------------------------
  1138.     if (z80p == 0xDD)
  1139.         r8 = z80r8_2;
  1140.     //-------------------------------------------------------------------------
  1141.     if (z80p == 0xFD)
  1142.         r8 = z80r8_3;
  1143.     //-------------------------------------------------------------------------
  1144. //  in = getindex(ptr, r8, 5, 8);
  1145.     in = (getindex(ptr, r8, Z80R8_WIDTH, Z80R8_COUNT));         //+alt набор [NS]
  1146.     if (in >= 0) in &= 0x07;    //обрезка alt набора
  1147.     //printf("in %d\n",in);
  1148.     //-------------------------------------------------------------------------
  1149.     if (!z80p)
  1150.         return in;
  1151.     //-------------------------------------------------------------------------
  1152.     // not (ix
  1153.     if (*(unsigned short*)(*ptr) != WORD2('(','i'))
  1154.     {
  1155.         return in;
  1156.     }
  1157.     //-------------------------------------------------------------------------
  1158.     (*ptr) += 3;
  1159.     char c = char(*(*ptr - 1));
  1160.     if (((z80p == 0xDD) && (c != 'x')) || ((z80p == 0xFD) && (c != 'y')))
  1161.     {
  1162.         return -1;
  1163.     }
  1164.     //-------------------------------------------------------------------------
  1165.     int ofs = (**ptr == ')')  ?  0 :
  1166.                                  scanhex(ptr);
  1167.     //-------------------------------------------------------------------------
  1168.     if (ofs > 127 || ofs < -128)
  1169.         return -1;
  1170.     //-------------------------------------------------------------------------
  1171.     if (*((*ptr)++) != ')')
  1172.         return -1;
  1173.     //-------------------------------------------------------------------------
  1174.     *(signed char*)(*cm)++ = (signed char)ofs;
  1175.     return 6;
  1176. }
  1177. //=============================================================================
  1178.  
  1179.  
  1180. //=============================================================================
  1181. static unsigned assemble(unsigned addr)
  1182. {
  1183.     char *z80r16 = z80r16_1;
  1184.     //-------------------------------------------------------------------------
  1185.     if (z80p == 0xDD)
  1186.         z80r16 = z80r16_2;
  1187.     //-------------------------------------------------------------------------
  1188.     if (z80p == 0xFD)
  1189.         z80r16 = z80r16_3;
  1190.     //-------------------------------------------------------------------------
  1191.     for (unsigned char *p1 = asm_tab_z80;    *p1;    )
  1192.     {
  1193.         memset(cmdb, 0, sizeof(cmdb));
  1194.         unsigned char *cc = a_command;
  1195.         memcpy(cmdb, p1+1, *p1);
  1196.         unsigned char *cmd = cmdb;
  1197.         unsigned char *rcmd = cmd;
  1198.         unsigned char *cm;
  1199.         //---------------------------------------------------------------------
  1200.         if (*cmd == 0xED)
  1201.         {
  1202.             rcmd++;
  1203.             //-----------------------------------------------------------------
  1204.             if (z80p)
  1205.                 goto nextcmd;
  1206.             //-----------------------------------------------------------------
  1207.         }
  1208.         //---------------------------------------------------------------------
  1209.         cm = rcmd+1;
  1210.  
  1211.         int in;
  1212.         unsigned char *ptr; //Alone Coder
  1213.         //---------------------------------------------------------------------
  1214.         for (ptr = p1+2 * *p1+1;    *ptr;    ptr++)
  1215.         {
  1216.             //-----------------------------------------------------------------
  1217.             switch (*ptr)
  1218.             {
  1219.                 //-------------------------------------------------------------
  1220.                 case _zr16: // in rcmd & 0x30
  1221.                     //---------------------------------------------------------
  1222.                     if ((in = getindex(&cc, z80r16, 3, 4)) < 0)
  1223.                         goto nextcmd;
  1224.                     //---------------------------------------------------------
  1225.                     *rcmd |= (in << 4);
  1226.                     break;
  1227.                 //-------------------------------------------------------------
  1228.                 case _zr16a: // in rcmd & 0x30
  1229.                     //---------------------------------------------------------
  1230.                     if (*(unsigned short*)cc == WORD2('a','f'))
  1231.                     {
  1232.                         cc += 2;
  1233.                         in = 3;
  1234.                     }
  1235.                     //---------------------------------------------------------
  1236.                     else
  1237.                     {
  1238.                         //-----------------------------------------------------
  1239.                         if ((in = getindex(&cc, z80r16, 3, 4)) < 0)
  1240.                             goto nextcmd;
  1241.                         //-----------------------------------------------------
  1242.                     }
  1243.                     //---------------------------------------------------------
  1244.                     *rcmd |= (in << 4);
  1245.                     break;
  1246.                 //-------------------------------------------------------------
  1247.                 case _zjr: // relative jumps
  1248.                     //---------------------------------------------------------
  1249.                     if ((in = getindex(&cc, zjr, 7, 8)) < 0)
  1250.                         goto nextcmd;
  1251.                     //---------------------------------------------------------
  1252.                     *rcmd |= (in << 3);
  1253.                     break;
  1254.                 //-------------------------------------------------------------
  1255.                 case _zop: // z80 ops
  1256.                     //---------------------------------------------------------
  1257.                   //if ((in = getindex(&cc, zop, 8, 8)) < 0)
  1258.                     if ((in = getindex(&cc, zop, ZOP_WIDTH, ZOP_COUNT)) < 0) // [NS]
  1259.                         goto nextcmd;
  1260.                     //---------------------------------------------------------
  1261.                     in &= 0x07; //обрезка alt вариантов [NS]
  1262.                     //---------------------------------------------------------
  1263.                     *rcmd |= (in << 3);
  1264.                     break;
  1265.                 //-------------------------------------------------------------
  1266.                 case _zf: // z80 flags
  1267.                     //---------------------------------------------------------
  1268.                     if ((in = getindex(&cc, zf, 3, 8)) < 0)
  1269.                         goto nextcmd;
  1270.                     //---------------------------------------------------------
  1271.                     *rcmd |= (in << 3);
  1272.                     break;
  1273.                 //-------------------------------------------------------------
  1274.                 case _hl: // hl/ix/iy
  1275.                     //---------------------------------------------------------
  1276.                     if ((in = getindex(&cc, z80r16, 3, 4)) != 2)
  1277.                         goto nextcmd;
  1278.                     //---------------------------------------------------------
  1279.                     break;
  1280.                 //-------------------------------------------------------------
  1281.                 case _cb: // all CB-opcodes
  1282.                 {
  1283.                     //---------------------------------------------------------
  1284.                     if ((in = getindex(&cc, cbtab, 7, 32)) < 0)
  1285.                         goto nextcmd;
  1286.                     //---------------------------------------------------------
  1287.                     int in1 = getindex(&cc, z80r8_1, 5, 8);
  1288.                     //---------------------------------------------------------
  1289.                     if (!z80p)
  1290.                     {
  1291.                         //-----------------------------------------------------
  1292.                         if (in1 < 0)
  1293.                             goto nextcmd;
  1294.                         //-----------------------------------------------------
  1295.                     }
  1296.                     //---------------------------------------------------------
  1297.                     else
  1298.                     {
  1299.                         //-----------------------------------------------------
  1300.                         if (in1 < 0)
  1301.                         {
  1302.                             in1 = z80scanr8(&cc, &cm);
  1303.                             //-------------------------------------------------
  1304.                             if (in1 < 0)
  1305.                                 goto nextcmd;
  1306.                             //-------------------------------------------------
  1307.                         }
  1308.                         //-----------------------------------------------------
  1309.                         else
  1310.                         {
  1311.                             //-------------------------------------------------
  1312.                             if (*cc++ != ',' || z80scanr8(&cc, &cm) != 6)
  1313.                                 goto nextcmd;
  1314.                             //-------------------------------------------------
  1315.                         }
  1316.                         //-----------------------------------------------------
  1317.                     }
  1318.                     //---------------------------------------------------------
  1319.                     *cm++ = u8(in*8+in1);
  1320.                     break;
  1321.                 }
  1322.                 //-------------------------------------------------------------
  1323.                 case _zr8: // r8 in *rcmd & 0x38
  1324.                 case _zr8_: // r8 in *rcmd & 0x38, in ld r8,r8
  1325.                     //---------------------------------------------------------
  1326.                     if ((in = z80scanr8(&cc, &cm)) < 0)
  1327.                         goto nextcmd;
  1328.                     //---------------------------------------------------------
  1329.                     *rcmd |= in << 3;
  1330.                     break;
  1331.                 //-------------------------------------------------------------
  1332.                 case _zr81: // r8 in *rcmd & 7
  1333.                 case _zr81_: // r8 in *rcmd & 7, in ld r8,r8
  1334.                     //---------------------------------------------------------
  1335.                     if ((in = z80scanr8(&cc, &cm)) < 0)
  1336.                         goto nextcmd;
  1337.                     //---------------------------------------------------------
  1338.                     *rcmd |= in;
  1339.                     break;
  1340.                 //-------------------------------------------------------------
  1341.                 case _ld:
  1342.                     //---------------------------------------------------------
  1343.                     if ((*(unsigned*)cc & 0xFFFFFF) != WORD4('l','d',' ',0))
  1344.                         goto nextcmd;
  1345.                     //---------------------------------------------------------
  1346.                     cc += 3;
  1347.                     break;
  1348.                 //-------------------------------------------------------------
  1349.                 case _shrt: // short jump
  1350.                 {
  1351.                     //---------------------------------------------------------
  1352.                     if (!ishex(char(*cc)))
  1353.                         goto nextcmd;
  1354.                     //---------------------------------------------------------
  1355.                     in = scanhex(&cc);
  1356.                     int x = i16( in - (int)addr + cmdb - cm - 1);
  1357.                     //---------------------------------------------------------
  1358.                     if (x > 0x7F || x < -0x80)
  1359.                         goto nextcmd;
  1360.                     //---------------------------------------------------------
  1361.                     *(char*)cm = char(x);
  1362.                     cm++;
  1363.                     break;
  1364.                 }
  1365.                 //-------------------------------------------------------------
  1366.                 case _ib: // immediate byte at cm
  1367.                     //---------------------------------------------------------
  1368.                     if ((*cc == '\'') && (cc[2] == '\''))
  1369.                     {
  1370.                         in = cc[1];
  1371.                         cc += 3;
  1372.                         goto imm;
  1373.                     }
  1374.                     //---------------------------------------------------------
  1375.                     if (!ishex(char(*cc)))
  1376.                         goto nextcmd;
  1377.                     //---------------------------------------------------------
  1378.                     in = scanhex(&cc);
  1379.                     //---------------------------------------------------------
  1380.                     if ((unsigned)in > 0xFF)
  1381.                         goto nextcmd;
  1382.                     //---------------------------------------------------------
  1383. imm:
  1384.                     *(char*)cm++ = (char)in;
  1385.                     break;
  1386.                 //---------------------------------------------------------
  1387.                 case _iw: // immediate word at cm
  1388.                     //---------------------------------------------------------
  1389.                     if (!ishex(char(*cc)))
  1390.                         goto nextcmd;
  1391.                     //---------------------------------------------------------
  1392.                     in = scanhex(&cc);
  1393.                     //---------------------------------------------------------
  1394.                     if ((unsigned)in > 0xFFFF)
  1395.                         goto nextcmd;
  1396.                     //---------------------------------------------------------
  1397.                     *(unsigned short*)cm = (unsigned short)in;
  1398.                     cm += 2;
  1399.                     break;
  1400.                 //-------------------------------------------------------------
  1401.                 default:
  1402.                     if (*ptr != *cc++)
  1403.                         goto nextcmd;
  1404.                 //-------------------------------------------------------------
  1405.             } //switch (*ptr)
  1406.             //-----------------------------------------------------------------
  1407.         } //for (ptr = p1+2 * *p1+1;    *ptr;    ptr++)
  1408.         //---------------------------------------------------------------------
  1409.         if (!*cc)
  1410.             return max(unsigned(cm-cmdb), unsigned(*p1));
  1411.         //---------------------------------------------------------------------
  1412. nextcmd:
  1413.         p1 += (2 * *p1) + 1;
  1414.         //---------------------------------------------------------------------
  1415.         while (*p1++);
  1416.         //---------------------------------------------------------------------
  1417.     }
  1418.     //-------------------------------------------------------------------------
  1419.     return 0;
  1420. }
  1421. //=============================================================================
  1422.  
  1423.  
  1424. //=============================================================================
  1425. unsigned assemble_cmd(unsigned char *cmd, unsigned addr)
  1426. {
  1427.     unsigned char *res = a_command;
  1428.     unsigned char bf[0x40];
  1429.     strcpy((char*)bf, (char*)cmd);
  1430.     //-------------------------------------------------------------------------
  1431.     for (res = bf;    *res;    res++)
  1432.     { // don't allow to kill space befor (# - place 0x01
  1433.         //---------------------------------------------------------------------
  1434.         if (*(short*)res == WORD2(   ' ',   '('   ))
  1435.             *(short*)res =  WORD2(     1,   '('   );
  1436.         //---------------------------------------------------------------------
  1437.         if (*(short*)res == WORD2(   ' ',   '#'   ))
  1438.             *(short*)res =  WORD2(     1,   '#'   );
  1439.         //---------------------------------------------------------------------
  1440.     }
  1441.     //-------------------------------------------------------------------------
  1442.     res = a_command;
  1443.     cmd = bf;
  1444.     //-------------------------------------------------------------------------
  1445.     while (*cmd == ' ')
  1446.         cmd++;
  1447.     //-------------------------------------------------------------------------
  1448.     while (*cmd && *cmd != ' ')
  1449.         *res++ = u8( tolower( *cmd++));
  1450.     //-------------------------------------------------------------------------
  1451.     while (*cmd)
  1452.     {
  1453.         //---------------------------------------------------------------------
  1454.         while (*cmd == ' ' && (!isalnum(cmd[1]) || !isalnum(res[-1])))
  1455.             cmd++;
  1456.         //---------------------------------------------------------------------
  1457.         *res++ = (cmd[-1] == '\'')   ?   *cmd :
  1458.                                          u8(tolower(*cmd));
  1459.         cmd++;
  1460.     }
  1461.     //-------------------------------------------------------------------------
  1462.     if (res[-1] == ' ')
  1463.         res[-1] = 0;
  1464.     //-------------------------------------------------------------------------
  1465.     *res = 0;
  1466.     //-------------------------------------------------------------------------
  1467.     // replace 0x01 to space again
  1468.     for (res = a_command;    *res;    res++)
  1469.         if (!(*res-1))
  1470.             *res = ' ';
  1471.     //-------------------------------------------------------------------------
  1472.     unsigned r;
  1473.     z80p = 0;    if ((r = assemble( addr))) goto inspref1;
  1474.     z80p = 0xDD; if ((r = assemble( addr))) goto inspref1;
  1475.     z80p = 0xFD; if ((r = assemble( addr))) goto inspref1;
  1476.     return 0;
  1477.     //-------------------------------------------------------------------------
  1478. inspref1:
  1479.     unsigned char *p = asmresult;
  1480.     //-------------------------------------------------------------------------
  1481.     if (z80p)
  1482.         *p++ = z80p;
  1483.     //-------------------------------------------------------------------------
  1484.     for (unsigned i=0;    i < r;    i++)
  1485.         *p++ = cmdb[i];
  1486.     //-------------------------------------------------------------------------
  1487.     return r + (z80p   ?   1 :
  1488.                            0 );
  1489. }
  1490. //=============================================================================
  1491.  
  1492.