ben
/
crater
mirror of https://github.com/earwig/crater
1
1
Fork 0
Code Releases 0 Activity
An emulator, assembler, and disassembler for the Sega Game Gear
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
120 Commits
2 Branches
695 KiB
 
 
 
 
 
Tree: a00dda6686
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a00dda6686'
${ noResults }
crater/src/assembler/instructions.c

1003 lines
26 KiB
Raw Blame History 

  1. /* Copyright (C) 2014-2015 Ben Kurtovic <ben.kurtovic@gmail.com>

  2.    Released under the terms of the MIT License. See LICENSE for details. */

  3. 

  4. #include <stdarg.h>

  5. #include <stdlib.h>

  6. 

  7. #include "instructions.h"

  8. #include "inst_args.h"

  9. #include "parse_util.h"

  10. #include "../util.h"

  11. 

  12. /* Helper macros for get_inst_parser() */

  13. 

  14. #define JOIN_(a, b, c, d) ((uint32_t) ((a << 24) + (b << 16) + (c << 8) + d))

  15. 

  16. #define DISPATCH_(s, z) (                                                     \

  17.     (z) == 2 ? JOIN_(s[0], s[1], 0x00, 0x00) :                                \

  18.     (z) == 3 ? JOIN_(s[0], s[1], s[2], 0x00) :                                \

  19.                JOIN_(s[0], s[1], s[2], s[3]))                                 \

  20. 

  21. #define MAKE_CMP_(s) DISPATCH_(s, sizeof(s) / sizeof(char) - 1)

  22. 

  23. #define HANDLE(m) if (key == MAKE_CMP_(#m)) return parse_inst_##m;

  24. 

  25. /* Internal helper macros for instruction parsers */

  26. 

  27. #define INST_ALLOC_(len)                                                      \

  28.     *length = len;                                                            \

  29.     *bytes = cr_malloc(sizeof(uint8_t) * (len));

  30. 

  31. #define INST_SET_(b, val) ((*bytes)[b] = val)

  32. #define INST_SET1_(b1) INST_SET_(0, b1)

  33. #define INST_SET2_(b1, b2) INST_SET1_(b1), INST_SET_(1, b2)

  34. #define INST_SET3_(b1, b2, b3) INST_SET2_(b1, b2), INST_SET_(2, b3)

  35. #define INST_SET4_(b1, b2, b3, b4) INST_SET3_(b1, b2, b3), INST_SET_(3, b4)

  36. 

  37. #define INST_DISPATCH_(a, b, c, d, target, ...) target

  38. 

  39. #define INST_FILL_BYTES_(len, ...)                                            \

  40.     ((len > 4) ? fill_bytes_variadic(*bytes, len, __VA_ARGS__) :              \

  41.     INST_DISPATCH_(__VA_ARGS__, INST_SET4_, INST_SET3_, INST_SET2_,           \

  42.                    INST_SET1_, __VA_ARGS__)(__VA_ARGS__));

  43. 

  44. #define INST_PREFIX_(reg)                                                     \

  45.     (((reg) == REG_IX || (reg) == REG_IXH || (reg) == REG_IXL) ? 0xDD : 0xFD)

  46. 

  47. #define INST_RETURN_WITH_SYMBOL_(len, label, ...) {                           \

  48.         *symbol = cr_strdup(label.text);                                      \

  49.         INST_ALLOC_(len)                                                      \

  50.         INST_FILL_BYTES_(len - 2, __VA_ARGS__)                                \

  51.         return ED_NONE;                                                       \

  52.     }

  53. 

  54. /* Helper macros for instruction parsers */

  55. 

  56. #define INST_FUNC(mnemonic)                                                   \

  57. static ASMErrorDesc parse_inst_##mnemonic(                                    \

  58.     uint8_t **bytes, size_t *length, char **symbol, ASMArgParseInfo ap_info)  \

  59. 

  60. #define INST_ERROR(desc) return ED_PS_##desc;

  61. 

  62. #define INST_TAKES_NO_ARGS                                                    \

  63.     if (ap_info.arg)                                                          \

  64.         INST_ERROR(TOO_MANY_ARGS)

  65. 

  66. #define INST_TAKES_ARGS(lo, hi)                                               \

  67.     if (!ap_info.arg)                                                         \

  68.         INST_ERROR(TOO_FEW_ARGS)                                              \

  69.     ASMInstArg args[3];                                                       \

  70.     size_t nargs = 0;                                                         \

  71.     ASMErrorDesc err = parse_args(args, &nargs, ap_info);                     \

  72.     if (err)                                                                  \

  73.         return err;                                                           \

  74.     if (nargs < lo)                                                           \

  75.         INST_ERROR(TOO_FEW_ARGS)                                              \

  76.     if (nargs > hi)                                                           \

  77.         INST_ERROR(TOO_MANY_ARGS)

  78. 

  79. #define INST_NARGS nargs

  80. #define INST_TYPE(n) args[n].type

  81. #define INST_REG(n) args[n].data.reg

  82. #define INST_IMM(n) args[n].data.imm

  83. #define INST_INDIRECT(n) args[n].data.indirect

  84. #define INST_INDEX(n) args[n].data.index

  85. #define INST_LABEL(n) args[n].data.label

  86. #define INST_COND(n) args[n].data.cond

  87. 

  88. #define INST_FORCE_TYPE(n, t) {                                               \

  89.         if (INST_TYPE(n) != t)                                                \

  90.             INST_ERROR(ARG##n##_TYPE)                                         \

  91.     }

  92. 

  93. #define INST_CHECK_IMM(n, m) {                                                \

  94.         if (!(INST_IMM(n).mask & (m)))                                        \

  95.             INST_ERROR(ARG##n##_RANGE)                                        \

  96.     }

  97. 

  98. #define INST_INDIRECT_HL_ONLY(n) {                                            \

  99.         if (INST_INDIRECT(n).type != AT_REGISTER)                             \

  100.             INST_ERROR(ARG##n##_TYPE)                                         \

  101.         if (INST_INDIRECT(n).addr.reg != REG_HL)                              \

  102.             INST_ERROR(ARG##n##_BAD_REG)                                      \

  103.     }

  104. 

  105. #define INST_RETURN(len, ...) {                                               \

  106.         (void) symbol;                                                        \

  107.         INST_ALLOC_(len)                                                      \

  108.         INST_FILL_BYTES_(len, __VA_ARGS__)                                    \

  109.         return ED_NONE;                                                       \

  110.     }

  111. 

  112. #define INST_INDEX_PREFIX(n) INST_PREFIX_(INST_INDEX(n).reg)

  113. 

  114. #define INST_INDEX_BYTES(n, b)                                                \

  115.     INST_INDEX_PREFIX(n), b, INST_INDEX(n).offset

  116. 

  117. #define INST_INDIRECT_IMM(n)                                                  \

  118.     INST_INDIRECT(n).addr.imm.uval >> 8,                                      \

  119.     INST_INDIRECT(n).addr.imm.uval & 0xFF

  120. 

  121. #define INST_RETURN_INDIRECT_LABEL(n, len, ...)                               \

  122.     INST_RETURN_WITH_SYMBOL_(len, INST_INDIRECT(n).addr.label, __VA_ARGS__)

  123. 

  124. /*

  125.     Fill an instruction's byte array with the given data.

  126. 

  127.     This internal function is only called for instructions longer than four

  128.     bytes (of which there is only one: the fake emulator debugging/testing

  129.     opcode with mnemonic "emu"), so it does not get used in normal situations.

  130. 

  131.     Return the value of the last byte inserted, for compatibility with the

  132.     INST_SETn_ family of macros.

  133. */

  134. static uint8_t fill_bytes_variadic(uint8_t *bytes, size_t len, ...)

  135. {

  136.     va_list vargs;

  137.     va_start(vargs, len);

  138.     for (size_t i = 0; i < len; i++)

  139.         bytes[i] = va_arg(vargs, unsigned);

  140.     va_end(vargs);

  141.     return bytes[len - 1];

  142. }

  143. 

  144. /*

  145.     Parse a single instruction argument into an ASMInstArg object.

  146. 

  147.     Return ED_NONE (0) on success or an error code on failure.

  148. */

  149. static ASMErrorDesc parse_arg(

  150.     ASMInstArg *arg, const char *str, size_t size, ASMDefineTable *deftable)

  151. {

  152. #define TRY_PARSER(func, argtype, field)                                      \

  153.     if (argparse_##func(&arg->data.field, info)) {                            \

  154.         arg->type = argtype;                                                  \

  155.         return ED_NONE;                                                       \

  156.     }

  157. 

  158.     ASMArgParseInfo info = {.arg = str, .size = size, .deftable = deftable};

  159.     TRY_PARSER(register, AT_REGISTER, reg)

  160.     TRY_PARSER(immediate, AT_IMMEDIATE, imm)

  161.     TRY_PARSER(indirect, AT_INDIRECT, indirect)

  162.     TRY_PARSER(indexed, AT_INDEXED, index)

  163.     TRY_PARSER(condition, AT_CONDITION, cond)

  164.     TRY_PARSER(label, AT_LABEL, label)

  165.     return ED_PS_ARG_SYNTAX;

  166. 

  167. #undef TRY_PARSER

  168. }

  169. 

  170. /*

  171.     Parse an argument string into ASMInstArg objects.

  172. 

  173.     Return ED_NONE (0) on success or an error code on failure.

  174. */

  175. static ASMErrorDesc parse_args(

  176.     ASMInstArg args[3], size_t *nargs, ASMArgParseInfo ap_info)

  177. {

  178.     ASMErrorDesc err;

  179.     ASMDefineTable *dt = ap_info.deftable;

  180.     const char *str = ap_info.arg;

  181.     size_t size = ap_info.size, start = 0, i = 0;

  182. 

  183.     while (i < size) {

  184.         char c = str[i];

  185.         if (c == ',') {

  186.             if (i == start)

  187.                 return ED_PS_ARG_SYNTAX;

  188.             if ((err = parse_arg(&args[*nargs], str + start, i - start, dt)))

  189.                 return err;

  190.             (*nargs)++;

  191. 

  192.             i++;

  193.             if (i < size && str[i] == ' ')

  194.                 i++;

  195.             start = i;

  196.             if (i == size)

  197.                 return ED_PS_ARG_SYNTAX;

  198.             if (*nargs >= 3)

  199.                 return ED_PS_TOO_MANY_ARGS;

  200.         } else {

  201.             if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||

  202.                  c == ' ' || c == '+' || c == '-' || c == '(' || c == ')' ||

  203.                  c == '$' || c == '_' || c == '.')

  204.                 i++;

  205.             else

  206.                 return ED_PS_ARG_SYNTAX;

  207.         }

  208.     }

  209. 

  210.     if (i > start) {

  211.         if ((err = parse_arg(&args[*nargs], str + start, i - start, dt)))

  212.             return err;

  213.         (*nargs)++;

  214.     }

  215.     return ED_NONE;

  216. }

  217. 

  218. /* Instruction parser functions */

  219. 

  220. INST_FUNC(adc)

  221. {

  222.     INST_TAKES_ARGS(2, 2)

  223.     INST_FORCE_TYPE(0, AT_REGISTER)

  224.     switch (INST_REG(0)) {

  225.         case REG_A:

  226.             switch (INST_TYPE(1)) {

  227.                 case AT_REGISTER:

  228.                     switch (INST_REG(1)) {

  229.                         case REG_A:   INST_RETURN(1, 0x8F)

  230.                         case REG_B:   INST_RETURN(1, 0x88)

  231.                         case REG_C:   INST_RETURN(1, 0x89)

  232.                         case REG_D:   INST_RETURN(1, 0x8A)

  233.                         case REG_E:   INST_RETURN(1, 0x8B)

  234.                         case REG_H:   INST_RETURN(1, 0x8C)

  235.                         case REG_L:   INST_RETURN(1, 0x8D)

  236.                         case REG_IXH: INST_RETURN(2, 0xDD, 0x8C)

  237.                         case REG_IXL: INST_RETURN(2, 0xDD, 0x8D)

  238.                         case REG_IYH: INST_RETURN(2, 0xFD, 0x8C)

  239.                         case REG_IYL: INST_RETURN(2, 0xFD, 0x8D)

  240.                         default: INST_ERROR(ARG1_BAD_REG)

  241.                     }

  242.                 case AT_IMMEDIATE:

  243.                     INST_CHECK_IMM(1, IMM_U8)

  244.                     INST_RETURN(2, 0xCE, INST_IMM(1).uval)

  245.                 case AT_INDIRECT:

  246.                     INST_INDIRECT_HL_ONLY(1)

  247.                     INST_RETURN(1, 0x8E)

  248.                 case AT_INDEXED:

  249.                     INST_RETURN(3, INST_INDEX_BYTES(1, 0x8E))

  250.                 default:

  251.                     INST_ERROR(ARG1_TYPE)

  252.             }

  253.         case REG_HL:

  254.             INST_FORCE_TYPE(1, AT_REGISTER)

  255.             switch (INST_REG(1)) {

  256.                 case REG_BC: INST_RETURN(2, 0xED, 0x4A)

  257.                 case REG_DE: INST_RETURN(2, 0xED, 0x5A)

  258.                 case REG_HL: INST_RETURN(2, 0xED, 0x6A)

  259.                 case REG_SP: INST_RETURN(2, 0xED, 0x7A)

  260.                 default: INST_ERROR(ARG1_BAD_REG)

  261.             }

  262.         default:

  263.             INST_ERROR(ARG0_TYPE)

  264.     }

  265. }

  266. 

  267. INST_FUNC(add)

  268. {

  269.     INST_TAKES_ARGS(2, 2)

  270.     INST_FORCE_TYPE(0, AT_REGISTER)

  271.     switch (INST_REG(0)) {

  272.         case REG_A:

  273.             switch (INST_TYPE(1)) {

  274.                 case AT_REGISTER:

  275.                     switch (INST_REG(1)) {

  276.                         case REG_A:   INST_RETURN(1, 0x87)

  277.                         case REG_B:   INST_RETURN(1, 0x80)

  278.                         case REG_C:   INST_RETURN(1, 0x81)

  279.                         case REG_D:   INST_RETURN(1, 0x82)

  280.                         case REG_E:   INST_RETURN(1, 0x83)

  281.                         case REG_H:   INST_RETURN(1, 0x84)

  282.                         case REG_L:   INST_RETURN(1, 0x85)

  283.                         case REG_IXH: INST_RETURN(2, 0xDD, 0x84)

  284.                         case REG_IXL: INST_RETURN(2, 0xDD, 0x85)

  285.                         case REG_IYH: INST_RETURN(2, 0xFD, 0x84)

  286.                         case REG_IYL: INST_RETURN(2, 0xFD, 0x85)

  287.                         default: INST_ERROR(ARG1_BAD_REG)

  288.                     }

  289.                 case AT_IMMEDIATE:

  290.                     INST_CHECK_IMM(1, IMM_U8)

  291.                     INST_RETURN(2, 0xC6, INST_IMM(1).uval)

  292.                 case AT_INDIRECT:

  293.                     INST_INDIRECT_HL_ONLY(1)

  294.                     INST_RETURN(1, 0x86)

  295.                 case AT_INDEXED:

  296.                     INST_RETURN(3, INST_INDEX_BYTES(1, 0x86))

  297.                 default:

  298.                     INST_ERROR(ARG1_TYPE)

  299.             }

  300.         case REG_HL:

  301.             INST_FORCE_TYPE(1, AT_REGISTER)

  302.             switch (INST_REG(1)) {

  303.                 case REG_BC: INST_RETURN(1, 0x09)

  304.                 case REG_DE: INST_RETURN(1, 0x19)

  305.                 case REG_HL: INST_RETURN(1, 0x29)

  306.                 case REG_SP: INST_RETURN(1, 0x39)

  307.                 default: INST_ERROR(ARG1_BAD_REG)

  308.             }

  309.         case REG_IX:

  310.         case REG_IY:

  311.             INST_FORCE_TYPE(1, AT_REGISTER)

  312.             switch (INST_REG(1)) {

  313.                 case REG_BC: INST_RETURN(2, INST_INDEX_PREFIX(1), 0x09)

  314.                 case REG_DE: INST_RETURN(2, INST_INDEX_PREFIX(1), 0x19)

  315.                 case REG_IX:

  316.                 case REG_IY:

  317.                     if (INST_REG(0) != INST_REG(1))

  318.                         INST_ERROR(ARG1_BAD_REG)

  319.                     INST_RETURN(2, INST_INDEX_PREFIX(1), 0x29)

  320.                 case REG_SP: INST_RETURN(2, INST_INDEX_PREFIX(1), 0x39)

  321.                 default: INST_ERROR(ARG1_BAD_REG)

  322.             }

  323.         default:

  324.             INST_ERROR(ARG0_TYPE)

  325.     }

  326. }

  327. 

  328. INST_FUNC(and)

  329. {

  330.     // TODO

  331.     INST_TAKES_NO_ARGS

  332.     INST_ERROR(ARG_SYNTAX)

  333.     INST_RETURN(1, 0xFF)

  334. }

  335. 

  336. INST_FUNC(bit)

  337. {

  338.     // TODO

  339.     INST_TAKES_NO_ARGS

  340.     INST_ERROR(ARG_SYNTAX)

  341.     INST_RETURN(1, 0xFF)

  342. }

  343. 

  344. INST_FUNC(call)

  345. {

  346.     // TODO

  347.     INST_TAKES_NO_ARGS

  348.     INST_ERROR(ARG_SYNTAX)

  349.     INST_RETURN(1, 0xFF)

  350. }

  351. 

  352. INST_FUNC(ccf)

  353. {

  354.     INST_TAKES_NO_ARGS

  355.     INST_RETURN(1, 0x3F)

  356. }

  357. 

  358. INST_FUNC(cp)

  359. {

  360.     // TODO

  361.     INST_TAKES_NO_ARGS

  362.     INST_ERROR(ARG_SYNTAX)

  363.     INST_RETURN(1, 0xFF)

  364. }

  365. 

  366. INST_FUNC(cpd)

  367. {

  368.     INST_TAKES_NO_ARGS

  369.     INST_RETURN(2, 0xED, 0xA9)

  370. }

  371. 

  372. INST_FUNC(cpdr)

  373. {

  374.     INST_TAKES_NO_ARGS

  375.     INST_RETURN(2, 0xED, 0xB9)

  376. }

  377. 

  378. INST_FUNC(cpi)

  379. {

  380.     INST_TAKES_NO_ARGS

  381.     INST_RETURN(2, 0xED, 0xA1)

  382. }

  383. 

  384. INST_FUNC(cpir)

  385. {

  386.     INST_TAKES_NO_ARGS

  387.     INST_RETURN(2, 0xED, 0xB1)

  388. }

  389. 

  390. INST_FUNC(cpl)

  391. {

  392.     INST_TAKES_NO_ARGS

  393.     INST_RETURN(1, 0x2F)

  394. }

  395. 

  396. INST_FUNC(daa)

  397. {

  398.     INST_TAKES_NO_ARGS

  399.     INST_RETURN(1, 0x27)

  400. }

  401. 

  402. INST_FUNC(dec)

  403. {

  404.     // TODO

  405.     INST_TAKES_NO_ARGS

  406.     INST_ERROR(ARG_SYNTAX)

  407.     INST_RETURN(1, 0xFF)

  408. }

  409. 

  410. INST_FUNC(di)

  411. {

  412.     INST_TAKES_NO_ARGS

  413.     INST_RETURN(1, 0xF3)

  414. }

  415. 

  416. INST_FUNC(djnz)

  417. {

  418.     // TODO

  419.     INST_TAKES_NO_ARGS

  420.     INST_ERROR(ARG_SYNTAX)

  421.     INST_RETURN(1, 0xFF)

  422. }

  423. 

  424. INST_FUNC(ei)

  425. {

  426.     INST_TAKES_NO_ARGS

  427.     INST_RETURN(1, 0xFB)

  428. }

  429. 

  430. INST_FUNC(ex)

  431. {

  432.     // TODO

  433.     INST_TAKES_NO_ARGS

  434.     INST_ERROR(ARG_SYNTAX)

  435.     INST_RETURN(1, 0xFF)

  436. }

  437. 

  438. INST_FUNC(exx)

  439. {

  440.     INST_TAKES_NO_ARGS

  441.     INST_RETURN(1, 0xD9)

  442. }

  443. 

  444. INST_FUNC(halt)

  445. {

  446.     INST_TAKES_NO_ARGS

  447.     INST_RETURN(1, 0x76)

  448. }

  449. 

  450. INST_FUNC(im)

  451. {

  452.     // TODO

  453.     INST_TAKES_NO_ARGS

  454.     INST_ERROR(ARG_SYNTAX)

  455.     INST_RETURN(1, 0xFF)

  456. }

  457. 

  458. INST_FUNC(in)

  459. {

  460.     // TODO

  461.     INST_TAKES_NO_ARGS

  462.     INST_ERROR(ARG_SYNTAX)

  463.     INST_RETURN(1, 0xFF)

  464. }

  465. 

  466. INST_FUNC(inc)

  467. {

  468.     INST_TAKES_ARGS(1, 1)

  469.     switch (INST_TYPE(0)) {

  470.         case AT_REGISTER:

  471.             switch (INST_REG(0)) {

  472.                 case REG_A:   INST_RETURN(1, 0x3C)

  473.                 case REG_B:   INST_RETURN(1, 0x04)

  474.                 case REG_C:   INST_RETURN(1, 0x0C)

  475.                 case REG_D:   INST_RETURN(1, 0x14)

  476.                 case REG_E:   INST_RETURN(1, 0x1C)

  477.                 case REG_H:   INST_RETURN(1, 0x24)

  478.                 case REG_L:   INST_RETURN(1, 0x2C)

  479.                 case REG_BC:  INST_RETURN(1, 0x03)

  480.                 case REG_DE:  INST_RETURN(1, 0x13)

  481.                 case REG_HL:  INST_RETURN(1, 0x23)

  482.                 case REG_SP:  INST_RETURN(1, 0x33)

  483.                 case REG_IX:  INST_RETURN(2, 0xDD, 0x23)

  484.                 case REG_IY:  INST_RETURN(2, 0xFD, 0x23)

  485.                 case REG_IXH: INST_RETURN(2, 0xDD, 0x2C)

  486.                 case REG_IXL: INST_RETURN(2, 0xFD, 0x2C)

  487.                 case REG_IYH: INST_RETURN(2, 0xDD, 0x2C)

  488.                 case REG_IYL: INST_RETURN(2, 0xFD, 0x2C)

  489.                 default: INST_ERROR(ARG0_BAD_REG)

  490.             }

  491.         case AT_INDIRECT:

  492.             INST_INDIRECT_HL_ONLY(0)

  493.             INST_RETURN(1, 0x34)

  494.         case AT_INDEXED:

  495.             INST_RETURN(3, INST_INDEX_BYTES(0, 0x34))

  496.         default:

  497.             INST_ERROR(ARG0_TYPE)

  498.     }

  499. }

  500. 

  501. INST_FUNC(ind)

  502. {

  503.     INST_TAKES_NO_ARGS

  504.     INST_RETURN(2, 0xED, 0xAA)

  505. }

  506. 

  507. INST_FUNC(indr)

  508. {

  509.     INST_TAKES_NO_ARGS

  510.     INST_RETURN(2, 0xED, 0xBA)

  511. }

  512. 

  513. INST_FUNC(ini)

  514. {

  515.     INST_TAKES_NO_ARGS

  516.     INST_RETURN(2, 0xED, 0xA2)

  517. }

  518. 

  519. INST_FUNC(inir)

  520. {

  521.     INST_TAKES_NO_ARGS

  522.     INST_RETURN(2, 0xED, 0xB2)

  523. }

  524. 

  525. INST_FUNC(jp)

  526. {

  527.     // TODO

  528.     INST_TAKES_NO_ARGS

  529.     INST_ERROR(ARG_SYNTAX)

  530.     INST_RETURN(1, 0xFF)

  531. }

  532. 

  533. INST_FUNC(jr)

  534. {

  535.     // TODO

  536.     INST_TAKES_NO_ARGS

  537.     INST_ERROR(ARG_SYNTAX)

  538.     INST_RETURN(1, 0xFF)

  539. }

  540. 

  541. INST_FUNC(ld)

  542. {

  543.     INST_TAKES_ARGS(2, 2)

  544.     switch (INST_TYPE(0)) {

  545.         case AT_REGISTER:

  546.             switch (INST_REG(0)) {

  547.                 case REG_A:

  548.                     switch (INST_TYPE(1)) {

  549.                         case AT_REGISTER:

  550.                             switch (INST_REG(1)) {

  551.                                 case REG_A:   INST_RETURN(1, 0x7F)

  552.                                 case REG_B:   INST_RETURN(1, 0x78)

  553.                                 case REG_C:   INST_RETURN(1, 0x79)

  554.                                 case REG_D:   INST_RETURN(1, 0x7A)

  555.                                 case REG_E:   INST_RETURN(1, 0x7B)

  556.                                 case REG_H:   INST_RETURN(1, 0x7C)

  557.                                 case REG_L:   INST_RETURN(1, 0x7D)

  558.                                 case REG_I:   INST_RETURN(2, 0xED, 0x57)

  559.                                 case REG_R:   INST_RETURN(2, 0xED, 0x5F)

  560.                                 case REG_IXH: INST_RETURN(2, 0xDD, 0x7C)

  561.                                 case REG_IXL: INST_RETURN(2, 0xDD, 0x7D)

  562.                                 case REG_IYH: INST_RETURN(2, 0xFD, 0x7C)

  563.                                 case REG_IYL: INST_RETURN(2, 0xFD, 0x7D)

  564.                                 default: INST_ERROR(ARG1_BAD_REG)

  565.                             }

  566.                         case AT_IMMEDIATE:

  567.                             INST_CHECK_IMM(1, IMM_U8)

  568.                             INST_RETURN(2, 0x3E, INST_IMM(1).uval)

  569.                         case AT_INDIRECT:

  570.                             switch (INST_INDIRECT(1).type) {

  571.                                 case AT_REGISTER:

  572.                                     switch (INST_INDIRECT(1).addr.reg) {

  573.                                         case REG_BC: INST_RETURN(1, 0x0A)

  574.                                         case REG_DE: INST_RETURN(1, 0x1A)

  575.                                         case REG_HL: INST_RETURN(1, 0x7E)

  576.                                         default: INST_ERROR(ARG0_BAD_REG)

  577.                                     }

  578.                                 case AT_IMMEDIATE:

  579.                                     INST_RETURN(3, 0x3A, INST_INDIRECT_IMM(1))

  580.                                 case AT_LABEL:

  581.                                     INST_RETURN_INDIRECT_LABEL(1, 3, 0x3A)

  582.                                 default:

  583.                                     INST_ERROR(ARG0_TYPE)

  584.                             }

  585.                         case AT_INDEXED:

  586.                             INST_RETURN(3, INST_INDEX_BYTES(1, 0x7E))

  587.                         default:

  588.                             INST_ERROR(ARG1_TYPE)

  589.                     }

  590.                 case REG_B:   // TODO (15 cases)

  591.                 case REG_C:   // TODO (15 cases)

  592.                 case REG_D:   // TODO (15 cases)

  593.                 case REG_E:   // TODO (15 cases)

  594.                 case REG_H:   // TODO (11 cases)

  595.                 case REG_L:   // TODO (11 cases)

  596.                 case REG_I:   // TODO ( 1 case )

  597.                 case REG_R:   // TODO ( 1 case )

  598.                 case REG_BC:  // TODO ( 2 cases)

  599.                 case REG_DE:  // TODO ( 2 cases)

  600.                 case REG_HL:  // TODO ( 3 cases)

  601.                 case REG_IX:  // TODO ( 2 cases)

  602.                 case REG_IY:  // TODO ( 2 cases)

  603.                 case REG_SP:  // TODO ( 5 cases)

  604.                 case REG_IXH: // TODO ( 8 cases)

  605.                 case REG_IXL: // TODO ( 8 cases)

  606.                 case REG_IYH: // TODO ( 8 cases)

  607.                 case REG_IYL: // TODO ( 8 cases)

  608.                 default: INST_ERROR(ARG0_BAD_REG)

  609.             }

  610.         case AT_INDIRECT:

  611.             switch (INST_INDIRECT(0).type) {

  612.                 case AT_REGISTER:

  613.                     switch (INST_INDIRECT(0).addr.reg) {

  614.                         case REG_BC: // TODO (1 case )

  615.                         case REG_DE: // TODO (1 case )

  616.                         case REG_HL: // TODO (8 cases)

  617.                         default: INST_ERROR(ARG0_BAD_REG)

  618.                     }

  619.                 case AT_IMMEDIATE:

  620.                     // TODO (8 cases)

  621.                 case AT_LABEL:

  622.                     // TODO (same 8 cases)

  623.                 default:

  624.                     INST_ERROR(ARG0_TYPE)

  625.             }

  626.         case AT_INDEXED:

  627.             // TODO (16 cases)

  628.         default:

  629.             INST_ERROR(ARG0_TYPE)

  630.     }

  631. }

  632. 

  633. INST_FUNC(ldd)

  634. {

  635.     INST_TAKES_NO_ARGS

  636.     INST_RETURN(2, 0xED, 0xA8)

  637. }

  638. 

  639. INST_FUNC(lddr)

  640. {

  641.     INST_TAKES_NO_ARGS

  642.     INST_RETURN(2, 0xED, 0xB8)

  643. }

  644. 

  645. INST_FUNC(ldi)

  646. {

  647.     INST_TAKES_NO_ARGS

  648.     INST_RETURN(2, 0xED, 0xA0)

  649. }

  650. 

  651. INST_FUNC(ldir)

  652. {

  653.     INST_TAKES_NO_ARGS

  654.     INST_RETURN(2, 0xED, 0xB0)

  655. }

  656. 

  657. INST_FUNC(neg)

  658. {

  659.     // TODO

  660.     INST_TAKES_NO_ARGS

  661.     INST_ERROR(ARG_SYNTAX)

  662.     INST_RETURN(1, 0xFF)

  663. }

  664. 

  665. INST_FUNC(nop)

  666. {

  667.     INST_TAKES_NO_ARGS

  668.     INST_RETURN(1, 0x00)

  669. }

  670. 

  671. INST_FUNC(or)

  672. {

  673.     // TODO

  674.     INST_TAKES_NO_ARGS

  675.     INST_ERROR(ARG_SYNTAX)

  676.     INST_RETURN(1, 0xFF)

  677. }

  678. 

  679. INST_FUNC(otdr)

  680. {

  681.     INST_TAKES_NO_ARGS

  682.     INST_RETURN(2, 0xED, 0xBB)

  683. }

  684. 

  685. INST_FUNC(otir)

  686. {

  687.     INST_TAKES_NO_ARGS

  688.     INST_RETURN(2, 0xED, 0xB3)

  689. }

  690. 

  691. INST_FUNC(out)

  692. {

  693.     // TODO

  694.     INST_TAKES_NO_ARGS

  695.     INST_ERROR(ARG_SYNTAX)

  696.     INST_RETURN(1, 0xFF)

  697. }

  698. 

  699. INST_FUNC(outd)

  700. {

  701.     INST_TAKES_NO_ARGS

  702.     INST_RETURN(2, 0xED, 0xAB)

  703. }

  704. 

  705. INST_FUNC(outi)

  706. {

  707.     INST_TAKES_NO_ARGS

  708.     INST_RETURN(2, 0xED, 0xA3)

  709. }

  710. 

  711. INST_FUNC(pop)

  712. {

  713.     // TODO

  714.     INST_TAKES_NO_ARGS

  715.     INST_ERROR(ARG_SYNTAX)

  716.     INST_RETURN(1, 0xFF)

  717. }

  718. 

  719. INST_FUNC(push)

  720. {

  721.     // TODO

  722.     INST_TAKES_NO_ARGS

  723.     INST_ERROR(ARG_SYNTAX)

  724.     INST_RETURN(1, 0xFF)

  725. }

  726. 

  727. INST_FUNC(res)

  728. {

  729.     // TODO

  730.     INST_TAKES_NO_ARGS

  731.     INST_ERROR(ARG_SYNTAX)

  732.     INST_RETURN(1, 0xFF)

  733. }

  734. 

  735. INST_FUNC(ret)

  736. {

  737.     // TODO

  738.     INST_TAKES_NO_ARGS

  739.     INST_ERROR(ARG_SYNTAX)

  740.     INST_RETURN(1, 0xFF)

  741. }

  742. 

  743. INST_FUNC(reti)

  744. {

  745.     INST_TAKES_NO_ARGS

  746.     INST_RETURN(2, 0xED, 0x4D)

  747. }

  748. 

  749. INST_FUNC(retn)

  750. {

  751.     INST_TAKES_NO_ARGS

  752.     INST_RETURN(2, 0xED, 0x45)

  753. }

  754. 

  755. INST_FUNC(rl)

  756. {

  757.     // TODO

  758.     INST_TAKES_NO_ARGS

  759.     INST_ERROR(ARG_SYNTAX)

  760.     INST_RETURN(1, 0xFF)

  761. }

  762. 

  763. INST_FUNC(rla)

  764. {

  765.     INST_TAKES_NO_ARGS

  766.     INST_RETURN(1, 0x17)

  767. }

  768. 

  769. INST_FUNC(rlc)

  770. {

  771.     // TODO

  772.     INST_TAKES_NO_ARGS

  773.     INST_ERROR(ARG_SYNTAX)

  774.     INST_RETURN(1, 0xFF)

  775. }

  776. 

  777. INST_FUNC(rlca)

  778. {

  779.     INST_TAKES_NO_ARGS

  780.     INST_RETURN(1, 0x07)

  781. }

  782. 

  783. INST_FUNC(rld)

  784. {

  785.     INST_TAKES_NO_ARGS

  786.     INST_RETURN(2, 0xED, 0x6F)

  787. }

  788. 

  789. INST_FUNC(rr)

  790. {

  791.     // TODO

  792.     INST_TAKES_NO_ARGS

  793.     INST_ERROR(ARG_SYNTAX)

  794.     INST_RETURN(1, 0xFF)

  795. }

  796. 

  797. INST_FUNC(rra)

  798. {

  799.     INST_TAKES_NO_ARGS

  800.     INST_RETURN(1, 0x1F)

  801. }

  802. 

  803. INST_FUNC(rrc)

  804. {

  805.     // TODO

  806.     INST_TAKES_NO_ARGS

  807.     INST_ERROR(ARG_SYNTAX)

  808.     INST_RETURN(1, 0xFF)

  809. }

  810. 

  811. INST_FUNC(rrca)

  812. {

  813.     INST_TAKES_NO_ARGS

  814.     INST_RETURN(1, 0x0F)

  815. }

  816. 

  817. INST_FUNC(rrd)

  818. {

  819.     // TODO

  820.     INST_TAKES_NO_ARGS

  821.     INST_ERROR(ARG_SYNTAX)

  822.     INST_RETURN(1, 0xFF)

  823. }

  824. 

  825. INST_FUNC(rst)

  826. {

  827.     // TODO

  828.     INST_TAKES_NO_ARGS

  829.     INST_ERROR(ARG_SYNTAX)

  830.     INST_RETURN(1, 0xFF)

  831. }

  832. 

  833. INST_FUNC(sbc)

  834. {

  835.     // TODO

  836.     INST_TAKES_NO_ARGS

  837.     INST_ERROR(ARG_SYNTAX)

  838.     INST_RETURN(1, 0xFF)

  839. }

  840. 

  841. INST_FUNC(scf)

  842. {

  843.     INST_TAKES_NO_ARGS

  844.     INST_RETURN(1, 0x37)

  845. }

  846. 

  847. INST_FUNC(set)

  848. {

  849.     // TODO

  850.     INST_TAKES_NO_ARGS

  851.     INST_ERROR(ARG_SYNTAX)

  852.     INST_RETURN(1, 0xFF)

  853. }

  854. 

  855. INST_FUNC(sl1)

  856. {

  857.     // TODO

  858.     INST_TAKES_NO_ARGS

  859.     INST_ERROR(ARG_SYNTAX)

  860.     INST_RETURN(1, 0xFF)

  861. }

  862. 

  863. INST_FUNC(sla)

  864. {

  865.     // TODO

  866.     INST_TAKES_NO_ARGS

  867.     INST_ERROR(ARG_SYNTAX)

  868.     INST_RETURN(1, 0xFF)

  869. }

  870. 

  871. INST_FUNC(sll)

  872. {

  873.     // TODO

  874.     INST_TAKES_NO_ARGS

  875.     INST_ERROR(ARG_SYNTAX)

  876.     INST_RETURN(1, 0xFF)

  877. }

  878. 

  879. INST_FUNC(sls)

  880. {

  881.     // TODO

  882.     INST_TAKES_NO_ARGS

  883.     INST_ERROR(ARG_SYNTAX)

  884.     INST_RETURN(1, 0xFF)

  885. }

  886. 

  887. INST_FUNC(sra)

  888. {

  889.     // TODO

  890.     INST_TAKES_NO_ARGS

  891.     INST_ERROR(ARG_SYNTAX)

  892.     INST_RETURN(1, 0xFF)

  893. }

  894. 

  895. INST_FUNC(srl)

  896. {

  897.     // TODO

  898.     INST_TAKES_NO_ARGS

  899.     INST_ERROR(ARG_SYNTAX)

  900.     INST_RETURN(1, 0xFF)

  901. }

  902. 

  903. INST_FUNC(sub)

  904. {

  905.     // TODO

  906.     INST_TAKES_NO_ARGS

  907.     INST_ERROR(ARG_SYNTAX)

  908.     INST_RETURN(1, 0xFF)

  909. }

  910. 

  911. INST_FUNC(xor)

  912. {

  913.     // TODO

  914.     INST_TAKES_NO_ARGS

  915.     INST_ERROR(ARG_SYNTAX)

  916.     INST_RETURN(1, 0xFF)

  917. }

  918. 

  919. /*

  920.     Return the relevant ASMInstParser function for a given mnemonic.

  921. 

  922.     NULL is returned if the mnemonic is not known.

  923. */

  924. ASMInstParser get_inst_parser(char mstr[MAX_MNEMONIC_SIZE])

  925. {

  926.     // Exploit the fact that we can store the entire mnemonic string as a

  927.     // single 32-bit value to do fast lookups:

  928.     uint32_t key = (mstr[0] << 24) + (mstr[1] << 16) + (mstr[2] << 8) + mstr[3];

  929. 

  930.     HANDLE(adc)

  931.     HANDLE(add)

  932.     HANDLE(and)

  933.     HANDLE(bit)

  934.     HANDLE(call)

  935.     HANDLE(ccf)

  936.     HANDLE(cp)

  937.     HANDLE(cpd)

  938.     HANDLE(cpdr)

  939.     HANDLE(cpi)

  940.     HANDLE(cpir)

  941.     HANDLE(cpl)

  942.     HANDLE(daa)

  943.     HANDLE(dec)

  944.     HANDLE(di)

  945.     HANDLE(djnz)

  946.     HANDLE(ei)

  947.     HANDLE(ex)

  948.     HANDLE(exx)

  949.     HANDLE(halt)

  950.     HANDLE(im)

  951.     HANDLE(in)

  952.     HANDLE(inc)

  953.     HANDLE(ind)

  954.     HANDLE(indr)

  955.     HANDLE(ini)

  956.     HANDLE(inir)

  957.     HANDLE(jp)

  958.     HANDLE(jr)

  959.     HANDLE(ld)

  960.     HANDLE(ldd)

  961.     HANDLE(lddr)

  962.     HANDLE(ldi)

  963.     HANDLE(ldir)

  964.     HANDLE(neg)

  965.     HANDLE(nop)

  966.     HANDLE(or)

  967.     HANDLE(otdr)

  968.     HANDLE(otir)

  969.     HANDLE(out)

  970.     HANDLE(outd)

  971.     HANDLE(outi)

  972.     HANDLE(pop)

  973.     HANDLE(push)

  974.     HANDLE(res)

  975.     HANDLE(ret)

  976.     HANDLE(reti)

  977.     HANDLE(retn)

  978.     HANDLE(rl)

  979.     HANDLE(rla)

  980.     HANDLE(rlc)

  981.     HANDLE(rlca)

  982.     HANDLE(rld)

  983.     HANDLE(rr)

  984.     HANDLE(rra)

  985.     HANDLE(rrc)

  986.     HANDLE(rrca)

  987.     HANDLE(rrd)

  988.     HANDLE(rst)

  989.     HANDLE(sbc)

  990.     HANDLE(scf)

  991.     HANDLE(set)

  992.     HANDLE(sl1)

  993.     HANDLE(sla)

  994.     HANDLE(sll)

  995.     HANDLE(sls)

  996.     HANDLE(sra)

  997.     HANDLE(srl)

  998.     HANDLE(sub)

  999.     HANDLE(xor)

  1000. 

  1001.     return NULL;

  1002. }