home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2038 < prev    next >
Internet Message Format  |  1990-12-28  |  46KB
  1. From: mrapple@quack.sac.ca.us (Nick Sayer)
  2. Newsgroups: alt.sources
  3. Subject: Z-80 emulator in C with CP/M BIOS (part 2/2)
  4. Message-ID: <kDCdLS0@quack.sac.ca.us>
  5. Date: 8 Nov 90 17:18:49 GMT
  6.  
  7.  
  8. #!/bin/sh
  9. # this is foo.02 (part 2 of a multipart archive)
  10. # do not concatenate these parts, unpack them in order with /bin/sh
  11. # file z80.c continued
  12. #
  13. if touch 2>&1 | fgrep '[-amc]' > /dev/null
  14.  then TOUCH=touch
  15.  else TOUCH=true
  16. fi
  17. if test ! -r shar3_seq_.tmp; then
  18.     echo "Please unpack part 1 first!"
  19.     exit 1
  20. fi
  21. (read Scheck
  22.  if test "$Scheck" != 2; then
  23.     echo "Please unpack part $Scheck next!"
  24.     exit 1
  25.  else
  26.     exit 0
  27.  fi
  28. ) < shar3_seq_.tmp || exit 1
  29. echo "x - Continuing file z80.c"
  30. sed 's/^X//' << 'SHAR_EOF' >> z80.c &&
  31. X
  32. X/* If last instruction was a HALT, we're out of here - NOT what a real
  33. X   Z-80 does, of course. */
  34. X 
  35. X  }
  36. X  while (!STOP_FLAG);
  37. X}
  38. X
  39. Xz80_instr()
  40. X{
  41. X  BYTE opcode,op_p1,op_p2,op_p3,op_p13;
  42. X
  43. X  opcode=z80_mem(PC++);
  44. X  op_p1=opcode&0x7;                /* Piece 1 - bottom 3 bits */
  45. X  op_p2=(opcode&0x38)>>3;          /* Piece 2 - middle 3 bits */
  46. X  op_p3=(opcode&0xC0)>>6;          /* Piece 3 - top 2 bits */
  47. X  op_p13=(opcode&0xC7);            /* Piece 1 and 3 OR'ed */
  48. X
  49. X/*
  50. X
  51. XNow we perform what amounts to just a bunch of ifs...
  52. X
  53. XSections noted as Z-80 only are not present on the 8080. To make
  54. Xan 8080 interpreter, comment these sections out. This is not
  55. Xstrictly necessary, however, since an 8080 program (e.g. CP/M)
  56. Xwill run just fine on a Z-80.
  57. X
  58. XFirst take care of the multi-byte opcodes. These are Z-80 only.
  59. X
  60. X*/
  61. X
  62. X  if (opcode==0xCB)
  63. X  {
  64. X    dlog("CB:");
  65. X    cb_ops(HL); /* see notes in z80_cbed.c */
  66. X    return;
  67. X  }
  68. X  if (opcode==0xFD || opcode==0xDD)
  69. X  {
  70. X    dlog(opcode==0xFD?"FD:":"DD:");
  71. X    ixy_ops(opcode==0xFD); /* pass 1 if IY */
  72. X    return;
  73. X  }
  74. X  if (opcode==0xED)
  75. X  {
  76. X    dlog("ED:");
  77. X    ed_ops();
  78. X    return;
  79. X  }
  80. X  
  81. X/*
  82. X
  83. XNOP & HALT
  84. X
  85. X*/
  86. X
  87. X  if (opcode==0x00) /* NOP */
  88. X    {
  89. X      dlog("NOP\n");
  90. X      return;
  91. X    }
  92. X
  93. X  if (opcode==0x76) /* HALT */
  94. X  {
  95. X    STOP_FLAG++;
  96. X    PC--;
  97. X    dlog("HALT\n");
  98. X    return;
  99. X  }
  100. X
  101. X/*
  102. X
  103. XInterrupt control: EI, DI
  104. X
  105. X*/
  106. X
  107. X  if (opcode==0xFB) /* EI */
  108. X  {
  109. X    INT_FLAGS|=0x20; /* counter decremented after this & next instr */
  110. X    dlog("EI\n");
  111. X    return;
  112. X  }
  113. X
  114. X  if (opcode==0xF3) /* DI */
  115. X  {
  116. X    INT_FLAGS&=~(IFF1|IFF2);
  117. X    dlog("DI\n");
  118. X    return;
  119. X  }
  120. X/*
  121. X
  122. XExchange group: EX, EXX
  123. X
  124. X*/
  125. X
  126. X  if (opcode==0x08) /* EX AF,AF' [Z-80 only] */
  127. X  {
  128. X    register WORD temp;
  129. X    temp=AF; AF=AF2; AF2=temp;
  130. X    dlog("EX AF,AF'\n");
  131. X    return;
  132. X  }
  133. X  if (opcode==0xEB) /* EX DE,HL */
  134. X  {
  135. X    register WORD temp;
  136. X    temp=DE; DE=HL; HL=temp;
  137. X    dlog("EX DE,HL\n");
  138. X    return;
  139. X  }
  140. X  if (opcode==0xE3) /* EX (SP),HL */
  141. X  {
  142. X    register WORD temp;
  143. X    temp=z80_mem(SP)|(z80_mem(SP+1)<<8);
  144. X    wr_z80_mem(SP,HL&0xff); wr_z80_mem(SP+1,HL>>8);
  145. X    HL=temp;
  146. X    dlog("EX (SP),HL\n");
  147. X    return;
  148. X  }
  149. X  if (opcode==0xD9) /* EXX [Z-80 only] */
  150. X  {
  151. X    register WORD temp;
  152. X    temp=BC; BC=BC2; BC2=temp;
  153. X    temp=DE; DE=DE2; DE2=temp;
  154. X    temp=HL; HL=HL2; HL2=temp;
  155. X    dlog("EXX\n");
  156. X    return;
  157. X  }
  158. X
  159. X/*
  160. X
  161. XExecution control: JP, JR, CALL, RET, RST
  162. X
  163. X*/
  164. X
  165. X  if (opcode==0xC3) /* JP uncond */
  166. X  {
  167. X    register WORD operand;
  168. X
  169. X    operand=z80_mem(PC++);
  170. X    operand|=z80_mem(PC++)<<8;
  171. X    PC=operand;
  172. X    dlog("JP 0x%04x\n",PC);
  173. X    return;
  174. X  }
  175. X
  176. X  if (op_p13==0xC2) /* JP conditional */
  177. X  {
  178. X    register WORD operand;
  179. X
  180. X    operand=z80_mem(PC++);
  181. X    operand|=z80_mem(PC++)<<8;
  182. X    switch(op_p2)
  183. X    {
  184. X      case 0: if (~AF&FLAG_Z)
  185. X                PC=operand;
  186. X      break;
  187. X      case 1: if (AF&FLAG_Z)
  188. X                PC=operand;
  189. X      break;
  190. X      case 2: if (~AF&FLAG_C)
  191. X                PC=operand;
  192. X      break;
  193. X      case 3: if (AF&FLAG_C)
  194. X                PC=operand;
  195. X      break;
  196. X      case 4: if (~AF&FLAG_PV)
  197. X                PC=operand;
  198. X      break;
  199. X      case 5: if (AF&FLAG_PV)
  200. X                PC=operand;
  201. X      break;
  202. X      case 6: if (~AF&FLAG_S)
  203. X                PC=operand;
  204. X      break;
  205. X      case 7: if (AF&FLAG_S)
  206. X                PC=operand;
  207. X    }   
  208. X    dlog("JP %c%c, 0x%04x\n",
  209. X     "NZ ZNC CPOPE P M"[(op_p2<<1)],
  210. X     "NZ ZNC CPOPE P M"[(op_p2<<1)+1],
  211. X     operand);
  212. X    return;
  213. X  }
  214. X
  215. X  if (opcode==0xE9) /* JP (HL) */
  216. X  {
  217. X    PC=HL;  /* The old 8080 called this instruction "PCHL" */
  218. X    dlog("JP (HL)\n");
  219. X    return;
  220. X  }
  221. X
  222. X  if (opcode==0x10) /* DJNZ [Z-80 only] */
  223. X  {
  224. X    register BYTE operand;
  225. X
  226. X    operand=z80_mem(PC++);
  227. X    BC-= 0x100;  /* B-- */
  228. X    if ( BC>>8 )
  229. X      DO_JR;
  230. X    dlog("DJNZ 0x%04x\n",PC);
  231. X    return;
  232. X  }
  233. X
  234. X  if (opcode==0x18) /* JR [Z-80 only] */
  235. X  {
  236. X    register BYTE operand;
  237. X
  238. X    operand=z80_mem(PC++);
  239. X    DO_JR;
  240. X    dlog("JR 0x%04x\n",PC);
  241. X    return;
  242. X  }
  243. X
  244. X  if ((opcode&0xE7)==0x20) /* JR cond [Z-80 only] */
  245. X  {
  246. X    register BYTE operand;
  247. X
  248. X    operand=z80_mem(PC++);
  249. X
  250. X/* if the flag in question is false and the 4th bit is false */
  251. X
  252. X#define XOR(a,b) ( (a!=0) != (b!=0) ) /* logical XOR, not standard C */
  253. X
  254. X    if ( XOR ( (AF&((opcode&0x10)?FLAG_C:FLAG_Z)) , !(opcode&0x08) ) )
  255. X      DO_JR;
  256. X    dlog("JR %d,0x%04x\n",opcode,PC);
  257. X    return;
  258. X  }
  259. X
  260. X  if (opcode==0xCD) /* CALL */
  261. X  {
  262. X    register WORD operand;
  263. X
  264. X    operand=z80_mem(PC++);
  265. X    operand|=z80_mem(PC++)<<8;
  266. X    push(PC);
  267. X    PC=operand;
  268. X    dlog("CALL 0x%04x\n",PC);
  269. X    return;
  270. X  }
  271. X
  272. X  if (op_p13==0xC4) /* CALL cond */
  273. X  {
  274. X    register WORD operand;
  275. X
  276. X    operand=z80_mem(PC++);
  277. X    operand|=z80_mem(PC++)<<8;
  278. X
  279. X    switch(op_p2)
  280. X    {
  281. X      case 0:if (~AF&FLAG_Z)
  282. X         {
  283. X           push(PC);
  284. X           PC=operand;
  285. X             }
  286. X      break;
  287. X      case 1:if (AF&FLAG_Z)
  288. X         {
  289. X           push(PC);
  290. X           PC=operand;
  291. X             }
  292. X      break;
  293. X      case 2:if (~AF&FLAG_C)
  294. X         {
  295. X           push(PC);
  296. X           PC=operand;
  297. X         }
  298. X      break;
  299. X      case 3:if (AF&FLAG_C)
  300. X         {
  301. X           push(PC);
  302. X           PC=operand;
  303. X             }
  304. X      break;
  305. X      case 4:if (~AF&FLAG_PV)
  306. X         {
  307. X           push(PC);
  308. X           PC=operand;
  309. X         }
  310. X      break;
  311. X      case 5:if (AF&FLAG_PV)
  312. X         {
  313. X           push(PC);
  314. X           PC=operand;
  315. X         }
  316. X      break;
  317. X      case 6:if (~AF&FLAG_S)
  318. X         {
  319. X           push(PC);
  320. X           PC=operand;
  321. X         }
  322. X      break;
  323. X      case 7:if (AF&FLAG_S)
  324. X         {
  325. X           push(PC);
  326. X           PC=operand;
  327. X         }
  328. X      break;
  329. X    }
  330. X    dlog("CALL %c%c, 0x%04x\n","NZ ZNC CPOPE P M"[(op_p2<<1)],
  331. X     "NZ ZNC CPOPE P M"[(op_p2<<1)+1],
  332. X     PC);    
  333. X    return;
  334. X  }
  335. X
  336. X  if (opcode==0xC9) /* RET */
  337. X  {
  338. X    PC=pop();
  339. X    dlog("RET\n");
  340. X    return;
  341. X  }
  342. X
  343. X  if (op_p13==0xC0) /* RET cond */
  344. X  {
  345. X    switch(op_p2)
  346. X    {
  347. X      case 0:if (~AF&FLAG_Z)
  348. X           PC=pop();
  349. X      break;
  350. X      case 1:if (AF&FLAG_Z)
  351. X           PC=pop();
  352. X      break;
  353. X      case 2:if (~AF&FLAG_C)
  354. X           PC=pop();
  355. X      break;
  356. X      case 3:if (AF&FLAG_C)
  357. X           PC=pop();
  358. X      break;
  359. X      case 4:if (~AF&FLAG_PV)
  360. X           PC=pop();
  361. X      break;
  362. X      case 5:if (AF&FLAG_PV)
  363. X           PC=pop();
  364. X      break;
  365. X      case 6:if (~AF&FLAG_S)
  366. X           PC=pop();
  367. X      break;
  368. X      case 7:if (AF&FLAG_S)
  369. X           PC=pop();
  370. X      break;
  371. X    }
  372. X    dlog("RET %c%c\n","NZ ZNC CPOPE P M"[op_p2<<1],
  373. X     "NZ ZNC CPOPE P M"[(op_p2<<1)+1]);
  374. X    return;
  375. X  }
  376. X
  377. X  if (op_p13==0xC7) /* RST ?? */
  378. X  {
  379. X    push(PC);
  380. X    PC=op_p2<<3;
  381. X    dlog("RST 0x%02x\n",PC);
  382. X    return;
  383. X  }
  384. X
  385. X/*
  386. X
  387. XLD
  388. X
  389. X*/
  390. X
  391. X  if (opcode==0x3A) /* LD A,(imm) */
  392. X  {
  393. X    register WORD operand;
  394. X
  395. X    operand=z80_mem(PC++);
  396. X    operand|=z80_mem(PC++)<<8;
  397. X    AF=(AF&0x00ff)|z80_mem(operand)<<8;
  398. X    dlog("LD A,(0x%04x)\n",operand);
  399. X    return;
  400. X  }
  401. X  if (opcode==0x32) /* LD (imm),A */
  402. X  {
  403. X    register WORD operand;
  404. X
  405. X    operand=z80_mem(PC++);
  406. X    operand|=z80_mem(PC++)<<8;
  407. X    wr_z80_mem(operand,AF>>8);
  408. X    dlog("LD (0x%04x),A\n",operand);
  409. X    return;
  410. X  }
  411. X  if ((opcode&0xEF)==0x0A) /* LD A,(rp) */
  412. X  {
  413. X    AF=(AF&0xff)|z80_mem((opcode&0x10)?DE:BC)<<8;
  414. X    dlog("LD A,(%s)\n",(opcode&0x10)?"DE":"BC");
  415. X    return;
  416. X  }
  417. X  if ((opcode&0xEF)==0x02) /* LD (rp),A */
  418. X  {
  419. X    wr_z80_mem((opcode&0x10)?DE:BC,AF>>8);
  420. X    dlog("LD (%s),A\n",(opcode&0x10)?"DE":"BC");
  421. X    return;
  422. X  }
  423. X  if (op_p3==0x1) /* LD reg,reg [and (HL) too] */
  424. X  {
  425. X    register BYTE value;
  426. X    switch(op_p1)
  427. X    {
  428. X      case 0:value=BC>>8;       break;
  429. X      case 1:value=BC&0xff;     break;
  430. X      case 2:value=DE>>8;       break;
  431. X      case 3:value=DE&0xff;     break;
  432. X      case 4:value=HL>>8;       break;
  433. X      case 5:value=HL&0xff;     break;
  434. X      case 6:value=z80_mem(HL); break;
  435. X      case 7:value=AF>>8;       break;
  436. X    }
  437. X    switch(op_p2)
  438. X    {
  439. X      case 0:BC=(BC&0xff)|(value<<8);  break;
  440. X      case 1:BC=(BC&0xff00)|value;     break;
  441. X      case 2:DE=(DE&0xff)|(value<<8);  break;
  442. X      case 3:DE=(DE&0xff00)|value;     break;
  443. X      case 4:HL=(HL&0xff)|(value<<8);  break;
  444. X      case 5:HL=(HL&0xff00)|value;     break;
  445. X      case 6:wr_z80_mem(HL,value);     break;
  446. X      case 7:AF=(AF&0xff)|(value<<8);  break;
  447. X    }
  448. X    dlog("LD %c,%c\n","BCDEHLMA"[op_p2],"BCDEHLMA"[op_p1]);
  449. X    return;
  450. X  }
  451. X  if (opcode==0x2A) /* LD HL,(imm) */
  452. X  {
  453. X    register WORD operand;
  454. X
  455. X    operand=z80_mem(PC++);
  456. X    operand|=z80_mem(PC++)<<8;
  457. X    HL=z80_mem(operand)|(z80_mem(operand+1)<<8);
  458. X    dlog("LD HL,(0x%04x)\n",operand);
  459. X    return;
  460. X  }
  461. X  if (opcode==0x22) /* LD (imm),HL */
  462. X  {
  463. X    register WORD operand;
  464. X
  465. X    operand=z80_mem(PC++);
  466. X    operand|=z80_mem(PC++)<<8;
  467. X    wr_z80_mem(operand,HL&0xff);
  468. X    wr_z80_mem(operand+1,HL>>8);
  469. X    dlog("LD (0x%04x),HL\n",operand);
  470. X    return;
  471. X  }
  472. X  if (op_p13==0x06) /* LD reg,imm and LD (HL),imm */
  473. X  {
  474. X    register BYTE operand;
  475. X
  476. X    operand=z80_mem(PC++);
  477. X
  478. X    switch (op_p2)
  479. X    {
  480. X      case 0:BC=(BC&0xff)|(operand<<8);
  481. X      break;
  482. X      case 1:BC=(BC&0xff00)|operand;
  483. X      break;
  484. X      case 2:DE=(DE&0xff)|(operand<<8);
  485. X      break;
  486. X      case 3:DE=(DE&0xFF00)|operand;
  487. X      break;
  488. X      case 4:HL=(HL&0xff)|(operand<<8);
  489. X      break;
  490. X      case 5:HL=(HL&0xff00)|operand;
  491. X      break;
  492. X      case 6:wr_z80_mem(HL,operand);
  493. X      break;
  494. X      case 7:AF=(AF&0xff)|(operand<<8);
  495. X      break;
  496. X    }
  497. X    dlog("LD %c,0x%x\n","BCDEHLMA"[op_p2],operand);
  498. X    return;
  499. X  }
  500. X  if ((opcode&0xCF)==0x01) /* LD rp,imm */
  501. X  {
  502. X    register WORD operand;
  503. X
  504. X    operand=z80_mem(PC++);
  505. X    operand|=z80_mem(PC++)<<8;
  506. X
  507. X    switch ((opcode&0x30)>>4)
  508. X    {
  509. X      case 0:BC=operand;
  510. X    dlog("LD BC,");
  511. X      break;
  512. X      case 1:DE=operand;
  513. X    dlog("LD DE,");
  514. X      break;
  515. X      case 2:HL=operand;
  516. X    dlog("LD HL,");
  517. X      break;
  518. X      case 3:SP=operand;
  519. X    dlog("LD SP,");
  520. X      break;
  521. X    }
  522. X    dlog("0x%04x\n",operand);
  523. X    return;
  524. X  }
  525. X  if (opcode==0xF9) /* LD SP,HL */
  526. X  {
  527. X    SP=HL;
  528. X    dlog("LD SP,HL\n");
  529. X    return;
  530. X  }
  531. X
  532. X/*
  533. X
  534. XPUSH & POP
  535. X
  536. X*/
  537. X
  538. X  if ((opcode&0xCF)==0xC5) /* PUSH rp */
  539. X  {
  540. X    switch ((opcode>>4)&3)
  541. X    {
  542. X      case 0:push(BC); break;
  543. X      case 1:push(DE); break;
  544. X      case 2:push(HL); break;
  545. X      case 3:push(AF); break;
  546. X      break;
  547. X    }
  548. X    dlog("PUSH %c%c\n","BDHA"[(opcode>>4)&3],"CELF"[(opcode>>4)&3]);
  549. X    return;
  550. X  }
  551. X
  552. X  if ((opcode&0xCF)==0xC1) /* POP rp */
  553. X  {
  554. X    switch ((opcode>>4)&3)
  555. X    {
  556. X      case 0:BC=pop(); break;
  557. X      case 1:DE=pop(); break;
  558. X      case 2:HL=pop(); break;
  559. X      case 3:AF=pop(); break;
  560. X      break;
  561. X    }
  562. X    dlog("POP %c%c\n","BDHA"[(opcode>>4)&3],"CELF"[(opcode>>4)&3]);
  563. X    return;
  564. X  }
  565. X
  566. X/*
  567. X
  568. XMATH & LOGICAL instructions
  569. X
  570. X*/
  571. X
  572. X  if (op_p13==0x03) /* 16 bit INC/DEC */
  573. X  {
  574. X    switch(op_p2>>1)
  575. X    {
  576. X      case 0:BC+=(op_p2&0x1)?-1:1;
  577. X      break;
  578. X      case 1:DE+=(op_p2&0x1)?-1:1;
  579. X      break;
  580. X      case 2:HL+=(op_p2&0x1)?-1:1;
  581. X      break;
  582. X      case 3:SP+=(op_p2&0x1)?-1:1;
  583. X      break;
  584. X    }
  585. X    dlog("%s %c%c\n",(op_p2&1)?"DEC":"INC","BDHS"[op_p2>>1],"CELP"[op_p2>>1]);
  586. X    return;
  587. X  }
  588. X
  589. X  if ((op_p13&0xFE)==0x04) /* 8 bit INC/DEC */
  590. X  {
  591. X    char temp;
  592. X    BYTE dir; WORD t;
  593. X
  594. X    temp=AF&FLAG_C; /* save carry flag */
  595. X
  596. X    dir=(op_p1&0x1)?~0:1; /* which direction? */
  597. X
  598. X    switch(op_p2)
  599. X    {
  600. X      case 0:BC=(BC&0xff)|(alu_add(BC>>8,dir)<<8);
  601. X      break;
  602. X      case 1:BC=(BC&0xff00)|alu_add(BC&0xff,dir);
  603. X      break;
  604. X      case 2:DE=(DE&0xff)|(alu_add(DE>>8,dir)<<8);
  605. X      break;
  606. X      case 3:DE=(DE&0xff00)|alu_add(DE&0xff,dir);
  607. X      break;
  608. X      case 4:HL=(HL&0xff)|(alu_add(HL>>8,dir)<<8);
  609. X      break;
  610. X      case 5:HL=(HL&0xff00)|alu_add(HL&0xff,dir);
  611. X      break;
  612. X      case 6:wr_z80_mem(HL,alu_add(z80_mem(HL),dir));
  613. X      break;
  614. X      case 7:t=alu_add(AF>>8,dir); AF&=0xff; AF|=t<<8;
  615. X      break;
  616. X    }
  617. X    AF=(AF&~FLAG_N)|((opcode&1)?FLAG_N:0);
  618. X    AF=(AF&~FLAG_C)|temp; /* restore carry flag */
  619. X    dlog("%s %c\n",(dir==1)?"INC":"DEC","BCDEHLMA"[op_p2]);
  620. X    return;
  621. X  }
  622. X
  623. X  if (op_p3==0x2) /* 8 bit ADD, ADC, SUB, SBC, AND, OR, XOR, CMP */
  624. X  {
  625. X    WORD t;
  626. X    switch(op_p2)
  627. X    {
  628. X      case 0: /* ADD */
  629. X    switch(op_p1)
  630. X    {
  631. X      case 0:t=alu_add(AF>>8,BC>>8)<<8; AF&=0xff; AF|=t;
  632. X      break;
  633. X      case 1:t=alu_add(AF>>8,BC&0xff)<<8; AF&=0xff; AF|=t;
  634. X      break;
  635. X      case 2:t=alu_add(AF>>8,DE>>8)<<8; AF&=0xff; AF|=t;
  636. X      break;
  637. X          case 3:t=alu_add(AF>>8,DE&0xff)<<8; AF&=0xff; AF|=t;
  638. X      break;
  639. X      case 4:t=alu_add(AF>>8,HL>>8)<<8; AF&=0xff; AF|=t;
  640. X      break;
  641. X      case 5:t=alu_add(AF>>8,HL&0xff)<<8; AF&=0xff; AF|=t;
  642. X      break;
  643. X      case 6:t=alu_add(AF>>8,z80_mem(HL))<<8; AF&=0xff; AF|=t;
  644. X      break;
  645. X      case 7:t=alu_add(AF>>8,AF>>8)<<8; /* Sigh */ AF&=0xff; AF|=t;
  646. X      break;
  647. X    }
  648. X    dlog("ADD %c\n","BCDEHLMA"[op_p1]);
  649. X      break;
  650. X      case 1: /* ADC */
  651. X    switch(op_p1)
  652. X    {
  653. X      case 0:t=alu_adc(AF>>8,BC>>8)<<8; AF&=0xff; AF|=t;
  654. X      break;
  655. X      case 1:t=alu_adc(AF>>8,BC&0xff)<<8; AF&=0xff; AF|=t;
  656. X      break;
  657. X      case 2:t=alu_adc(AF>>8,DE>>8)<<8; AF&=0xff; AF|=t;
  658. X      break;
  659. X          case 3:t=alu_adc(AF>>8,DE&0xff)<<8; AF&=0xff; AF|=t;
  660. X      break;
  661. X      case 4:t=alu_adc(AF>>8,HL>>8)<<8; AF&=0xff; AF|=t;
  662. X      break;
  663. X      case 5:t=alu_adc(AF>>8,HL&0xff)<<8; AF&=0xff; AF|=t;
  664. X      break;
  665. X      case 6:t=alu_adc(AF>>8,z80_mem(HL))<<8; AF&=0xff; AF|=t;
  666. X      break;
  667. X      case 7:t=alu_adc(AF>>8,AF>>8)<<8; /* Sigh */ AF&=0xff; AF|=t;
  668. X      break;
  669. X    }
  670. X    dlog("ADC %c\n","BCDEHLMA"[op_p1]);
  671. X      break;
  672. X      case 2: /* SUB */
  673. X    switch(op_p1)
  674. X    {
  675. X      case 0:t=alu_sub(AF>>8,BC>>8)<<8; AF&=0xff; AF|=t;
  676. X      break;
  677. X      case 1:t=alu_sub(AF>>8,BC&0xff)<<8; AF&=0xff; AF|=t;
  678. X      break;
  679. X      case 2:t=alu_sub(AF>>8,DE>>8)<<8; AF&=0xff; AF|=t;
  680. X      break;
  681. X          case 3:t=alu_sub(AF>>8,DE&0xff)<<8; AF&=0xff; AF|=t;
  682. X      break;
  683. X      case 4:t=alu_sub(AF>>8,HL>>8)<<8; AF&=0xff; AF|=t;
  684. X      break;
  685. X      case 5:t=alu_sub(AF>>8,HL&0xff)<<8; AF&=0xff; AF|=t;
  686. X      break;
  687. X      case 6:t=alu_sub(AF>>8,z80_mem(HL))<<8; AF&=0xff; AF|=t;
  688. X      break;
  689. X      case 7:t=alu_sub(AF>>8,AF>>8)<<8; /* Sigh */ AF&=0xff; AF|=t;
  690. X      break;
  691. X    }
  692. X    dlog("SUB %c\n","BCDEHLMA"[op_p1]);
  693. X      break;
  694. X      case 3: /* SBC */
  695. X    switch(op_p1)
  696. X    {
  697. X      case 0:t=alu_sbc(AF>>8,BC>>8)<<8; AF&=0xff; AF|=t;
  698. X      break;
  699. X      case 1:t=alu_sbc(AF>>8,BC&0xff)<<8; AF&=0xff; AF|=t;
  700. X      break;
  701. X      case 2:t=alu_sbc(AF>>8,DE>>8)<<8; AF&=0xff; AF|=t;
  702. X      break;
  703. X          case 3:t=alu_sbc(AF>>8,DE&0xff)<<8; AF&=0xff; AF|=t;
  704. X      break;
  705. X      case 4:t=alu_sbc(AF>>8,HL>>8)<<8; AF&=0xff; AF|=t;
  706. X      break;
  707. X      case 5:t=alu_sbc(AF>>8,HL&0xff)<<8; AF&=0xff; AF|=t;
  708. X      break;
  709. X      case 6:t=alu_sbc(AF>>8,z80_mem(HL))<<8; AF&=0xff; AF|=t;
  710. X      break;
  711. X      case 7:t=alu_sbc(AF>>8,AF>>8)<<8; /* Sigh */ AF&=0xff; AF|=t;
  712. X      break;
  713. X    }
  714. X    dlog("SBC %c\n","BCDEHLMA"[op_p1]);
  715. X      break;
  716. X      case 4: /* AND */
  717. X    switch (op_p1)
  718. X    {
  719. X      case 0:AF=(AF&0xff)|( ((AF>>8)&(BC>>8)) <<8 ); log_flags(AF>>8);
  720. X      break;
  721. X      case 1:AF=(AF&0xff)|( ((AF>>8)&(BC&0xff)) <<8 ); log_flags(AF>>8);
  722. X      break;
  723. X      case 2:AF=(AF&0xff)|( ((AF>>8)&(DE>>8)) <<8 ); log_flags(AF>>8);
  724. X      break;
  725. X      case 3:AF=(AF&0xff)|( ((AF>>8)&(DE&0xff)) <<8 ); log_flags(AF>>8);
  726. X      break;
  727. X      case 4:AF=(AF&0xff)|( ((AF>>8)&(HL>>8)) <<8 ); log_flags(AF>>8);
  728. X      break;
  729. X      case 5:AF=(AF&0xff)|( ((AF>>8)&(HL&0xff)) <<8 ); log_flags(AF>>8);
  730. X      break;
  731. X      case 6:AF=(AF&0xff)|( ((AF>>8)&(z80_mem(HL))) <<8 );
  732. X         log_flags(AF>>8);
  733. X      break;
  734. X      case 7:AF=(AF&0xff)|( ((AF>>8)&(AF>>8)) <<8 ); log_flags(AF>>8);
  735. X      break;
  736. X    }
  737. X    AF&=~FLAG_C;
  738. X    dlog("AND %c\n","BCDEHLMA"[op_p1]);
  739. X      break;
  740. X      case 5: /* XOR */
  741. X    switch (op_p1)
  742. X    {
  743. X      case 0:AF=(AF&0xff)|( ((AF>>8)^(BC>>8)) <<8 ); log_flags(AF>>8);
  744. X      break;
  745. X      case 1:AF=(AF&0xff)|( ((AF>>8)^(BC&0xff)) <<8 ); log_flags(AF>>8);
  746. X      break;
  747. X      case 2:AF=(AF&0xff)|( ((AF>>8)^(DE>>8)) <<8 ); log_flags(AF>>8);
  748. X      break;
  749. X      case 3:AF=(AF&0xff)|( ((AF>>8)^(DE&0xff)) <<8 ); log_flags(AF>>8);
  750. X      break;
  751. X      case 4:AF=(AF&0xff)|( ((AF>>8)^(HL>>8)) <<8 ); log_flags(AF>>8);
  752. X      break;
  753. X      case 5:AF=(AF&0xff)|( ((AF>>8)^(HL&0xff)) <<8 ); log_flags(AF>>8);
  754. X      break;
  755. X      case 6:AF=(AF&0xff)|( ((AF>>8)^(z80_mem(HL))) <<8 );
  756. X         log_flags(AF>>8);
  757. X      break;
  758. X      case 7:AF=(AF&0xff)|( ((AF>>8)^(AF>>8)) <<8 ); log_flags(AF>>8);
  759. X      break;
  760. X    }
  761. X    dlog("XOR %c\n","BCDEHLMA"[op_p1]);
  762. X    AF&=~FLAG_C;
  763. X      break;
  764. X      case 6: /* OR */
  765. X    switch (op_p1)
  766. X    {
  767. X      case 0:AF=(AF&0xff)|( ((AF>>8)|(BC>>8)) <<8 ); log_flags(AF>>8);
  768. X      break;
  769. X      case 1:AF=(AF&0xff)|( ((AF>>8)|(BC&0xff)) <<8 ); log_flags(AF>>8);
  770. X      break;
  771. X      case 2:AF=(AF&0xff)|( ((AF>>8)|(DE>>8)) <<8 ); log_flags(AF>>8);
  772. X      break;
  773. X      case 3:AF=(AF&0xff)|( ((AF>>8)|(DE&0xff)) <<8 ); log_flags(AF>>8);
  774. X      break;
  775. X      case 4:AF=(AF&0xff)|( ((AF>>8)|(HL>>8)) <<8 ); log_flags(AF>>8);
  776. X      break;
  777. X      case 5:AF=(AF&0xff)|( ((AF>>8)|(HL&0xff)) <<8 ); log_flags(AF>>8);
  778. X      break;
  779. X      case 6:AF=(AF&0xff)|( ((AF>>8)|(z80_mem(HL))) <<8 );
  780. X         log_flags(AF>>8);
  781. X      break;
  782. X      case 7:AF=(AF&0xff)|( ((AF>>8)|(AF>>8)) <<8 ); log_flags(AF>>8);
  783. X      break;
  784. X    }
  785. X    dlog("OR %c\n","BCDEHLMA"[op_p1]);
  786. X    AF&=~FLAG_C;
  787. X      break;
  788. X      case 7: /* CMP */
  789. X    switch(op_p1)
  790. X    {
  791. X      case 0:alu_sub(AF>>8,BC>>8);
  792. X      break;
  793. X      case 1:alu_sub(AF>>8,BC&0xff);
  794. X      break;
  795. X      case 2:alu_sub(AF>>8,DE>>8);
  796. X      break;
  797. X      case 3:alu_sub(AF>>8,DE&0xff);
  798. X      break;
  799. X      case 4:alu_sub(AF>>8,HL>>8);
  800. X      break;
  801. X      case 5:alu_sub(AF>>8,HL&0xff);
  802. X      break;
  803. X      case 6:alu_sub(AF>>8,z80_mem(HL));
  804. X      break;
  805. X      case 7:alu_sub(AF>>8,AF>>8); /* Sigh... What a waste */
  806. X      break;
  807. X    }
  808. X    dlog("CMP %c\n","BCDEHLMA"[op_p1]);
  809. X    }
  810. X    return;
  811. X  }
  812. X  if (op_p13==0xC6) /* 8 bit math with immediate operands. */
  813. X  {
  814. X    register BYTE operand;
  815. X    WORD t;
  816. X    
  817. X    operand=z80_mem(PC++);
  818. X
  819. X    switch(op_p2)
  820. X    {
  821. X      case 0:t=alu_add(AF>>8,operand)<<8; AF&=0xff; AF|=t;
  822. X    dlog("ADD 0x%02x\n",operand);
  823. X      break;
  824. X      case 1:t=alu_adc(AF>>8,operand)<<8; AF&=0xff; AF|=t;
  825. X    dlog("ADC 0x%02x\n",operand);
  826. X      break;
  827. X      case 2:t=alu_sub(AF>>8,operand)<<8; AF&=0xff; AF|=t;
  828. X    dlog("SUB 0x%02x\n",operand);
  829. X      break;
  830. X      case 3:t=alu_sbc(AF>>8,operand)<<8; AF&=0xff; AF|=t;
  831. X    dlog("SBC 0x%02x\n",operand);
  832. X      break;
  833. X      case 4:AF=(AF&0xff)|( ((AF>>8)&operand) <<8 ); log_flags(AF>>8);
  834. X         AF&=~FLAG_C;
  835. X    dlog("AND 0x%02x\n",operand);
  836. X      break;
  837. X      case 5:AF=(AF&0xff)|( ((AF>>8)|operand) <<8 ); log_flags(AF>>8);
  838. X         AF&=~FLAG_C;
  839. X    dlog("OR 0x%02x\n",operand);
  840. X      break;
  841. X      case 6:AF=(AF&0xff)|( ((AF>>8)^operand) <<8 ); log_flags(AF>>8);
  842. X         AF&=~FLAG_C;
  843. X    dlog("XOR 0x%02x\n",operand);
  844. X      break;
  845. X      case 7:alu_sub(AF>>8,operand);
  846. X    dlog("CMP 0x%02x\n",operand);
  847. X      break;
  848. X    }
  849. X
  850. X    return;
  851. X  }
  852. X
  853. X  if ((opcode&0xCF)==0x09) /* ADD HL,rp */
  854. X  {
  855. X    register int temp;
  856. X    
  857. X    switch ((opcode&0x30)>>4)
  858. X    {
  859. X      case 0:temp=HL+BC; break;
  860. X      case 1:temp=HL+DE; break;
  861. X      case 2:temp=HL+HL; break;
  862. X      case 3:temp=HL+SP; break;
  863. X    }
  864. X    HL=(WORD) temp;
  865. X    AF=(AF&~FLAG_C)|((temp>0xffff)?FLAG_C:0);
  866. X    AF&=~FLAG_N;
  867. X    dlog("ADD HL,%c%c\n","BDHS"[op_p2>>1],"CELP"[op_p2>>1]);
  868. X    return;
  869. X
  870. X  }
  871. X
  872. X  if (opcode==0x27) /* DAA */
  873. X  {
  874. X    WORD t;
  875. X    if ( (((AF>>8)&0xf)>9) || (AF&FLAG_H) )
  876. X      if (AF&FLAG_N)
  877. X    { t=alu_sbc(AF>>8,6)<<8;  AF&=0xff; AF|=t; }
  878. X      else
  879. X    { t=alu_add(AF>>8,6)<<8;  AF&=0xff; AF|=t; }
  880. X    if ( (AF&FLAG_C) || (((AF>>8)&0xf0)>0x90) )
  881. X      if (AF&FLAG_N)
  882. X    { t=alu_sbc(AF>>8,0x60)<<8;  AF&=0xff; AF|=t; }
  883. X      else
  884. X    { t=alu_add(AF>>8,0x60)<<8;  AF&=0xff; AF|=t; }
  885. X
  886. X    dlog("DAA\n");
  887. X    return;
  888. X  }
  889. X
  890. X/*
  891. X
  892. XROTATES
  893. X
  894. X*/
  895. X
  896. X  if ((opcode&0xE7)==0x07)
  897. X  {
  898. X    switch ((opcode&0x18)>>3)
  899. X    {
  900. X      case 0:if (AF&0x8000) /* RLCA */
  901. X           {
  902. X         AF=(AF&0xff)|((AF&0x7f00)<<1)|0x100|FLAG_C;
  903. X           }
  904. X           else
  905. X           {
  906. X         AF=(AF&0xff&~FLAG_C)|((AF&0x7f00)<<1);
  907. X           }
  908. X    dlog("RLCA\n");
  909. X      break;
  910. X      case 1:if (AF&0x100) /* RRCA */
  911. X           {
  912. X         AF=(AF&0xff)|((AF&0xfe00)>>1)|0x8000|FLAG_C;
  913. X           }
  914. X           else
  915. X           {
  916. X         AF=(AF&0xff&~FLAG_C)|((AF&0xfe00)>>1);
  917. X           }
  918. X    dlog("RRCA\n");
  919. X      break;
  920. X      case 2:if (AF&FLAG_C) /* RLA */
  921. X         {
  922. X           AF=(AF&~FLAG_C)|((AF&0x8000)?FLAG_C:0);
  923. X           AF=(AF&0xff)|((AF&0x7f00)<<1)|0x100;
  924. X         }
  925. X         else
  926. X         {
  927. X           AF=(AF&~FLAG_C)|((AF&0x8000)?FLAG_C:0);
  928. X           AF=(AF&0xff)|((AF&0x7f00)<<1);
  929. X         }
  930. X    dlog("RLA\n");
  931. X      break;
  932. X      case 3:if (AF&FLAG_C) /* RRA */
  933. X         {
  934. X           /*  clr carry  then set it if bit 0 set */
  935. X           AF=(AF&~FLAG_C)|((AF&0x100)?FLAG_C:0);
  936. X           /* set A to A>>1, then add in known carry on top */
  937. X           AF=(AF&0xff)|((AF&0xfe00)>>1)|0x8000;
  938. X         }
  939. X         else
  940. X         {
  941. X           AF=(AF&~FLAG_C)|((AF&0x100)?FLAG_C:0);
  942. X           AF=(AF&0xff)|((AF&0xfe00)>>1);
  943. X         }
  944. X    dlog("RRA\n");
  945. X      break;
  946. X    }
  947. X    AF&=~(FLAG_H|FLAG_N);    /* according to Z80 prod spec, p. 13 */
  948. X    return;
  949. X  }
  950. X
  951. X/*
  952. X
  953. XI/O
  954. X
  955. X*/
  956. X
  957. X  if (opcode==0xD3) /* OUT (port),A */
  958. X  {
  959. X    wrport(z80_mem(PC++),AF>>8);
  960. X    dlog("OUT (0x%02x),A\n",z80_mem(PC-1));
  961. X    return;
  962. X  }
  963. X
  964. X  if (opcode==0xDB) /* IN A,(port) */
  965. X  {
  966. X    AF=(AF&0xff)|rdport(z80_mem(PC++))<<8;
  967. X    dlog("IN A,(0x%02x)\n",z80_mem(PC-1));
  968. X    return;
  969. X  }
  970. X
  971. X/*
  972. X
  973. Xmisc - xCF, CPL
  974. X
  975. X*/
  976. X
  977. X  if (opcode==0x3f) /* CCF */
  978. X  {
  979. X    AF^=FLAG_C;
  980. X    AF&=~(FLAG_N);
  981. X    dlog("CCF\n");
  982. X    return;
  983. X  }
  984. X
  985. X  if (opcode==0x37) /* SCF */
  986. X  {
  987. X    AF|=FLAG_C;
  988. X    AF&=~(FLAG_N|FLAG_H);
  989. X    dlog("SCF\n");
  990. X    return;
  991. X  }
  992. X
  993. X  if (opcode==0x2f) /* CPL */
  994. X  {
  995. X    AF^=0xff00;
  996. X    AF|=FLAG_H|FLAG_N;
  997. X    dlog("CPL\n");
  998. X    return;
  999. X  }
  1000. X
  1001. X/*
  1002. X
  1003. XWE SHOULD NEVER APPEAR HERE!!!!
  1004. X
  1005. XThere is no value of the first opcode byte of a Z-80 instruction that is
  1006. Xinvalid. If we get here, the above code is severely hosed.
  1007. X
  1008. X*/
  1009. X
  1010. X  printf("OH NO!!! PARSE ERROR - FIRST OPCODE BYTE!!!!!\n");
  1011. X  printf("PC = %4x  (PC) = %2x\n\n",PC-1,opcode);
  1012. X  exit(99);
  1013. X
  1014. X}
  1015. X
  1016. X/*
  1017. X
  1018. Xadditional routines:
  1019. X
  1020. Xalu_adc takes two bytes and adds them, creating the proper effect
  1021. Xon the flags register. For an add without carry, c=0. S, Z, C and H are
  1022. Xset as defined. P/V is set to indicate overflow.
  1023. X
  1024. XFor 16 bit add, lo=add(lo(a),lo(b)); hi=add(hi(a),hi(b)+((AF&FLAG_C)!=0));
  1025. XTHIS PRESUMES THAT != OPERATIONS ON YOUR COMPILER RETURN 0 OR 1!!!
  1026. X
  1027. X*/
  1028. X
  1029. XBYTE alu_adc(a,b)        /* X+Y+c... */
  1030. XWORD a,b;
  1031. X{
  1032. X    BYTE answer;
  1033. X    answer = alu_add(a,b+((AF&FLAG_C)!=0));
  1034. X    return answer;
  1035. X}
  1036. X
  1037. XBYTE alu_add(a,b)        /* essentially, X+Y, set FLAG_C as needed */
  1038. XWORD a,b;
  1039. X{
  1040. X
  1041. X  register BYTE answer=(a+b)&0xff;
  1042. X  register WORD flags=AF&0xff;
  1043. X  flags&= ~FLAG_N; /* Addition op */
  1044. X  flags=(flags&~FLAG_Z)|((answer==0)?FLAG_Z:0);
  1045. X  flags=(flags&~FLAG_S)|((answer&0x80)?FLAG_S:0);
  1046. X
  1047. X/*  For the H flag, we chop to 1 nibble each and check LSB of hi nibble
  1048. X    for carry. Yuck! */
  1049. X  flags=(flags&~FLAG_H)|( (((a&0xf)+(b&0xf))&0x10) ?FLAG_H:0);
  1050. X
  1051. X/* Bring the operands out to WORD size, add and see if the result's too big. */
  1052. X  flags=(flags&~FLAG_C)|(  ( (((WORD)a)+((WORD)b)) >0xff )  ?FLAG_C:0);
  1053. X
  1054. X/* The next one is complicated. It reads, "if the high bits of the operands
  1055. X   are the same, and the high bit of the first operand is different from
  1056. X   the high bit of the answer, overflow has occurred." Bleahack!!! */
  1057. X
  1058. X  flags=(flags&~FLAG_PV) |(( ((a>0x7f)==(b>0x7f)) && ((a>0x7f)!=(answer>0x7f)))
  1059. X               ?FLAG_PV:0);
  1060. X  AF &= 0xff00; AF |= flags;
  1061. X  return answer;
  1062. X}
  1063. X
  1064. XBYTE alu_sbc(a,b)
  1065. XBYTE a,b;
  1066. X{
  1067. X  BYTE answer;
  1068. X  AF ^= FLAG_C;
  1069. X  answer=alu_adc(a,(~b)&0xff);
  1070. X  AF ^= FLAG_C;
  1071. X  AF^=FLAG_H; /* same for half-carry */
  1072. X  AF|=FLAG_N; /* set for subtract op */
  1073. X  return answer;
  1074. X}
  1075. X
  1076. XBYTE alu_sub(a,b)
  1077. XBYTE a,b;
  1078. X{
  1079. X  BYTE answer;
  1080. X/*  AF ^= FLAG_C; */
  1081. X  answer=alu_add(a,(0xff&~b)+1);
  1082. X  AF ^= FLAG_C;
  1083. X  AF^=FLAG_H; /* same for half-carry */
  1084. X  AF|=FLAG_N; /* set for subtract op */
  1085. X  return answer;
  1086. X}
  1087. X
  1088. X/*
  1089. X
  1090. Xlog_flags - set flags after a logical operation. N & H =0, P/V set to
  1091. Xindicate parity, S with sign, and Z if zero as expected.
  1092. X
  1093. X*/
  1094. X
  1095. Xlog_flags(a)
  1096. XBYTE a;
  1097. X{
  1098. X  char count=0,i;
  1099. X
  1100. X  AF&=~(FLAG_N|FLAG_H);
  1101. X  AF=(AF&~FLAG_S)|((a&0x80)?FLAG_S:0);
  1102. X  AF=(AF&~FLAG_Z)|((a==0)?FLAG_Z:0);
  1103. X
  1104. X/*  for(i=0;i<8;i++)
  1105. X    {
  1106. X      if (a&1)
  1107. X    count++;
  1108. X      a=a>>1;
  1109. X    }
  1110. X  AF=(AF&~FLAG_PV)|((count%2)?0:FLAG_PV);
  1111. X*/
  1112. X  i = a;
  1113. X  i = (i & 0xf0) ^ ( (i&0x0f) << 4);
  1114. X  i = (i & 0xc0) ^ ( (i&0x30) << 2);
  1115. X  i = (i & 0x80) ^ ( (i&0x40) << 1);
  1116. X  AF=(AF&~FLAG_PV)|((0x80==i)?0:FLAG_PV);
  1117. X}
  1118. X
  1119. X/*
  1120. X
  1121. XStack routines
  1122. X
  1123. Xpush & pop do the obvious.
  1124. X
  1125. X*/
  1126. X
  1127. Xpush(a)
  1128. XWORD a;
  1129. X{
  1130. X  wr_z80_mem(--SP,a>>8);
  1131. X  wr_z80_mem(--SP,a&0xff);
  1132. X}
  1133. X
  1134. XWORD pop()
  1135. X{
  1136. X  register WORD temp;
  1137. X  temp=z80_mem(SP++);
  1138. X  temp|=z80_mem(SP++)<<8;
  1139. X  return temp;
  1140. X}
  1141. X
  1142. SHAR_EOF
  1143. echo "File z80.c is complete" &&
  1144. $TOUCH -am 0928182190 z80.c &&
  1145. chmod 0644 z80.c ||
  1146. echo "restore of z80.c failed"
  1147. set `wc -c z80.c`;Wc_c=$1
  1148. if test "$Wc_c" != "27243"; then
  1149.     echo original size 27243, current size $Wc_c
  1150. fi
  1151. # ============= z80.h ==============
  1152. echo "x - extracting z80.h (Text)"
  1153. sed 's/^X//' << 'SHAR_EOF' > z80.h &&
  1154. X/*
  1155. X
  1156. Xz80.h - defines for the z80 emulator.
  1157. X
  1158. XCopyright MCMXC - Nick Sayer - All rights reserved.
  1159. X
  1160. XSee COPYRIGHT file for more info.
  1161. X
  1162. X
  1163. XThere's only one configuration option. Some compilers have trouble
  1164. Xwith signed chars, and that's how we do JR, so choose one of these
  1165. Xtwo definitions to be used in the JR instructions
  1166. X
  1167. X*/
  1168. X
  1169. X    
  1170. X/* #define DO_JR PC+= (operand>127)?(-(256-operand)):(operand); */
  1171. X#define DO_JR PC+= (char) operand /* */
  1172. X/* #define DO_JR PC+= (operand>127)?256-(operand&0x7f):operand /* */
  1173. X
  1174. X/*
  1175. X
  1176. XGlobal types, data, and routines:
  1177. X
  1178. X*/
  1179. X
  1180. X#define BYTE unsigned char
  1181. X#define WORD unsigned short
  1182. X
  1183. Xextern BYTE real_z80_mem[65536];
  1184. X#define z80_mem(x) real_z80_mem[x]
  1185. X#define wr_z80_mem(x,y) debug_write(x,y)
  1186. Xextern WORD AF,BC,DE,HL,IX,IY,AF2,BC2,DE2,HL2,IR,PC,SP,INT_FLAGS;
  1187. Xextern z80_instr(),z80_run(),wrport();
  1188. Xextern BYTE rdport(),int_read();
  1189. Xextern char INT,NMI,RESET;
  1190. X
  1191. X/*
  1192. X
  1193. Xflag bits - these represent positions within the AF register.
  1194. X
  1195. X*/
  1196. X
  1197. X#define FLAG_C    0x01
  1198. X#define FLAG_N    0x02
  1199. X#define FLAG_PV    0x04
  1200. X#define FLAG_H    0x10
  1201. X#define FLAG_Z    0x40
  1202. X#define FLAG_S    0x80
  1203. X
  1204. X/*
  1205. X
  1206. XThe INT_FLAGS register doesn't really exist, we use it to store the IM status
  1207. Xand the two IFF flags.
  1208. X
  1209. XIFTMP is a counter to allow EI to take effect after the NEXT
  1210. Xinstruction.
  1211. X
  1212. X*/
  1213. X
  1214. X#define IM_STAT    0x03
  1215. X#define IFF1    0x04
  1216. X#define IFF2    0x08
  1217. X#define IFTMP    0x30
  1218. X
  1219. X/*
  1220. X
  1221. XThese routines are internal. We include it here just to keep
  1222. Xz80_cbed.c happy. Don't use 'em!!
  1223. X
  1224. X*/
  1225. X
  1226. XWORD pop();
  1227. XBYTE alu_adc(),alu_sbc(),alu_sub(),alu_add();
  1228. X
  1229. Xint dlogflag;
  1230. Xint debugflag;
  1231. Xint biosflag;
  1232. Xint TRAPval;
  1233. Xint TWRTval;
  1234. X
  1235. X#define dlog if(dlogflag) printf
  1236. X#define bioslog if(biosflag) printf
  1237. X/* static void dlog() { return; }  */
  1238. SHAR_EOF
  1239. $TOUCH -am 0928182190 z80.h &&
  1240. chmod 0644 z80.h ||
  1241. echo "restore of z80.h failed"
  1242. set `wc -c z80.h`;Wc_c=$1
  1243. if test "$Wc_c" != "1672"; then
  1244.     echo original size 1672, current size $Wc_c
  1245. fi
  1246. # ============= z80_cbed.c ==============
  1247. echo "x - extracting z80_cbed.c (Text)"
  1248. sed 's/^X//' << 'SHAR_EOF' > z80_cbed.c &&
  1249. X/*
  1250. X
  1251. Xz80_cbed.c - Z-80 microprocessor emulator, part 2.
  1252. X
  1253. XCopyright MCMXC - Nick Sayer - All rights reserved.
  1254. X
  1255. XSee COPYRIGHT file for details.
  1256. X
  1257. Xv0.0   - 04/08/90 - epoch
  1258. Xv0.0A0 - 04/13/90 - alpha-test.
  1259. Xv0.0A1 - 08/03/90 - alpha-test 2.
  1260. Xv0.0A2 - 09/04/90 - alpha-test 3.
  1261. X
  1262. XCB, ED, and DD/FD ops:
  1263. X
  1264. Xcb_ops(mem);
  1265. XWORD mem;
  1266. X
  1267. Xed_ops();
  1268. X
  1269. Xixy_ops(iy_reg);
  1270. Xchar iy_reg;
  1271. X
  1272. Xcb_ops called if first opcode byte is CB. PC points to byte after the
  1273. XCB. CB is passed the location of the "M" register. See comments before
  1274. Xcb_ops() for details.
  1275. X
  1276. Xed_ops called if first opcode byte is ED.
  1277. X
  1278. Xixy_ops similarly called if first opcode byte is DD or FD. iy_reg true for FD.
  1279. X
  1280. X*/
  1281. X
  1282. X#include "z80.h"
  1283. X
  1284. Xed_ops()
  1285. X{
  1286. X  BYTE op2,op2_p1,op2_p2,op2_p3,op2_p13;
  1287. X
  1288. X  op2=z80_mem(PC++);
  1289. X  op2_p1=op2&0x7;
  1290. X  op2_p2=(op2&0x38)>>3;
  1291. X  op2_p3=(op2&0xC0)>>6;
  1292. X  op2_p13=op2&0xC7;
  1293. X
  1294. X/* Now another horrendous if statement string... */
  1295. X
  1296. X  if (op2_p13==0x42) /* SBC/ADC HL,rp */
  1297. X  {
  1298. X    register WORD temp,temp2,sub_flag=0;
  1299. X
  1300. X    switch(op2_p2)
  1301. X    {
  1302. X      case 0:temp=BC; sub_flag++; break;
  1303. X      case 1:temp=BC;             break;
  1304. X      case 2:temp=DE; sub_flag++; break;
  1305. X      case 3:temp=DE;          break;
  1306. X      case 4:temp=HL; sub_flag++; break;
  1307. X      case 5:temp=HL;          break;
  1308. X      case 6:temp=SP; sub_flag++; break;
  1309. X      case 7:temp=SP;          break;
  1310. X    }
  1311. X    if (sub_flag)
  1312. X    {
  1313. X      temp2=alu_sbc(HL&0xff,temp&0xff);
  1314. X      AF^=FLAG_C; /* proper chaining! */
  1315. X      HL=temp2|(alu_sbc(HL>>8,(temp>>8))<<8);
  1316. X    }
  1317. X    else
  1318. X    {
  1319. X      temp2=alu_adc(HL&0xff,temp&0xff);
  1320. X      HL=temp2|(alu_adc(HL>>8,temp>>8)<<8);
  1321. X    }
  1322. X    return;
  1323. X  }
  1324. X
  1325. X  if (op2_p13==0x43) /* LD (imm),rp & rp,(imm) */
  1326. X  {
  1327. X    register WORD operand;
  1328. X
  1329. X    operand=z80_mem(PC++);
  1330. X    operand|=z80_mem(PC++)<<8;
  1331. X    switch(op2_p2)
  1332. X    {
  1333. X      case 0:wr_z80_mem(operand,BC&0xff); wr_z80_mem(operand+1,BC>>8); break;
  1334. X      case 1:BC=z80_mem(operand)|(z80_mem(operand+1)<<8); break;
  1335. X      case 2:wr_z80_mem(operand,DE&0xff); wr_z80_mem(operand+1,DE>>8); break;
  1336. X      case 3:DE=z80_mem(operand)|(z80_mem(operand+1)<<8); break;
  1337. X      case 4:wr_z80_mem(operand,HL&0xff); wr_z80_mem(operand+1,HL>>8); break;
  1338. X      case 5:HL=z80_mem(operand)|(z80_mem(operand+1)<<8); break;
  1339. X      case 6:wr_z80_mem(operand,SP&0xff); wr_z80_mem(operand+1,SP>>8); break;
  1340. X      case 7:SP=z80_mem(operand)|(z80_mem(operand+1)<<8); break;
  1341. X    }
  1342. X    return;
  1343. X  }
  1344. X
  1345. X  if ((op2&0xF7)==0x67) /* RLD or RRD */
  1346. X  {
  1347. X    register BYTE temp;
  1348. X
  1349. X    if (op2&0x8)
  1350. X    {
  1351. X      temp=z80_mem(HL)>>4;
  1352. X      wr_z80_mem(HL,(z80_mem(HL)<<4)|((AF&0x0f00)>>8));
  1353. X      AF=(AF&0xf0ff)|(temp<<8);
  1354. X    }
  1355. X    else
  1356. X    {
  1357. X      temp=z80_mem(HL)&0xf;
  1358. X      wr_z80_mem(HL,(z80_mem(HL)>>4)|((AF&0x0f00)>>4));
  1359. X      AF=(AF&0xf0ff)|(temp<<8);
  1360. X    }
  1361. X    log_flags(AF>>8);
  1362. X
  1363. X    return;
  1364. X  }
  1365. X
  1366. X  if (op2_p13==0x40) /* IN reg,(C) */
  1367. X  {
  1368. X    switch (op2_p2)
  1369. X    {
  1370. X      case 0:BC=(HL&0xff)|(rdport(BC&0xff)<<8); break;
  1371. X      case 1:BC=(BC&0xff00)|rdport(BC&0xff);    break;
  1372. X      case 2:DE=(DE&0xff)|(rdport(BC&0xff)<<8); break;
  1373. X      case 3:DE=(DE&0xff00)|rdport(DE&0xff);    break;
  1374. X      case 4:HL=(HL&0xff)|(rdport(BC&0xff)<<8); break;
  1375. X      case 5:HL=(HL&0xff00)|rdport(BC&0xff);    break;
  1376. X      case 6:wr_z80_mem(HL,rdport(BC&0xff));   break;/* is this REALLY true? */
  1377. X      case 7:AF=(AF&0xFF)|(rdport(BC&0xff)<<8); break;
  1378. X    }
  1379. X    return;
  1380. X  }
  1381. X
  1382. X  if (op2_p13==0x41) /* OUT (C),reg */
  1383. X  {
  1384. X    switch (op2_p2)
  1385. X    {
  1386. X      case 0:wrport(BC&0xff,BC>>8);       break;
  1387. X      case 1:wrport(BC&0xff,BC&0xff);     break;
  1388. X      case 2:wrport(BC&0xff,DE>>8);       break;
  1389. X      case 3:wrport(BC&0xff,DE&0xff);     break;
  1390. X      case 4:wrport(BC&0xff,HL>>8);       break;
  1391. X      case 5:wrport(BC&0xff,HL&0xff);     break;
  1392. X      case 6:wrport(BC&0xff,z80_mem(HL)); break; /* Is this REALLY true? */
  1393. X      case 7:wrport(BC&0xff,AF>>8);       break;
  1394. X    }
  1395. X    return;
  1396. X  }
  1397. X
  1398. X  if (op2==0x44) /* NEG */
  1399. X  {
  1400. X    WORD t;
  1401. X    t=alu_sub(0,AF>>8)<<8; AF&=0xff; AF|=t;
  1402. X    return;
  1403. X  }
  1404. X
  1405. X  if (op2==0x45) /* RETN */
  1406. X  {
  1407. X     /* restore IFF1 from IFF2 */
  1408. X    INT_FLAGS=(INT_FLAGS&~IFF1)|((INT_FLAGS&IFF2)?IFF1:0);
  1409. X    PC=pop();
  1410. X    return;
  1411. X  }
  1412. X
  1413. X  if (op2==0x4D) /* RETI */
  1414. X  {
  1415. X    PC=pop();
  1416. X    return;
  1417. X  }
  1418. X
  1419. X  if ((op2&0xE7)==0x46) /* IM ? */
  1420. X  {
  1421. X    INT_FLAGS&=~IM_STAT;
  1422. X    switch ((op2&0x18)>>3)
  1423. X    {
  1424. X      case 0: /* IM 0 - we're done! */
  1425. X      break;
  1426. X      case 2:INT_FLAGS|=1; /* IM 1 - perverse, isn't it? */
  1427. X      break;
  1428. X      case 3:INT_FLAGS|=2; /* IM 2 */
  1429. X    }
  1430. X    return;
  1431. X  }
  1432. X
  1433. X  if ((op2&0xE7)==0x47) /* moves involving I & R */
  1434. X  {
  1435. X    switch((op2&0x10)>>4) /* which way? */
  1436. X    {
  1437. X      case 1:switch ((op2&0x8)>>3) /* which reg? */
  1438. X         {
  1439. X           case 0:AF=(AF&0xff)|(IR&0xff00); break;  /* A,I */
  1440. X           case 1:AF=(AF&0xff)|(IR<<8);     break;  /* A,R */
  1441. X         }
  1442. X         AF=(AF&~(FLAG_H|FLAG_N));
  1443. X         AF=(AF&~FLAG_PV)|((INT_FLAGS&IFF1)?FLAG_PV:0);
  1444. X         AF=(AF&~FLAG_S)|((AF&0x8000)?FLAG_S:0);
  1445. X         AF=(AF&~FLAG_Z)|(((AF>>8)==0)?FLAG_Z:0);
  1446. X      break;
  1447. X      case 0:switch ((op2&0x8)>>3)
  1448. X             {
  1449. X           case 0:IR=(IR&0xff)|(AF&0xff00); break; /* I,A */
  1450. X           case 1:IR=(IR&0xff00)|(AF>>8);   break; /* R,A */
  1451. X         }
  1452. X      break;
  1453. X    }
  1454. X    return;
  1455. X  }
  1456. X
  1457. X/*
  1458. X
  1459. X{LD,CP,OT,IN}[ID][R] instructions (e.g. LDIR, OTD, etc)
  1460. X
  1461. X*/
  1462. X
  1463. X  if ((op2&0xE4)==0xA0)
  1464. X  {
  1465. X    register BYTE dir;
  1466. X    register BYTE repeat;
  1467. X
  1468. X    dir=op2&0x8;
  1469. X    repeat=op2&0x10;
  1470. X    switch (op2&3)
  1471. X    {
  1472. X      case 0:wr_z80_mem(DE,z80_mem(HL));
  1473. X         if (dir)
  1474. X           DE--,HL--;
  1475. X         else
  1476. X           DE++,HL++;
  1477. X             BC--;
  1478. X         AF=AF&~(FLAG_N|FLAG_H);
  1479. X         AF=(AF&FLAG_PV)|((BC==0)?FLAG_PV:0);
  1480. X         if (repeat && BC)
  1481. X           PC-= 2;
  1482. X      break;
  1483. X      case 1:alu_sbc(AF>>8,z80_mem(HL));
  1484. X         if (dir)
  1485. X           HL--;
  1486. X             else
  1487. X           HL++;
  1488. X             BC--;
  1489. X         AF=(AF&FLAG_PV)|((BC==0)?FLAG_PV:0);
  1490. X         if (repeat && BC && !(AF&FLAG_Z))
  1491. X           PC-= 2;
  1492. X      break;
  1493. X      case 2:wr_z80_mem(HL,rdport(BC&0xff));
  1494. X         if (dir)
  1495. X           HL--;
  1496. X             else
  1497. X           HL++;
  1498. X             BC-=0x100;
  1499. X         AF=FLAG_N|(AF&FLAG_Z)|(((BC>>8)==0)?FLAG_Z:0);
  1500. X         if (repeat && (BC>>8))
  1501. X           PC-= 2;
  1502. X      break;
  1503. X      case 3:wrport(BC&0xff,z80_mem(HL));
  1504. X         if (dir)
  1505. X           HL--;
  1506. X         else
  1507. X           HL++;
  1508. X             BC-= 0x100;
  1509. X         AF=FLAG_N|(AF&FLAG_Z)|(((BC>>8)==0)?FLAG_Z:0);
  1510. X         if (repeat && (BC>>8))
  1511. X           PC-= 2;
  1512. X      break;
  1513. X    }
  1514. X    return;
  1515. X  }
  1516. X
  1517. X/* I don't know if there are any unparsable ED ops or not. If
  1518. X   we get here, crash'n'burn */
  1519. X
  1520. X   printf("OH NO!!!!! PARSE ERROR - 2nd opcode - ED ops\n");
  1521. X   printf("PC = %4x  (PC) = %2x\n\n",PC-1,op2);
  1522. X   exit(99);
  1523. X
  1524. X}
  1525. X
  1526. X/*
  1527. X
  1528. XCB operations can also be activated with index registers, e.g.
  1529. XBIT 0,(IY+5). The opcodes for this are FD CB 05 46. In machine-type
  1530. Xlanguage, this says "use index register IY+5 instead of HL for
  1531. Xthe operation "CB 46". The operation "CB 46" says BIT 6,(HL). This
  1532. Xis in fact how all the index operations work. The opcode after
  1533. XFD/ED relates in some way to (HL). Its just as easy to rewrite
  1534. Xthe small portion of the opcode table relating to index registers
  1535. Xin this file, but for CB ops, it's just easier to pass the
  1536. Xaddress to the CB parser it should use if (HL) is referred to.
  1537. XIf we are parsing a straight CB op, this routine is called
  1538. Xwith the contents of HL. If it's an FD/ED op, we call it with
  1539. XIX/IY + d. Calling this number "mem" is a throwback to the 8080.
  1540. X(HL) was called "M" the meta-register "memory." LD A,(HL) was written
  1541. X"MOV A,M". That sort of thing can be seen all over in the opcode
  1542. Xtable - especially the math and load ops. register "M" was number 6 in
  1543. Xthe numbering scheme (BCDEHLMA).
  1544. X
  1545. XThe problem with doing this is that if we're passed a CB op from the
  1546. XFD/ED parser, and that op doesn't refer to mem, it will act as if the
  1547. Xindex register is not involved. But such an op would have unpredictable
  1548. Xresults on a real Z-80 anyway. fnord.
  1549. X
  1550. X*/
  1551. X
  1552. Xcb_ops(mem)
  1553. XWORD mem;
  1554. X{
  1555. X  register BYTE op2,op_typ,op_reg;
  1556. X
  1557. X  op2=z80_mem(PC++);
  1558. X  op_typ=(op2&0x38)>>3;
  1559. X  op_reg=op2&0x7;
  1560. X
  1561. X/* And off we go again... */
  1562. X
  1563. X  switch((op2&0xC0)>>6)
  1564. X  {
  1565. X    case 1: /* BIT */
  1566. X      switch(op_reg)
  1567. X      {
  1568. X    case 0:AF=(AF&~FLAG_Z)|((BC&(1<<(op_typ+8)))?0:FLAG_Z);       break;
  1569. X    case 1:AF=(AF&~FLAG_Z)|((BC&(1<<op_typ))?0:FLAG_Z);           break;
  1570. X    case 2:AF=(AF&~FLAG_Z)|((DE&(1<<(op_typ+8)))?0:FLAG_Z);       break;
  1571. X    case 3:AF=(AF&~FLAG_Z)|((DE&(1<<op_typ))?0:FLAG_Z);           break;
  1572. X    case 4:AF=(AF&~FLAG_Z)|((HL&(1<<(op_typ+8)))?0:FLAG_Z);       break;
  1573. X    case 5:AF=(AF&~FLAG_Z)|((HL&(1<<op_typ))?0:FLAG_Z);           break;
  1574. X    case 6:AF=(AF&~FLAG_Z)|((z80_mem(mem)&(1<<op_typ))?0:FLAG_Z); break;
  1575. X    case 7:AF=(AF&~FLAG_Z)|((AF&(1<<(op_typ+8)))?0:FLAG_Z);       break;
  1576. X      }
  1577. X      AF|=FLAG_H;
  1578. X      AF&=~FLAG_N;
  1579. X    break;
  1580. X    case 2: /* RES */
  1581. X      switch(op_reg)
  1582. X      {
  1583. X    case 0:BC&=~(1<<(op_typ+8));        break;
  1584. X    case 1:BC&=~(1<<op_typ);            break;
  1585. X    case 2:DE&=~(1<<(op_typ+8));        break;
  1586. X    case 3:DE&=~(1<<op_typ);            break;
  1587. X    case 4:HL&=~(1<<(op_typ+8));        break;
  1588. X    case 5:HL&=~(1<<op_typ);            break;
  1589. X    case 6:wr_z80_mem(mem,z80_mem(mem)&~(1<<op_typ));  break;
  1590. X    case 7:AF&=~(1<<(op_typ+8));        break;
  1591. X      }
  1592. X    break;
  1593. X    case 3: /* SET */
  1594. X      switch(op_reg)
  1595. X      {
  1596. X    case 0:BC|=1<<(op_typ+8);       break;
  1597. X    case 1:BC|=1<<op_typ;           break;
  1598. X    case 2:DE|=1<<(op_typ+8);       break;
  1599. X    case 3:DE|=1<<op_typ;           break;
  1600. X    case 4:HL|=1<<(op_typ+8);       break;
  1601. X    case 5:HL|=1<<op_typ;           break;
  1602. X    case 6:wr_z80_mem(mem,z80_mem(mem)|1<<op_typ); break;
  1603. X    case 7:AF|=1<<(op_typ+8);       break;
  1604. X      }
  1605. X    break;
  1606. X    case 0: /* Additional rotate/shift section */
  1607. X    {
  1608. X      register BYTE temp,temp2;
  1609. X
  1610. X      switch(op_reg) /* get it out */
  1611. X      {
  1612. X    case 0:temp=((BC&0xff00)>>8); break;
  1613. X    case 1:temp=BC&0xff;          break;
  1614. X    case 2:temp=((DE&0xff00)>>8); break;
  1615. X    case 3:temp=DE&0xff;          break;
  1616. X    case 4:temp=((HL&0xff00)>>8); break;
  1617. X    case 5:temp=HL&0xff;          break;
  1618. X    case 6:temp=z80_mem(mem);     break;
  1619. X    case 7:temp=((AF&0xff00)>>8); break;
  1620. X      }
  1621. X      switch(op_typ)
  1622. X      {
  1623. X    case 0: /* RLC */
  1624. X           temp=(temp<<1)|((temp&0x80)?1:0);
  1625. X           log_flags(temp);
  1626. X           AF=(AF&~FLAG_C)|((temp&1)?FLAG_C:0);
  1627. X        break;
  1628. X        case 1: /* RRC */
  1629. X           temp=(temp>>1)|((temp&1)?0x80:0);
  1630. X           log_flags(temp);
  1631. X           AF=(AF&~FLAG_C)|((temp&0x80)?FLAG_C:0);
  1632. X    break;
  1633. X        case 2: /* RL */
  1634. X           temp2=temp&0x80;
  1635. X           temp=(temp<<1)|((AF&FLAG_C)?1:0);
  1636. X           log_flags(temp);
  1637. X           AF=(AF&~FLAG_C)|(temp2?FLAG_C:0);
  1638. X        break;
  1639. X        case 3: /* RR */
  1640. X           temp2=temp&0x1;
  1641. X           temp=(temp>>1)|((AF&FLAG_C)?0x80:0);
  1642. X           log_flags(temp);
  1643. X           AF=(AF&~FLAG_C)|(temp2?FLAG_C:0);
  1644. X        break;
  1645. X        case 4: /* SLA */
  1646. X           AF=(AF&~FLAG_C)|((temp&0x80)?FLAG_C:0);
  1647. X           temp=temp<<1;
  1648. X           log_flags(temp);
  1649. X        break;
  1650. X        case 5: /* SRA */
  1651. X           AF=(AF&~FLAG_C)|((temp&1)?FLAG_C:0);
  1652. X           temp=(temp>>1)|((temp&0x80)?0x80:0);
  1653. X           log_flags(temp);
  1654. X        break;
  1655. X        case 6: /* NOT USED - NOP */
  1656. X        break;
  1657. X    case 7: /* SRL */
  1658. X           AF=(AF&~FLAG_C)|((temp&1)?FLAG_C:0);
  1659. X           temp=temp>>1;
  1660. X           log_flags(temp);
  1661. X        break;
  1662. X      }
  1663. X      switch(op_reg) /* put it back */
  1664. X      {
  1665. X    case 0:BC=(BC&0xff)|(temp<<8); break;
  1666. X    case 1:BC=(BC&0xff00)|temp;    break;
  1667. X    case 2:DE=(DE&0xff)|(temp<<8); break;
  1668. X    case 3:DE=(DE&0xff00)|temp;    break;
  1669. X    case 4:HL=(HL&0xff)|(temp<<8); break;
  1670. X    case 5:HL=(HL&0xff00)|temp;    break;
  1671. X    case 6:wr_z80_mem(mem,temp);   break;
  1672. X    case 7:AF=(AF&0xff)|(temp<<8); break;
  1673. X      }
  1674. X    }
  1675. X    break;
  1676. X  }
  1677. X
  1678. X/* This parser is a little different. It's normal to get here. Don't
  1679. X   crash'n'burn */
  1680. X
  1681. X  return;
  1682. X}
  1683. X
  1684. X/* this'll help \/  */
  1685. X
  1686. X#define INDEX_VALUE ((IY_FLAG)?IY+d:IX+d)
  1687. X
  1688. Xixy_ops(IY_FLAG)
  1689. Xchar IY_FLAG; /* true for IY */
  1690. X{
  1691. X  register BYTE op2;
  1692. X  register BYTE d;
  1693. X
  1694. X  op2=z80_mem(PC++);
  1695. X  d=z80_mem(PC++);    /* DANGER WILL ROBINSON!!! Better fix this
  1696. X             for PUSH, INC et all */
  1697. X
  1698. X/* And away they go!... */
  1699. X
  1700. X  if (op2==0xCB) /* CB ops */
  1701. X  {
  1702. X    cb_ops(INDEX_VALUE);
  1703. X    return;
  1704. X  }
  1705. X
  1706. X  if ((op2&0xC0)==0x40) /* LD (I?+d),reg or reg,(I?+d) */
  1707. X  {
  1708. X    register BYTE value;
  1709. X    switch((op2&0x38)>>3)
  1710. X    {
  1711. X      case 0:value=BC>>8;       break;
  1712. X      case 1:value=BC&0xff;     break;
  1713. X      case 2:value=DE>>8;       break;
  1714. X      case 3:value=DE&0xff;     break;
  1715. X      case 4:value=HL>>8;       break;
  1716. X      case 5:value=HL&0xff;     break;
  1717. X      case 6:value=z80_mem(INDEX_VALUE); break;
  1718. X      case 7:value=AF>>8;       break;
  1719. X    }
  1720. X    switch(op2&0x7)
  1721. X    {
  1722. X      case 0:BC=(BC&0xff)|(value<<8);  break;
  1723. X      case 1:BC=(BC&0xff00)|value;     break;
  1724. X      case 2:DE=(DE&0xff)|(value<<8);  break;
  1725. X      case 3:DE=(DE&0xff00)|value;     break;
  1726. X      case 4:HL=(HL&0xff)|(value<<8);  break;
  1727. X      case 5:HL=(HL&0xff00)|value;     break;
  1728. X      case 6:wr_z80_mem(INDEX_VALUE,value); break;
  1729. X      case 7:AF=(AF&0xff)|(value<<8);  break;
  1730. X    }
  1731. X
  1732. X    return;
  1733. X  }
  1734. X
  1735. X  if (op2==0x36) /* LD (I?+d),imm */
  1736. X  {
  1737. X    wr_z80_mem(INDEX_VALUE,z80_mem(PC++));
  1738. X    return;
  1739. X  }
  1740. X
  1741. X  if ((op2&0xFE)==0x34) /* INC/DEC (I?+d) */
  1742. X  {
  1743. X    switch (op2&1)
  1744. X    {
  1745. X      case 0:wr_z80_mem(INDEX_VALUE,alu_add(z80_mem(INDEX_VALUE),1));
  1746. X      break;
  1747. X      case 1:wr_z80_mem(INDEX_VALUE,alu_sub(z80_mem(INDEX_VALUE),1));
  1748. X      break;
  1749. X    }
  1750. X    return;
  1751. X  }
  1752. X
  1753. X  if ((op2&0xC7)==0x86) /* MATH OPS (I?+d) */
  1754. X  {
  1755. X    WORD t;
  1756. X    switch((op2&0x38)>>3)
  1757. X    {
  1758. X      case 0:t=alu_add(AF>>8,z80_mem(INDEX_VALUE))<<8; AF&=0xff; AF|=t; /* ADD */
  1759. X      break;
  1760. X      case 1:t=alu_adc(AF>>8,z80_mem(INDEX_VALUE))<<8; AF&=0xff; AF|=t;          /* ADC */
  1761. X      break;
  1762. X      case 2:t=alu_sub(AF>>8,z80_mem(INDEX_VALUE))<<8; AF&=0xff; AF|=t; /* SUB */
  1763. X      break;
  1764. X      case 3:t=alu_sbc(AF>>8,z80_mem(INDEX_VALUE))<<8; AF&=0xff; AF|=t;          /* SBC */
  1765. X      break;
  1766. X      case 4:AF=(AF&0xff)|(((AF>>8) & z80_mem(INDEX_VALUE))<<8);
  1767. X         log_flags(AF>>8);
  1768. X         /* AND */
  1769. X      break;
  1770. X      case 5:AF=(AF&0xff)|(((AF>>8) ^ z80_mem(INDEX_VALUE))<<8);
  1771. X         log_flags(AF>>8);
  1772. X         /* XOR */
  1773. X      break;
  1774. X      case 6:AF=(AF&0xff)|(((AF>>8) | z80_mem(INDEX_VALUE))<<8);
  1775. X         log_flags(AF>>8);
  1776. X         /* OR */
  1777. X      break;
  1778. X      case 7:alu_sub(AF>>8,z80_mem(INDEX_VALUE)); /* CMP */
  1779. X      break;
  1780. X    }
  1781. X
  1782. X    return;
  1783. X  }
  1784. X
  1785. X/* From here on are ops that don't involve d. For these, we
  1786. X   must decrement the PC to make up for the extra increment we did
  1787. X   to fetch d in the first place. d must be the opcode for the
  1788. X   next instruction. */
  1789. X
  1790. X  PC--;
  1791. X  d=0;  /* this makes our macro work. What a yucky hack! */
  1792. X
  1793. X  if (op2==0x21) /* LD I?,imm */
  1794. X  {
  1795. X    register WORD operand;
  1796. X
  1797. X    operand=z80_mem(PC++);
  1798. X    operand|=z80_mem(PC++)<<8;
  1799. X    if (IY_FLAG)
  1800. X      IY=operand;
  1801. X    else
  1802. X      IX=operand;
  1803. X
  1804. X    return;
  1805. X  }
  1806. X  if (op2==0x22) /* LD (imm),I? */
  1807. X  {
  1808. X    register WORD operand;
  1809. X
  1810. X    operand=z80_mem(PC++);
  1811. X    operand|=z80_mem(PC++)<<8;
  1812. X
  1813. X    wr_z80_mem(operand,INDEX_VALUE&0xff);
  1814. X    wr_z80_mem(operand+1,INDEX_VALUE>>8);
  1815. X
  1816. X    return;
  1817. X  }
  1818. X  if (op2==0x2A) /* LD I?,(imm) */
  1819. X  {
  1820. X    register WORD operand;
  1821. X
  1822. X    operand=z80_mem(PC++);
  1823. X    operand|=z80_mem(PC++)<<8;
  1824. X
  1825. X    if (IY_FLAG)
  1826. X      IY=z80_mem(operand)|(z80_mem(operand+1)<<8);
  1827. X    else
  1828. X      IX=z80_mem(operand)|(z80_mem(operand+1)<<8);
  1829. X
  1830. X    return;
  1831. X  }
  1832. X
  1833. X  if ((op2&0xCF)==0x09) /* ADD I?,rp */
  1834. X  {
  1835. X    register int temp;
  1836. X
  1837. X    switch ((op2&0x30)>>4)
  1838. X    {
  1839. X      case 0:temp=INDEX_VALUE+BC; break;
  1840. X      case 1:temp=INDEX_VALUE+DE; break;
  1841. X      case 2:temp=INDEX_VALUE+HL; break;
  1842. X      case 3:temp=INDEX_VALUE+SP; break;
  1843. X    }
  1844. X    if (IY_FLAG)
  1845. X      IY=(WORD) temp;
  1846. X    else
  1847. X      IX=(WORD) temp;
  1848. X    AF|=((temp>0xffff)?FLAG_C:0);
  1849. X    AF&=~FLAG_N;
  1850. X    return;
  1851. X  }
  1852. X
  1853. X  if (op2==0x23) /* INC I? */
  1854. X  {
  1855. X    if (IY_FLAG)
  1856. X      IY++;
  1857. X    else
  1858. X      IX++;
  1859. X
  1860. X    return;
  1861. X  }
  1862. X  if (op2==0x2B) /* DEC I? */
  1863. X  {
  1864. X    if (IY_FLAG)
  1865. X      IY--;
  1866. X    else
  1867. X      IX--;
  1868. X
  1869. X    return;
  1870. X  }
  1871. X  if (op2==0xE1) /* POP I? */
  1872. X  {
  1873. X    if (IY_FLAG)
  1874. X      IY=pop();
  1875. X    else
  1876. X      IX=pop();
  1877. X
  1878. X    return;
  1879. X  }
  1880. X  if (op2==0xE5) /* PUSH I? */
  1881. X  {
  1882. X    push(INDEX_VALUE);
  1883. X    return;
  1884. X  }
  1885. X  if (op2==0xE9) /* JP (I?) */
  1886. X  {
  1887. X    PC=INDEX_VALUE;
  1888. X    return;
  1889. X  }
  1890. X  if (op2==0xE3) /* EX (SP),I? */
  1891. X  {
  1892. X    register WORD temp;
  1893. X
  1894. X    temp=z80_mem(SP)|(z80_mem(SP+1)<<8);
  1895. X    wr_z80_mem(SP,INDEX_VALUE&0xff);
  1896. X    wr_z80_mem(SP+1,INDEX_VALUE>>8);
  1897. X    if (IY_FLAG)
  1898. X      IY=temp;
  1899. X    else
  1900. X      IX=temp;
  1901. X
  1902. X    return;
  1903. X  }
  1904. X  if (op2==0xF9) /* LD SP,I? */
  1905. X  {
  1906. X    SP=INDEX_VALUE;
  1907. X    return;
  1908. X  }
  1909. X
  1910. X/* There are undefined ED/FD ops. What do we do about it? Good
  1911. X   question. My theory says crash-n-burn. */
  1912. X
  1913. X  printf("OH NO!!!!! PARSE ERROR 2nd operand, Index ops\n");
  1914. X  printf("PC = %4x  (PC) = %2x\n\n",PC-1,op2);
  1915. X
  1916. X  exit(99);
  1917. X}
  1918. SHAR_EOF
  1919. $TOUCH -am 0928182190 z80_cbed.c &&
  1920. chmod 0644 z80_cbed.c ||
  1921. echo "restore of z80_cbed.c failed"
  1922. set `wc -c z80_cbed.c`;Wc_c=$1
  1923. if test "$Wc_c" != "16492"; then
  1924.     echo original size 16492, current size $Wc_c
  1925. fi
  1926. rm -f shar3_seq_.tmp
  1927. echo "You have unpacked the last part"
  1928. exit 0
  1929. -- 
  1930. Nick Sayer              | Disclaimer: "Don't try this at home, | RIP: Mel Blanc
  1931. mrapple@quack.sac.ca.us | kids. This should only be done by    |   1908-1989
  1932. N6QQQ  [44.2.1.17]      | trained, professional idiots."       |  May he never
  1933. 209-952-5347 (Telebit)  |                     --Plucky Duck    |  be silenced.
  1934.