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.
121 Révisions
2 Branches
2.4 MiB
 
 
 
 
 
Aborescence: 2e2e5d6216
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '2e2e5d6216'
${ noResults }
crater/src/assembler/instructions.c

792 lignes
17 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 "instructions.h"

  5. #include "inst_support.h"

  6. 

  7. /* Instruction parser functions */

  8. 

  9. INST_FUNC(adc)

  10. {

  11.     INST_TAKES_ARGS(2, 2)

  12.     INST_FORCE_TYPE(0, AT_REGISTER)

  13.     switch (INST_REG(0)) {

  14.         case REG_A:

  15.             switch (INST_TYPE(1)) {

  16.                 case AT_REGISTER:

  17.                     switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

  29.                         default: INST_ERROR(ARG1_BAD_REG)

  30.                     }

  31.                 case AT_IMMEDIATE:

  32.                     INST_CHECK_IMM(1, IMM_U8)

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

  34.                 case AT_INDIRECT:

  35.                     INST_INDIRECT_HL_ONLY(1)

  36.                     INST_RETURN(1, 0x8E)

  37.                 case AT_INDEXED:

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

  39.                 default:

  40.                     INST_ERROR(ARG1_TYPE)

  41.             }

  42.         case REG_HL:

  43.             INST_FORCE_TYPE(1, AT_REGISTER)

  44.             switch (INST_REG(1)) {

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

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

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

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

  49.                 default: INST_ERROR(ARG1_BAD_REG)

  50.             }

  51.         default:

  52.             INST_ERROR(ARG0_TYPE)

  53.     }

  54. }

  55. 

  56. INST_FUNC(add)

  57. {

  58.     INST_TAKES_ARGS(2, 2)

  59.     INST_FORCE_TYPE(0, AT_REGISTER)

  60.     switch (INST_REG(0)) {

  61.         case REG_A:

  62.             switch (INST_TYPE(1)) {

  63.                 case AT_REGISTER:

  64.                     switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

  76.                         default: INST_ERROR(ARG1_BAD_REG)

  77.                     }

  78.                 case AT_IMMEDIATE:

  79.                     INST_CHECK_IMM(1, IMM_U8)

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

  81.                 case AT_INDIRECT:

  82.                     INST_INDIRECT_HL_ONLY(1)

  83.                     INST_RETURN(1, 0x86)

  84.                 case AT_INDEXED:

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

  86.                 default:

  87.                     INST_ERROR(ARG1_TYPE)

  88.             }

  89.         case REG_HL:

  90.             INST_FORCE_TYPE(1, AT_REGISTER)

  91.             switch (INST_REG(1)) {

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

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

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

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

  96.                 default: INST_ERROR(ARG1_BAD_REG)

  97.             }

  98.         case REG_IX:

  99.         case REG_IY:

  100.             INST_FORCE_TYPE(1, AT_REGISTER)

  101.             switch (INST_REG(1)) {

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

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

  104.                 case REG_IX:

  105.                 case REG_IY:

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

  107.                         INST_ERROR(ARG1_BAD_REG)

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

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

  110.                 default: INST_ERROR(ARG1_BAD_REG)

  111.             }

  112.         default:

  113.             INST_ERROR(ARG0_TYPE)

  114.     }

  115. }

  116. 

  117. INST_FUNC(and)

  118. {

  119.     // TODO

  120.     INST_TAKES_NO_ARGS

  121.     INST_ERROR(ARG_SYNTAX)

  122.     INST_RETURN(1, 0xFF)

  123. }

  124. 

  125. INST_FUNC(bit)

  126. {

  127.     // TODO

  128.     INST_TAKES_NO_ARGS

  129.     INST_ERROR(ARG_SYNTAX)

  130.     INST_RETURN(1, 0xFF)

  131. }

  132. 

  133. INST_FUNC(call)

  134. {

  135.     // TODO

  136.     INST_TAKES_NO_ARGS

  137.     INST_ERROR(ARG_SYNTAX)

  138.     INST_RETURN(1, 0xFF)

  139. }

  140. 

  141. INST_FUNC(ccf)

  142. {

  143.     INST_TAKES_NO_ARGS

  144.     INST_RETURN(1, 0x3F)

  145. }

  146. 

  147. INST_FUNC(cp)

  148. {

  149.     // TODO

  150.     INST_TAKES_NO_ARGS

  151.     INST_ERROR(ARG_SYNTAX)

  152.     INST_RETURN(1, 0xFF)

  153. }

  154. 

  155. INST_FUNC(cpd)

  156. {

  157.     INST_TAKES_NO_ARGS

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

  159. }

  160. 

  161. INST_FUNC(cpdr)

  162. {

  163.     INST_TAKES_NO_ARGS

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

  165. }

  166. 

  167. INST_FUNC(cpi)

  168. {

  169.     INST_TAKES_NO_ARGS

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

  171. }

  172. 

  173. INST_FUNC(cpir)

  174. {

  175.     INST_TAKES_NO_ARGS

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

  177. }

  178. 

  179. INST_FUNC(cpl)

  180. {

  181.     INST_TAKES_NO_ARGS

  182.     INST_RETURN(1, 0x2F)

  183. }

  184. 

  185. INST_FUNC(daa)

  186. {

  187.     INST_TAKES_NO_ARGS

  188.     INST_RETURN(1, 0x27)

  189. }

  190. 

  191. INST_FUNC(dec)

  192. {

  193.     // TODO

  194.     INST_TAKES_NO_ARGS

  195.     INST_ERROR(ARG_SYNTAX)

  196.     INST_RETURN(1, 0xFF)

  197. }

  198. 

  199. INST_FUNC(di)

  200. {

  201.     INST_TAKES_NO_ARGS

  202.     INST_RETURN(1, 0xF3)

  203. }

  204. 

  205. INST_FUNC(djnz)

  206. {

  207.     // TODO

  208.     INST_TAKES_NO_ARGS

  209.     INST_ERROR(ARG_SYNTAX)

  210.     INST_RETURN(1, 0xFF)

  211. }

  212. 

  213. INST_FUNC(ei)

  214. {

  215.     INST_TAKES_NO_ARGS

  216.     INST_RETURN(1, 0xFB)

  217. }

  218. 

  219. INST_FUNC(ex)

  220. {

  221.     // TODO

  222.     INST_TAKES_NO_ARGS

  223.     INST_ERROR(ARG_SYNTAX)

  224.     INST_RETURN(1, 0xFF)

  225. }

  226. 

  227. INST_FUNC(exx)

  228. {

  229.     INST_TAKES_NO_ARGS

  230.     INST_RETURN(1, 0xD9)

  231. }

  232. 

  233. INST_FUNC(halt)

  234. {

  235.     INST_TAKES_NO_ARGS

  236.     INST_RETURN(1, 0x76)

  237. }

  238. 

  239. INST_FUNC(im)

  240. {

  241.     // TODO

  242.     INST_TAKES_NO_ARGS

  243.     INST_ERROR(ARG_SYNTAX)

  244.     INST_RETURN(1, 0xFF)

  245. }

  246. 

  247. INST_FUNC(in)

  248. {

  249.     // TODO

  250.     INST_TAKES_NO_ARGS

  251.     INST_ERROR(ARG_SYNTAX)

  252.     INST_RETURN(1, 0xFF)

  253. }

  254. 

  255. INST_FUNC(inc)

  256. {

  257.     INST_TAKES_ARGS(1, 1)

  258.     switch (INST_TYPE(0)) {

  259.         case AT_REGISTER:

  260.             switch (INST_REG(0)) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  278.                 default: INST_ERROR(ARG0_BAD_REG)

  279.             }

  280.         case AT_INDIRECT:

  281.             INST_INDIRECT_HL_ONLY(0)

  282.             INST_RETURN(1, 0x34)

  283.         case AT_INDEXED:

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

  285.         default:

  286.             INST_ERROR(ARG0_TYPE)

  287.     }

  288. }

  289. 

  290. INST_FUNC(ind)

  291. {

  292.     INST_TAKES_NO_ARGS

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

  294. }

  295. 

  296. INST_FUNC(indr)

  297. {

  298.     INST_TAKES_NO_ARGS

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

  300. }

  301. 

  302. INST_FUNC(ini)

  303. {

  304.     INST_TAKES_NO_ARGS

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

  306. }

  307. 

  308. INST_FUNC(inir)

  309. {

  310.     INST_TAKES_NO_ARGS

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

  312. }

  313. 

  314. INST_FUNC(jp)

  315. {

  316.     // TODO

  317.     INST_TAKES_NO_ARGS

  318.     INST_ERROR(ARG_SYNTAX)

  319.     INST_RETURN(1, 0xFF)

  320. }

  321. 

  322. INST_FUNC(jr)

  323. {

  324.     // TODO

  325.     INST_TAKES_NO_ARGS

  326.     INST_ERROR(ARG_SYNTAX)

  327.     INST_RETURN(1, 0xFF)

  328. }

  329. 

  330. INST_FUNC(ld)

  331. {

  332.     INST_TAKES_ARGS(2, 2)

  333.     switch (INST_TYPE(0)) {

  334.         case AT_REGISTER:

  335.             switch (INST_REG(0)) {

  336.                 case REG_A:

  337.                     switch (INST_TYPE(1)) {

  338.                         case AT_REGISTER:

  339.                             switch (INST_REG(1)) {

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

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

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

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

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

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

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

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

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

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

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

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

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

  353.                                 default: INST_ERROR(ARG1_BAD_REG)

  354.                             }

  355.                         case AT_IMMEDIATE:

  356.                             INST_CHECK_IMM(1, IMM_U8)

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

  358.                         case AT_INDIRECT:

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

  360.                                 case AT_REGISTER:

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

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

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

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

  365.                                         default: INST_ERROR(ARG0_BAD_REG)

  366.                                     }

  367.                                 case AT_IMMEDIATE:

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

  369.                                 case AT_LABEL:

  370.                                     INST_RETURN_INDIRECT_LABEL(1, 3, 0x3A)

  371.                                 default:

  372.                                     INST_ERROR(ARG0_TYPE)

  373.                             }

  374.                         case AT_INDEXED:

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

  376.                         default:

  377.                             INST_ERROR(ARG1_TYPE)

  378.                     }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  397.                 default: INST_ERROR(ARG0_BAD_REG)

  398.             }

  399.         case AT_INDIRECT:

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

  401.                 case AT_REGISTER:

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

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

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

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

  406.                         default: INST_ERROR(ARG0_BAD_REG)

  407.                     }

  408.                 case AT_IMMEDIATE:

  409.                     // TODO (8 cases)

  410.                 case AT_LABEL:

  411.                     // TODO (same 8 cases)

  412.                 default:

  413.                     INST_ERROR(ARG0_TYPE)

  414.             }

  415.         case AT_INDEXED:

  416.             // TODO (16 cases)

  417.         default:

  418.             INST_ERROR(ARG0_TYPE)

  419.     }

  420. }

  421. 

  422. INST_FUNC(ldd)

  423. {

  424.     INST_TAKES_NO_ARGS

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

  426. }

  427. 

  428. INST_FUNC(lddr)

  429. {

  430.     INST_TAKES_NO_ARGS

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

  432. }

  433. 

  434. INST_FUNC(ldi)

  435. {

  436.     INST_TAKES_NO_ARGS

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

  438. }

  439. 

  440. INST_FUNC(ldir)

  441. {

  442.     INST_TAKES_NO_ARGS

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

  444. }

  445. 

  446. INST_FUNC(neg)

  447. {

  448.     // TODO

  449.     INST_TAKES_NO_ARGS

  450.     INST_ERROR(ARG_SYNTAX)

  451.     INST_RETURN(1, 0xFF)

  452. }

  453. 

  454. INST_FUNC(nop)

  455. {

  456.     INST_TAKES_NO_ARGS

  457.     INST_RETURN(1, 0x00)

  458. }

  459. 

  460. INST_FUNC(or)

  461. {

  462.     // TODO

  463.     INST_TAKES_NO_ARGS

  464.     INST_ERROR(ARG_SYNTAX)

  465.     INST_RETURN(1, 0xFF)

  466. }

  467. 

  468. INST_FUNC(otdr)

  469. {

  470.     INST_TAKES_NO_ARGS

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

  472. }

  473. 

  474. INST_FUNC(otir)

  475. {

  476.     INST_TAKES_NO_ARGS

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

  478. }

  479. 

  480. INST_FUNC(out)

  481. {

  482.     // TODO

  483.     INST_TAKES_NO_ARGS

  484.     INST_ERROR(ARG_SYNTAX)

  485.     INST_RETURN(1, 0xFF)

  486. }

  487. 

  488. INST_FUNC(outd)

  489. {

  490.     INST_TAKES_NO_ARGS

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

  492. }

  493. 

  494. INST_FUNC(outi)

  495. {

  496.     INST_TAKES_NO_ARGS

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

  498. }

  499. 

  500. INST_FUNC(pop)

  501. {

  502.     // TODO

  503.     INST_TAKES_NO_ARGS

  504.     INST_ERROR(ARG_SYNTAX)

  505.     INST_RETURN(1, 0xFF)

  506. }

  507. 

  508. INST_FUNC(push)

  509. {

  510.     // TODO

  511.     INST_TAKES_NO_ARGS

  512.     INST_ERROR(ARG_SYNTAX)

  513.     INST_RETURN(1, 0xFF)

  514. }

  515. 

  516. INST_FUNC(res)

  517. {

  518.     // TODO

  519.     INST_TAKES_NO_ARGS

  520.     INST_ERROR(ARG_SYNTAX)

  521.     INST_RETURN(1, 0xFF)

  522. }

  523. 

  524. INST_FUNC(ret)

  525. {

  526.     // TODO

  527.     INST_TAKES_NO_ARGS

  528.     INST_ERROR(ARG_SYNTAX)

  529.     INST_RETURN(1, 0xFF)

  530. }

  531. 

  532. INST_FUNC(reti)

  533. {

  534.     INST_TAKES_NO_ARGS

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

  536. }

  537. 

  538. INST_FUNC(retn)

  539. {

  540.     INST_TAKES_NO_ARGS

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

  542. }

  543. 

  544. INST_FUNC(rl)

  545. {

  546.     // TODO

  547.     INST_TAKES_NO_ARGS

  548.     INST_ERROR(ARG_SYNTAX)

  549.     INST_RETURN(1, 0xFF)

  550. }

  551. 

  552. INST_FUNC(rla)

  553. {

  554.     INST_TAKES_NO_ARGS

  555.     INST_RETURN(1, 0x17)

  556. }

  557. 

  558. INST_FUNC(rlc)

  559. {

  560.     // TODO

  561.     INST_TAKES_NO_ARGS

  562.     INST_ERROR(ARG_SYNTAX)

  563.     INST_RETURN(1, 0xFF)

  564. }

  565. 

  566. INST_FUNC(rlca)

  567. {

  568.     INST_TAKES_NO_ARGS

  569.     INST_RETURN(1, 0x07)

  570. }

  571. 

  572. INST_FUNC(rld)

  573. {

  574.     INST_TAKES_NO_ARGS

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

  576. }

  577. 

  578. INST_FUNC(rr)

  579. {

  580.     // TODO

  581.     INST_TAKES_NO_ARGS

  582.     INST_ERROR(ARG_SYNTAX)

  583.     INST_RETURN(1, 0xFF)

  584. }

  585. 

  586. INST_FUNC(rra)

  587. {

  588.     INST_TAKES_NO_ARGS

  589.     INST_RETURN(1, 0x1F)

  590. }

  591. 

  592. INST_FUNC(rrc)

  593. {

  594.     // TODO

  595.     INST_TAKES_NO_ARGS

  596.     INST_ERROR(ARG_SYNTAX)

  597.     INST_RETURN(1, 0xFF)

  598. }

  599. 

  600. INST_FUNC(rrca)

  601. {

  602.     INST_TAKES_NO_ARGS

  603.     INST_RETURN(1, 0x0F)

  604. }

  605. 

  606. INST_FUNC(rrd)

  607. {

  608.     // TODO

  609.     INST_TAKES_NO_ARGS

  610.     INST_ERROR(ARG_SYNTAX)

  611.     INST_RETURN(1, 0xFF)

  612. }

  613. 

  614. INST_FUNC(rst)

  615. {

  616.     // TODO

  617.     INST_TAKES_NO_ARGS

  618.     INST_ERROR(ARG_SYNTAX)

  619.     INST_RETURN(1, 0xFF)

  620. }

  621. 

  622. INST_FUNC(sbc)

  623. {

  624.     // TODO

  625.     INST_TAKES_NO_ARGS

  626.     INST_ERROR(ARG_SYNTAX)

  627.     INST_RETURN(1, 0xFF)

  628. }

  629. 

  630. INST_FUNC(scf)

  631. {

  632.     INST_TAKES_NO_ARGS

  633.     INST_RETURN(1, 0x37)

  634. }

  635. 

  636. INST_FUNC(set)

  637. {

  638.     // TODO

  639.     INST_TAKES_NO_ARGS

  640.     INST_ERROR(ARG_SYNTAX)

  641.     INST_RETURN(1, 0xFF)

  642. }

  643. 

  644. INST_FUNC(sl1)

  645. {

  646.     // TODO

  647.     INST_TAKES_NO_ARGS

  648.     INST_ERROR(ARG_SYNTAX)

  649.     INST_RETURN(1, 0xFF)

  650. }

  651. 

  652. INST_FUNC(sla)

  653. {

  654.     // TODO

  655.     INST_TAKES_NO_ARGS

  656.     INST_ERROR(ARG_SYNTAX)

  657.     INST_RETURN(1, 0xFF)

  658. }

  659. 

  660. INST_FUNC(sll)

  661. {

  662.     // TODO

  663.     INST_TAKES_NO_ARGS

  664.     INST_ERROR(ARG_SYNTAX)

  665.     INST_RETURN(1, 0xFF)

  666. }

  667. 

  668. INST_FUNC(sls)

  669. {

  670.     // TODO

  671.     INST_TAKES_NO_ARGS

  672.     INST_ERROR(ARG_SYNTAX)

  673.     INST_RETURN(1, 0xFF)

  674. }

  675. 

  676. INST_FUNC(sra)

  677. {

  678.     // TODO

  679.     INST_TAKES_NO_ARGS

  680.     INST_ERROR(ARG_SYNTAX)

  681.     INST_RETURN(1, 0xFF)

  682. }

  683. 

  684. INST_FUNC(srl)

  685. {

  686.     // TODO

  687.     INST_TAKES_NO_ARGS

  688.     INST_ERROR(ARG_SYNTAX)

  689.     INST_RETURN(1, 0xFF)

  690. }

  691. 

  692. INST_FUNC(sub)

  693. {

  694.     // TODO

  695.     INST_TAKES_NO_ARGS

  696.     INST_ERROR(ARG_SYNTAX)

  697.     INST_RETURN(1, 0xFF)

  698. }

  699. 

  700. INST_FUNC(xor)

  701. {

  702.     // TODO

  703.     INST_TAKES_NO_ARGS

  704.     INST_ERROR(ARG_SYNTAX)

  705.     INST_RETURN(1, 0xFF)

  706. }

  707. 

  708. /*

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

  710. 

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

  712. */

  713. ASMInstParser get_inst_parser(char mstr[MAX_MNEMONIC_SIZE])

  714. {

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

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

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

  718. 

  719.     HANDLE(adc)

  720.     HANDLE(add)

  721.     HANDLE(and)

  722.     HANDLE(bit)

  723.     HANDLE(call)

  724.     HANDLE(ccf)

  725.     HANDLE(cp)

  726.     HANDLE(cpd)

  727.     HANDLE(cpdr)

  728.     HANDLE(cpi)

  729.     HANDLE(cpir)

  730.     HANDLE(cpl)

  731.     HANDLE(daa)

  732.     HANDLE(dec)

  733.     HANDLE(di)

  734.     HANDLE(djnz)

  735.     HANDLE(ei)

  736.     HANDLE(ex)

  737.     HANDLE(exx)

  738.     HANDLE(halt)

  739.     HANDLE(im)

  740.     HANDLE(in)

  741.     HANDLE(inc)

  742.     HANDLE(ind)

  743.     HANDLE(indr)

  744.     HANDLE(ini)

  745.     HANDLE(inir)

  746.     HANDLE(jp)

  747.     HANDLE(jr)

  748.     HANDLE(ld)

  749.     HANDLE(ldd)

  750.     HANDLE(lddr)

  751.     HANDLE(ldi)

  752.     HANDLE(ldir)

  753.     HANDLE(neg)

  754.     HANDLE(nop)

  755.     HANDLE(or)

  756.     HANDLE(otdr)

  757.     HANDLE(otir)

  758.     HANDLE(out)

  759.     HANDLE(outd)

  760.     HANDLE(outi)

  761.     HANDLE(pop)

  762.     HANDLE(push)

  763.     HANDLE(res)

  764.     HANDLE(ret)

  765.     HANDLE(reti)

  766.     HANDLE(retn)

  767.     HANDLE(rl)

  768.     HANDLE(rla)

  769.     HANDLE(rlc)

  770.     HANDLE(rlca)

  771.     HANDLE(rld)

  772.     HANDLE(rr)

  773.     HANDLE(rra)

  774.     HANDLE(rrc)

  775.     HANDLE(rrca)

  776.     HANDLE(rrd)

  777.     HANDLE(rst)

  778.     HANDLE(sbc)

  779.     HANDLE(scf)

  780.     HANDLE(set)

  781.     HANDLE(sl1)

  782.     HANDLE(sla)

  783.     HANDLE(sll)

  784.     HANDLE(sls)

  785.     HANDLE(sra)

  786.     HANDLE(srl)

  787.     HANDLE(sub)

  788.     HANDLE(xor)

  789. 

  790.     return NULL;

  791. }