URL https://opencores.org/ocsvn/thor/thor/trunk

Subversion Repositories thor

[/] [thor/] [trunk/] [software/] [emuThor/] [source/] [clsSystem.cpp] - Blame information for rev 32

Go to most recent revision | Details | Compare with Previous | View Log


#include "stdafx.h"
 
extern unsigned int breakpoints[30];
extern unsigned __int64 ibreakpoints[10];
extern bool ib_active[10];
extern bool isRunning;
extern bool stepout, stepover;
extern unsigned int step_depth, stepover_depth;
extern unsigned int stepoverBkpt;
extern unsigned int stepover_pc;
extern bool animate;
extern bool fullspeed;
extern bool runstop;
 
clsSystem::clsSystem() {
        int nn;
        WriteROM = false;
        for (nn = 0; nn < sizeof(memory); nn+=8) {
                memory[nn>>3] = 0;
        }
        quit = false;
        Reset();
};
void clsSystem::Reset()
{
        int nn;
        WriteROM = false;
        m_z = 88888888;
        m_w = 12345678;
        for (nn = 0; nn < 4096; nn++) {
                VideoMem[nn] = random();
                VideoMemDirty[nn] = true;
        }
        leds = 0;
        write_error = false;
        runstop = false;
        cpu2.system1 = this;
        refscreen = true;
        cpu2.Reset();
        pic1.Reset();
        uart1.Reset();
};
        unsigned __int64 clsSystem::Read(unsigned int ad, int sr) {
                __int64 rr;
                unsigned __int8 sc;
                unsigned __int8 st;
                if (sr) {
                        if (radr1 == 0)
                                radr1 = ad;
                        else if (radr2 == 0)
                                radr2 = ad;
                        else {
                                if (random()&1)
                                        radr2 = ad;
                                else
                                        radr1 = ad;
                        }
                }
                if (ad < 134217728) {
                        return memory[ad >> 3];
                }
                else if ((ad & 0xFFFF0000)==0xFFD00000) {
                        rr = VideoMem[(ad>>2)& 0xFFF];
                        rr = (rr << 32) | rr;
                        return rr;
                }
                else if ((ad & 0xFFFC0000)==0xFFFC0000) {
                        return rom[(ad&0x3FFFF)>>3];
                }
                else if (keybd.IsSelected(ad)) {
                        switch(ad & 0x1) {
                        case 0:
                                sc = keybd.Get();
                                rr = ((int)sc<<24)|((int)sc << 16)|((int)sc<<8)|sc;
                                rr = (rr << 32) | rr;
                                break;
                        case 1:
                                st = keybd.GetStatus();
                                rr = ((int)st<<24)|((int)st<<16)|((int)st<<8)|st;
                                rr = (rr << 32) | rr;
                                keybd_status = st;
                                break;
                        }
                        return rr;
                }
                else if (pic1.IsSelected(ad)) {
                        rr = pic1.Read(ad);
                        rr = (rr << 48) | (rr << 32) | (rr << 16) | rr;
                        return rr;
                }
                else if (uart1.IsSelected(ad)) {
                        rr = uart1.Read(ad) & 0xFF;
                        rr = (rr << 56) | (rr << 48) || (rr << 40) | (rr << 32)
                                 | (rr << 24) | (rr << 16) | (rr << 8) | rr;
                        return rr;
                }
                return 0;
        };
        int clsSystem::Write(unsigned int ad, unsigned __int64 dat, unsigned int mask, int cr) {
                int nn;
                int ret;
 
                if (cr && (ad!=radr1 && ad!=radr2)) {
                        ret = false;
                        goto j1;
                }
                if (cr) {
                        if (ad==radr1)
                                radr1 = 0x00000000;
                        if (ad==radr2)
                                radr2 = 0x00000000;
                }
                if (ad < 134217728) {
                        if (ad >= 0xFFFC0000LL) {
                                write_error = true;
                                ret = true;
                                goto j1;
                        }
                        if ((ad & 0xfffffff0)==0x00c431a0) {
                                ret = true;
                        }
                        switch(mask) {
                        case 0xFF:
                                memory[ad>>3] = dat;
                                break;
                        case 0x1:
                                memory[ad >> 3] &= 0xFFFFFFFFFFFFFF00LL;
                                memory[ad >> 3] |= dat & 0xFFLL;
                                break;
                        case 0x2:
                                memory[ad >> 3] &= 0xFFFFFFFFFFFF00FFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 8;
                                break;
                        case 0x4:
                                memory[ad >> 3] &= 0xFFFFFFFFFF00FFFFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 16;
                                break;
                        case 0x8:
                                memory[ad >> 3] &= 0xFFFFFFFF00FFFFFFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 24;
                                break;
                        case 0x10:
                                memory[ad >> 3] &= 0xFFFFFF00FFFFFFFFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 32;
                                break;
                        case 0x20:
                                memory[ad >> 3] &= 0xFFFF00FFFFFFFFFFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 40;
                                break;
                        case 0x40:
                                memory[ad >> 3] &= 0xFF00FFFFFFFFFFFFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 48;
                                break;
                        case 0x80:
                                memory[ad >> 3] &= 0x00FFFFFFFFFFFFFFLL;
                                memory[ad >> 3] |= (dat & 0xFFLL) << 56;
                                break;
                        case 0x3:
                                memory[ad >> 3] &= 0xFFFFFFFFFFFF0000;
                                memory[ad >> 3] |= dat & 0xFFFFLL;
                                break;
                        case 0x6:
                                memory[ad >> 3] &= 0xFFFFFFFFFF0000FF;
                                memory[ad >> 3] |= (dat & 0xFFFFLL) << 8;
                                break;
                        case 0xC:
                                memory[ad >> 3] &= 0xFFFFFFFF0000FFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFLL) << 16;
                        case 0x18:
                                break;
                                memory[ad >> 3] &= 0xFFFFFF0000FFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFLL) << 24;
                                break;
                        case 0x30:
                                memory[ad >> 3] &= 0xFFFF0000FFFFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFLL) << 32;
                                break;
                        case 0x60:
                                memory[ad >> 3] &= 0xFF0000FFFFFFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFLL) << 40;
                                break;
                        case 0xC0:
                                memory[ad >> 3] &= 0x0000FFFFFFFFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFLL) << 48;
                                break;
                        case 0x0F:
                                memory[ad >> 3] &= 0xFFFFFFFF00000000;
                                memory[ad >> 3] |= (dat & 0xFFFFFFFFLL) << 0;
                                break;
                        case 0x1E:
                                memory[ad >> 3] &= 0xFFFFFF00000000FF;
                                memory[ad >> 3] |= (dat & 0xFFFFFFFFLL) << 8;
                                break;
                        case 0x3C:
                                memory[ad >> 3] &= 0xFFFF00000000FFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFFFFFLL) << 16;
                                break;
                        case 0x78:
                                memory[ad >> 3] &= 0xFF00000000FFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFFFFFLL) << 24;
                                break;
                        case 0xF0:
                                memory[ad >> 3] &= 0x00000000FFFFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFFFFFLL) << 32;
                                break;
                        case 0xE0:
                                memory[ad >> 3] &= 0x000000FFFFFFFFFF;
                                memory[ad >> 3] |= (dat & 0xFFFFFFFFLL) << 40;
                                break;
                        }
                }
                else if ((ad & 0xFFFFFF00)==0xFFDC0600) {
                        leds = dat;
                }
                else if ((ad & 0xFFFF0000)==0xFFD00000) {
                        VideoMem[(ad>>2)& 0xFFF] = dat;
                        VideoMemDirty[(ad>>2)&0xfff] = true;
                        refscreen = true;
                }
                else if ((ad & 0xFFFF0000)==0xFFD10000) {
                        DBGVideoMem[(ad>>2)& 0xFFF] = dat;
                        DBGVideoMemDirty[(ad>>2)&0xfff] = true;
                        refscreen = true;
                }
                else if ((ad & 0xFFFC0000)==0xFFFC0000 && WriteROM) {
                        rom[(ad&0x3FFFF)>>3] = dat;
                }
                else if (keybd.IsSelected(ad)) {
                        switch(ad & 1) {
                        case 1: keybd_status = 0; pic1.irqKeyboard = keybd.GetStatus()==0x80; break;
                        }
                }
                else if (pic1.IsSelected(ad)) {
                        pic1.Write(ad,dat,0x3);
                }
                else if (uart1.IsSelected(ad)) {
                        uart1.Write(ad,dat,0x1);
                }
                ret = true;
