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.
116 Commits
2 Branches
1.0 MiB
 
 
 
 
 
Tree: cfebed6a33
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cfebed6a33'
${ noResults }
crater/src/assembler/instructions.c

973 lines
23 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 "../logging.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.     if (!(*bytes = malloc(sizeof(uint8_t) * (len))))                          \

  30.         OUT_OF_MEMORY()

  31. 

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

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

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

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

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

  37. 

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

  39. 

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

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

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

  43.                    INST_SET1_, __VA_ARGS__)(__VA_ARGS__));

  44. 

  45. #define INST_PREFIX_(reg)                                                     \

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

  47. 

  48. /* Helper macros for instruction parsers */

  49. 

  50. #define INST_FUNC(mnemonic)                                                   \

  51. static ASMErrorDesc parse_inst_##mnemonic(                                    \

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

  53. 

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

  55. 

  56. #define INST_TAKES_NO_ARGS                                                    \

  57.     if (ap_info.arg)                                                          \

  58.         INST_ERROR(TOO_MANY_ARGS)                                             \

  59. 

  60. #define INST_TAKES_ARGS(lo, hi)                                               \

  61.     if (!ap_info.arg)                                                         \

  62.         INST_ERROR(TOO_FEW_ARGS)                                              \

  63.     ASMInstArg args[3];                                                       \

  64.     size_t nargs = 0;                                                         \

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

  66.     if (err)                                                                  \

  67.         return err;                                                           \

  68.     if (nargs < lo)                                                           \

  69.         INST_ERROR(TOO_FEW_ARGS)                                              \

  70.     if (nargs > hi)                                                           \

  71.         INST_ERROR(TOO_MANY_ARGS)

  72. 

  73. #define INST_NARGS nargs

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

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

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

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

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

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

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

  81. 

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

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

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

  85.     }

  86. 

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

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

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

  90.     }

  91. 

  92. #define INST_INDIRECT_HL_ONLY(n) {                                            \

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

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

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

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

  97.     }

  98. 

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

  100.         (void) symbol;                                                        \

  101.         INST_ALLOC_(len)                                                      \

  102.         INST_FILL_BYTES_(len, __VA_ARGS__)                                    \

  103.         return ED_NONE;                                                       \

  104.     }

  105. 

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

  107.         *symbol = strdup(label);                                              \

  108.         if (!(*symbol))                                                       \

  109.             OUT_OF_MEMORY()                                                   \

  110.         INST_ALLOC_(len)                                                      \

  111.         INST_FILL_BYTES_(len - 2, __VA_ARGS__)                                \

  112.         return ED_NONE;                                                       \

  113.     }

  114. 

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

  116. 

  117. #define INST_INDEX_BYTES(n, b)                                                \

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

  119. 

  120. /*

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

  122. 

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

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

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

  126. 

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

  128.     INST_SETn_ family of macros.

  129. */

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

  131. {

  132.     va_list vargs;

  133.     va_start(vargs, len);

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

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

  136.     va_end(vargs);

  137.     return bytes[len - 1];

  138. }

  139. 

  140. /*

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

  142. 

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

  144. */

  145. static ASMErrorDesc parse_arg(

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

  147. {

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

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

  150.         arg->type = argtype;                                                  \

  151.         return ED_NONE;                                                       \

  152.     }

  153. 

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

  155.     TRY_PARSER(register, AT_REGISTER, reg)

  156.     TRY_PARSER(immediate, AT_IMMEDIATE, imm)

  157.     TRY_PARSER(indirect, AT_INDIRECT, indirect)

  158.     TRY_PARSER(indexed, AT_INDEXED, index)

  159.     TRY_PARSER(condition, AT_CONDITION, cond)

  160.     TRY_PARSER(label, AT_LABEL, label)

  161.     return ED_PS_ARG_SYNTAX;

  162. 

  163. #undef TRY_PARSER

  164. }

  165. 

  166. /*

  167.     Parse an argument string into ASMInstArg objects.

  168. 

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

  170. */

  171. static ASMErrorDesc parse_args(

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

  173. {

  174.     ASMErrorDesc err;

  175.     ASMDefineTable *dt = ap_info.deftable;

  176.     const char *str = ap_info.arg;

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

  178. 

  179.     while (i < size) {

  180.         char c = str[i];

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

  182.             if (i == start)

  183.                 return ED_PS_ARG_SYNTAX;

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

  185.                 return err;

  186.             (*nargs)++;

  187. 

  188.             i++;

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

  190.                 i++;

  191.             start = i;

  192.             if (i == size)

  193.                 return ED_PS_ARG_SYNTAX;

  194.             if (*nargs >= 3)

  195.                 return ED_PS_TOO_MANY_ARGS;

  196.         } else {

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

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

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

  200.                 i++;

  201.             else

  202.                 return ED_PS_ARG_SYNTAX;

  203.         }

  204.     }

  205. 

  206.     if (i > start) {

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

  208.             return err;

  209.         (*nargs)++;

  210.     }

  211.     return ED_NONE;

  212. }

  213. 

  214. /* Instruction parser functions */

  215. 

  216. INST_FUNC(adc)

  217. {

  218.     INST_TAKES_ARGS(2, 2)

  219.     INST_FORCE_TYPE(0, AT_REGISTER)

  220.     switch (INST_REG(0)) {

  221.         case REG_A:

  222.             switch (INST_TYPE(1)) {

  223.                 case AT_REGISTER:

  224.                     switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

  236.                         default: INST_ERROR(ARG1_BAD_REG)

  237.                     }

  238.                 case AT_IMMEDIATE:

  239.                     INST_CHECK_IMM(1, IMM_U8)

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

  241.                 case AT_INDIRECT:

  242.                     INST_INDIRECT_HL_ONLY(1)

  243.                     INST_RETURN(1, 0x8E)

  244.                 case AT_INDEXED:

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

  246.                 default:

  247.                     INST_ERROR(ARG1_TYPE)

  248.             }

  249.         case REG_HL:

  250.             INST_FORCE_TYPE(1, AT_REGISTER)

  251.             switch (INST_REG(1)) {

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

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

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

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

  256.                 default: INST_ERROR(ARG1_BAD_REG)

  257.             }

  258.         default:

  259.             INST_ERROR(ARG0_TYPE)

  260.     }

  261. }

  262. 

  263. INST_FUNC(add)

  264. {

  265.     INST_TAKES_ARGS(2, 2)

  266.     INST_FORCE_TYPE(0, AT_REGISTER)

  267.     switch (INST_REG(0)) {

  268.         case REG_A:

  269.             switch (INST_TYPE(1)) {

  270.                 case AT_REGISTER:

  271.                     switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

  283.                         default: INST_ERROR(ARG1_BAD_REG)

  284.                     }

  285.                 case AT_IMMEDIATE:

  286.                     INST_CHECK_IMM(1, IMM_U8)

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

  288.                 case AT_INDIRECT:

  289.                     INST_INDIRECT_HL_ONLY(1)

  290.                     INST_RETURN(1, 0x86)

  291.                 case AT_INDEXED:

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

  293.                 default:

  294.                     INST_ERROR(ARG1_TYPE)

  295.             }

  296.         case REG_HL:

  297.             INST_FORCE_TYPE(1, AT_REGISTER)

  298.             switch (INST_REG(1)) {

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

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

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

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

  303.                 default: INST_ERROR(ARG1_BAD_REG)

  304.             }

  305.         case REG_IX:

  306.         case REG_IY:

  307.             INST_FORCE_TYPE(1, AT_REGISTER)

  308.             switch (INST_REG(1)) {

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

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

  311.                 case REG_IX:

  312.                 case REG_IY:

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

  314.                         INST_ERROR(ARG1_BAD_REG)

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

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

  317.                 default: INST_ERROR(ARG1_BAD_REG)

  318.             }

  319.         default:

  320.             INST_ERROR(ARG0_TYPE)

  321.     }

  322. }

  323. 

  324. INST_FUNC(and)

  325. {

  326.     // TODO

  327.     INST_TAKES_NO_ARGS

  328.     INST_ERROR(ARG_SYNTAX)

  329.     INST_RETURN(1, 0xFF)

  330. }

  331. 

  332. INST_FUNC(bit)

  333. {

  334.     // TODO

  335.     INST_TAKES_NO_ARGS

  336.     INST_ERROR(ARG_SYNTAX)

  337.     INST_RETURN(1, 0xFF)

  338. }

  339. 

  340. INST_FUNC(call)

  341. {

  342.     // TODO

  343.     INST_TAKES_NO_ARGS

  344.     INST_ERROR(ARG_SYNTAX)

  345.     INST_RETURN(1, 0xFF)

  346. }

  347. 

  348. INST_FUNC(ccf)

  349. {

  350.     // TODO

  351.     INST_TAKES_NO_ARGS

  352.     INST_ERROR(ARG_SYNTAX)

  353.     INST_RETURN(1, 0xFF)

  354. }

  355. 

  356. INST_FUNC(cp)

  357. {

  358.     // TODO

  359.     INST_TAKES_NO_ARGS

  360.     INST_ERROR(ARG_SYNTAX)

  361.     INST_RETURN(1, 0xFF)

  362. }

  363. 

  364. INST_FUNC(cpd)

  365. {

  366.     // TODO

  367.     INST_TAKES_NO_ARGS

  368.     INST_ERROR(ARG_SYNTAX)

  369.     INST_RETURN(1, 0xFF)

  370. }

  371. 

  372. INST_FUNC(cpdr)

  373. {

  374.     // TODO

  375.     INST_TAKES_NO_ARGS

  376.     INST_ERROR(ARG_SYNTAX)

  377.     INST_RETURN(1, 0xFF)

  378. }

  379. 

  380. INST_FUNC(cpi)

  381. {

  382.     // TODO

  383.     INST_TAKES_NO_ARGS

  384.     INST_ERROR(ARG_SYNTAX)

  385.     INST_RETURN(1, 0xFF)

  386. }

  387. 

  388. INST_FUNC(cpir)

  389. {

  390.     // TODO

  391.     INST_TAKES_NO_ARGS

  392.     INST_ERROR(ARG_SYNTAX)

  393.     INST_RETURN(1, 0xFF)

  394. }

  395. 

  396. INST_FUNC(cpl)

  397. {

  398.     // TODO

  399.     INST_TAKES_NO_ARGS

  400.     INST_ERROR(ARG_SYNTAX)

  401.     INST_RETURN(1, 0xFF)

  402. }

  403. 

  404. INST_FUNC(daa)

  405. {

  406.     // TODO

  407.     INST_TAKES_NO_ARGS

  408.     INST_ERROR(ARG_SYNTAX)

  409.     INST_RETURN(1, 0xFF)

  410. }

  411. 

  412. INST_FUNC(dec)

  413. {

  414.     // TODO

  415.     INST_TAKES_NO_ARGS

  416.     INST_ERROR(ARG_SYNTAX)

  417.     INST_RETURN(1, 0xFF)

  418. }

  419. 

  420. INST_FUNC(di)

  421. {

  422.     // TODO

  423.     INST_TAKES_NO_ARGS

  424.     INST_ERROR(ARG_SYNTAX)

  425.     INST_RETURN(1, 0xFF)

  426. }

  427. 

  428. INST_FUNC(djnz)

  429. {

  430.     // TODO

  431.     INST_TAKES_NO_ARGS

  432.     INST_ERROR(ARG_SYNTAX)

  433.     INST_RETURN(1, 0xFF)

  434. }

  435. 

  436. INST_FUNC(ei)

  437. {

  438.     // TODO

  439.     INST_TAKES_NO_ARGS

  440.     INST_ERROR(ARG_SYNTAX)

  441.     INST_RETURN(1, 0xFF)

  442. }

  443. 

  444. INST_FUNC(ex)

  445. {

  446.     // TODO

  447.     INST_TAKES_NO_ARGS

  448.     INST_ERROR(ARG_SYNTAX)

  449.     INST_RETURN(1, 0xFF)

  450. }

  451. 

  452. INST_FUNC(exx)

  453. {

  454.     // TODO

  455.     INST_TAKES_NO_ARGS

  456.     INST_ERROR(ARG_SYNTAX)

  457.     INST_RETURN(1, 0xFF)

  458. }

  459. 

  460. INST_FUNC(halt)

  461. {

  462.     // TODO

  463.     INST_TAKES_NO_ARGS

  464.     INST_ERROR(ARG_SYNTAX)

  465.     INST_RETURN(1, 0xFF)

  466. }

  467. 

  468. INST_FUNC(im)

  469. {

  470.     // TODO

  471.     INST_TAKES_NO_ARGS

  472.     INST_ERROR(ARG_SYNTAX)

  473.     INST_RETURN(1, 0xFF)

  474. }

  475. 

  476. INST_FUNC(in)

  477. {

  478.     // TODO

  479.     INST_TAKES_NO_ARGS

  480.     INST_ERROR(ARG_SYNTAX)

  481.     INST_RETURN(1, 0xFF)

  482. }

  483. 

  484. INST_FUNC(inc)

  485. {

  486.     INST_TAKES_ARGS(1, 1)

  487.     switch (INST_TYPE(0)) {

  488.         case AT_REGISTER:

  489.             switch (INST_REG(0)) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  507.                 default: INST_ERROR(ARG0_BAD_REG)

  508.             }

  509.         case AT_INDIRECT:

  510.             INST_INDIRECT_HL_ONLY(0)

  511.             INST_RETURN(1, 0x34)

  512.         case AT_INDEXED:

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

  514.         default:

  515.             INST_ERROR(ARG0_TYPE)

  516.     }

  517. }

  518. 

  519. INST_FUNC(ind)

  520. {

  521.     // TODO

  522.     INST_TAKES_NO_ARGS

  523.     INST_ERROR(ARG_SYNTAX)

  524.     INST_RETURN(1, 0xFF)

  525. }

  526. 

  527. INST_FUNC(indr)

  528. {

  529.     // TODO

  530.     INST_TAKES_NO_ARGS

  531.     INST_ERROR(ARG_SYNTAX)

  532.     INST_RETURN(1, 0xFF)

  533. }

  534. 

  535. INST_FUNC(ini)

  536. {

  537.     // TODO

  538.     INST_TAKES_NO_ARGS

  539.     INST_ERROR(ARG_SYNTAX)

  540.     INST_RETURN(1, 0xFF)

  541. }

  542. 

  543. INST_FUNC(inir)

  544. {

  545.     // TODO

  546.     INST_TAKES_NO_ARGS

  547.     INST_ERROR(ARG_SYNTAX)

  548.     INST_RETURN(1, 0xFF)

  549. }

  550. 

  551. INST_FUNC(jp)

  552. {

  553.     // TODO

  554.     INST_TAKES_NO_ARGS

  555.     INST_ERROR(ARG_SYNTAX)

  556.     INST_RETURN(1, 0xFF)

  557. }

  558. 

  559. INST_FUNC(jr)

  560. {

  561.     // TODO

  562.     INST_TAKES_NO_ARGS

  563.     INST_ERROR(ARG_SYNTAX)

  564.     INST_RETURN(1, 0xFF)

  565. }

  566. 

  567. INST_FUNC(ld)

  568. {

  569.     // TODO

  570.     INST_TAKES_NO_ARGS

  571.     INST_ERROR(ARG_SYNTAX)

  572.     INST_RETURN(1, 0xFF)

  573. }

  574. 

  575. INST_FUNC(ldd)

  576. {

  577.     // TODO

  578.     INST_TAKES_NO_ARGS

  579.     INST_ERROR(ARG_SYNTAX)

  580.     INST_RETURN(1, 0xFF)

  581. }

  582. 

  583. INST_FUNC(lddr)

  584. {

  585.     // TODO

  586.     INST_TAKES_NO_ARGS

  587.     INST_ERROR(ARG_SYNTAX)

  588.     INST_RETURN(1, 0xFF)

  589. }

  590. 

  591. INST_FUNC(ldi)

  592. {

  593.     // TODO

  594.     INST_TAKES_NO_ARGS

  595.     INST_ERROR(ARG_SYNTAX)

  596.     INST_RETURN(1, 0xFF)

  597. }

  598. 

  599. INST_FUNC(ldir)

  600. {

  601.     // TODO

  602.     INST_TAKES_NO_ARGS

  603.     INST_ERROR(ARG_SYNTAX)

  604.     INST_RETURN(1, 0xFF)

  605. }

  606. 

  607. INST_FUNC(neg)

  608. {

  609.     // TODO

  610.     INST_TAKES_NO_ARGS

  611.     INST_ERROR(ARG_SYNTAX)

  612.     INST_RETURN(1, 0xFF)

  613. }

  614. 

  615. INST_FUNC(nop)

  616. {

  617.     INST_TAKES_NO_ARGS

  618.     INST_RETURN(1, 0x00)

  619. }

  620. 

  621. INST_FUNC(or)

  622. {

  623.     // TODO

  624.     INST_TAKES_NO_ARGS

  625.     INST_ERROR(ARG_SYNTAX)

  626.     INST_RETURN(1, 0xFF)

  627. }

  628. 

  629. INST_FUNC(otdr)

  630. {

  631.     // TODO

  632.     INST_TAKES_NO_ARGS

  633.     INST_ERROR(ARG_SYNTAX)

  634.     INST_RETURN(1, 0xFF)

  635. }

  636. 

  637. INST_FUNC(otir)

  638. {

  639.     // TODO

  640.     INST_TAKES_NO_ARGS

  641.     INST_ERROR(ARG_SYNTAX)

  642.     INST_RETURN(1, 0xFF)

  643. }

  644. 

  645. INST_FUNC(out)

  646. {

  647.     // TODO

  648.     INST_TAKES_NO_ARGS

  649.     INST_ERROR(ARG_SYNTAX)

  650.     INST_RETURN(1, 0xFF)

  651. }

  652. 

  653. INST_FUNC(outd)

  654. {

  655.     // TODO

  656.     INST_TAKES_NO_ARGS

  657.     INST_ERROR(ARG_SYNTAX)

  658.     INST_RETURN(1, 0xFF)

  659. }

  660. 

  661. INST_FUNC(outi)

  662. {

  663.     // TODO

  664.     INST_TAKES_NO_ARGS

  665.     INST_ERROR(ARG_SYNTAX)

  666.     INST_RETURN(1, 0xFF)

  667. }

  668. 

  669. INST_FUNC(pop)

  670. {

  671.     // TODO

  672.     INST_TAKES_NO_ARGS

  673.     INST_ERROR(ARG_SYNTAX)

  674.     INST_RETURN(1, 0xFF)

  675. }

  676. 

  677. INST_FUNC(push)

  678. {

  679.     // TODO

  680.     INST_TAKES_NO_ARGS

  681.     INST_ERROR(ARG_SYNTAX)

  682.     INST_RETURN(1, 0xFF)

  683. }

  684. 

  685. INST_FUNC(res)

  686. {

  687.     // TODO

  688.     INST_TAKES_NO_ARGS

  689.     INST_ERROR(ARG_SYNTAX)

  690.     INST_RETURN(1, 0xFF)

  691. }

  692. 

  693. INST_FUNC(ret)

  694. {

  695.     // TODO

  696.     INST_TAKES_NO_ARGS

  697.     INST_ERROR(ARG_SYNTAX)

  698.     INST_RETURN(1, 0xFF)

  699. }

  700. 

  701. INST_FUNC(reti)

  702. {

  703.     INST_TAKES_NO_ARGS

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

  705. }

  706. 

  707. INST_FUNC(retn)

  708. {

  709.     INST_TAKES_NO_ARGS

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

  711. }

  712. 

  713. INST_FUNC(rl)

  714. {

  715.     // TODO

  716.     INST_TAKES_NO_ARGS

  717.     INST_ERROR(ARG_SYNTAX)

  718.     INST_RETURN(1, 0xFF)

  719. }

  720. 

  721. INST_FUNC(rla)

  722. {

  723.     // TODO

  724.     INST_TAKES_NO_ARGS

  725.     INST_ERROR(ARG_SYNTAX)

  726.     INST_RETURN(1, 0xFF)

  727. }

  728. 

  729. INST_FUNC(rlc)

  730. {

  731.     // TODO

  732.     INST_TAKES_NO_ARGS

  733.     INST_ERROR(ARG_SYNTAX)

  734.     INST_RETURN(1, 0xFF)

  735. }

  736. 

  737. INST_FUNC(rlca)

  738. {

  739.     // TODO

  740.     INST_TAKES_NO_ARGS

  741.     INST_ERROR(ARG_SYNTAX)

  742.     INST_RETURN(1, 0xFF)

  743. }

  744. 

  745. INST_FUNC(rld)

  746. {

  747.     // TODO

  748.     INST_TAKES_NO_ARGS

  749.     INST_ERROR(ARG_SYNTAX)

  750.     INST_RETURN(1, 0xFF)

  751. }

  752. 

  753. INST_FUNC(rr)

  754. {

  755.     // TODO

  756.     INST_TAKES_NO_ARGS

  757.     INST_ERROR(ARG_SYNTAX)

  758.     INST_RETURN(1, 0xFF)

  759. }

  760. 

  761. INST_FUNC(rra)

  762. {

  763.     // TODO

  764.     INST_TAKES_NO_ARGS

  765.     INST_ERROR(ARG_SYNTAX)

  766.     INST_RETURN(1, 0xFF)

  767. }

  768. 

  769. INST_FUNC(rrc)

  770. {

  771.     // TODO

  772.     INST_TAKES_NO_ARGS

  773.     INST_ERROR(ARG_SYNTAX)

  774.     INST_RETURN(1, 0xFF)

  775. }

  776. 

  777. INST_FUNC(rrca)

  778. {

  779.     // TODO

  780.     INST_TAKES_NO_ARGS

  781.     INST_ERROR(ARG_SYNTAX)

  782.     INST_RETURN(1, 0xFF)

  783. }

  784. 

  785. INST_FUNC(rrd)

  786. {

  787.     // TODO

  788.     INST_TAKES_NO_ARGS

  789.     INST_ERROR(ARG_SYNTAX)

  790.     INST_RETURN(1, 0xFF)

  791. }

  792. 

  793. INST_FUNC(rst)

  794. {

  795.     // TODO

  796.     INST_TAKES_NO_ARGS

  797.     INST_ERROR(ARG_SYNTAX)

  798.     INST_RETURN(1, 0xFF)

  799. }

  800. 

  801. INST_FUNC(sbc)

  802. {

  803.     // TODO

  804.     INST_TAKES_NO_ARGS

  805.     INST_ERROR(ARG_SYNTAX)

  806.     INST_RETURN(1, 0xFF)

  807. }

  808. 

  809. INST_FUNC(scf)

  810. {

  811.     // TODO

  812.     INST_TAKES_NO_ARGS

  813.     INST_ERROR(ARG_SYNTAX)

  814.     INST_RETURN(1, 0xFF)

  815. }

  816. 

  817. INST_FUNC(set)

  818. {

  819.     // TODO

  820.     INST_TAKES_NO_ARGS

  821.     INST_ERROR(ARG_SYNTAX)

  822.     INST_RETURN(1, 0xFF)

  823. }

  824. 

  825. INST_FUNC(sl1)

  826. {

  827.     // TODO

  828.     INST_TAKES_NO_ARGS

  829.     INST_ERROR(ARG_SYNTAX)

  830.     INST_RETURN(1, 0xFF)

  831. }

  832. 

  833. INST_FUNC(sla)

  834. {

  835.     // TODO

  836.     INST_TAKES_NO_ARGS

  837.     INST_ERROR(ARG_SYNTAX)

  838.     INST_RETURN(1, 0xFF)

  839. }

  840. 

  841. INST_FUNC(sll)

  842. {

  843.     // TODO

  844.     INST_TAKES_NO_ARGS

  845.     INST_ERROR(ARG_SYNTAX)

  846.     INST_RETURN(1, 0xFF)

  847. }

  848. 

  849. INST_FUNC(sls)

  850. {

  851.     // TODO

  852.     INST_TAKES_NO_ARGS

  853.     INST_ERROR(ARG_SYNTAX)

  854.     INST_RETURN(1, 0xFF)

  855. }

  856. 

  857. INST_FUNC(sra)

  858. {

  859.     // TODO

  860.     INST_TAKES_NO_ARGS

  861.     INST_ERROR(ARG_SYNTAX)

  862.     INST_RETURN(1, 0xFF)

  863. }

  864. 

  865. INST_FUNC(srl)

  866. {

  867.     // TODO

  868.     INST_TAKES_NO_ARGS

  869.     INST_ERROR(ARG_SYNTAX)

  870.     INST_RETURN(1, 0xFF)

  871. }

  872. 

  873. INST_FUNC(sub)

  874. {

  875.     // TODO

  876.     INST_TAKES_NO_ARGS

  877.     INST_ERROR(ARG_SYNTAX)

  878.     INST_RETURN(1, 0xFF)

  879. }

  880. 

  881. INST_FUNC(xor)

  882. {

  883.     // TODO

  884.     INST_TAKES_NO_ARGS

  885.     INST_ERROR(ARG_SYNTAX)

  886.     INST_RETURN(1, 0xFF)

  887. }

  888. 

  889. /*

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

  891. 

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

  893. */

  894. ASMInstParser get_inst_parser(char mstr[MAX_MNEMONIC_SIZE])

  895. {

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

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

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

  899. 

  900.     HANDLE(adc)

  901.     HANDLE(add)

  902.     HANDLE(and)

  903.     HANDLE(bit)

  904.     HANDLE(call)

  905.     HANDLE(ccf)

  906.     HANDLE(cp)

  907.     HANDLE(cpd)

  908.     HANDLE(cpdr)

  909.     HANDLE(cpi)

  910.     HANDLE(cpir)

  911.     HANDLE(cpl)

  912.     HANDLE(daa)

  913.     HANDLE(dec)

  914.     HANDLE(di)

  915.     HANDLE(djnz)

  916.     HANDLE(ei)

  917.     HANDLE(ex)

  918.     HANDLE(exx)

  919.     HANDLE(halt)

  920.     HANDLE(im)

  921.     HANDLE(in)

  922.     HANDLE(inc)

  923.     HANDLE(ind)

  924.     HANDLE(indr)

  925.     HANDLE(ini)

  926.     HANDLE(inir)

  927.     HANDLE(jp)

  928.     HANDLE(jr)

  929.     HANDLE(ld)

  930.     HANDLE(ldd)

  931.     HANDLE(lddr)

  932.     HANDLE(ldi)

  933.     HANDLE(ldir)

  934.     HANDLE(neg)

  935.     HANDLE(nop)

  936.     HANDLE(or)

  937.     HANDLE(otdr)

  938.     HANDLE(otir)

  939.     HANDLE(out)

  940.     HANDLE(outd)

  941.     HANDLE(outi)

  942.     HANDLE(pop)

  943.     HANDLE(push)

  944.     HANDLE(res)

  945.     HANDLE(ret)

  946.     HANDLE(reti)

  947.     HANDLE(retn)

  948.     HANDLE(rl)

  949.     HANDLE(rla)

  950.     HANDLE(rlc)

  951.     HANDLE(rlca)

  952.     HANDLE(rld)

  953.     HANDLE(rr)

  954.     HANDLE(rra)

  955.     HANDLE(rrc)

  956.     HANDLE(rrca)

  957.     HANDLE(rrd)

  958.     HANDLE(rst)

  959.     HANDLE(sbc)

  960.     HANDLE(scf)

  961.     HANDLE(set)

  962.     HANDLE(sl1)

  963.     HANDLE(sla)

  964.     HANDLE(sll)

  965.     HANDLE(sls)

  966.     HANDLE(sra)

  967.     HANDLE(srl)

  968.     HANDLE(sub)

  969.     HANDLE(xor)

  970. 

  971.     return NULL;

  972. }