Category
Home > Category > Code/Resource > Crypt_Decrypt algrithms > CA program > View Code

cpu.cpp

Package [view]: EmuNation2.0.0.2-Sou
Upload User: lihuahe
Upload Date: 2009-10-16
Package Size: 7122k
Code Size: 34k
Category: CA program
Development Platform: C++
cpu.cpp：Code Content
  1. /*
  2.  * Softcam plugin to VDR (C++)
  3.  *
  4.  * This code is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This code is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  18.  */
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. //#include <unistd.h>
  24. #include <ctype.h>
  25. #include "stdafx.h"
  26. //#include <vdr/tools.h>
  28. #include "common.h"
  29. #include "data.h"
  31. #include "debug.h"
  32. #include "cpu.h"
  34. #include "xnprintf.h"
  36. #include "main.h"
  37. extern class DllClass m_DLLInstance;
  39. static bool pc80flag=false;
  41. // -- cMapMem ------------------------------------------------------------------
  43. cMapMem::cMapMem(unsigned short Offset, int Size)
  44. {
  45. offset=Offset; size=Size;
  46. if((mem=(unsigned char *)malloc(size)))
  47. memset(mem,0,size);
  48. dn(printf("mapmem: new map off=%04x size=%04xn",offset,size))
  49. }
  51. cMapMem::~cMapMem()
  52. {
  53. free(mem);
  54. }
  56. bool cMapMem::IsFine(void)
  57. {
  58. return (mem!=0);
  59. }
  61. unsigned char cMapMem::Get(unsigned short ea)
  62. {
  63. return (ea>=offset && ea<offset+size) ? mem[ea-offset] : 0;
  64. }
  66. void cMapMem::Set(unsigned short ea, unsigned char val)
  67. {
  68. if(ea>=offset && ea<offset+size)
  69. mem[ea-offset]=val;
  70. }
  72. // -- cMapRom ------------------------------------------------------------------
  74. cMapRom::cMapRom(unsigned short Offset, const char *Filename, int InFileOffset)
  75. {
  76. offset=Offset; addr=0;
  77. fm=filemaps.GetFileMap(Filename,FILEMAP_DOMAIN,false);
  78. if(fm && fm->Map()) {
  79. addr=fm->Addr()+InFileOffset;
  80. size=fm->Size()-InFileOffset;
  81. dn(printf("maprom: new map off=%04x size=%04xn",offset,size))
  82. }
  83. }
  85. cMapRom::~cMapRom()
  86. {
  87. if(fm) fm->Unmap();
  88. }
  90. bool cMapRom::IsFine(void)
  91. {
  92. return (addr!=0);
  93. }
  95. unsigned char cMapRom::Get(unsigned short ea)
  96. {
  97. return (ea>=offset && ea<offset+size) ? addr[ea-offset] : 0;
  98. }
  100. void cMapRom::Set(unsigned short ea, unsigned char val)
  101. {
  102. Show_Diss = m_DLLInstance.m_show_diss;
  103. if(ea>=offset && ea<offset+size) if (Show_Diss==1) de(printf("[ROM] "))
  104. // this is a ROM!
  105. }
  107. // -- cMapEeprom ---------------------------------------------------------------
  109. cMapEeprom::cMapEeprom(unsigned short Offset, const char *Filename, int OtpSize, int InFileOffset)
  110. {
  111. offset=Offset; otpSize=OtpSize; addr=0;
  112. fm=filemaps.GetFileMap(Filename,FILEMAP_DOMAIN,true);
  113. if(fm && fm->Map()) {
  114. addr=fm->Addr()+InFileOffset;
  115. size=fm->Size()-InFileOffset;
  116. dn(printf("mapeeprom: new map off=%04x size=%04x otp=%04xn",offset,size,otpSize))
  117. }
  118. }
  120. cMapEeprom::~cMapEeprom()
  121. {
  122. if(fm) fm->Unmap();
  123. }
  125. bool cMapEeprom::IsFine(void)
  126. {
  127. return (addr!=0);
  128. }
  130. unsigned char cMapEeprom::Get(unsigned short ea)
  131. {
  132. return (ea>=offset && ea<offset+size) ? addr[ea-offset] : 0;
  133. }
  135. void cMapEeprom::Set(unsigned short ea, unsigned char val)
  136. {
  137. Show_Diss = m_DLLInstance.m_show_diss;
  138. if(ea>=offset && ea<offset+otpSize) {
  139. if(addr[ea-offset]==0) {
  140. addr[ea-offset]=val;
  141. if (Show_Diss==1) de(printf("[OTP-SET] "))
  142. }
  143. if (Show_Diss==1) de(printf("[OTP] "))
  144. }
  145. if(ea>=offset+otpSize && ea<offset+size) {
  146. addr[ea-offset]=val;
  147. if (Show_Diss==1) de(printf("[EEP] "))
  148. }
  149. }
  151. // -- c6805 --------------------------------------------------------------------
  153. #define HILO(ea)      ((Get(ea)<<8)+Get((ea)+1))
  154. #define HILOS(s,ea)   ((Get((ea),(s))<<8)+Get((ea)+1,(s)))
  155. #define PAGEOFF(ea,s) (((ea)&0x8000) ? pageMap[s]:0)
  157. static char * __paddr(unsigned char s, unsigned short ea)
  158. {
  159. static char addr[32];
  160. _snprintf(addr,sizeof(addr),((ea&0x8000) && s>0)?"%2$x:%1$04x":"%04x",ea,s);
  161. return addr;
  162. }
  163. #define PADDR(s,ea)   __paddr(s,ea)
  165. c6805::c6805(void) {
  166. cc.c=0; cc.z=0; cc.n=0; cc.i=0; cc.h=0; cc.v=1;
  167. pc=0; a=0; x=0; y=0; cr=dr=0; sp=spHi=0x100; spLow=0xC0;
  168. ClearBreakpoints();
  169. InitMapper();
  170. #ifdef DEBUG_STAT
  171. memset(stats,0,sizeof(stats));
  172. #endif
  173. }
  175. c6805::~c6805()
  176. {
  177. #ifdef DEBUG_STAT
  178. int i, j, sort[256];
  179. bool done=false;
  180. for(i=0 ; i<256 ; i++) sort[i]=i;
  181. for(i=0 ; i<256 && !done ; i++)
  182. for(j=0 ; j<255 ; j++)
  183. if(stats[sort[j]]<stats[sort[j+1]]) {
  184. int x=sort[j];
  185. sort[j]=sort[j+1];
  186. sort[j+1]=x;
  187. done=false;
  188. }
  189. printf("6805: opcode statisticsn");
  190. for(i=0 ; i<256 ; i++)
  191. if((j=stats[sort[i]])) printf("6805: opcode %02x: %dn",sort[i],j);
  192. #endif
  193. ClearMapper();
  194. }
  196. bool c6805::AddMapper(cMap *map, unsigned short start, int size, unsigned char seg)
  197. {
  198. if(map && map->IsFine()) {
  199. if(nextMapper<MAX_MAPPER) {
  200. mapper[nextMapper]=map;
  201. memset(&mapMap[start+PAGEOFF(start,seg)],nextMapper,size);
  202. nextMapper++;
  203. return true;
  204. }
  205. else if (Show_Diss==1) dee(printf("6805: too many mappersn"))
  206. }
  207. else if (Show_Diss==1) dee(printf("6805: mapper not readyn"))
  208. delete map;
  209. return false;
  210. }
  212. void c6805::ResetMapper(void)
  213. {
  214. ClearMapper(); InitMapper();
  215. }
  217. void c6805::InitMapper(void)
  218. {
  219. memset(mapMap,0,sizeof(mapMap));
  220. memset(mapper,0,sizeof(mapper));
  221. mapper[0]=new cMapMem(0,PAGE_SIZE*2);
  222. nextMapper=1;
  223. memset(pageMap,0,sizeof(pageMap));
  224. pageMap[0]=PAGE_SIZE*0;
  225. pageMap[1]=PAGE_SIZE*1;
  226. pageMap[2]=PAGE_SIZE*2;
  227. pageMap[0x80]=PAGE_SIZE*3;
  228. }
  230. void c6805::ClearMapper(void)
  231. {
  232. for(int i=0; i<MAX_MAPPER; i++) delete mapper[i];
  233. }
  235. unsigned char c6805::Get(unsigned short ea) const
  236. {
  237. return mapper[mapMap[ea+PAGEOFF(ea,cr)]&0x7f]->Get(ea);
  238. }
  240. unsigned char c6805::Get(unsigned char seg, unsigned short ea) const
  241. {
  242. return mapper[mapMap[ea+PAGEOFF(ea,seg)]&0x7f]->Get(ea);
  243. }
  245. void c6805::Set(unsigned short ea, unsigned char val)
  246. {
  247. unsigned char mapId=mapMap[ea+PAGEOFF(ea,cr)];
  248. if(!(mapId&0x80)) mapper[mapId&0x7f]->Set(ea,val);
  249. }
  251. void c6805::Set(unsigned char seg, unsigned short ea, unsigned char val)
  252. {
  253. unsigned char mapId=mapMap[ea+PAGEOFF(ea,seg)];
  254. if(!(mapId&0x80)) mapper[mapId&0x7f]->Set(ea,val);
  255. }
  257. void c6805::ForceSet(unsigned short ea, unsigned char val, bool ro)
  258. {
  259. mapMap[ea]=0;      // reset to RAM map
  260. Set(0,ea,val);       // set value
  261. if(ro) mapMap[ea]|=0x80;  // protect byte
  262. }
  264. void c6805::SetMem(unsigned short addr, const unsigned char *data, int len, unsigned char seg)
  265. {
  266. while(len>0) { Set(seg,addr++,*data++); len--; }
  267. }
  269. void c6805::GetMem(unsigned short addr, unsigned char *data, int len, unsigned char seg) const
  270. {
  271. while(len>0) { *data++=Get(seg,addr++); len--; }
  272. }
  274. void c6805::SetSp(unsigned short SpHi, unsigned short SpLow)
  275. {
  276. spHi =sp=SpHi;
  277. spLow   =SpLow;
  278. }
  280. void c6805::SetPc(unsigned short addr)
  281. {
  282. pc=addr;
  283. }
  285. void c6805::AddBreakpoint(unsigned short addr)
  286. {
  287. Show_Diss = m_DLLInstance.m_show_diss;
  288. if(numBp<MAX_BREAKPOINTS) {
  289. bp[numBp++]=addr;
  290. if (Show_Diss==1) dee(printf("6805: setting breakpoint at 0x%04xn",addr))
  291. }
  292. else if (Show_Diss==1) dee(printf("6805: too many breakpointsn"))
  293. }
  295. void c6805::ClearBreakpoints(void)
  296. {
  297. numBp=0;
  298. memset(bp,0,sizeof(bp));
  299. }
  301. static const char * const ops[] = {
  302. //         0x00    0x01    0x02    0x03    0x04    0x05    0x06    0x07    0x08    0x09    0x0a    0x0b    0x0c    0x0d    0x0e    0x0f
  303. /* 0x00 */ "BRSET","BRCLR","BRSET","BRCLR","BRSET","BRCLR","BRSET","BRCLR","BRSET","BRCLR","BRSET","BRCLR","BRSET","BRCLR","BRSET","BRCLR",
  304. /* 0x10 */ "BSET", "BCLR", "BSET", "BCLR", "BSET", "BCLR", "BSET", "BCLR", "BSET", "BCLR", "BSET", "BCLR", "BSET", "BCLR", "BSET", "BCLR",
  305. /* 0x20 */ "BRA",  "BRN",  "BHI",  "BLS",  "BCC",  "BCS",  "BNE",  "BEQ",  "BHCC", "BHCS", "BPL",  "BMI",  "BMC",  "BMS",  "BIL",  "BIH",
  306. /* 0x30 */ "NEG",  "pre31","pre32","COM",  "LSR",  "op35", "ROR",  "ASR",  "ASL",  "ROL",  "DEC",  "op3b", "INC",  "TST",  "SWAP", "CLR",
  307. /* 0x40 */ "NEG",  "op41", "MUL",  "COM",  "LSR",  "op45", "ROR",  "ASR",  "ASL",  "ROL",  "DEC",  "op4b", "INC",  "TST",  "SWAP", "CLR",
  308. /* 0x50 */ "NEG",  "op51", "MUL",  "COM",  "LSR",  "op55", "ROR",  "ASR",  "ASL",  "ROL",  "DEC",  "op5b", "INC",  "TST",  "SWAP", "CLR",
  309. /* 0x60 */ "NEG",  "op61", "op62", "COM",  "LSR",  "op65", "ROR",  "ASR",  "ASL",  "ROL",  "DEC",  "op6b", "INC",  "TST",  "SWAP", "CLR",
  310. /* 0x70 */ "NEG",  "LDD",  "LDD",  "COM",  "LSR",  "LDD",  "ROR",  "ASR",  "ASL",  "ROL",  "DEC",  "TAD",  "INC",  "TST",  "SWAP", "CLR",
  311. /* 0x80 */ "RTI",  "RTS",  "op82", "SWI",  "POPA", "POP%c","POPC", "PRTS", "PUSHA","PUSH%c","PUSHC","TDA", "TCA",  "PJSR", "STOP", "WAIT",
  312. /* 0x90 */ "pre90","pre91","pre92","T%2$c%1$c","T%cS","TAS","TS%c","TA%c", "CLC",  "SEC",  "CLI",  "SEI",  "RSP",  "NOP",  "TSA",  "T%cA",
  313. /* 0xa0 */ "SUB",  "CMP",  "SBC",  "CP%c", "AND",  "BIT",  "LDA",  "opa7", "EOR",  "ADC",  "ORA",  "ADD",  "PUSHD","BSR",  "LD%c", "POPD",
  314. /* 0xb0 */ "SUB",  "CMP",  "SBC",  "CP%c", "AND",  "BIT",  "LDA",  "STA",  "EOR",  "ADC",  "ORA",  "ADD",  "JMP",  "JSR",  "LD%c", "ST%c",
  315. /* 0xc0 */ "SUB",  "CMP",  "SBC",  "CP%c", "AND",  "BIT",  "LDA",  "STA",  "EOR",  "ADC",  "ORA",  "ADD",  "JMP",  "JSR",  "LD%c", "ST%c",
  316. /* 0xd0 */ "SUB",  "CMP",  "SBC",  "CP%c", "AND",  "BIT",  "LDA",  "STA",  "EOR",  "ADC",  "ORA",  "ADD",  "JMP",  "JSR",  "LD%c", "ST%c",
  317. /* 0xe0 */ "SUB",  "CMP",  "SBC",  "CP%c", "AND",  "BIT",  "LDA",  "STA",  "EOR",  "ADC",  "ORA",  "ADD",  "JMP",  "JSR",  "LD%c", "ST%c",
  318. /* 0xf0 */ "SUB",  "CMP",  "SBC",  "CP%c", "AND",  "BIT",  "LDA",  "STA",  "EOR",  "ADC",  "ORA",  "ADD",  "JMP",  "JSR",  "LD%c", "ST%c",
  319. };
  320. static const char * const vops[] = {
  321. "BVGT","BVLE","BVGE","BVLT","BVC","BVS"
  322. };
  324. // Flags:
  325. // 1 - read operant
  326. // 2 - write operant
  327. // 4 - use dr register
  328. // 8 - special address mode in high nibble
  329. static const char opFlags[] = {
  330. //            00    01    02    03    04    05    06    07    08    09    0a    0b    0c    0d    0e    0f
  331. /* 0x00 */  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  332. /* 0x10 */  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  333. /* 0x20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  334. /* 0x30 */  0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02,
  335. /* 0x40 */  0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02,
  336. /* 0x50 */  0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02,
  337. /* 0x60 */  0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02,
  338. /* 0x70 */  0x03, 0xA9, 0xB9, 0x03, 0x03, 0xC9, 0x03, 0x03, 0x03, 0x03, 0x03, 0x88, 0x03, 0x01, 0x03, 0x02,
  339. /* 0x80 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  340. /* 0x90 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  341. /* 0xa0 */  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x88, 0x88, 0x01, 0x88,
  342. /* 0xb0 */  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x02,
  343. /* 0xc0 */  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x05, 0x06,
  344. /* 0xd0 */  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x05, 0x06,
  345. /* 0xe0 */  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x05, 0x06,
  346. /* 0xf0 */  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x05, 0x06,
  347. };
  349. // OP Code - Instruction Set Length
  350. static const unsigned int ISlen[] = {
  351. //         0x00  0x01  0x02  0x03  0x04  0x05  0x06  0x07  0x08  0x09  0x0a  0x0b  0x0c  0x0d  0x0e  0x0f
  352. /* 0x00 */ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  353. /* 0x10 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  354. /* 0x20 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  355. /* 0x30 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  356. /* 0x40 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  357. /* 0x50 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  358. /* 0x60 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  359. /* 0x70 */ 0x01, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  360. /* 0x80 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  361. /* 0x90 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  362. /* 0xa0 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x01,
  363. /* 0xb0 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  364. /* 0xc0 */ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  365. /* 0xd0 */ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  366. /* 0xe0 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  367. /* 0xf0 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  368. };
  370. int c6805::Run(int max_count)
  371. {
  372. // returns:
  373. // 0 - breakpoint
  374. // 1 - stack overflow
  375. // 2 - instruction counter exeeded
  376. // 3 - unsupported instruction
  378. Show_Diss = m_DLLInstance.m_show_diss;
  379. pc80flag=false;
  380. LoopCount=0;
  381. if (Show_Diss==1) dee(printf("6805: cr:-pc- aa xx yy dr -sp- VHINZC -mem@pc- -mem@sp-n"))
  382. while (1) {
  383. if (sp<spLow) {
  384. printf("*** stack overflow (count=%d)n",LoopCount);
  385. return 1;
  386. }
  387. if (spHi>spLow && sp>spHi) {
  388. printf("*** stack underflow (count=%d)n",LoopCount);
  389. return 1;
  390. }
  391. LoopCount++;
  393. bool flag=(pc>=0x80 && pc<0xE0);
  394. if (pc80flag && !flag && Show_Diss==1) printf("6805: [...]n");
  395. pc80flag=flag;
  397. sprintf(displaystr1,"  %.4X: ", pc);
  398.     sprintf(displaystr2,"");
  399. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  400. if (Show_Diss==1) de(printf("6805: %02x:%04x %02x %02x %02x %02x %04x %c%c%c%c%c%c %02x%02x%02x%02x %02x%02x%02x%02x ",
  401.        cr,pc,a,x,y,dr,sp,
  402.        cc.v?'V':'.',cc.h?'H':'.',cc.i?'I':'.',cc.n?'N':'.',cc.z?'Z':'.',cc.c?'C':'.',
  403.        Get(pc),Get(pc+1),Get(pc+2),Get(pc+3),Get(sp+1),Get(sp+2),Get(sp+3),Get(sp+4)))
  405. Stepper();
  406. unsigned char *ex=&x;
  407. unsigned short idx=*ex;
  408. indirect=false;
  409. bool paged=false, vbra=false;
  410. unsigned char ins=Get(pc++);
  411. char xs='X', xi='X';
  412.  
  413.   // check pre-bytes
  414. switch (ins) {
  415. case 0x31: // use SP indexed or indirect paged mode (ST19)
  416. ins=Get(pc++);
  417. switch(ins) {
  418. case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: 
  419. vbra=true; 
  420. if (Show_Diss==1) printf("WARN: V-flag not yet calculated ");
  421. break;
  422. case 0x75:
  423. case 0x8D:
  424. case 0xC0: case 0xC1: case 0xC2: case 0xC3: case 0xC4: case 0xC5: case 0xC6: case 0xC7: case 0xC8: case 0xC9: case 0xCA: case 0xCB:
  425. case 0xCE: case 0xCF:
  426. case 0xD0: case 0xD1: case 0xD2: case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7: case 0xD8: case 0xD9: case 0xDA: case 0xDB:
  427. case 0xDE: case 0xDF: 
  428. paged=true; 
  429. indirect=true; 
  430. break;
  431. case 0xE0: case 0xE1: case 0xE2: case 0xE3: case 0xE4: case 0xE5: case 0xE6: case 0xE7: case 0xE8: case 0xE9: case 0xEA: case 0xEB:
  432. case 0xEE: case 0xEF: 
  433. idx=sp; 
  434. de(xi='S') 
  435. break;
  436. }
  437. break;
  438. case 0x32: // use indirect SP indexed or indirect paged Y indexed mode (ST19)
  439. ins=Get(pc++);
  440. switch(ins) {
  441. case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: 
  442. vbra=true; 
  443. if (Show_Diss==1) printf("WARN: V-flag not yet calculated ");
  444. indirect=true; 
  445. break;
  446. case 0xC3:
  447. case 0xCE: case 0xCF:
  448. case 0xD0: case 0xD1: case 0xD2: case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7: case 0xD8: case 0xD9: case 0xDA: case 0xDB:
  449. case 0xDE: case 0xDF: 
  450. paged=true; 
  451. indirect=true; 
  452. ex=&y; idx=*ex; 
  453. de(xs='Y') 
  454. de(xi='Y') 
  455. break;
  456. case 0xE0: case 0xE1: case 0xE2: case 0xE3: case 0xE4: case 0xE5: case 0xE6: case 0xE7: case 0xE8: case 0xE9: case 0xEA: case 0xEB:
  457. case 0xEE: case 0xEF: indirect=true; idx=sp; de(xi='S') break;
  458. }
  459. break;
  460. case 0x91: // use Y register with indirect addr mode (ST7)
  461. indirect=true;
  462. // fall through
  463. case 0x90: // use Y register (ST7)
  464. ex=&y; idx=*ex; de(xs='Y') de(xi='Y')
  465. ins=Get(pc++);
  466. break;
  467. case 0x92: // use indirect addr mode (ST7)
  468. indirect=true;
  469. ins=Get(pc++);
  470. break;
  471. }
  473. char str[8];
  474. if (!vbra) _snprintf(str,sizeof(str),ops[ins],xs,xs^1);
  475. else       _snprintf(str,sizeof(str),"%s",vops[ins-0x22]);
  476. sprintf(txt,"%-5s ", str); strcat(displaystr2, txt);
  477. if (pc80flag && Show_Diss==1) printf(txt);
  479.   // address decoding
  480. unsigned short ea=0;
  481. unsigned char flags=opFlags[ins];
  482. unsigned char pr=(flags&4) ? dr:cr;
  483. switch (((flags&8) ? flags:ins)>>4) {
  484. case 0x2: // no or special address mode
  485. case 0x8:
  486. case 0x9:
  487. if (ISlen[ins] == 2) {
  488. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  489. }
  490. break;
  491. case 0xA: // immediate
  492. if (ISlen[ins] == 2) {
  493. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  494. }
  495. sprintf(txt,"#%02x ",Get(pc)); strcat(displaystr2, txt);
  496. if (pc80flag && Show_Diss==1) printf(txt);
  497. ea=pc++; break;
  498. case 0x3: // short
  499. case 0xB:
  500. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  501. ea=Get(pc++);
  503. if (ea==5) 
  504. //Special Attribute bit
  505. ea = 5;
  506. else {
  507. if(!indirect) { // short direct
  508.   }
  509. else { // short indirect
  510.   de(printf("[%02x] -> ",ea))
  511.   ea=Get(ea);
  512. }
  513. }
  514. sprintf(txt,"%02x ",ea); strcat(displaystr2, txt);
  515. if (pc80flag && Show_Diss==1) printf(txt);
  516. break;
  517. case 0xC: // long
  518. if(!indirect) { // long direct
  519. sprintf(txt,"%.2X%.2X", Get(pc),Get(pc+1)); strcat(displaystr1, txt);
  520. ea=HILO(pc); pc+=2;
  521. } else { // long indirect
  522. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  523. if (paged) {
  524. ea=HILO(pc); pc+=2;
  525. sprintf(txt,"[%s] -> ",PADDR(pr,ea)); strcat(displaystr2, txt);
  526. if (pc80flag && Show_Diss==1) printf(txt);
  527. unsigned char s=Get(pr,ea);
  528. ea=HILOS(pr,ea+1);
  529. pr=s;
  530.     } else {
  531. ea=Get(pc++);
  532. sprintf(txt,"[%02x] -> ",ea); strcat(displaystr2, txt);
  533. if (pc80flag && Show_Diss==1) printf(txt);
  534. ea=HILO(ea);
  535.     }
  536. }
  537. sprintf(txt,"%s ",PADDR(pr,ea)); strcat(displaystr2, txt);
  538. if (pc80flag && Show_Diss==1) printf(txt);
  539. break;
  540. case 0xD: // long indexed
  541. if(!indirect) { // long direct indexed
  542. sprintf(txt,"%.2X%.2X", Get(pc),Get(pc+1)); strcat(displaystr1, txt);
  543. ea=HILO(pc); pc+=2;
  544. sprintf(txt,"(%s",PADDR(cr,ea)); strcat(displaystr2, txt);
  545. if (pc80flag && Show_Diss==1) printf(txt);
  546. } else { // long indirect indexed
  547. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  548. if(paged) {
  549. ea=HILO(pc); pc+=2;
  550. sprintf(txt,"([%s]",PADDR(pr,ea)); strcat(displaystr2, txt);
  551. if (pc80flag && Show_Diss==1) printf(txt);
  552. unsigned char s=Get(pr,ea++);
  553. ea=HILOS(pr,ea);
  554. pr=s;
  555.     } else {
  556. ea=Get(pc++);
  557. sprintf(txt,"([%02x]",ea); strcat(displaystr2, txt);
  558. if (pc80flag && Show_Diss==1) printf(txt);
  559. ea=HILO(ea);
  560.     }
  561. sprintf(txt,",%c) -> (%s",xi,PADDR(pr,ea)); strcat(displaystr2, txt);
  562. if (pc80flag && Show_Diss==1) printf(txt);
  563. }
  564. ea+=idx;
  565. sprintf(txt,",%c) -> %s ",xi,PADDR(pr,ea)); strcat(displaystr2, txt);
  566. if (pc80flag && Show_Diss==1) printf(txt);
  567. break;
  568. case 0x6: // short indexed
  569. case 0xE:
  570. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  571. ea=Get(pc++);
  572. if(!indirect) { // short direct indexed
  573. sprintf(txt,"(%02x",ea); strcat(displaystr2, txt);
  574. if (pc80flag && Show_Diss==1) printf(txt);
  575. } else { // short indirect indexed
  576. sprintf(txt,"([%02x]",ea); strcat(displaystr2, txt);
  577. if (pc80flag && Show_Diss==1) printf(txt);
  578. ea=Get(ea);
  579. sprintf(txt,",%c) -> (%02x",xi,ea); strcat(displaystr2, txt);
  580. if (pc80flag && Show_Diss==1) printf(txt);
  581. }
  582. ea+=idx;
  583. sprintf(txt,",%c) -> %s ",xi,PADDR(pr,ea)); strcat(displaystr2, txt);
  584. if (pc80flag && Show_Diss==1) printf(txt);
  585. break;
  586. case 0x7: // indexed
  587. case 0xF:
  588. ea=idx;
  589. sprintf(txt,"(%c) -> %s ",xi,PADDR(pr,ea)); strcat(displaystr2, txt);
  590. if (pc80flag && Show_Diss==1) printf(txt);
  591. break;
  592. case 0x4: // inherent A
  593. sprintf(txt,"A "); strcat(displaystr2, txt);
  594. if (pc80flag && Show_Diss==1) printf(txt);
  595. break;
  596. case 0x5: // inherent X/Y
  597. sprintf(txt,"%c ",xs); strcat(displaystr2, txt);
  598. if (pc80flag && Show_Diss==1) printf(txt);
  599. break;
  600. case 0x0: // bit
  601. case 0x1:
  602. sprintf(txt,"%.2X", Get(pc)); strcat(displaystr1, txt);
  603. ea=Get(pc++);
  604. if(!indirect) {
  605. } else {
  606. sprintf(txt,"[%02x] -> ",ea); strcat(displaystr2, txt);
  607. if (pc80flag && Show_Diss==1) printf(txt);
  608. ea=Get(ea);
  609. indirect=false; // don't use indirect mode in case this is a bit branch
  610. }
  611. sprintf(txt,"%02x ",ea); strcat(displaystr2, txt);
  612. if (pc80flag && Show_Diss==1) printf(txt);
  613. break;
  614. }
  616. // read operant
  617. unsigned char op=0;
  618. if (flags & 1) {
  619. switch (((flags&8) ? flags:ins)>>4) {
  620. case 0x2: // no or special address mode
  621. case 0x8:
  622. case 0x9:
  623.   break;
  624. case 0xA: // immediate
  625. case 0x3: // short
  626. case 0xB:
  627. case 0xC: // long
  628. case 0xD: // long indexed
  629. case 0x6: // short indexed
  630. case 0xE:
  631. case 0x7: // indexed
  632. case 0xF:
  633. case 0x0: // bit
  634. case 0x1:
  635.   //if register 5 bit 7 is set
  636.   if (Get(0x00,0x05)& 0x40) {
  637.   //Get Start and end of codespace from bin
  638.   unsigned short start = Get(0, 0x30C0);
  639.   unsigned short end =  Get(0,0x30C1);
  640.   if ( ((ea>>8) >=start) && ((ea>>8)<=end))
  641.   //its in the dataspace - return 0
  642.   op = 0x00;
  643.   else
  644.   //its in the codespace return 1
  645.   op = 0x01;
  646.   }
  647.   else
  648.   op=Get(pr,ea); 
  649.   break;
  650. case 0x4: // inherent A
  651.   op=a; break;
  652. case 0x5: // inherent X/Y
  653.   op=*ex; break;
  654. }
  655. }
  657. // command decoding
  658. #ifdef DEBUG_STAT
  659. stats[ins]++;
  660. #endif
  661. switch (ins) {
  662. case 0xA6: // LDA
  663. case 0xB6:
  664. case 0xC6:
  665. case 0xD6:
  666. case 0xE6:
  667. case 0xF6:
  668. a=op; tst(op); break;
  669. case 0xAE: // LDX
  670. case 0xBE:
  671. case 0xCE:
  672. case 0xDE:
  673. case 0xEE:
  674. case 0xFE:
  675. *ex=op; tst(op); break;
  676. case 0xB7: // STA
  677. case 0xC7:
  678. case 0xD7:
  679. case 0xE7:
  680. case 0xF7:
  681. op=a; tst(op); break;
  682. case 0xBF: // STX
  683. case 0xCF:
  684. case 0xDF:
  685. case 0xEF:
  686. case 0xFF:
  687. op=*ex; tst(op); break;
  688. case 0x97: // TAX
  689. *ex=a; break;
  690. case 0x9F: // TXA
  691. a=*ex; break;
  692. case 0x93: // TYX (ST7)
  693. if(ex==&x) *ex=y; else *ex=x; break;
  694. case 0x3D: // TST
  695. case 0x4D:
  696. case 0x5D:
  697. case 0x6D:
  698. case 0x7D:
  699. tst(op); break;
  700. case 0x3F: // CLR
  701. case 0x4F:
  702. case 0x5F:
  703. case 0x6F:
  704. case 0x7F:
  705. op=0; tst(0); break;
  706. case 0x3C: // INC
  707. case 0x4C:
  708. case 0x5C:
  709. case 0x6C:
  710. case 0x7C:
  711. op++; tst(op); break;
  712. case 0x3A: // DEC
  713. case 0x4A:
  714. case 0x5A:
  715. case 0x6A:
  716. case 0x7A:
  717. op--; tst(op); break;
  718. case 0x33: // COM
  719. case 0x43:
  720. case 0x53:
  721. case 0x63:
  722. case 0x73:
  723. op=~op; cc.c=1; tst(op); break;
  724. case 0x30: // NEG
  725. case 0x40:
  726. case 0x50:
  727. case 0x60:
  728. case 0x70:
  729. op=~op+1; if(!op) cc.c=0; tst(op); break;
  730. case 0x42: // MUL
  731. case 0x52:
  732. {
  733. unsigned short res=*ex * a;
  734. *ex=(res>>8); a=res&0xff; cc.c=0; cc.h=0;
  735. break;
  736. }
  737. case 0xA9: // ADC
  738. case 0xB9:
  739. case 0xC9:
  740. case 0xD9:
  741. case 0xE9:
  742. case 0xF9:
  743. a=add(op,cc.c); break;
  744. case 0xAB: // ADD
  745. case 0xBB:
  746. case 0xCB:
  747. case 0xDB:
  748. case 0xEB:
  749. case 0xFB:
  750. a=add(op,0); break;
  751. case 0xA2: // SBC
  752. case 0xB2:
  753. case 0xC2:
  754. case 0xD2:
  755. case 0xE2:
  756. case 0xF2:
  757. a=sub(a,op,cc.c); break;
  758. case 0xA0: // SUB
  759. case 0xB0:
  760. case 0xC0:
  761. case 0xD0:
  762. case 0xE0:
  763. case 0xF0:
  764. a=sub(a,op,0); break;
  765. case 0xA1: // CMP
  766. case 0xB1:
  767. case 0xC1:
  768. case 0xD1:
  769. case 0xE1:
  770. case 0xF1:
  771. sub(a,op,0); break;
  772. case 0xA3: // CPX
  773. case 0xB3:
  774. case 0xC3:
  775. case 0xD3:
  776. case 0xE3:
  777. case 0xF3:
  778. sub(*ex,op,0); break;
  779. case 0xA4: // AND
  780. case 0xB4:
  781. case 0xC4:
  782. case 0xD4:
  783. case 0xE4:
  784. case 0xF4:
  785. a &= op; tst(a); break;
  786. case 0xAA: // ORA
  787. case 0xBA:
  788. case 0xCA:
  789. case 0xDA:
  790. case 0xEA:
  791. case 0xFA:
  792. a |= op; tst(a); break;
  793. case 0xA8: // EOR
  794. case 0xB8:
  795. case 0xC8:
  796. case 0xD8:
  797. case 0xE8:
  798. case 0xF8:
  799. a ^= op; tst(a); break;
  800. case 0xA5: // BIT
  801. case 0xB5:
  802. case 0xC5:
  803. case 0xD5:
  804. case 0xE5:
  805. case 0xF5:
  806. tst(a & op); break;
  807. case 0x38: // ASL
  808. case 0x48:
  809. case 0x58:
  810. case 0x68:
  811. case 0x78:
  812. op=rollL(op,0); break;
  813. case 0x39: // ROL
  814. case 0x49:
  815. case 0x59:
  816. case 0x69:
  817. case 0x79:
  818. op=rollL(op,cc.c); break;
  819. case 0x37: // ASR
  820. case 0x47:
  821. case 0x57:
  822. case 0x67:
  823. case 0x77:
  824. op=rollR(op,bitset(op,7)); break;
  825. case 0x34: // LSR
  826. case 0x44:
  827. case 0x54:
  828. case 0x64:
  829. case 0x74:
  830. op=rollR(op,0); break;
  831. case 0x36: // ROR
  832. case 0x46:
  833. case 0x56:
  834. case 0x66:
  835. case 0x76:
  836. op=rollR(op,cc.c); break;
  837. case 0x3E: // SWAP (ST7)
  838. case 0x4E:
  839. case 0x5E:
  840. case 0x6E:
  841. case 0x7E:
  842. op=(op<<4)|(op>>4); tst(op); break;
  843.   case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F: // BRSET BRCLR
  844. {
  845. int bit=(ins&0x0F)>>1;
  846. sprintf(txt,",#%x,",bit); strcat(displaystr2, txt);
  847. if (pc80flag && Show_Diss==1) printf(txt);
  848. cc.c=bitset(op,bit);
  849. branch((ins&0x01) ? !cc.c:cc.c);
  850. break;
  851. }
  852.   case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F: // BSET BCLR
  853. {
  854. int bit=(ins&0x0F)>>1;
  855. sprintf(txt,",#%x",bit); strcat(displaystr2, txt);
  856. if (pc80flag && Show_Diss==1) printf(txt);
  857. if(ins&0x01) op &= ~(1<<bit);
  858. else         op |=  (1<<bit);
  859. break;
  860. }
  861. case 0x20: // BRA
  862. branch(true); break;
  863. case 0x21: // BRN
  864. branch(false); break;
  865. case 0x22: // BHI
  866. if(vbra) branch(!cc.z && ((cc.n && cc.v) || (!cc.n && !cc.v)));
  867. else branch(!cc.c && !cc.z);
  868. break;
  869. case 0x23: // BLS
  870. if(vbra) branch(cc.z || (cc.n && !cc.v) || (!cc.n && cc.v));
  871. else branch( cc.c ||  cc.z);
  872. break;
  873. case 0x24: // BCC BHS
  874. if(vbra) branch((cc.n && cc.v) || (!cc.n && !cc.v));
  875. else branch(!cc.c);
  876. break;
  877. case 0x25: // BCS BLO
  878. if(vbra) branch((cc.n && !cc.v) || (!cc.n && cc.v));
  879. else branch( cc.c);
  880. break;
  881. case 0x26: // BNE
  882. if(vbra) branch(!cc.v);
  883. else branch(!cc.z);
  884. break;
  885. case 0x27: // BEQ
  886. if(vbra) branch(cc.v);
  887. else branch( cc.z); break;
  888. case 0x28: // BHCC
  889. branch(!cc.h); break;
  890. case 0x29: // BHCS
  891. branch( cc.h); break;
  892. case 0x2A: // BPL
  893. branch(!cc.n); break;
  894. case 0x2B: // BMI
  895. branch( cc.n); break;
  896. case 0x2C: // BMC
  897. branch(!cc.i); break;
  898. case 0x2D: // BMS
  899. branch( cc.i); break;
  900. case 0xBC: // JMP
  901. case 0xCC:
  902. case 0xDC:
  903. case 0xEC:
  904. case 0xFC:
  905. pc=ea; break;
  906. case 0xAD: // BSR
  907. pc++; pushpc(); pc--; branch(true); break;
  908. case 0xBD: // JSR
  909. case 0xCD:
  910. case 0xDD:
  911. case 0xED:
  912. case 0xFD:
  913. pushpc(); pc=ea; break;
  914. case 0x81: // RTS
  915. poppc(); break;
  916. case 0x83: // SWI
  917. pushpc(); push(x); push(a); pushc();
  918. cc.i=1; pc=HILO(0x1ffc); break;
  919. case 0x80: // RTI
  920. popc(); a=pop(); x=pop(); poppc(); break;
  921. case 0x9C: // RSP
  922. sp=spHi; break;
  923. case 0x96: // TSX
  924. *ex=sp; break;
  925. case 0x94: // TXS (ST7)
  926. sp=*ex; break;
  927. case 0x9E: // TSA
  928. a=sp; break;
  929. case 0x95: // TAS (ST7)
  930. sp=a; break;
  931. case 0x84: // POPA (ST7)
  932. a=pop(); break;
  933. case 0x85: // POPX (ST7)
  934. *ex=pop(); break;
  935. case 0x86: // POPC (ST7)
  936. popc(); break;
  937. case 0x88: // PUSHA (ST7)
  938. push(a); break;
  939. case 0x89: // PUSHX (ST7)
  940. push(*ex); break;
  941. case 0x8A: // PUSHC (ST7)
  942. pushc(); break;
  943. case 0x98: // CLC
  944. cc.c=0; break;
  945. case 0x99: // SEC
  946. cc.c=1; break;
  947. case 0x9A: // CLI
  948. cc.i=0; break;
  949. case 0x9B: // SEI
  950. cc.i=1; break;
  951. case 0x9D: // NOP
  952. break;
  954. case 0x71: // LDD (ST19)
  955. case 0x72:
  956. case 0x75:
  957. dr=op; break;
  958. case 0x7B: // TAD (ST19)
  959. dr=a; break;
  960. case 0x8B: // TDA (ST19)
  961. a=dr; break;
  962. case 0x8C: // TCA (ST19)
  963. a=cr; break;
  964. case 0xAC: // PUSHD (ST19)
  965. push(dr); break;
  966. case 0xAF: // POPD (ST19)
  967. dr=pop(); break;
  968. case 0x87: // PRTS (ST19)
  969. cr=pop(); poppc(); break;
  970. case 0x8D: // PJSR (ST19)
  971. if (paged) {
  972. ea=HILO(pc); pc+=2;
  973. sprintf(txt,"[%s] -> ",PADDR(cr,ea)); strcat(displaystr2, txt);
  974. if (pc80flag && Show_Diss==1) printf(txt);
  975. } else {
  976. ea=pc; pc+=3;
  977. }
  978. sprintf(txt,"%s ",PADDR(pr,ea)); strcat(displaystr2, txt);
  979. if (pc80flag && Show_Diss==1) printf(txt);
  980. pr=Get(ea++);
  981. ea=HILO(ea);
  982. pushpc(); push(cr); cr=pr; pc=ea; 
  983. break;
  985. case 0x90: // pre-bytes
  986. case 0x91:
  987. case 0x92:
  988. case 0x31:
  989. case 0x32:
  990. printf("*** pre-byte %02x in command decoding (count=%d)n",ins,LoopCount);
  991. return 3;
  992. default:
  993. printf("*** unsupported instruction 0x%02x (count=%d)n",ins,LoopCount);
  994. return 3;
  995. }
  997. // write operant
  998. if(flags & 2) {
  999. switch(((flags&8) ? flags:ins)>>4) {
  1000. case 0x2: // no or special address mode
  1001. case 0x8:
  1002. case 0x9:
  1003. break;
  1004. case 0xA: // immediate
  1005. case 0x3: // short
  1006. case 0xB:
  1007. case 0xC: // long
  1008. case 0xD: // long indexed
  1009. case 0x6: // short indexed
  1010. case 0xE:
  1011. case 0x7: // indexed
  1012. case 0xF:
  1013. case 0x0: // bit
  1014. case 0x1:
  1015. if (ea==0x16) op = op & 0x7F; // This is new
  1016. Set(ea,op); break;
  1017. case 0x4: // inherent A
  1018. a=op; break;
  1019. case 0x5: // inherent X/Y
  1020. *ex=op; break;
  1021. }
  1022. } 
  1024. for (int i=numBp-1 ; i>=0 ; i--) {
  1025. if (bp[i] == pc) {
  1026.        if (bp[i]==0x9569 && Show_Diss==0 ) {
  1027. // printf("*** %s {next EMM_CMD}nn", displaystr2);
  1028. } else if (bp[i]==0x9569 && Show_Diss==1 ) {
  1029. printf(" {next EMM_CMD}nn");
  1030. } else if (bp[i]==0x9569 && Show_Diss==2 ) {
  1031. printf("%-18s ;%s {next EMM_CMD}nn", displaystr1, displaystr2);
  1032. } else {
  1033. printf("*** Breakpoint at: %04x (count=%d)nn",pc,LoopCount);
  1034. }
  1035. return 0;
  1036. }
  1037. }
  1038. if (pc80flag && Show_Diss==1) printf("n");
  1040. if (LoopCount >= max_count) {
  1041. printf("*** Max. instruction counter exceeded (count=%d)n",LoopCount);
  1042. return 2;
  1043. }
  1044. if (Show_Diss==2) printf("%-18s ;%sn", displaystr1, displaystr2);
  1045. }
  1046. }
  1048. void c6805::branch(bool branch)
  1049. {
  1050. if (pc80flag) {
  1051. unsigned char off=Get(pc);
  1052. if (indirect) {
  1053. sprintf(txt,"[%02x] -> ",off); strcat(displaystr2, txt);
  1054. if (pc80flag && Show_Diss==1) printf(txt);
  1055. off=Get(off);
  1056. }
  1057. unsigned short npc=pc+off+1;
  1058. if (off&0x80) npc-=0x100; // gcc fixup. take care of sign
  1059. sprintf(txt,"%s ",PADDR(cr,npc)); strcat(displaystr2, txt);
  1060. if (pc80flag && Show_Diss==1) printf(txt);
  1061. if (branch) {
  1062. sprintf(txt,"(taken) "); strcat(displaystr2, txt);
  1063. if (pc80flag && Show_Diss==1) printf(txt);
  1064. }
  1065. }
  1066. pc++;
  1067. if(branch) {
  1068. unsigned char offset=Get(pc-1);
  1069. if(indirect) offset=Get(offset);
  1070. pc+=offset;
  1071. if(offset&0x80) pc-=0x100; // gcc fixup. take care of sign
  1072. }
  1073. }
  1075. void c6805::push(unsigned char c)
  1076. {
  1077. Set(sp--,c);
  1078. }
  1080. unsigned char c6805::pop(void)
  1081. {
  1082. return Get(++sp);
  1083. }
  1085. void c6805::pushpc(void)
  1086. {
  1087. push(pc & 0xff);
  1088. push(pc >> 8);
  1089. }
  1091. void c6805::poppc(void)
  1092. {
  1093. pc=(pop()<<8) | pop();
  1094. }
  1096. void c6805::pushc(void)
  1097. {
  1098. unsigned char c=0xC0+(cc.v?32:0)+(cc.h?16:0)+(cc.i?8:0)+(cc.n?4:0)+(cc.z?2:0)+(cc.c?1:0);
  1099. push(c);
  1100. }
  1102. void c6805::popc(void)
  1103. {
  1104. unsigned char c=pop();
  1105. cc.v=(c&32) ? 1:0;
  1106. cc.h=(c&16) ? 1:0;
  1107. cc.i=(c& 8) ? 1:0;
  1108. cc.n=(c& 4) ? 1:0;
  1109. cc.z=(c& 2) ? 1:0;
  1110. cc.c=(c& 1) ? 1:0;
  1111. }
  1113. void c6805::tst(unsigned char c)
  1114. {
  1115. cc.z=!c;
  1116. cc.n=bitset(c,7);
  1117. }
  1119. unsigned char c6805::add(unsigned char op, unsigned char c)
  1120. {
  1121. unsigned short res_half=(a&0x0f) + (op&0x0f) + c;
  1122. unsigned short res=(unsigned short)a + (unsigned short)op + (unsigned short)c;
  1123. cc.h=res_half > 0x0f;
  1124. cc.c=res > 0xff;
  1125. res&=0xff;
  1126. tst(res);
  1127. return res;
  1128. }
  1130. unsigned char c6805::sub(unsigned char op1, unsigned char op2, unsigned char c)
  1131. {
  1132. short res=(short)op1 - (short)op2 - (short)c;
  1133. cc.c=res < 0;
  1134. res&=0xff;
  1135. tst(res);
  1136. return res;
  1137. }
  1139. unsigned char c6805::rollR(unsigned char op, unsigned char c)
  1140. {
  1141. cc.c=bitset(op,0);
  1142. op >>= 1;
  1143. op |= c << 7;
  1144. tst(op);
  1145. return op;
  1146. }
  1148. unsigned char c6805::rollL(unsigned char op, unsigned char c)
  1149. {
  1150. cc.c=bitset(op,7);
  1151. op <<= 1;
  1152. op |= c;
  1153. tst(op);
  1154. return op;
  1155. }