j1:
                for (nn = 0; nn < numDataBreakpoints; nn++) {
                        if (ad==dataBreakpoints[nn]) {
                                runstop = true;
                        }
                }
                return ret;
        };
        int clsSystem::random() {
                m_z = 36969 * (m_z & 65535) + (m_z >> 16);
                m_w = 18000 * (m_w & 65535) + (m_w >> 16);
                return (m_z << 16) + m_w;
        };
 
unsigned __int64 clsSystem::ReadByte(unsigned int ad) {
unsigned __int64 dat = Read(ad);
        return (dat >> ((ad & 7) * 8)) & 0xFFLL;
}
unsigned __int64 clsSystem::ReadChar(unsigned int ad) {
unsigned __int64 dat = Read(ad);
        return (dat >> ((ad & 7) * 8)) & 0xFFFFLL;
}
unsigned __int64 clsSystem::ReadHalf(unsigned int ad) {
unsigned __int64 dat = Read(ad);
        return (dat >> ((ad & 7) * 8)) & 0xFFFFFFFFLL;
}
 
 
void clsSystem::Step() {
        uart1.Step();
        keybd.Step();
        pic1.Step();
        cpu2.Step();
}
 
void clsSystem::Run() {
        int nn,kk;
        int xx;
 
        do {
                if (isRunning) {
                //                      if (cpu2.pc > 134217727) {
                        if (cpu2.pc < 0xFFFC0000LL && cpu2.pc & 0x1000 != 0x1000) {
                                isRunning = false;
                                continue;
                        }
                        if (cpu2.pc == stepoverBkpt) {
                                stepoverBkpt = 0;
                                isRunning = false;
                                continue;
                        }
                        for (kk = 0; kk < 5; kk++) {
                                if (cpu2.pc == ibreakpoints[kk] && ib_active[kk]) {
                                        isRunning = false;
                                        continue;
                                }
                        }
                        if (system1.write_error==true) {
                                isRunning = false;
                                continue;
                        //                              this->lblWriteErr->Visible = true;
                        }
                        // Runstop becomes active when a data breakpoint is hit.
                        if (runstop) {
                                isRunning = false;
                                runstop = false;
                                continue;
                        }
                        cpu2.Step();
                        pic1.Step();
                        if (stepout) {
                                if (cpu2.sub_depth<step_depth) {
                                        isRunning = false;
                                        stepout = false;
                                        continue;
                                }
                        }
                        if (stepover) {
                                if (cpu2.pc > stepover_pc && cpu2.sub_depth==stepover_depth) {
                                        isRunning = false;
                                        stepover = false;
                                        continue;
                                }
                        }
                                        /*
                                if (cpu2.pc == stepoverBkpt) {
                                        stepoverBkpt = 0;
                                        cpu2.isRunning = false;
                                        UpdateListBox(cpu2.pc-32);
                                        return;
                                }
                                for (kk = 0; kk < numBreakpoints; kk++) {
                                        if (cpu2.pc == breakpoints[kk]) {
                                                cpu2.isRunning = false;
                                                        UpdateListBox(cpu2.pc-32);
                                                return;
                                        }
                                }
                                        cpu2.Step();
                                pic1.Step();
                                        UpdateListBox(cpu2.pc-32);
                                        */
                        //                       UpdateListBox(cpu2.pc-32);
                }
        } while (false);        // !quit
}

