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

792 lines
17 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 "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. }