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.
118 Commits
2 Branches
960 KiB
 
 
 
 
 
Tree: 8babffb562
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8babffb562'
${ noResults }
crater/src/assembler/instructions.c

914 lines
21 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. /* Helper macros for instruction parsers */

  48. 

  49. #define INST_FUNC(mnemonic)                                                   \

  50. static ASMErrorDesc parse_inst_##mnemonic(                                    \

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

  52. 

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

  54. 

  55. #define INST_TAKES_NO_ARGS                                                    \

  56.     if (ap_info.arg)                                                          \

  57.         INST_ERROR(TOO_MANY_ARGS)

  58. 

  59. #define INST_TAKES_ARGS(lo, hi)                                               \

  60.     if (!ap_info.arg)                                                         \

  61.         INST_ERROR(TOO_FEW_ARGS)                                              \

  62.     ASMInstArg args[3];                                                       \

  63.     size_t nargs = 0;                                                         \

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

  65.     if (err)                                                                  \

  66.         return err;                                                           \

  67.     if (nargs < lo)                                                           \

  68.         INST_ERROR(TOO_FEW_ARGS)                                              \

  69.     if (nargs > hi)                                                           \

  70.         INST_ERROR(TOO_MANY_ARGS)

  71. 

  72. #define INST_NARGS nargs

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

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

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

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

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

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

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

  80. 

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

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

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

  84.     }

  85. 

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

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

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

  89.     }

  90. 

  91. #define INST_INDIRECT_HL_ONLY(n) {                                            \

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

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

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

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

  96.     }

  97. 

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

  99.         (void) symbol;                                                        \

  100.         INST_ALLOC_(len)                                                      \

  101.         INST_FILL_BYTES_(len, __VA_ARGS__)                                    \

  102.         return ED_NONE;                                                       \

  103.     }

  104. 

  105. #define INST_RETURN_WITH_SYMBOL(len, label, ...) {                            \

  106.         *symbol = cr_strdup(label);                                           \

  107.         INST_ALLOC_(len)                                                      \

  108.         INST_FILL_BYTES_(len - 2, __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. /*

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

  119. 

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

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

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

  123. 

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

  125.     INST_SETn_ family of macros.

  126. */

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

  128. {

  129.     va_list vargs;

  130.     va_start(vargs, len);

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

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

  133.     va_end(vargs);

  134.     return bytes[len - 1];

  135. }

  136. 

  137. /*

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

  139. 

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

  141. */

  142. static ASMErrorDesc parse_arg(

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

  144. {

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

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

  147.         arg->type = argtype;                                                  \

  148.         return ED_NONE;                                                       \

  149.     }

  150. 

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

  152.     TRY_PARSER(register, AT_REGISTER, reg)

  153.     TRY_PARSER(immediate, AT_IMMEDIATE, imm)

  154.     TRY_PARSER(indirect, AT_INDIRECT, indirect)

  155.     TRY_PARSER(indexed, AT_INDEXED, index)

  156.     TRY_PARSER(condition, AT_CONDITION, cond)

  157.     TRY_PARSER(label, AT_LABEL, label)

  158.     return ED_PS_ARG_SYNTAX;

  159. 

  160. #undef TRY_PARSER

  161. }

  162. 

  163. /*

  164.     Parse an argument string into ASMInstArg objects.

  165. 

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

  167. */

  168. static ASMErrorDesc parse_args(

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

  170. {

  171.     ASMErrorDesc err;

  172.     ASMDefineTable *dt = ap_info.deftable;

  173.     const char *str = ap_info.arg;

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

  175. 

  176.     while (i < size) {

  177.         char c = str[i];

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

  179.             if (i == start)

  180.                 return ED_PS_ARG_SYNTAX;

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

  182.                 return err;

  183.             (*nargs)++;

  184. 

  185.             i++;

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

  187.                 i++;

  188.             start = i;

  189.             if (i == size)

  190.                 return ED_PS_ARG_SYNTAX;

  191.             if (*nargs >= 3)

  192.                 return ED_PS_TOO_MANY_ARGS;

  193.         } else {

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

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

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

  197.                 i++;

  198.             else

  199.                 return ED_PS_ARG_SYNTAX;

  200.         }

  201.     }

  202. 

  203.     if (i > start) {

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

  205.             return err;

  206.         (*nargs)++;

  207.     }

  208.     return ED_NONE;

  209. }

  210. 

  211. /* Instruction parser functions */

  212. 

  213. INST_FUNC(adc)

  214. {

  215.     INST_TAKES_ARGS(2, 2)

  216.     INST_FORCE_TYPE(0, AT_REGISTER)

  217.     switch (INST_REG(0)) {

  218.         case REG_A:

  219.             switch (INST_TYPE(1)) {

  220.                 case AT_REGISTER:

  221.                     switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

  233.                         default: INST_ERROR(ARG1_BAD_REG)

  234.                     }

  235.                 case AT_IMMEDIATE:

  236.                     INST_CHECK_IMM(1, IMM_U8)

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

  238.                 case AT_INDIRECT:

  239.                     INST_INDIRECT_HL_ONLY(1)

  240.                     INST_RETURN(1, 0x8E)

  241.                 case AT_INDEXED:

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

  243.                 default:

  244.                     INST_ERROR(ARG1_TYPE)

  245.             }

  246.         case REG_HL:

  247.             INST_FORCE_TYPE(1, AT_REGISTER)

  248.             switch (INST_REG(1)) {

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

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

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

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

  253.                 default: INST_ERROR(ARG1_BAD_REG)

  254.             }

  255.         default:

  256.             INST_ERROR(ARG0_TYPE)

  257.     }

  258. }

  259. 

  260. INST_FUNC(add)

  261. {

  262.     INST_TAKES_ARGS(2, 2)

  263.     INST_FORCE_TYPE(0, AT_REGISTER)

  264.     switch (INST_REG(0)) {

  265.         case REG_A:

  266.             switch (INST_TYPE(1)) {

  267.                 case AT_REGISTER:

  268.                     switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

  280.                         default: INST_ERROR(ARG1_BAD_REG)

  281.                     }

  282.                 case AT_IMMEDIATE:

  283.                     INST_CHECK_IMM(1, IMM_U8)

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

  285.                 case AT_INDIRECT:

  286.                     INST_INDIRECT_HL_ONLY(1)

  287.                     INST_RETURN(1, 0x86)

  288.                 case AT_INDEXED:

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

  290.                 default:

  291.                     INST_ERROR(ARG1_TYPE)

  292.             }

  293.         case REG_HL:

  294.             INST_FORCE_TYPE(1, AT_REGISTER)

  295.             switch (INST_REG(1)) {

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

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

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

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

  300.                 default: INST_ERROR(ARG1_BAD_REG)

  301.             }

  302.         case REG_IX:

  303.         case REG_IY:

  304.             INST_FORCE_TYPE(1, AT_REGISTER)

  305.             switch (INST_REG(1)) {

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

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

  308.                 case REG_IX:

  309.                 case REG_IY:

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

  311.                         INST_ERROR(ARG1_BAD_REG)

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

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

  314.                 default: INST_ERROR(ARG1_BAD_REG)

  315.             }

  316.         default:

  317.             INST_ERROR(ARG0_TYPE)

  318.     }

  319. }

  320. 

  321. INST_FUNC(and)

  322. {

  323.     // TODO

  324.     INST_TAKES_NO_ARGS

  325.     INST_ERROR(ARG_SYNTAX)

  326.     INST_RETURN(1, 0xFF)

  327. }

  328. 

  329. INST_FUNC(bit)

  330. {

  331.     // TODO

  332.     INST_TAKES_NO_ARGS

  333.     INST_ERROR(ARG_SYNTAX)

  334.     INST_RETURN(1, 0xFF)

  335. }

  336. 

  337. INST_FUNC(call)

  338. {

  339.     // TODO

  340.     INST_TAKES_NO_ARGS

  341.     INST_ERROR(ARG_SYNTAX)

  342.     INST_RETURN(1, 0xFF)

  343. }

  344. 

  345. INST_FUNC(ccf)

  346. {

  347.     INST_TAKES_NO_ARGS

  348.     INST_RETURN(1, 0x3F)

  349. }

  350. 

  351. INST_FUNC(cp)

  352. {

  353.     // TODO

  354.     INST_TAKES_NO_ARGS

  355.     INST_ERROR(ARG_SYNTAX)

  356.     INST_RETURN(1, 0xFF)

  357. }

  358. 

  359. INST_FUNC(cpd)

  360. {

  361.     INST_TAKES_NO_ARGS

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

  363. }

  364. 

  365. INST_FUNC(cpdr)

  366. {

  367.     INST_TAKES_NO_ARGS

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

  369. }

  370. 

  371. INST_FUNC(cpi)

  372. {

  373.     INST_TAKES_NO_ARGS

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

  375. }

  376. 

  377. INST_FUNC(cpir)

  378. {

  379.     INST_TAKES_NO_ARGS

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

  381. }

  382. 

  383. INST_FUNC(cpl)

  384. {

  385.     INST_TAKES_NO_ARGS

  386.     INST_RETURN(1, 0x2F)

  387. }

  388. 

  389. INST_FUNC(daa)

  390. {

  391.     INST_TAKES_NO_ARGS

  392.     INST_RETURN(1, 0x27)

  393. }

  394. 

  395. INST_FUNC(dec)

  396. {

  397.     // TODO

  398.     INST_TAKES_NO_ARGS

  399.     INST_ERROR(ARG_SYNTAX)

  400.     INST_RETURN(1, 0xFF)

  401. }

  402. 

  403. INST_FUNC(di)

  404. {

  405.     INST_TAKES_NO_ARGS

  406.     INST_RETURN(1, 0xF3)

  407. }

  408. 

  409. INST_FUNC(djnz)

  410. {

  411.     // TODO

  412.     INST_TAKES_NO_ARGS

  413.     INST_ERROR(ARG_SYNTAX)

  414.     INST_RETURN(1, 0xFF)

  415. }

  416. 

  417. INST_FUNC(ei)

  418. {

  419.     INST_TAKES_NO_ARGS

  420.     INST_RETURN(1, 0xFB)

  421. }

  422. 

  423. INST_FUNC(ex)

  424. {

  425.     // TODO

  426.     INST_TAKES_NO_ARGS

  427.     INST_ERROR(ARG_SYNTAX)

  428.     INST_RETURN(1, 0xFF)

  429. }

  430. 

  431. INST_FUNC(exx)

  432. {

  433.     INST_TAKES_NO_ARGS

  434.     INST_RETURN(1, 0xD9)

  435. }

  436. 

  437. INST_FUNC(halt)

  438. {

  439.     INST_TAKES_NO_ARGS

  440.     INST_RETURN(1, 0x76)

  441. }

  442. 

  443. INST_FUNC(im)

  444. {

  445.     // TODO

  446.     INST_TAKES_NO_ARGS

  447.     INST_ERROR(ARG_SYNTAX)

  448.     INST_RETURN(1, 0xFF)

  449. }

  450. 

  451. INST_FUNC(in)

  452. {

  453.     // TODO

  454.     INST_TAKES_NO_ARGS

  455.     INST_ERROR(ARG_SYNTAX)

  456.     INST_RETURN(1, 0xFF)

  457. }

  458. 

  459. INST_FUNC(inc)

  460. {

  461.     INST_TAKES_ARGS(1, 1)

  462.     switch (INST_TYPE(0)) {

  463.         case AT_REGISTER:

  464.             switch (INST_REG(0)) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  482.                 default: INST_ERROR(ARG0_BAD_REG)

  483.             }

  484.         case AT_INDIRECT:

  485.             INST_INDIRECT_HL_ONLY(0)

  486.             INST_RETURN(1, 0x34)

  487.         case AT_INDEXED:

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

  489.         default:

  490.             INST_ERROR(ARG0_TYPE)

  491.     }

  492. }

  493. 

  494. INST_FUNC(ind)

  495. {

  496.     INST_TAKES_NO_ARGS

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

  498. }

  499. 

  500. INST_FUNC(indr)

  501. {

  502.     INST_TAKES_NO_ARGS

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

  504. }

  505. 

  506. INST_FUNC(ini)

  507. {

  508.     INST_TAKES_NO_ARGS

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

  510. }

  511. 

  512. INST_FUNC(inir)

  513. {

  514.     INST_TAKES_NO_ARGS

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

  516. }

  517. 

  518. INST_FUNC(jp)

  519. {

  520.     // TODO

  521.     INST_TAKES_NO_ARGS

  522.     INST_ERROR(ARG_SYNTAX)

  523.     INST_RETURN(1, 0xFF)

  524. }

  525. 

  526. INST_FUNC(jr)

  527. {

  528.     // TODO

  529.     INST_TAKES_NO_ARGS

  530.     INST_ERROR(ARG_SYNTAX)

  531.     INST_RETURN(1, 0xFF)

  532. }

  533. 

  534. INST_FUNC(ld)

  535. {

  536.     // TODO

  537.     INST_TAKES_NO_ARGS

  538.     INST_ERROR(ARG_SYNTAX)

  539.     INST_RETURN(1, 0xFF)

  540. }

  541. 

  542. INST_FUNC(ldd)

  543. {

  544.     INST_TAKES_NO_ARGS

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

  546. }

  547. 

  548. INST_FUNC(lddr)

  549. {

  550.     INST_TAKES_NO_ARGS

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

  552. }

  553. 

  554. INST_FUNC(ldi)

  555. {

  556.     INST_TAKES_NO_ARGS

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

  558. }

  559. 

  560. INST_FUNC(ldir)

  561. {

  562.     INST_TAKES_NO_ARGS

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

  564. }

  565. 

  566. INST_FUNC(neg)

  567. {

  568.     // TODO

  569.     INST_TAKES_NO_ARGS

  570.     INST_ERROR(ARG_SYNTAX)

  571.     INST_RETURN(1, 0xFF)

  572. }

  573. 

  574. INST_FUNC(nop)

  575. {

  576.     INST_TAKES_NO_ARGS

  577.     INST_RETURN(1, 0x00)

  578. }

  579. 

  580. INST_FUNC(or)

  581. {

  582.     // TODO

  583.     INST_TAKES_NO_ARGS

  584.     INST_ERROR(ARG_SYNTAX)

  585.     INST_RETURN(1, 0xFF)

  586. }

  587. 

  588. INST_FUNC(otdr)

  589. {

  590.     INST_TAKES_NO_ARGS

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

  592. }

  593. 

  594. INST_FUNC(otir)

  595. {

  596.     INST_TAKES_NO_ARGS

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

  598. }

  599. 

  600. INST_FUNC(out)

  601. {

  602.     // TODO

  603.     INST_TAKES_NO_ARGS

  604.     INST_ERROR(ARG_SYNTAX)

  605.     INST_RETURN(1, 0xFF)

  606. }

  607. 

  608. INST_FUNC(outd)

  609. {

  610.     INST_TAKES_NO_ARGS

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

  612. }

  613. 

  614. INST_FUNC(outi)

  615. {

  616.     INST_TAKES_NO_ARGS

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

  618. }

  619. 

  620. INST_FUNC(pop)

  621. {

  622.     // TODO

  623.     INST_TAKES_NO_ARGS

  624.     INST_ERROR(ARG_SYNTAX)

  625.     INST_RETURN(1, 0xFF)

  626. }

  627. 

  628. INST_FUNC(push)

  629. {

  630.     // TODO

  631.     INST_TAKES_NO_ARGS

  632.     INST_ERROR(ARG_SYNTAX)

  633.     INST_RETURN(1, 0xFF)

  634. }

  635. 

  636. INST_FUNC(res)

  637. {

  638.     // TODO

  639.     INST_TAKES_NO_ARGS

  640.     INST_ERROR(ARG_SYNTAX)

  641.     INST_RETURN(1, 0xFF)

  642. }

  643. 

  644. INST_FUNC(ret)

  645. {

  646.     // TODO

  647.     INST_TAKES_NO_ARGS

  648.     INST_ERROR(ARG_SYNTAX)

  649.     INST_RETURN(1, 0xFF)

  650. }

  651. 

  652. INST_FUNC(reti)

  653. {

  654.     INST_TAKES_NO_ARGS

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

  656. }

  657. 

  658. INST_FUNC(retn)

  659. {

  660.     INST_TAKES_NO_ARGS

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

  662. }

  663. 

  664. INST_FUNC(rl)

  665. {

  666.     // TODO

  667.     INST_TAKES_NO_ARGS

  668.     INST_ERROR(ARG_SYNTAX)

  669.     INST_RETURN(1, 0xFF)

  670. }

  671. 

  672. INST_FUNC(rla)

  673. {

  674.     INST_TAKES_NO_ARGS

  675.     INST_RETURN(1, 0x17)

  676. }

  677. 

  678. INST_FUNC(rlc)

  679. {

  680.     // TODO

  681.     INST_TAKES_NO_ARGS

  682.     INST_ERROR(ARG_SYNTAX)

  683.     INST_RETURN(1, 0xFF)

  684. }

  685. 

  686. INST_FUNC(rlca)

  687. {

  688.     INST_TAKES_NO_ARGS

  689.     INST_RETURN(1, 0x07)

  690. }

  691. 

  692. INST_FUNC(rld)

  693. {

  694.     // TODO

  695.     INST_TAKES_NO_ARGS

  696.     INST_ERROR(ARG_SYNTAX)

  697.     INST_RETURN(1, 0xFF)

  698. }

  699. 

  700. INST_FUNC(rr)

  701. {

  702.     // TODO

  703.     INST_TAKES_NO_ARGS

  704.     INST_ERROR(ARG_SYNTAX)

  705.     INST_RETURN(1, 0xFF)

  706. }

  707. 

  708. INST_FUNC(rra)

  709. {

  710.     INST_TAKES_NO_ARGS

  711.     INST_RETURN(1, 0x1F)

  712. }

  713. 

  714. INST_FUNC(rrc)

  715. {

  716.     // TODO

  717.     INST_TAKES_NO_ARGS

  718.     INST_ERROR(ARG_SYNTAX)

  719.     INST_RETURN(1, 0xFF)

  720. }

  721. 

  722. INST_FUNC(rrca)

  723. {

  724.     INST_TAKES_NO_ARGS

  725.     INST_RETURN(1, 0x0F)

  726. }

  727. 

  728. INST_FUNC(rrd)

  729. {

  730.     // TODO

  731.     INST_TAKES_NO_ARGS

  732.     INST_ERROR(ARG_SYNTAX)

  733.     INST_RETURN(1, 0xFF)

  734. }

  735. 

  736. INST_FUNC(rst)

  737. {

  738.     // TODO

  739.     INST_TAKES_NO_ARGS

  740.     INST_ERROR(ARG_SYNTAX)

  741.     INST_RETURN(1, 0xFF)

  742. }

  743. 

  744. INST_FUNC(sbc)

  745. {

  746.     // TODO

  747.     INST_TAKES_NO_ARGS

  748.     INST_ERROR(ARG_SYNTAX)

  749.     INST_RETURN(1, 0xFF)

  750. }

  751. 

  752. INST_FUNC(scf)

  753. {

  754.     INST_TAKES_NO_ARGS

  755.     INST_RETURN(1, 0x37)

  756. }

  757. 

  758. INST_FUNC(set)

  759. {

  760.     // TODO

  761.     INST_TAKES_NO_ARGS

  762.     INST_ERROR(ARG_SYNTAX)

  763.     INST_RETURN(1, 0xFF)

  764. }

  765. 

  766. INST_FUNC(sl1)

  767. {

  768.     // TODO

  769.     INST_TAKES_NO_ARGS

  770.     INST_ERROR(ARG_SYNTAX)

  771.     INST_RETURN(1, 0xFF)

  772. }

  773. 

  774. INST_FUNC(sla)

  775. {

  776.     // TODO

  777.     INST_TAKES_NO_ARGS

  778.     INST_ERROR(ARG_SYNTAX)

  779.     INST_RETURN(1, 0xFF)

  780. }

  781. 

  782. INST_FUNC(sll)

  783. {

  784.     // TODO

  785.     INST_TAKES_NO_ARGS

  786.     INST_ERROR(ARG_SYNTAX)

  787.     INST_RETURN(1, 0xFF)

  788. }

  789. 

  790. INST_FUNC(sls)

  791. {

  792.     // TODO

  793.     INST_TAKES_NO_ARGS

  794.     INST_ERROR(ARG_SYNTAX)

  795.     INST_RETURN(1, 0xFF)

  796. }

  797. 

  798. INST_FUNC(sra)

  799. {

  800.     // TODO

  801.     INST_TAKES_NO_ARGS

  802.     INST_ERROR(ARG_SYNTAX)

  803.     INST_RETURN(1, 0xFF)

  804. }

  805. 

  806. INST_FUNC(srl)

  807. {

  808.     // TODO

  809.     INST_TAKES_NO_ARGS

  810.     INST_ERROR(ARG_SYNTAX)

  811.     INST_RETURN(1, 0xFF)

  812. }

  813. 

  814. INST_FUNC(sub)

  815. {

  816.     // TODO

  817.     INST_TAKES_NO_ARGS

  818.     INST_ERROR(ARG_SYNTAX)

  819.     INST_RETURN(1, 0xFF)

  820. }

  821. 

  822. INST_FUNC(xor)

  823. {

  824.     // TODO

  825.     INST_TAKES_NO_ARGS

  826.     INST_ERROR(ARG_SYNTAX)

  827.     INST_RETURN(1, 0xFF)

  828. }

  829. 

  830. /*

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

  832. 

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

  834. */

  835. ASMInstParser get_inst_parser(char mstr[MAX_MNEMONIC_SIZE])

  836. {

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

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

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

  840. 

  841.     HANDLE(adc)

  842.     HANDLE(add)

  843.     HANDLE(and)

  844.     HANDLE(bit)

  845.     HANDLE(call)

  846.     HANDLE(ccf)

  847.     HANDLE(cp)

  848.     HANDLE(cpd)

  849.     HANDLE(cpdr)

  850.     HANDLE(cpi)

  851.     HANDLE(cpir)

  852.     HANDLE(cpl)

  853.     HANDLE(daa)

  854.     HANDLE(dec)

  855.     HANDLE(di)

  856.     HANDLE(djnz)

  857.     HANDLE(ei)

  858.     HANDLE(ex)

  859.     HANDLE(exx)

  860.     HANDLE(halt)

  861.     HANDLE(im)

  862.     HANDLE(in)

  863.     HANDLE(inc)

  864.     HANDLE(ind)

  865.     HANDLE(indr)

  866.     HANDLE(ini)

  867.     HANDLE(inir)

  868.     HANDLE(jp)

  869.     HANDLE(jr)

  870.     HANDLE(ld)

  871.     HANDLE(ldd)

  872.     HANDLE(lddr)

  873.     HANDLE(ldi)

  874.     HANDLE(ldir)

  875.     HANDLE(neg)

  876.     HANDLE(nop)

  877.     HANDLE(or)

  878.     HANDLE(otdr)

  879.     HANDLE(otir)

  880.     HANDLE(out)

  881.     HANDLE(outd)

  882.     HANDLE(outi)

  883.     HANDLE(pop)

  884.     HANDLE(push)

  885.     HANDLE(res)

  886.     HANDLE(ret)

  887.     HANDLE(reti)

  888.     HANDLE(retn)

  889.     HANDLE(rl)

  890.     HANDLE(rla)

  891.     HANDLE(rlc)

  892.     HANDLE(rlca)

  893.     HANDLE(rld)

  894.     HANDLE(rr)

  895.     HANDLE(rra)

  896.     HANDLE(rrc)

  897.     HANDLE(rrca)

  898.     HANDLE(rrd)

  899.     HANDLE(rst)

  900.     HANDLE(sbc)

  901.     HANDLE(scf)

  902.     HANDLE(set)

  903.     HANDLE(sl1)

  904.     HANDLE(sla)

  905.     HANDLE(sll)

  906.     HANDLE(sls)

  907.     HANDLE(sra)

  908.     HANDLE(srl)

  909.     HANDLE(sub)

  910.     HANDLE(xor)

  911. 

  912.     return NULL;

  913. }