home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / Z80 emulator / PPC version / Codes.c next >
Encoding:
Text File  |  1995-11-01  |  13.4 KB  |  447 lines  |  [TEXT/CWIE]
  1. /*    Z80 Emulator: Normal instruction handlers
  2.     Copyright (C) 1995 G.Woigk
  3.     
  4.     This file is part of Mac Spectacle and it is free software
  5.     See application.c for details
  6.             
  7.     This program is distributed in the hope that it will be useful,
  8.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  10.  
  11.     based on fMSX; Copyright (C) Marat Fayzullin 1994,1995
  12.     All opcodes covered, no unsupported opcodes!
  13. */
  14.  
  15.  
  16. increment_r;
  17. COUNT_PC;
  18. COUNT_INSTR;
  19.  
  20. switch(n)
  21. {
  22.  
  23.  
  24. // -------    JUMPING, BRANCHING etc. ------------------------
  25.  
  26. case JP:        time(10);                          pc=nn;loop;
  27. case JP_NZ:        time(10); w=nn; if(!(rf&Z_FLAG))  pc=w; loop;
  28. case JP_NC:        time(10); w=nn; if(!(rf&C_FLAG))  pc=w; loop;
  29. case JP_PO:        time(10); w=nn; if(!(rf&P_FLAG))  pc=w; loop;
  30. case JP_P:        time(10); w=nn; if(!(rf&S_FLAG))  pc=w; loop;
  31. case JP_Z:        time(10); w=nn; if(  rf&Z_FLAG )  pc=w; loop;
  32. case JP_C:        time(10); w=nn; if(  rf&C_FLAG )  pc=w; loop;
  33. case JP_PE:        time(10); w=nn; if(  rf&P_FLAG )  pc=w; loop;
  34. case JP_M:        time(10); w=nn; if(  rf&S_FLAG )  pc=w; loop;
  35.  
  36.  
  37. case JR:                        { pc+=dis; time(12); loop; }
  38. case JR_NZ:        if(rf&Z_FLAG)    { pc++;    time(7);  loop; } 
  39.                                 { pc+=dis; time(12); loop; }
  40. case JR_NC:        if(rf&C_FLAG)    { pc++;    time(7);  loop; } 
  41.                                  { pc+=dis; time(12); loop; }
  42. case JR_Z:        if(rf&Z_FLAG)    { pc+=dis; time(12); loop; }
  43.                                  { pc++;    time(7);  loop; }
  44. case JR_C:        if(rf&C_FLAG)    { pc+=dis; time(12); loop; }
  45.                                 { pc++;    time(7);  loop; }
  46. case DJNZ:        if(--RB)          { pc+=dis; time(13); loop; } 
  47.                                  { pc++;    time(8);  loop; }
  48.  
  49.  
  50.  
  51. case CALL:        w=nn;                { push(pc); pc=w; time(17); loop; }
  52. case CALL_NZ:    w=nn; if(rf&Z_FLAG)    {                   time(10); loop; }
  53.                                     { push(pc); pc=w; time(17); loop; }
  54. case CALL_NC:    w=nn; if(rf&C_FLAG)    {                   time(10); loop; }
  55.                                     { push(pc); pc=w; time(17); loop; }
  56. case CALL_PO:    w=nn; if(rf&P_FLAG)    {                   time(10); loop; }
  57.                                     { push(pc); pc=w; time(17); loop; }
  58. case CALL_P:     w=nn; if(rf&S_FLAG)    {                   time(10); loop; }
  59.                                     { push(pc); pc=w; time(17); loop; }
  60. case CALL_Z:     w=nn; if(rf&Z_FLAG)    { push(pc); pc=w; time(17); loop; }
  61.                                     {                   time(10); loop; }
  62. case CALL_C:     w=nn; if(rf&C_FLAG)    { push(pc); pc=w; time(17); loop; }
  63.                                     {                   time(10); loop; }
  64. case CALL_PE:    w=nn; if(rf&P_FLAG)    { push(pc); pc=w; time(17); loop; }
  65.                                     {                   time(10); loop; }
  66. case CALL_M:     w=nn; if(rf&S_FLAG)    { push(pc); pc=w; time(17); loop; }
  67.                                     {                   time(10); loop; }
  68.  
  69.  
  70. case RET:                        { pc=pop(); time(10); loop; }
  71. case RET_NZ:    if(rf&Z_FLAG)    {             time(5);  loop; } 
  72.                                 { pc=pop(); time(11); loop; }
  73. case RET_NC:    if(rf&C_FLAG)    {             time(5);  loop; } 
  74.                                 { pc=pop(); time(11); loop; }
  75. case RET_PO:    if(rf&P_FLAG)    {             time(5);  loop; } 
  76.                                 { pc=pop(); time(11); loop; }
  77. case RET_P:        if(rf&S_FLAG)    {             time(5);  loop; } 
  78.                                 { pc=pop(); time(11); loop; }
  79. case RET_Z:        if(rf&Z_FLAG)    { pc=pop(); time(11); loop; }
  80.                                 {             time(5);  loop; } 
  81. case RET_C:        if(rf&C_FLAG)    { pc=pop(); time(11); loop; }
  82.                                 {             time(5);  loop; } 
  83. case RET_PE:    if(rf&P_FLAG)    { pc=pop(); time(11); loop; }
  84.                                 {             time(5);  loop; } 
  85. case RET_M:        if(rf&S_FLAG)    { pc=pop(); time(11); loop; }
  86.                                 {             time(5);  loop; } 
  87.  
  88.  
  89. case RST00:      info_misc1;time(11); exit(rst0_instr);
  90. case RST08:      info_misc1;time(11); push(pc);pc=0x0008;loop;
  91. case RST10:      info_misc1;time(11); push(pc);pc=0x0010;loop;
  92. case RST18:      info_misc1;time(11); push(pc);pc=0x0018;loop;
  93. case RST20:      info_misc1;time(11); push(pc);pc=0x0020;loop;
  94. case RST28:      info_misc1;time(11); push(pc);pc=0x0028;loop;
  95. case RST30:      info_misc1;time(11); push(pc);pc=0x0030;loop;
  96. case RST38:      info_misc1;time(11); push(pc);pc=0x0038;loop;
  97.  
  98.  
  99. // ---- LD R,X --------------------------------------------
  100.  
  101. case LD_B_B:    time(4); RB=RB;loop;
  102. case LD_C_B:    time(4); RC=RB;loop;
  103. case LD_D_B:    time(4); RD=RB;loop;
  104. case LD_E_B:    time(4); RE=RB;loop;
  105. case LD_H_B:    time(4); RH=RB;loop;
  106. case LD_L_B:    time(4); RL=RB;loop;
  107. case LD_A_B:    time(4); ra=RB;loop;
  108. case LD_X_B:    time(7); rompoke(HL,RB);loop;
  109.  
  110. case LD_B_C:    time(4); RB=RC;loop;
  111. case LD_C_C:    time(4); RC=RC;loop;
  112. case LD_D_C:    time(4); RD=RC;loop;
  113. case LD_E_C:    time(4); RE=RC;loop;
  114. case LD_H_C:    time(4); RH=RC;loop;
  115. case LD_L_C:    time(4); RL=RC;loop;
  116. case LD_A_C:    time(4); ra=RC;loop;
  117. case LD_X_C:    time(7); rompoke(HL,RC);loop;
  118.  
  119. case LD_B_D:    time(4); RB=RD;loop;
  120. case LD_C_D:    time(4); RC=RD;loop;
  121. case LD_D_D:    time(4); RD=RD;loop;
  122. case LD_E_D:    time(4); RE=RD;loop;
  123. case LD_H_D:    time(4); RH=RD;loop;
  124. case LD_L_D:    time(4); RL=RD;loop;
  125. case LD_A_D:    time(4); ra=RD;loop;
  126. case LD_X_D:    time(7); rompoke(HL,RD);loop;
  127.  
  128. case LD_B_E:    time(4); RB=RE;loop;
  129. case LD_C_E:    time(4); RC=RE;loop;
  130. case LD_D_E:    time(4); RD=RE;loop;
  131. case LD_E_E:    time(4); RE=RE;loop;
  132. case LD_H_E:    time(4); RH=RE;loop;
  133. case LD_L_E:    time(4); RL=RE;loop;
  134. case LD_A_E:    time(4); ra=RE;loop;
  135. case LD_X_E:    time(7); rompoke(HL,RE);loop;
  136.  
  137. case LD_B_H:    time(4); RB=RH;loop;
  138. case LD_C_H:    time(4); RC=RH;loop;
  139. case LD_D_H:    time(4); RD=RH;loop;
  140. case LD_E_H:    time(4); RE=RH;loop;
  141. case LD_H_H:    time(4); RH=RH;loop;
  142. case LD_L_H:    time(4); RL=RH;loop;
  143. case LD_A_H:    time(4); ra=RH;loop;
  144. case LD_X_H:    time(7); rompoke(HL,RH);loop;
  145.  
  146. case LD_B_L:    time(4); RB=RL;loop;
  147. case LD_C_L:    time(4); RC=RL;loop;
  148. case LD_D_L:    time(4); RD=RL;loop;
  149. case LD_E_L:    time(4); RE=RL;loop;
  150. case LD_H_L:    time(4); RH=RL;loop;
  151. case LD_L_L:    time(4); RL=RL;loop;
  152. case LD_A_L:    time(4); ra=RL;loop;
  153. case LD_X_L:    time(7); rompoke(HL,RL);loop;
  154.  
  155. case LD_B_A:    time(4); RB=ra;loop;
  156. case LD_C_A:    time(4); RC=ra;loop;
  157. case LD_D_A:    time(4); RD=ra;loop;
  158. case LD_E_A:    time(4); RE=ra;loop;
  159. case LD_H_A:    time(4); RH=ra;loop;
  160. case LD_L_A:    time(4); RL=ra;loop;
  161. case LD_A_A:    time(4); ra=ra;loop;
  162. case LD_X_A:    time(7); rompoke(HL,ra);loop;
  163.  
  164. case LD_B_X:    time(7); RB=peek(HL);    loop;
  165. case LD_C_X:    time(7); RC=peek(HL);    loop;
  166. case LD_D_X:    time(7); RD=peek(HL);    loop;
  167. case LD_E_X:    time(7); RE=peek(HL);    loop;
  168. case LD_H_X:    time(7); RH=peek(HL);    loop;
  169. case LD_L_X:    time(7); RL=peek(HL);    loop;
  170. case LD_A_X:    time(7); ra=peek(HL);    loop;
  171.  
  172. case LD_B_N:    time(7); RB=n;    loop;
  173. case LD_C_N:    time(7); RC=n;    loop;
  174. case LD_D_N:    time(7); RD=n;    loop;
  175. case LD_E_N:    time(7); RE=n;    loop;
  176. case LD_H_N:    time(7); RH=n;    loop;
  177. case LD_L_N:    time(7); RL=n;    loop;
  178. case LD_A_N:    time(7); ra=n;    loop;
  179. case LD_X_N:    time(10);rompoke(HL,n);    loop;
  180.  
  181. case LD_xWORD_A:time(13);w=nn;rompoke(w,ra);loop;
  182. case LD_xBC_A:    time(7); rompoke(BC,ra);    loop;
  183. case LD_xDE_A:    time(7); rompoke(DE,ra);    loop;
  184. case LD_A_xBC:    time(7); ra = peek(BC);        loop;
  185. case LD_A_xDE:    time(7); ra = peek(DE);        loop;
  186. case LD_A_xWORD:time(13);ra = peek(nn);        loop;
  187.  
  188.  
  189. // -------    ARITHMETIC + BOOLEAN OPERATIONS ------------------------
  190.  
  191. case ADD_B:    time(4); M_ADD(RB);loop;
  192. case ADD_C:    time(4); M_ADD(RC);loop;
  193. case ADD_D:    time(4); M_ADD(RD);loop;
  194. case ADD_E:    time(4); M_ADD(RE);loop;
  195. case ADD_H:    time(4); M_ADD(RH);loop;
  196. case ADD_L:    time(4); M_ADD(RL);loop;
  197. case ADD_A:    time(4); M_ADD(ra);loop;
  198. case ADD_X:    time(7); c=peek(HL);M_ADD(c);loop;
  199. case ADD_N:    time(7); c=n;       M_ADD(c);loop;
  200.  
  201. case SUB_B: time(4); M_SUB(RB);loop;
  202. case SUB_C: time(4); M_SUB(RC);loop;
  203. case SUB_D: time(4); M_SUB(RD);loop;
  204. case SUB_E: time(4); M_SUB(RE);loop;
  205. case SUB_H: time(4); M_SUB(RH);loop;
  206. case SUB_L: time(4); M_SUB(RL);loop;
  207. case SUB_A: time(4); M_SUB(ra);loop;    // ra=0;rf=N_FLAG|Z_FLAG;loop;
  208. case SUB_X: time(7); c=peek(HL);M_SUB(c);loop;
  209. case SUB_N: time(7); c=n;       M_SUB(c);loop;
  210.  
  211. case ADC_B:    time(4); M_ADC(RB);loop;
  212. case ADC_C:    time(4); M_ADC(RC);loop;
  213. case ADC_D:    time(4); M_ADC(RD);loop;
  214. case ADC_E:    time(4); M_ADC(RE);loop;
  215. case ADC_H:    time(4); M_ADC(RH);loop;
  216. case ADC_L:    time(4); M_ADC(RL);loop;
  217. case ADC_A:    time(4); M_ADC(ra);loop;
  218. case ADC_X:    time(7); c=peek(HL);M_ADC(c);loop;
  219. case ADC_N:    time(7); c=n;       M_ADC(c);loop;
  220.  
  221. case SBC_B:    time(4); M_SBC(RB);loop;
  222. case SBC_C:    time(4); M_SBC(RC);loop;
  223. case SBC_D:    time(4); M_SBC(RD);loop;
  224. case SBC_E:    time(4); M_SBC(RE);loop;
  225. case SBC_H:    time(4); M_SBC(RH);loop;
  226. case SBC_L:    time(4); M_SBC(RL);loop;
  227. case SBC_A:    time(4); M_SBC(ra);loop;
  228. case SBC_X:    time(7); c=peek(HL);M_SBC(c);loop;
  229. case SBC_N:    time(7); c=n;       M_SBC(c);loop;
  230.  
  231. case CP_B:    time(4); M_CP(RB);loop;
  232. case CP_C:    time(4); M_CP(RC);loop;
  233. case CP_D:    time(4); M_CP(RD);loop;
  234. case CP_E:    time(4); M_CP(RE);loop;
  235. case CP_H:    time(4); M_CP(RH);loop;
  236. case CP_L:    time(4); M_CP(RL);loop;
  237. case CP_A:    time(4); M_CP(ra);loop;    // rf=N_FLAG|Z_FLAG;loop;
  238. case CP_X:    time(7); c=peek(HL);M_CP(c);loop;
  239. case CP_N:    time(7); c=n;       M_CP(c);loop;
  240.  
  241. case AND_B:    time(4); M_AND(RB);loop;
  242. case AND_C:    time(4); M_AND(RC);loop;
  243. case AND_D:    time(4); M_AND(RD);loop;
  244. case AND_E:    time(4); M_AND(RE);loop;
  245. case AND_H:    time(4); M_AND(RH);loop;
  246. case AND_L:    time(4); M_AND(RL);loop;
  247. case AND_A:    time(4); M_AND(ra);loop;
  248. case AND_X:    time(7); M_AND(peek(HL));loop;
  249. case AND_N:    time(7); M_AND(n); loop;
  250.  
  251. case OR_B:    time(4); M_OR(RB);loop;
  252. case OR_C:    time(4); M_OR(RC);loop;
  253. case OR_D:    time(4); M_OR(RD);loop;
  254. case OR_E:    time(4); M_OR(RE);loop;
  255. case OR_H:    time(4); M_OR(RH);loop;
  256. case OR_L:    time(4); M_OR(RL);loop;
  257. case OR_A:    time(4); M_OR(ra);loop;
  258. case OR_X:    time(7); M_OR(peek(HL));loop;
  259. case OR_N:    time(7); M_OR(n); loop;
  260.  
  261. case XOR_B:    time(4); M_XOR(RB);loop;
  262. case XOR_C:    time(4); M_XOR(RC);loop;
  263. case XOR_D:    time(4); M_XOR(RD);loop;
  264. case XOR_E:    time(4); M_XOR(RE);loop;
  265. case XOR_H:    time(4); M_XOR(RH);loop;
  266. case XOR_L:    time(4); M_XOR(RL);loop;
  267. case XOR_A:    time(4); M_XOR(ra);loop;    // ra=0;rf=P_FLAG|Z_FLAG;loop;
  268. case XOR_X:    time(7); M_XOR(peek(HL));loop;
  269. case XOR_N:    time(7); M_XOR(n);loop;
  270.  
  271. case DEC_B:    time(4); M_DEC(RB);loop;
  272. case DEC_C:    time(4); M_DEC(RC);loop;
  273. case DEC_D:    time(4); M_DEC(RD);loop;
  274. case DEC_E:    time(4); M_DEC(RE);loop;
  275. case DEC_H:    time(4); M_DEC(RH);loop;
  276. case DEC_L:    time(4); M_DEC(RL);loop;
  277. case DEC_A:    time(4); M_DEC(ra);loop;
  278. case DEC_X:    time(11);c=peek(HL);M_DEC(c);rompoke(HL,c);loop;
  279.  
  280. case INC_B:    time(4); M_INC(RB);loop;
  281. case INC_C:    time(4); M_INC(RC);loop;
  282. case INC_D:    time(4); M_INC(RD);loop;
  283. case INC_E:    time(4); M_INC(RE);loop;
  284. case INC_H:    time(4); M_INC(RH);loop;
  285. case INC_L:    time(4); M_INC(RL);loop;
  286. case INC_A:    time(4); M_INC(ra);loop;
  287. case INC_X:    time(11);c=peek(HL);M_INC(c);rompoke(HL,c);loop;
  288.  
  289.  
  290. /*    RLCA...RRA    set/clr    C
  291.                 clear    H=0, N=0
  292.                 pres    Z, P, S
  293. */
  294. case RLCA:    
  295.     time(4); 
  296.       ra = (ra<<1) + (ra>>7);
  297.       rf = (rf&~(C_FLAG+N_FLAG+H_FLAG)) + (ra&C_FLAG);
  298.       loop;
  299. case RRCA:        
  300.     time(4); 
  301.     ra = (ra>>1) + (ra<<7);
  302.     rf = (rf&~(C_FLAG+N_FLAG+H_FLAG)) + (ra>>7);
  303.     loop;
  304. case RLA:
  305.     time(4); 
  306.     c  = ra>>7;
  307.     ra = (ra<<1) + (rf&C_FLAG);
  308.     rf = (rf&~(C_FLAG+N_FLAG+H_FLAG)) + c;
  309.     loop;
  310. case RRA:
  311.     time(4); 
  312.     c  = ra&C_FLAG;
  313.     ra = (ra>>1) + (rf<<7);
  314.     rf = (rf&~(C_FLAG+N_FLAG+H_FLAG)) + c;
  315.     loop;
  316.  
  317.  
  318. // ----    WORD OPERATIONS -----------------------------------------
  319.  
  320. case LD_BC_WORD:     time(10); BC = nn;    loop;
  321. case LD_DE_WORD:     time(10); DE = nn;    loop;
  322. case LD_HL_WORD:     time(10); HL = nn;    loop;
  323. case LD_SP_WORD:     time(10); sp = nn;    loop;
  324.  
  325. case LD_xNN_HL:    time(16); w=nn; rompoke2(w,HL);    loop;
  326. case LD_HL_xNN:    time(16); w=nn; RL=peek(w); RH=peek(w+1);    loop;
  327.  
  328. case LD_PC_HL:        time(4);  pc = HL;    loop;
  329. case LD_SP_HL:        time(6);  sp = HL;    loop;
  330.  
  331. case ADD_HL_BC:        time(11); M_ADDW(HL,BC);    loop;
  332. case ADD_HL_DE:        time(11); M_ADDW(HL,DE);    loop;
  333. case ADD_HL_HL:        time(11); M_ADDW(HL,HL);    loop;
  334. case ADD_HL_SP:        time(11); M_ADDW(HL,sp);    loop;
  335.  
  336. case DEC_BC:        time(6);  BC--;        loop;
  337. case DEC_DE:        time(6);  DE--;        loop;
  338. case DEC_HL:        time(6);  HL--;        loop;
  339. case DEC_SP:        time(6);  sp--;        loop;
  340.  
  341. case INC_BC:        time(6);  BC++;        loop;
  342. case INC_DE:        time(6);  DE++;        loop;
  343. case INC_HL:        time(6);  HL++;        loop;
  344. case INC_SP:        time(6);  sp++;        loop;
  345.  
  346. case PUSH_BC:        time(11); push(BC);    loop;
  347. case PUSH_DE:        time(11); push(DE);    loop;
  348. case PUSH_HL:        time(11); push(HL);    loop;
  349. case PUSH_AF:        time(11); poke(--sp,ra); poke(--sp,rf); loop;
  350.  
  351. case POP_BC:        time(10); BC=pop();    loop;
  352. case POP_DE:        time(10); DE=pop();    loop;
  353. case POP_HL:        time(10); HL=pop();    loop;
  354. case POP_AF:        time(10); rf=peek(sp++); ra = peek(sp++); loop;
  355.  
  356. case EX_DE_HL:    
  357.     time(4);
  358.     w=DE;DE=HL;HL=w;
  359.     loop;
  360. case EX_AF_AF:    
  361.     time(4);
  362.     c=ra;ra=RA2;RA2=c; 
  363.     c=rf;rf=RF2;RF2=c; 
  364.     loop;
  365. case EXX:    
  366.     time(4);
  367.     w=BC;BC=BC2;BC2=w; 
  368.     w=DE;DE=DE2;DE2=w;
  369.     w=HL;HL=HL2;HL2=w; 
  370.     loop;
  371. case EX_HL_xSP:    
  372.     time(19);
  373.     w=pop(); 
  374.     push(HL); 
  375.     HL = w; 
  376.     loop;
  377.  
  378.  
  379. // ----    ODDS ----------------------------------------------
  380.  
  381. case SCF:     time(4); rf|=C_FLAG; rf&=~(N_FLAG+H_FLAG);            loop;
  382. case CCF:     time(4); rf^=C_FLAG; rf&=~N_FLAG;                    loop;
  383. case CPL:     time(4); ra=~ra; rf|=N_FLAG+H_FLAG;                    loop;
  384. case NOP:     time(4);                                             loop;
  385. case DI:      info_misc1; time(4); IFF1=IFF2=disabled;    loop;
  386. case EI:      info_misc1; time(4);
  387. #ifdef EI_WITH_DELAY
  388.             if (WUFF && IFF1==disabled) ccx=cc-4;
  389.             IFF1=IFF2=enabled;    loop;
  390. #else
  391.             IFF1=IFF2=enabled;    goto check_wuff;
  392. #endif
  393. case HALT:    info_misc1; time(4); exit(halt_instr);
  394.  
  395. case OUTA:    
  396.     time(11);
  397.     sto_cc;
  398.     Do_Output ( ((Short)ra<<8) + n,ra );    
  399.     loop;
  400. case INA:     
  401.     time(11);
  402.     sto_cc;
  403.     ra = Do_Input ( ((Short)ra<<8) + n);
  404.     loop;
  405.  
  406.  
  407. // ----    DAA --------------------------------------------------------
  408.  
  409. case DAA:
  410.     info_misc1;
  411.     time(4);
  412.     if (rf&N_FLAG)            // previous instruction was SUB
  413.     {    if (rf&H_FLAG) ra -= 0x06;
  414.         if (rf&C_FLAG) ra -= 0x60;
  415.     }
  416.     else                    // previous instruction was ADD
  417.     {    if ((ra&0x0F)>0x09) rf |= H_FLAG;
  418.         if (rf&H_FLAG)         ra += 0x06;
  419.         if (ra>0x99)         rf |= C_FLAG;
  420.         if (rf&C_FLAG)        ra += 0x60;
  421.     };
  422.  
  423.     rf &= C_FLAG+N_FLAG;
  424.     rf |= zlog_flags[ra];
  425.     loop;
  426.  
  427.  
  428. // ----    PREFIX COMMANDS ---------------------------------------------
  429.  
  430. case PFX_FD:    izp = (dreg*)&IY; goto XY;
  431. case PFX_DD:    izp = (dreg*)&IX;       XY:
  432. #include "CodesXX.c"
  433.  
  434. case PFX_CB:
  435. #include "CodesCB.c"
  436.  
  437. case PFX_ED:
  438. #include "CodesED.c"
  439.  
  440. default:        // this should never happen
  441.     pc-=1;
  442.     exit(nimp_instr);
  443.  
  444. };
  445. loop;
  446.  
  447.