Line No.	Rev	Author	Line
1	30	robfinch	`#include "stdafx.h"`
2
3	32	robfinch	`extern unsigned int breakpoints[30];`
4			`extern unsigned __int64 ibreakpoints[10];`
5			`extern bool ib_active[10];`
6			`extern bool isRunning;`
7			`extern bool stepout, stepover;`
8			`extern unsigned int step_depth, stepover_depth;`
9			`extern unsigned int stepoverBkpt;`
10			`extern unsigned int stepover_pc;`
11			`extern bool animate;`
12			`extern bool fullspeed;`
13			`extern bool runstop;`
14	30	robfinch
15			`clsSystem::clsSystem() {`
16			`int nn;`
17			`WriteROM = false;`
18			`for (nn = 0; nn < sizeof(memory); nn+=8) {`
19			`memory[nn>>3] = 0;`
20			`}`
21	32	robfinch	`quit = false;`
22	30	robfinch	`Reset();`
23			`};`
24			`void clsSystem::Reset()`
25			`{`
26			`int nn;`
27			`WriteROM = false;`
28			`m_z = 88888888;`
29			`m_w = 12345678;`
30			`for (nn = 0; nn < 4096; nn++) {`
31			`VideoMem[nn] = random();`
32			`VideoMemDirty[nn] = true;`
33			`}`
34			`leds = 0;`
35			`write_error = false;`
36			`runstop = false;`
37	32	robfinch	`cpu2.system1 = this;`
38	30	robfinch	`refscreen = true;`
39	32	robfinch	`cpu2.Reset();`
40			`pic1.Reset();`
41			`uart1.Reset();`
42	30	robfinch	`};`
43			`unsigned __int64 clsSystem::Read(unsigned int ad, int sr) {`
44			`__int64 rr;`
45			`unsigned __int8 sc;`
46			`unsigned __int8 st;`
47			`if (sr) {`
48			`if (radr1 == 0)`
49			`radr1 = ad;`
50			`else if (radr2 == 0)`
51			`radr2 = ad;`
52			`else {`
53			`if (random()&1)`
54			`radr2 = ad;`
55			`else`
56			`radr1 = ad;`
57			`}`
58			`}`
59			`if (ad < 134217728) {`
60			`return memory[ad >> 3];`
61			`}`
62			`else if ((ad & 0xFFFF0000)==0xFFD00000) {`
63			`rr = VideoMem[(ad>>2)& 0xFFF];`
64			`rr = (rr << 32) \| rr;`
65			`return rr;`
66			`}`
67			`else if ((ad & 0xFFFC0000)==0xFFFC0000) {`
68			`return rom[(ad&0x3FFFF)>>3];`
69			`}`
70			`else if (keybd.IsSelected(ad)) {`
71			`switch(ad & 0x1) {`
72			`case 0:`
73			`sc = keybd.Get();`
74			`rr = ((int)sc<<24)\|((int)sc << 16)\|((int)sc<<8)\|sc;`
75			`rr = (rr << 32) \| rr;`
76			`break;`
77			`case 1:`
78			`st = keybd.GetStatus();`
79			`rr = ((int)st<<24)\|((int)st<<16)\|((int)st<<8)\|st;`
80			`rr = (rr << 32) \| rr;`
81			`keybd_status = st;`
82			`break;`
83			`}`
84			`return rr;`
85			`}`
86			`else if (pic1.IsSelected(ad)) {`
87			`rr = pic1.Read(ad);`
88			`rr = (rr << 48) \| (rr << 32) \| (rr << 16) \| rr;`
89			`return rr;`
90			`}`
91	32	robfinch	`else if (uart1.IsSelected(ad)) {`
92			`rr = uart1.Read(ad) & 0xFF;`
93			`rr = (rr << 56) \| (rr << 48) \|\| (rr << 40) \| (rr << 32)`
94			`\| (rr << 24) \| (rr << 16) \| (rr << 8) \| rr;`
95			`return rr;`
96			`}`
97	30	robfinch	`return 0;`
98			`};`
99			`int clsSystem::Write(unsigned int ad, unsigned __int64 dat, unsigned int mask, int cr) {`
100			`int nn;`
101			`int ret;`
102
103			`if (cr && (ad!=radr1 && ad!=radr2)) {`
104			`ret = false;`
105			`goto j1;`
106			`}`
107			`if (cr) {`
108			`if (ad==radr1)`
109			`radr1 = 0x00000000;`
110			`if (ad==radr2)`
111			`radr2 = 0x00000000;`
112			`}`
113			`if (ad < 134217728) {`
114	32	robfinch	`if (ad >= 0xFFFC0000LL) {`
115	30	robfinch	`write_error = true;`
116			`ret = true;`
117			`goto j1;`
118			`}`
119			`if ((ad & 0xfffffff0)==0x00c431a0) {`
120			`ret = true;`
121			`}`
122			`switch(mask) {`
123			`case 0xFF:`
124			`memory[ad>>3] = dat;`
125			`break;`
126			`case 0x1:`
127			`memory[ad >> 3] &= 0xFFFFFFFFFFFFFF00LL;`
128			`memory[ad >> 3] \|= dat & 0xFFLL;`
129			`break;`
130			`case 0x2:`
131			`memory[ad >> 3] &= 0xFFFFFFFFFFFF00FFLL;`
132			`memory[ad >> 3] \|= (dat & 0xFFLL) << 8;`
133			`break;`
134			`case 0x4:`
135			`memory[ad >> 3] &= 0xFFFFFFFFFF00FFFFLL;`
136			`memory[ad >> 3] \|= (dat & 0xFFLL) << 16;`
137			`break;`
138			`case 0x8:`
139			`memory[ad >> 3] &= 0xFFFFFFFF00FFFFFFLL;`
140			`memory[ad >> 3] \|= (dat & 0xFFLL) << 24;`
141			`break;`
142			`case 0x10:`
143			`memory[ad >> 3] &= 0xFFFFFF00FFFFFFFFLL;`
144			`memory[ad >> 3] \|= (dat & 0xFFLL) << 32;`
145			`break;`
146			`case 0x20:`
147			`memory[ad >> 3] &= 0xFFFF00FFFFFFFFFFLL;`
148			`memory[ad >> 3] \|= (dat & 0xFFLL) << 40;`
149			`break;`
150			`case 0x40:`
151			`memory[ad >> 3] &= 0xFF00FFFFFFFFFFFFLL;`
152			`memory[ad >> 3] \|= (dat & 0xFFLL) << 48;`
153			`break;`
154			`case 0x80:`
155			`memory[ad >> 3] &= 0x00FFFFFFFFFFFFFFLL;`
156			`memory[ad >> 3] \|= (dat & 0xFFLL) << 56;`
157			`break;`
158			`case 0x3:`
159			`memory[ad >> 3] &= 0xFFFFFFFFFFFF0000;`
160			`memory[ad >> 3] \|= dat & 0xFFFFLL;`
161			`break;`
162			`case 0x6:`
163			`memory[ad >> 3] &= 0xFFFFFFFFFF0000FF;`
164			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 8;`
165			`break;`
166			`case 0xC:`
167			`memory[ad >> 3] &= 0xFFFFFFFF0000FFFF;`
168			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 16;`
169			`case 0x18:`
170			`break;`
171			`memory[ad >> 3] &= 0xFFFFFF0000FFFFFF;`
172			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 24;`
173			`break;`
174			`case 0x30:`
175			`memory[ad >> 3] &= 0xFFFF0000FFFFFFFF;`
176			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 32;`
177			`break;`
178			`case 0x60:`
179			`memory[ad >> 3] &= 0xFF0000FFFFFFFFFF;`
180			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 40;`
181			`break;`
182			`case 0xC0:`
183			`memory[ad >> 3] &= 0x0000FFFFFFFFFFFF;`
184			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 48;`
185			`break;`
186			`case 0x0F:`
187			`memory[ad >> 3] &= 0xFFFFFFFF00000000;`
188			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 0;`
189			`break;`
190			`case 0x1E:`
191			`memory[ad >> 3] &= 0xFFFFFF00000000FF;`
192			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 8;`
193			`break;`
194			`case 0x3C:`
195			`memory[ad >> 3] &= 0xFFFF00000000FFFF;`
196			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 16;`
197			`break;`
198			`case 0x78:`
199			`memory[ad >> 3] &= 0xFF00000000FFFFFF;`
200			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 24;`
201			`break;`
202			`case 0xF0:`
203			`memory[ad >> 3] &= 0x00000000FFFFFFFF;`
204			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 32;`
205			`break;`
206			`case 0xE0:`
207			`memory[ad >> 3] &= 0x000000FFFFFFFFFF;`
208			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 40;`
209			`break;`
210			`}`
211			`}`
212			`else if ((ad & 0xFFFFFF00)==0xFFDC0600) {`
213			`leds = dat;`
214			`}`
215			`else if ((ad & 0xFFFF0000)==0xFFD00000) {`
216			`VideoMem[(ad>>2)& 0xFFF] = dat;`
217			`VideoMemDirty[(ad>>2)&0xfff] = true;`
218			`refscreen = true;`
219			`}`
220	32	robfinch	`else if ((ad & 0xFFFF0000)==0xFFD10000) {`
221			`DBGVideoMem[(ad>>2)& 0xFFF] = dat;`
222			`DBGVideoMemDirty[(ad>>2)&0xfff] = true;`
223			`refscreen = true;`
224			`}`
225	30	robfinch	`else if ((ad & 0xFFFC0000)==0xFFFC0000 && WriteROM) {`
226			`rom[(ad&0x3FFFF)>>3] = dat;`
227			`}`
228			`else if (keybd.IsSelected(ad)) {`
229			`switch(ad & 1) {`
230			`case 1: keybd_status = 0; pic1.irqKeyboard = keybd.GetStatus()==0x80; break;`
231			`}`
232			`}`
233			`else if (pic1.IsSelected(ad)) {`
234			`pic1.Write(ad,dat,0x3);`
235			`}`
236	32	robfinch	`else if (uart1.IsSelected(ad)) {`
237			`uart1.Write(ad,dat,0x1);`
238			`}`
239	30	robfinch	`ret = true;`
240			`j1:`
241			`for (nn = 0; nn < numDataBreakpoints; nn++) {`
242			`if (ad==dataBreakpoints[nn]) {`
243			`runstop = true;`
244			`}`
245			`}`
246			`return ret;`
247			`};`
248			`int clsSystem::random() {`
249			`m_z = 36969 * (m_z & 65535) + (m_z >> 16);`
250			`m_w = 18000 * (m_w & 65535) + (m_w >> 16);`
251			`return (m_z << 16) + m_w;`
252			`};`
253
254			`unsigned __int64 clsSystem::ReadByte(unsigned int ad) {`
255			`unsigned __int64 dat = Read(ad);`
256			`return (dat >> ((ad & 7) * 8)) & 0xFFLL;`
257			`}`
258	32	robfinch	`unsigned __int64 clsSystem::ReadChar(unsigned int ad) {`
259			`unsigned __int64 dat = Read(ad);`
260			`return (dat >> ((ad & 7) * 8)) & 0xFFFFLL;`
261			`}`
262			`unsigned __int64 clsSystem::ReadHalf(unsigned int ad) {`
263			`unsigned __int64 dat = Read(ad);`
264			`return (dat >> ((ad & 7) * 8)) & 0xFFFFFFFFLL;`
265			`}`
266
267
268			`void clsSystem::Step() {`
269			`uart1.Step();`
270			`keybd.Step();`
271			`pic1.Step();`
272			`cpu2.Step();`
273			`}`
274
275			`void clsSystem::Run() {`
276			`int nn,kk;`
277			`int xx;`
278
279			`do {`
280			`if (isRunning) {`
281			`// if (cpu2.pc > 134217727) {`
282			`if (cpu2.pc < 0xFFFC0000LL && cpu2.pc & 0x1000 != 0x1000) {`
283			`isRunning = false;`
284			`continue;`
285			`}`
286			`if (cpu2.pc == stepoverBkpt) {`
287			`stepoverBkpt = 0;`
288			`isRunning = false;`
289			`continue;`
290			`}`
291			`for (kk = 0; kk < 5; kk++) {`
292			`if (cpu2.pc == ibreakpoints[kk] && ib_active[kk]) {`
293			`isRunning = false;`
294			`continue;`
295			`}`
296			`}`
297			`if (system1.write_error==true) {`
298			`isRunning = false;`
299			`continue;`
300			`// this->lblWriteErr->Visible = true;`
301			`}`
302			`// Runstop becomes active when a data breakpoint is hit.`
303			`if (runstop) {`
304			`isRunning = false;`
305			`runstop = false;`
306			`continue;`
307			`}`
308			`cpu2.Step();`
309			`pic1.Step();`
310			`if (stepout) {`
311			`if (cpu2.sub_depth<step_depth) {`
312			`isRunning = false;`
313			`stepout = false;`
314			`continue;`
315			`}`
316			`}`
317			`if (stepover) {`
318			`if (cpu2.pc > stepover_pc && cpu2.sub_depth==stepover_depth) {`
319			`isRunning = false;`
320			`stepover = false;`
321			`continue;`
322			`}`
323			`}`
324			`/*`
325			`if (cpu2.pc == stepoverBkpt) {`
326			`stepoverBkpt = 0;`
327			`cpu2.isRunning = false;`
328			`UpdateListBox(cpu2.pc-32);`
329			`return;`
330			`}`
331			`for (kk = 0; kk < numBreakpoints; kk++) {`
332			`if (cpu2.pc == breakpoints[kk]) {`
333			`cpu2.isRunning = false;`
334			`UpdateListBox(cpu2.pc-32);`
335			`return;`
336			`}`
337			`}`
338			`cpu2.Step();`
339			`pic1.Step();`
340			`UpdateListBox(cpu2.pc-32);`
341			`*/`
342			`// UpdateListBox(cpu2.pc-32);`
343			`}`
344			`} while (false); // !quit`
345			`}`

Browse

Tools

Subversion Repositories thor

[/] [thor/] [trunk/] [software/] [emuThor/] [source/] [clsSystem.cpp] - Blame information for rev 32