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

Subversion Repositories thor

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

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


#include "stdafx.h"
 
extern clsPIC pic1;
 
clsSystem::clsSystem() {
        int nn;
        WriteROM = false;
        for (nn = 0; nn < sizeof(memory); nn+=8) {
                memory[nn>>3] = 0;
        }
        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;
        cpu1.system1 = this;
        refscreen = true;
};
        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;
                }
                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 >= 0x10000 && ad < 0x20000) {
                                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 & 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);
                }
                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;
}

Browse

Tools

Subversion Repositories thor

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

Line No.	Rev	Author	Line
1	30	robfinch	`#include "stdafx.h"`
2
3			`extern clsPIC pic1;`
4
5			`clsSystem::clsSystem() {`
6			`int nn;`
7			`WriteROM = false;`
8			`for (nn = 0; nn < sizeof(memory); nn+=8) {`
9			`memory[nn>>3] = 0;`
10			`}`
11			`Reset();`
12			`};`
13			`void clsSystem::Reset()`
14			`{`
15			`int nn;`
16			`WriteROM = false;`
17			`m_z = 88888888;`
18			`m_w = 12345678;`
19			`for (nn = 0; nn < 4096; nn++) {`
20			`VideoMem[nn] = random();`
21			`VideoMemDirty[nn] = true;`
22			`}`
23			`leds = 0;`
24			`write_error = false;`
25			`runstop = false;`
26			`cpu1.system1 = this;`
27			`refscreen = true;`
28			`};`
29			`unsigned __int64 clsSystem::Read(unsigned int ad, int sr) {`
30			`__int64 rr;`
31			`unsigned __int8 sc;`
32			`unsigned __int8 st;`
33			`if (sr) {`
34			`if (radr1 == 0)`
35			`radr1 = ad;`
36			`else if (radr2 == 0)`
37			`radr2 = ad;`
38			`else {`
39			`if (random()&1)`
40			`radr2 = ad;`
41			`else`
42			`radr1 = ad;`
43			`}`
44			`}`
45			`if (ad < 134217728) {`
46			`return memory[ad >> 3];`
47			`}`
48			`else if ((ad & 0xFFFF0000)==0xFFD00000) {`
49			`rr = VideoMem[(ad>>2)& 0xFFF];`
50			`rr = (rr << 32) \| rr;`
51			`return rr;`
52			`}`
53			`else if ((ad & 0xFFFC0000)==0xFFFC0000) {`
54			`return rom[(ad&0x3FFFF)>>3];`
55			`}`
56			`else if (keybd.IsSelected(ad)) {`
57			`switch(ad & 0x1) {`
58			`case 0:`
59			`sc = keybd.Get();`
60			`rr = ((int)sc<<24)\|((int)sc << 16)\|((int)sc<<8)\|sc;`
61			`rr = (rr << 32) \| rr;`
62			`break;`
63			`case 1:`
64			`st = keybd.GetStatus();`
65			`rr = ((int)st<<24)\|((int)st<<16)\|((int)st<<8)\|st;`
66			`rr = (rr << 32) \| rr;`
67			`keybd_status = st;`
68			`break;`
69			`}`
70			`return rr;`
71			`}`
72			`else if (pic1.IsSelected(ad)) {`
73			`rr = pic1.Read(ad);`
74			`rr = (rr << 48) \| (rr << 32) \| (rr << 16) \| rr;`
75			`return rr;`
76			`}`
77			`return 0;`
78			`};`
79			`int clsSystem::Write(unsigned int ad, unsigned __int64 dat, unsigned int mask, int cr) {`
80			`int nn;`
81			`int ret;`
82
83			`if (cr && (ad!=radr1 && ad!=radr2)) {`
84			`ret = false;`
85			`goto j1;`
86			`}`
87			`if (cr) {`
88			`if (ad==radr1)`
89			`radr1 = 0x00000000;`
90			`if (ad==radr2)`
91			`radr2 = 0x00000000;`
92			`}`
93			`if (ad < 134217728) {`
94			`if (ad >= 0x10000 && ad < 0x20000) {`
95			`write_error = true;`
96			`ret = true;`
97			`goto j1;`
98			`}`
99			`if ((ad & 0xfffffff0)==0x00c431a0) {`
100			`ret = true;`
101			`}`
102			`switch(mask) {`
103			`case 0xFF:`
104			`memory[ad>>3] = dat;`
105			`break;`
106			`case 0x1:`
107			`memory[ad >> 3] &= 0xFFFFFFFFFFFFFF00LL;`
108			`memory[ad >> 3] \|= dat & 0xFFLL;`
109			`break;`
110			`case 0x2:`
111			`memory[ad >> 3] &= 0xFFFFFFFFFFFF00FFLL;`
112			`memory[ad >> 3] \|= (dat & 0xFFLL) << 8;`
113			`break;`
114			`case 0x4:`
115			`memory[ad >> 3] &= 0xFFFFFFFFFF00FFFFLL;`
116			`memory[ad >> 3] \|= (dat & 0xFFLL) << 16;`
117			`break;`
118			`case 0x8:`
119			`memory[ad >> 3] &= 0xFFFFFFFF00FFFFFFLL;`
120			`memory[ad >> 3] \|= (dat & 0xFFLL) << 24;`
121			`break;`
122			`case 0x10:`
123			`memory[ad >> 3] &= 0xFFFFFF00FFFFFFFFLL;`
124			`memory[ad >> 3] \|= (dat & 0xFFLL) << 32;`
125			`break;`
126			`case 0x20:`
127			`memory[ad >> 3] &= 0xFFFF00FFFFFFFFFFLL;`
128			`memory[ad >> 3] \|= (dat & 0xFFLL) << 40;`
129			`break;`
130			`case 0x40:`
131			`memory[ad >> 3] &= 0xFF00FFFFFFFFFFFFLL;`
132			`memory[ad >> 3] \|= (dat & 0xFFLL) << 48;`
133			`break;`
134			`case 0x80:`
135			`memory[ad >> 3] &= 0x00FFFFFFFFFFFFFFLL;`
136			`memory[ad >> 3] \|= (dat & 0xFFLL) << 56;`
137			`break;`
138			`case 0x3:`
139			`memory[ad >> 3] &= 0xFFFFFFFFFFFF0000;`
140			`memory[ad >> 3] \|= dat & 0xFFFFLL;`
141			`break;`
142			`case 0x6:`
143			`memory[ad >> 3] &= 0xFFFFFFFFFF0000FF;`
144			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 8;`
145			`break;`
146			`case 0xC:`
147			`memory[ad >> 3] &= 0xFFFFFFFF0000FFFF;`
148			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 16;`
149			`case 0x18:`
150			`break;`
151			`memory[ad >> 3] &= 0xFFFFFF0000FFFFFF;`
152			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 24;`
153			`break;`
154			`case 0x30:`
155			`memory[ad >> 3] &= 0xFFFF0000FFFFFFFF;`
156			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 32;`
157			`break;`
158			`case 0x60:`
159			`memory[ad >> 3] &= 0xFF0000FFFFFFFFFF;`
160			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 40;`
161			`break;`
162			`case 0xC0:`
163			`memory[ad >> 3] &= 0x0000FFFFFFFFFFFF;`
164			`memory[ad >> 3] \|= (dat & 0xFFFFLL) << 48;`
165			`break;`
166			`case 0x0F:`
167			`memory[ad >> 3] &= 0xFFFFFFFF00000000;`
168			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 0;`
169			`break;`
170			`case 0x1E:`
171			`memory[ad >> 3] &= 0xFFFFFF00000000FF;`
172			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 8;`
173			`break;`
174			`case 0x3C:`
175			`memory[ad >> 3] &= 0xFFFF00000000FFFF;`
176			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 16;`
177			`break;`
178			`case 0x78:`
179			`memory[ad >> 3] &= 0xFF00000000FFFFFF;`
180			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 24;`
181			`break;`
182			`case 0xF0:`
183			`memory[ad >> 3] &= 0x00000000FFFFFFFF;`
184			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 32;`
185			`break;`
186			`case 0xE0:`
187			`memory[ad >> 3] &= 0x000000FFFFFFFFFF;`
188			`memory[ad >> 3] \|= (dat & 0xFFFFFFFFLL) << 40;`
189			`break;`
190			`}`
191			`}`
192			`else if ((ad & 0xFFFFFF00)==0xFFDC0600) {`
193			`leds = dat;`
194			`}`
195			`else if ((ad & 0xFFFF0000)==0xFFD00000) {`
196			`VideoMem[(ad>>2)& 0xFFF] = dat;`
197			`VideoMemDirty[(ad>>2)&0xfff] = true;`
198			`refscreen = true;`
199			`}`
200			`else if ((ad & 0xFFFC0000)==0xFFFC0000 && WriteROM) {`
201			`rom[(ad&0x3FFFF)>>3] = dat;`
202			`}`
203			`else if (keybd.IsSelected(ad)) {`
204			`switch(ad & 1) {`
205			`case 1: keybd_status = 0; pic1.irqKeyboard = keybd.GetStatus()==0x80; break;`
206			`}`
207			`}`
208			`else if (pic1.IsSelected(ad)) {`
209			`pic1.Write(ad,dat,0x3);`
210			`}`
211			`ret = true;`
212			`j1:`
213			`for (nn = 0; nn < numDataBreakpoints; nn++) {`
214			`if (ad==dataBreakpoints[nn]) {`
215			`runstop = true;`
216			`}`
217			`}`
218			`return ret;`
219			`};`
220			`int clsSystem::random() {`
221			`m_z = 36969 * (m_z & 65535) + (m_z >> 16);`
222			`m_w = 18000 * (m_w & 65535) + (m_w >> 16);`
223			`return (m_z << 16) + m_w;`
224			`};`
225
226			`unsigned __int64 clsSystem::ReadByte(unsigned int ad) {`
227			`unsigned __int64 dat = Read(ad);`
228			`return (dat >> ((ad & 7) * 8)) & 0xFFLL;`
229			`}`