ben
/
crater
miroir de https://github.com/earwig/crater
1
1
Bifurcation 0
Code Versions 0 Activité
An emulator, assembler, and disassembler for the Sega Game Gear
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
117 Révisions
2 Branches
2.2 MiB
 
 
 
 
 
Aborescence: 13b7b29157
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '13b7b29157'
${ noResults }
crater/src/assembler/instructions.c

970 lignes
22 KiB
Brut Annotations Historique 

  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.     // TODO

  348.     INST_TAKES_NO_ARGS

  349.     INST_ERROR(ARG_SYNTAX)

  350.     INST_RETURN(1, 0xFF)

  351. }

  352. 

  353. INST_FUNC(cp)

  354. {

  355.     // TODO

  356.     INST_TAKES_NO_ARGS

  357.     INST_ERROR(ARG_SYNTAX)

  358.     INST_RETURN(1, 0xFF)

  359. }

  360. 

  361. INST_FUNC(cpd)

  362. {

  363.     // TODO

  364.     INST_TAKES_NO_ARGS

  365.     INST_ERROR(ARG_SYNTAX)

  366.     INST_RETURN(1, 0xFF)

  367. }

  368. 

  369. INST_FUNC(cpdr)

  370. {

  371.     // TODO

  372.     INST_TAKES_NO_ARGS

  373.     INST_ERROR(ARG_SYNTAX)

  374.     INST_RETURN(1, 0xFF)

  375. }

  376. 

  377. INST_FUNC(cpi)

  378. {

  379.     // TODO

  380.     INST_TAKES_NO_ARGS

  381.     INST_ERROR(ARG_SYNTAX)

  382.     INST_RETURN(1, 0xFF)

  383. }

  384. 

  385. INST_FUNC(cpir)

  386. {

  387.     // TODO

  388.     INST_TAKES_NO_ARGS

  389.     INST_ERROR(ARG_SYNTAX)

  390.     INST_RETURN(1, 0xFF)

  391. }

  392. 

  393. INST_FUNC(cpl)

  394. {

  395.     // TODO

  396.     INST_TAKES_NO_ARGS

  397.     INST_ERROR(ARG_SYNTAX)

  398.     INST_RETURN(1, 0xFF)

  399. }

  400. 

  401. INST_FUNC(daa)

  402. {

  403.     // TODO

  404.     INST_TAKES_NO_ARGS

  405.     INST_ERROR(ARG_SYNTAX)

  406.     INST_RETURN(1, 0xFF)

  407. }

  408. 

  409. INST_FUNC(dec)

  410. {

  411.     // TODO

  412.     INST_TAKES_NO_ARGS

  413.     INST_ERROR(ARG_SYNTAX)

  414.     INST_RETURN(1, 0xFF)

  415. }

  416. 

  417. INST_FUNC(di)

  418. {

  419.     // TODO

  420.     INST_TAKES_NO_ARGS

  421.     INST_ERROR(ARG_SYNTAX)

  422.     INST_RETURN(1, 0xFF)

  423. }

  424. 

  425. INST_FUNC(djnz)

  426. {

  427.     // TODO

  428.     INST_TAKES_NO_ARGS

  429.     INST_ERROR(ARG_SYNTAX)

  430.     INST_RETURN(1, 0xFF)

  431. }

  432. 

  433. INST_FUNC(ei)

  434. {

  435.     // TODO

  436.     INST_TAKES_NO_ARGS

  437.     INST_ERROR(ARG_SYNTAX)

  438.     INST_RETURN(1, 0xFF)

  439. }

  440. 

  441. INST_FUNC(ex)

  442. {

  443.     // TODO

  444.     INST_TAKES_NO_ARGS

  445.     INST_ERROR(ARG_SYNTAX)

  446.     INST_RETURN(1, 0xFF)

  447. }

  448. 

  449. INST_FUNC(exx)

  450. {

  451.     // TODO

  452.     INST_TAKES_NO_ARGS

  453.     INST_ERROR(ARG_SYNTAX)

  454.     INST_RETURN(1, 0xFF)

  455. }

  456. 

  457. INST_FUNC(halt)

  458. {

  459.     // TODO

  460.     INST_TAKES_NO_ARGS

  461.     INST_ERROR(ARG_SYNTAX)

  462.     INST_RETURN(1, 0xFF)

  463. }

  464. 

  465. INST_FUNC(im)

  466. {

  467.     // TODO

  468.     INST_TAKES_NO_ARGS

  469.     INST_ERROR(ARG_SYNTAX)

  470.     INST_RETURN(1, 0xFF)

  471. }

  472. 

  473. INST_FUNC(in)

  474. {

  475.     // TODO

  476.     INST_TAKES_NO_ARGS

  477.     INST_ERROR(ARG_SYNTAX)

  478.     INST_RETURN(1, 0xFF)

  479. }

  480. 

  481. INST_FUNC(inc)

  482. {

  483.     INST_TAKES_ARGS(1, 1)

  484.     switch (INST_TYPE(0)) {

  485.         case AT_REGISTER:

  486.             switch (INST_REG(0)) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  504.                 default: INST_ERROR(ARG0_BAD_REG)

  505.             }

  506.         case AT_INDIRECT:

  507.             INST_INDIRECT_HL_ONLY(0)

  508.             INST_RETURN(1, 0x34)

  509.         case AT_INDEXED:

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

  511.         default:

  512.             INST_ERROR(ARG0_TYPE)

  513.     }

  514. }

  515. 

  516. INST_FUNC(ind)

  517. {

  518.     // TODO

  519.     INST_TAKES_NO_ARGS

  520.     INST_ERROR(ARG_SYNTAX)

  521.     INST_RETURN(1, 0xFF)

  522. }

  523. 

  524. INST_FUNC(indr)

  525. {

  526.     // TODO

  527.     INST_TAKES_NO_ARGS

  528.     INST_ERROR(ARG_SYNTAX)

  529.     INST_RETURN(1, 0xFF)

  530. }

  531. 

  532. INST_FUNC(ini)

  533. {

  534.     // TODO

  535.     INST_TAKES_NO_ARGS

  536.     INST_ERROR(ARG_SYNTAX)

  537.     INST_RETURN(1, 0xFF)

  538. }

  539. 

  540. INST_FUNC(inir)

  541. {

  542.     // TODO

  543.     INST_TAKES_NO_ARGS

  544.     INST_ERROR(ARG_SYNTAX)

  545.     INST_RETURN(1, 0xFF)

  546. }

  547. 

  548. INST_FUNC(jp)

  549. {

  550.     // TODO

  551.     INST_TAKES_NO_ARGS

  552.     INST_ERROR(ARG_SYNTAX)

  553.     INST_RETURN(1, 0xFF)

  554. }

  555. 

  556. INST_FUNC(jr)

  557. {

  558.     // TODO

  559.     INST_TAKES_NO_ARGS

  560.     INST_ERROR(ARG_SYNTAX)

  561.     INST_RETURN(1, 0xFF)

  562. }

  563. 

  564. INST_FUNC(ld)

  565. {

  566.     // TODO

  567.     INST_TAKES_NO_ARGS

  568.     INST_ERROR(ARG_SYNTAX)

  569.     INST_RETURN(1, 0xFF)

  570. }

  571. 

  572. INST_FUNC(ldd)

  573. {

  574.     // TODO

  575.     INST_TAKES_NO_ARGS

  576.     INST_ERROR(ARG_SYNTAX)

  577.     INST_RETURN(1, 0xFF)

  578. }

  579. 

  580. INST_FUNC(lddr)

  581. {

  582.     // TODO

  583.     INST_TAKES_NO_ARGS

  584.     INST_ERROR(ARG_SYNTAX)

  585.     INST_RETURN(1, 0xFF)

  586. }

  587. 

  588. INST_FUNC(ldi)

  589. {

  590.     // TODO

  591.     INST_TAKES_NO_ARGS

  592.     INST_ERROR(ARG_SYNTAX)

  593.     INST_RETURN(1, 0xFF)

  594. }

  595. 

  596. INST_FUNC(ldir)

  597. {

  598.     // TODO

  599.     INST_TAKES_NO_ARGS

  600.     INST_ERROR(ARG_SYNTAX)

  601.     INST_RETURN(1, 0xFF)

  602. }

  603. 

  604. INST_FUNC(neg)

  605. {

  606.     // TODO

  607.     INST_TAKES_NO_ARGS

  608.     INST_ERROR(ARG_SYNTAX)

  609.     INST_RETURN(1, 0xFF)

  610. }

  611. 

  612. INST_FUNC(nop)

  613. {

  614.     INST_TAKES_NO_ARGS

  615.     INST_RETURN(1, 0x00)

  616. }

  617. 

  618. INST_FUNC(or)

  619. {

  620.     // TODO

  621.     INST_TAKES_NO_ARGS

  622.     INST_ERROR(ARG_SYNTAX)

  623.     INST_RETURN(1, 0xFF)

  624. }

  625. 

  626. INST_FUNC(otdr)

  627. {

  628.     // TODO

  629.     INST_TAKES_NO_ARGS

  630.     INST_ERROR(ARG_SYNTAX)

  631.     INST_RETURN(1, 0xFF)

  632. }

  633. 

  634. INST_FUNC(otir)

  635. {

  636.     // TODO

  637.     INST_TAKES_NO_ARGS

  638.     INST_ERROR(ARG_SYNTAX)

  639.     INST_RETURN(1, 0xFF)

  640. }

  641. 

  642. INST_FUNC(out)

  643. {

  644.     // TODO

  645.     INST_TAKES_NO_ARGS

  646.     INST_ERROR(ARG_SYNTAX)

  647.     INST_RETURN(1, 0xFF)

  648. }

  649. 

  650. INST_FUNC(outd)

  651. {

  652.     // TODO

  653.     INST_TAKES_NO_ARGS

  654.     INST_ERROR(ARG_SYNTAX)

  655.     INST_RETURN(1, 0xFF)

  656. }

  657. 

  658. INST_FUNC(outi)

  659. {

  660.     // TODO

  661.     INST_TAKES_NO_ARGS

  662.     INST_ERROR(ARG_SYNTAX)

  663.     INST_RETURN(1, 0xFF)

  664. }

  665. 

  666. INST_FUNC(pop)

  667. {

  668.     // TODO

  669.     INST_TAKES_NO_ARGS

  670.     INST_ERROR(ARG_SYNTAX)

  671.     INST_RETURN(1, 0xFF)

  672. }

  673. 

  674. INST_FUNC(push)

  675. {

  676.     // TODO

  677.     INST_TAKES_NO_ARGS

  678.     INST_ERROR(ARG_SYNTAX)

  679.     INST_RETURN(1, 0xFF)

  680. }

  681. 

  682. INST_FUNC(res)

  683. {

  684.     // TODO

  685.     INST_TAKES_NO_ARGS

  686.     INST_ERROR(ARG_SYNTAX)

  687.     INST_RETURN(1, 0xFF)

  688. }

  689. 

  690. INST_FUNC(ret)

  691. {

  692.     // TODO

  693.     INST_TAKES_NO_ARGS

  694.     INST_ERROR(ARG_SYNTAX)

  695.     INST_RETURN(1, 0xFF)

  696. }

  697. 

  698. INST_FUNC(reti)

  699. {

  700.     INST_TAKES_NO_ARGS

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

  702. }

  703. 

  704. INST_FUNC(retn)

  705. {

  706.     INST_TAKES_NO_ARGS

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

  708. }

  709. 

  710. INST_FUNC(rl)

  711. {

  712.     // TODO

  713.     INST_TAKES_NO_ARGS

  714.     INST_ERROR(ARG_SYNTAX)

  715.     INST_RETURN(1, 0xFF)

  716. }

  717. 

  718. INST_FUNC(rla)

  719. {

  720.     // TODO

  721.     INST_TAKES_NO_ARGS

  722.     INST_ERROR(ARG_SYNTAX)

  723.     INST_RETURN(1, 0xFF)

  724. }

  725. 

  726. INST_FUNC(rlc)

  727. {

  728.     // TODO

  729.     INST_TAKES_NO_ARGS

  730.     INST_ERROR(ARG_SYNTAX)

  731.     INST_RETURN(1, 0xFF)

  732. }

  733. 

  734. INST_FUNC(rlca)

  735. {

  736.     // TODO

  737.     INST_TAKES_NO_ARGS

  738.     INST_ERROR(ARG_SYNTAX)

  739.     INST_RETURN(1, 0xFF)

  740. }

  741. 

  742. INST_FUNC(rld)

  743. {

  744.     // TODO

  745.     INST_TAKES_NO_ARGS

  746.     INST_ERROR(ARG_SYNTAX)

  747.     INST_RETURN(1, 0xFF)

  748. }

  749. 

  750. INST_FUNC(rr)

  751. {

  752.     // TODO

  753.     INST_TAKES_NO_ARGS

  754.     INST_ERROR(ARG_SYNTAX)

  755.     INST_RETURN(1, 0xFF)

  756. }

  757. 

  758. INST_FUNC(rra)

  759. {

  760.     // TODO

  761.     INST_TAKES_NO_ARGS

  762.     INST_ERROR(ARG_SYNTAX)

  763.     INST_RETURN(1, 0xFF)

  764. }

  765. 

  766. INST_FUNC(rrc)

  767. {

  768.     // TODO

  769.     INST_TAKES_NO_ARGS

  770.     INST_ERROR(ARG_SYNTAX)

  771.     INST_RETURN(1, 0xFF)

  772. }

  773. 

  774. INST_FUNC(rrca)

  775. {

  776.     // TODO

  777.     INST_TAKES_NO_ARGS

  778.     INST_ERROR(ARG_SYNTAX)

  779.     INST_RETURN(1, 0xFF)

  780. }

  781. 

  782. INST_FUNC(rrd)

  783. {

  784.     // TODO

  785.     INST_TAKES_NO_ARGS

  786.     INST_ERROR(ARG_SYNTAX)

  787.     INST_RETURN(1, 0xFF)

  788. }

  789. 

  790. INST_FUNC(rst)

  791. {

  792.     // TODO

  793.     INST_TAKES_NO_ARGS

  794.     INST_ERROR(ARG_SYNTAX)

  795.     INST_RETURN(1, 0xFF)

  796. }

  797. 

  798. INST_FUNC(sbc)

  799. {

  800.     // TODO

  801.     INST_TAKES_NO_ARGS

  802.     INST_ERROR(ARG_SYNTAX)

  803.     INST_RETURN(1, 0xFF)

  804. }

  805. 

  806. INST_FUNC(scf)

  807. {

  808.     // TODO

  809.     INST_TAKES_NO_ARGS

  810.     INST_ERROR(ARG_SYNTAX)

  811.     INST_RETURN(1, 0xFF)

  812. }

  813. 

  814. INST_FUNC(set)

  815. {

  816.     // TODO

  817.     INST_TAKES_NO_ARGS

  818.     INST_ERROR(ARG_SYNTAX)

  819.     INST_RETURN(1, 0xFF)

  820. }

  821. 

  822. INST_FUNC(sl1)

  823. {

  824.     // TODO

  825.     INST_TAKES_NO_ARGS

  826.     INST_ERROR(ARG_SYNTAX)

  827.     INST_RETURN(1, 0xFF)

  828. }

  829. 

  830. INST_FUNC(sla)

  831. {

  832.     // TODO

  833.     INST_TAKES_NO_ARGS

  834.     INST_ERROR(ARG_SYNTAX)

  835.     INST_RETURN(1, 0xFF)

  836. }

  837. 

  838. INST_FUNC(sll)

  839. {

  840.     // TODO

  841.     INST_TAKES_NO_ARGS

  842.     INST_ERROR(ARG_SYNTAX)

  843.     INST_RETURN(1, 0xFF)

  844. }

  845. 

  846. INST_FUNC(sls)

  847. {

  848.     // TODO

  849.     INST_TAKES_NO_ARGS

  850.     INST_ERROR(ARG_SYNTAX)

  851.     INST_RETURN(1, 0xFF)

  852. }

  853. 

  854. INST_FUNC(sra)

  855. {

  856.     // TODO

  857.     INST_TAKES_NO_ARGS

  858.     INST_ERROR(ARG_SYNTAX)

  859.     INST_RETURN(1, 0xFF)

  860. }

  861. 

  862. INST_FUNC(srl)

  863. {

  864.     // TODO

  865.     INST_TAKES_NO_ARGS

  866.     INST_ERROR(ARG_SYNTAX)

  867.     INST_RETURN(1, 0xFF)

  868. }

  869. 

  870. INST_FUNC(sub)

  871. {

  872.     // TODO

  873.     INST_TAKES_NO_ARGS

  874.     INST_ERROR(ARG_SYNTAX)

  875.     INST_RETURN(1, 0xFF)

  876. }

  877. 

  878. INST_FUNC(xor)

  879. {

  880.     // TODO

  881.     INST_TAKES_NO_ARGS

  882.     INST_ERROR(ARG_SYNTAX)

  883.     INST_RETURN(1, 0xFF)

  884. }

  885. 

  886. /*

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

  888. 

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

  890. */

  891. ASMInstParser get_inst_parser(char mstr[MAX_MNEMONIC_SIZE])

  892. {

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

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

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

  896. 

  897.     HANDLE(adc)

  898.     HANDLE(add)

  899.     HANDLE(and)

  900.     HANDLE(bit)

  901.     HANDLE(call)

  902.     HANDLE(ccf)

  903.     HANDLE(cp)

  904.     HANDLE(cpd)

  905.     HANDLE(cpdr)

  906.     HANDLE(cpi)

  907.     HANDLE(cpir)

  908.     HANDLE(cpl)

  909.     HANDLE(daa)

  910.     HANDLE(dec)

  911.     HANDLE(di)

  912.     HANDLE(djnz)

  913.     HANDLE(ei)

  914.     HANDLE(ex)

  915.     HANDLE(exx)

  916.     HANDLE(halt)

  917.     HANDLE(im)

  918.     HANDLE(in)

  919.     HANDLE(inc)

  920.     HANDLE(ind)

  921.     HANDLE(indr)

  922.     HANDLE(ini)

  923.     HANDLE(inir)

  924.     HANDLE(jp)

  925.     HANDLE(jr)

  926.     HANDLE(ld)

  927.     HANDLE(ldd)

  928.     HANDLE(lddr)

  929.     HANDLE(ldi)

  930.     HANDLE(ldir)

  931.     HANDLE(neg)

  932.     HANDLE(nop)

  933.     HANDLE(or)

  934.     HANDLE(otdr)

  935.     HANDLE(otir)

  936.     HANDLE(out)

  937.     HANDLE(outd)

  938.     HANDLE(outi)

  939.     HANDLE(pop)

  940.     HANDLE(push)

  941.     HANDLE(res)

  942.     HANDLE(ret)

  943.     HANDLE(reti)

  944.     HANDLE(retn)

  945.     HANDLE(rl)

  946.     HANDLE(rla)

  947.     HANDLE(rlc)

  948.     HANDLE(rlca)

  949.     HANDLE(rld)

  950.     HANDLE(rr)

  951.     HANDLE(rra)

  952.     HANDLE(rrc)

  953.     HANDLE(rrca)

  954.     HANDLE(rrd)

  955.     HANDLE(rst)

  956.     HANDLE(sbc)

  957.     HANDLE(scf)

  958.     HANDLE(set)

  959.     HANDLE(sl1)

  960.     HANDLE(sla)

  961.     HANDLE(sll)

  962.     HANDLE(sls)

  963.     HANDLE(sra)

  964.     HANDLE(srl)

  965.     HANDLE(sub)

  966.     HANDLE(xor)

  967. 

  968.     return NULL;

  969. }