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