home *** CD-ROM | disk | FTP | other *** search
/ ftp.whtech.com / ftp.whtech.com.tar / ftp.whtech.com / Geneve / 9640news / CAT36 / EMULSRC.ZIP / PROCESSO.C < prev    next >
Text File  |  1993-04-22  |  8KB  |  444 lines
  1. /**
  2.  **    Instruction bodies.
  3.  **
  4.  **/
  5.  
  6. void SRA()
  7. {
  8.     typeVoperands();
  9.     if (DestVal>1) SourceVal=(signed int)SourceVal>>(DestVal-1);
  10.     CY=SourceVal&1;
  11.     SourceVal=(signed int)SourceVal>>1;
  12.     set_status(SourceVal);
  13.     memory_write(SourceOpAdr,SourceVal);
  14. }
  15.  
  16. void SRL()
  17. {
  18.     typeVoperands();
  19.     if (DestVal>1) SourceVal>>=DestVal-1;
  20.     CY=SourceVal&1;
  21.     SourceVal>>=1;
  22.     set_status(SourceVal);
  23.     memory_write(SourceOpAdr,SourceVal);
  24. }
  25.  
  26. void SLA()
  27. {
  28.     typeVoperands();
  29.     OV=((((signed int)0x8000>>DestVal) &SourceVal)!=0);
  30.     if (DestVal>1) SourceVal<<=DestVal-1;
  31.     CY=((SourceVal&0x8000)!=0);
  32.     SourceVal<<=1;
  33.     set_status(SourceVal);
  34.     memory_write(SourceOpAdr,SourceVal);
  35. }
  36.  
  37. void SRC()
  38. {
  39.     typeVoperands();
  40.     SourceVal=(word)(SourceVal>>DestVal)|(SourceVal<<(16-DestVal));
  41.     CY=((SourceVal&0x8000)!=0);
  42.     set_status(SourceVal);
  43.     memory_write(SourceOpAdr,SourceVal);
  44. }
  45.  
  46. void SZC()
  47. {
  48.     typeIoperands();
  49.     DestVal&=~SourceVal;
  50.     set_status(DestVal);
  51.     memory_write(DestOpAdr,DestVal);
  52. }
  53.  
  54. void SZCB()
  55. {
  56.     typeIoperands();
  57.     DestVal&=(~SourceVal|0xFF);
  58.     set_status(DestVal&0xFF00);
  59.     set_parity(DestVal);
  60.     memory_write(DestOpAdr,DestVal);
  61. }
  62.  
  63. void S()
  64. {
  65.     typeIoperands();
  66.     DestVal=add(DestVal,1+~SourceVal);
  67.     set_status(DestVal);
  68.     memory_write(DestOpAdr,DestVal);
  69. }
  70.  
  71. void SB()
  72. {
  73.     typeIoperands();
  74.     DestVal=(DestVal&0xFF)|add(DestVal&0xFF00,1+~(SourceVal&0xFF00));
  75.     set_status(DestVal&0xFF00);
  76.     set_parity(DestVal);
  77.     memory_write(DestOpAdr,DestVal);
  78. }
  79.  
  80. void C()
  81. {
  82.     typeIoperands();
  83.     compare(SourceVal,DestVal);
  84. }
  85.  
  86. void CB()
  87. {
  88.     typeIoperands();
  89.     compare(SourceVal&0xFF00,DestVal&0xFF00);
  90.     set_parity(SourceVal);
  91. }
  92.  
  93. void A()
  94. {
  95.     typeIoperands();
  96.     DestVal=add(SourceVal,DestVal);
  97.     set_status(DestVal);
  98.     memory_write(DestOpAdr,DestVal);
  99. }
  100.  
  101. void AB()
  102. {
  103.     typeIoperands();
  104.     SourceVal=add(SourceVal&0xFF00,DestVal&0xFF00);
  105.     set_status(SourceVal&0xFF00);
  106.     set_parity(SourceVal);
  107.     memory_write(DestOpAdr,(SourceVal&0xFF00)|(DestVal&0xFF));
  108. }
  109.  
  110. void MOV()
  111. {
  112.     typeIoperands();
  113.     set_status(SourceVal);
  114.     memory_write(DestOpAdr,SourceVal);
  115. }
  116.  
  117. void MOVB()
  118. {
  119.     typeIoperands();
  120.     set_status(SourceVal&0xFF00);
  121.     set_parity(SourceVal);
  122.     memory_write(DestOpAdr,(SourceVal&0xFF00)|(DestVal&0xFF));
  123. }
  124.  
  125. void SOC()
  126. {
  127.     typeIoperands();
  128.     DestVal|=SourceVal;
  129.     set_status(DestVal);
  130.     memory_write(DestOpAdr,DestVal);
  131. }
  132.  
  133. void SOCB()
  134. {
  135.     typeIoperands();
  136.     DestVal|=SourceVal&0xFF00;
  137.     set_status(DestVal&0xFF00);
  138.     set_parity(DestVal);
  139.     memory_write(DestOpAdr,DestVal);
  140. }
  141.  
  142. void do_jump(void)
  143. {
  144.     PC+=(IR&0xFF)<<1;
  145.     if (IR&0x0080) PC-=0x200;
  146. }
  147.  
  148. void JMP() {                 do_jump(); }
  149. void JLT() { if (AGT==0 && EQ==0)     do_jump(); }
  150. void JLE() { if (LGT==FALSE || EQ==1)     do_jump(); }
  151. void JEQ() { if (EQ==1)         do_jump(); }
  152. void JHE() { if (LGT==1 || EQ==1)     do_jump(); }
  153. void JGT() { if (AGT==1)         do_jump(); }
  154. void JNE() { if (EQ==0)         do_jump(); }
  155. void JNC() { if (CY==0)         do_jump(); }
  156. void JOC() { if (CY==1)         do_jump(); }
  157. void JNO() { if (OV==0)         do_jump(); }
  158. void JL()  { if (LGT==0 && EQ==0)     do_jump(); }
  159. void JH()  { if (LGT==1)         do_jump(); }
  160. void JOP() { if (OP==1)         do_jump(); }
  161.  
  162. void SBO()
  163. {
  164.     if (PC==0x2BE) KSCAN(); /* truc: detecteer kscan */
  165. }
  166.  
  167. void SBZ() {}
  168. void TB() { EQ=0; }
  169.  
  170. void COC()
  171. {
  172.     typeIIIoperands();
  173.     EQ=( (SourceVal&~DestVal)==0 );
  174. }
  175.  
  176. void CZC()
  177. {
  178.     typeIIIoperands();
  179.     EQ=( (SourceVal&DestVal)==0 );
  180. }
  181.  
  182. void XOR()
  183. {
  184.     typeIIIoperands();
  185.     DestVal^=SourceVal;
  186.     set_status(DestVal);
  187.     memory_write(DestOpAdr,DestVal);
  188. }
  189.  
  190. void XOP()
  191. {
  192.     word oldwp,oldpc;
  193.     typeIVoperands();
  194.     oldwp=WP;
  195.     oldpc=PC;
  196.     WP=memory_read(0x40+(DestVal<<2));
  197.     PC=memory_read(0x42+(DestVal<<2));
  198.     memory_write(R11,SourceVal);
  199.     memory_write(R13,oldwp);
  200.     memory_write(R14,oldpc);
  201.     get_status();
  202.     memory_write(R15,STATUS);
  203.     X=1;
  204. }
  205.  
  206. void LDCR()
  207. {
  208.     EQ=0;
  209.     typeIVoperands();
  210.     if (PC==0x4ba) /* CLEAR-tastaturabfrage */
  211.     {
  212.         EQ=0;
  213.         if (kbhit())
  214.         {
  215.             int key;
  216.             key=getch();
  217.             if (key!=0) ungetch(key);
  218.             else EQ=(getch()==62);    /* F4 */
  219.         }
  220.         PC=0x4dc;
  221.     }
  222. /*    else set_status(SourceVal); */
  223. }
  224.  
  225. void STCR()
  226. {
  227.     typeIVoperands();
  228.     memory_write(SourceOpAdr,0xFFFF);
  229.     set_status(SourceVal);
  230. }
  231.  
  232. void MPY()
  233. {
  234.     unsigned long int m;
  235.     typeIIIoperands();
  236.     m=(unsigned long int)SourceVal*(unsigned long int)DestVal;
  237.     memory_write(DestOpAdr,(word)(m>>16));
  238.     memory_write(DestOpAdr+2,(word)(m&0xFFFF));
  239. }
  240.  
  241. void DIV()
  242. {
  243.     unsigned long int m;
  244.     typeIIIoperands();
  245.     m=((unsigned long int)(DestVal)<<16)+
  246.       (unsigned long int)memory_read(DestOpAdr+2);
  247.     OV=(SourceVal<=DestVal);
  248.     if ((SourceVal)&&!OV)
  249.     {
  250.         memory_write(DestOpAdr,(word)(m/SourceVal));
  251.         memory_write(DestOpAdr+2,(word)(m%SourceVal));
  252.     }
  253. }
  254.  
  255. void LI()
  256. {
  257.     typeVIIIoperands();
  258.     memory_write(SourceOpAdr,DestVal);
  259.     set_status(DestVal);
  260. }
  261.  
  262. void AI()
  263. {
  264.     typeVIIIoperands();
  265.     DestVal=add(SourceVal,DestVal);
  266.     memory_write(SourceOpAdr,DestVal);
  267.     set_status(DestVal);
  268. }
  269.  
  270. void ANDI()
  271. {
  272.     typeVIIIoperands();
  273.     DestVal&=SourceVal;
  274.     memory_write(SourceOpAdr,DestVal);
  275.     set_status(DestVal);
  276. }
  277.  
  278. void ORI()
  279. {
  280.     typeVIIIoperands();
  281.     DestVal|=SourceVal;
  282.     memory_write(SourceOpAdr,DestVal);
  283.     set_status(DestVal);
  284. }
  285.  
  286. void CI()
  287. {
  288.     typeVIIIoperands();
  289.     compare(SourceVal,DestVal);
  290. }
  291.  
  292. void STWP()
  293. {
  294.     typeIXoperands();
  295.     memory_write(SourceOpAdr,WP);
  296. }
  297.  
  298. void STST()
  299. {
  300.     typeIXoperands();
  301.     get_status();
  302.     memory_write(SourceOpAdr,STATUS);
  303. }
  304.  
  305. void LWPI()
  306. {
  307.     typeXoperands();
  308.     WP=SourceVal;
  309. }
  310.  
  311. void LIMI()
  312. {
  313.     static int intcounter=0;
  314.     typeXoperands();
  315.     IMASK=SourceVal&0xF;
  316.     if ((IMASK)&&(intcounter++==CURSOR_SPEED))
  317.     {
  318.         intcounter=0;
  319.         vdp_interrupt();        /* Fake interrupt! */
  320.     }
  321. }
  322.  
  323. void RTWP()
  324. {
  325.     PC=    memory_read(R14);
  326.     STATUS=    memory_read(R15);
  327.     WP=    memory_read(R13);
  328. }
  329.  
  330. void BLWP()
  331. {
  332.     word oldwp;
  333.     typeVIoperands();
  334.     oldwp=WP;
  335.     WP=SourceVal;            /* get new workspace */
  336.     memory_write(R13,oldwp);        /* store old WP in new R13 */
  337.     memory_write(R14,PC);        /* store old PC in new R14 */
  338.     memory_write(R15,STATUS);    /* store old STATUS in R15 */
  339.     PC=memory_read(SourceOpAdr+2);    /* get new PC :-) */
  340. }
  341.  
  342. void B()
  343. {
  344.     typeVIoperands();
  345.     PC=SourceOpAdr;
  346. }
  347.  
  348. void eX()
  349. {
  350.     typeVIoperands();
  351.     IR=SourceVal;
  352.         (*opcode_table[IR>>8])();    /* execute instruction */
  353. }
  354.  
  355. void CLR()
  356. {
  357.     typeVIoperands();
  358.     memory_write(SourceOpAdr,0);
  359. }
  360.  
  361. void NEG()
  362. {
  363.         typeVIoperands();
  364.     DestVal=add(~SourceVal,1);
  365.     set_status(DestVal);
  366.     memory_write(SourceOpAdr,DestVal);
  367. }
  368.  
  369. void INV()
  370. {
  371.     typeVIoperands();
  372.     DestVal=~SourceVal;
  373.     set_status(DestVal);
  374.     memory_write(SourceOpAdr,DestVal);
  375. }
  376.  
  377. void INC()
  378. {
  379.     typeVIoperands();
  380.     DestVal=add(SourceVal,1);
  381.     set_status(DestVal);
  382.     memory_write(SourceOpAdr,DestVal);
  383. }
  384.  
  385. void INCT()
  386. {
  387.     typeVIoperands();
  388.     DestVal=add(SourceVal,2);
  389.     set_status(DestVal);
  390.     memory_write(SourceOpAdr,DestVal);
  391. }
  392.  
  393. void DEC()
  394. {
  395.     typeVIoperands();
  396.     DestVal=add(SourceVal,0xFFFF);
  397.     set_status(DestVal);
  398.     memory_write(SourceOpAdr,DestVal);
  399. }
  400.  
  401. void DECT()
  402. {
  403.     typeVIoperands();
  404.     DestVal=add(SourceVal,0xFFFE);
  405.     set_status(DestVal);
  406.     memory_write(SourceOpAdr,DestVal);
  407. }
  408.  
  409. void BL()
  410. {
  411.     typeVIoperands();
  412.     memory_write(R11,PC);
  413.     PC=SourceOpAdr;
  414. }
  415.  
  416. void SWPB()
  417. {
  418.     typeVIoperands();
  419.     SourceVal=((SourceVal&0xFF)<<8) | (SourceVal>>8);
  420.     memory_write(SourceOpAdr,SourceVal);
  421. }
  422.  
  423. void SETO()
  424. {
  425.     typeVIoperands();
  426.     memory_write(SourceOpAdr,0xFFFF);
  427. }
  428.  
  429. void ABS()
  430. {
  431.     typeVIoperands();
  432.     set_status(SourceVal);
  433.     OV=(SourceVal==0x8000);
  434.     if (SourceVal&0x8000) SourceVal=~SourceVal+1;
  435.     memory_write(SourceOpAdr,SourceVal);
  436. }
  437.  
  438. void ILL()
  439. {
  440.     printf("\nIllegal opcode %04x at address >%04x\n",IR,PC-2);
  441.     printf("GROM=>%04x, VDP=>%04x",GromAddressCounter,VdpAddressCounter);
  442.     exit(0);
  443. }
  444.