Added RiotDebug class, which for now only duplicates the previous

functionality of the Debugger::riotState() method.  It will become
more useful when I add a RIOT tab to the debugger.  Also, added
change tracking infrastructure.

Fixed long-standing bug with viewing the contents of TIM{1, 8, 64, 1024}T
registers.  Apparently, the output generated by the 'riot' debugger
command showed either INTIM or TIMINT for those registers, and not the
actual value written to those registers.

Added INTIM, TIMINT, and TIMCLKS to the riot output, which show the
current values of the timer, the timer interrupt, and the number of
'timer clocks' resulting from writing to a timer register.

Cleaned up some of the debugger API, removing pointers and using
references instead.


git-svn-id: svn://svn.code.sf.net/p/stella/code/trunk@1479 8b62c5a3-ac7e-4cc8-8f21-d9a121418aba
This commit is contained in:
stephena 2008-04-19 21:11:52 +00:00
parent 6cde4a35af
commit 735144457d
17 changed files with 852 additions and 558 deletions

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: Array.hxx,v 1.5 2008-02-06 13:45:19 stephena Exp $ // $Id: Array.hxx,v 1.6 2008-04-19 21:11:52 stephena Exp $
// //
// Based on code from ScummVM - Scumm Interpreter // Based on code from ScummVM - Scumm Interpreter
// Copyright (C) 2002-2004 The ScummVM project // Copyright (C) 2002-2004 The ScummVM project
@ -22,7 +22,7 @@
#ifndef ARRAY_HXX #ifndef ARRAY_HXX
#define ARRAY_HXX #define ARRAY_HXX
#include <assert.h> #include <cassert>
#include "bspf.hxx" #include "bspf.hxx"

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: CpuDebug.cxx,v 1.10 2008-04-02 01:54:31 stephena Exp $ // $Id: CpuDebug.cxx,v 1.11 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#include <sstream> #include <sstream>
@ -21,34 +21,27 @@
#include "Array.hxx" #include "Array.hxx"
#include "EquateList.hxx" #include "EquateList.hxx"
#include "M6502.hxx" #include "M6502.hxx"
#include "TIADebug.hxx"
#include "CpuDebug.hxx" #include "CpuDebug.hxx"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CpuDebug::CpuDebug(Debugger* dbg, Console* console) CpuDebug::CpuDebug(Debugger& dbg, Console& console)
: DebuggerSystem(dbg, console), : DebuggerSystem(dbg, console)
mySystem(&(console->system()))
{ {
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
DebuggerState& CpuDebug::getState() const DebuggerState& CpuDebug::getState()
{ {
myState.PC = mySystem->m6502().PC; myState.PC = mySystem.m6502().PC;
myState.SP = mySystem->m6502().SP; myState.SP = mySystem.m6502().SP;
myState.PS = mySystem->m6502().PS(); myState.PS = mySystem.m6502().PS();
myState.A = mySystem->m6502().A; myState.A = mySystem.m6502().A;
myState.X = mySystem->m6502().X; myState.X = mySystem.m6502().X;
myState.Y = mySystem->m6502().Y; myState.Y = mySystem.m6502().Y;
myState.PSbits.clear(); Debugger::set_bits(myState.PS, myState.PSbits);
for(int i = 0; i < 8; ++i)
{
if(myState.PS & (1<<(7-i)))
myState.PSbits.push_back(true);
else
myState.PSbits.push_back(false);
}
return myState; return myState;
} }
@ -56,21 +49,72 @@ DebuggerState& CpuDebug::getState()
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::saveOldState() void CpuDebug::saveOldState()
{ {
myOldState.PC = mySystem->m6502().PC; myOldState.PC = mySystem.m6502().PC;
myOldState.SP = mySystem->m6502().SP; myOldState.SP = mySystem.m6502().SP;
myOldState.PS = mySystem->m6502().PS(); myOldState.PS = mySystem.m6502().PS();
myOldState.A = mySystem->m6502().A; myOldState.A = mySystem.m6502().A;
myOldState.X = mySystem->m6502().X; myOldState.X = mySystem.m6502().X;
myOldState.Y = mySystem->m6502().Y; myOldState.Y = mySystem.m6502().Y;
myOldState.PSbits.clear(); Debugger::set_bits(myOldState.PS, myOldState.PSbits);
for(int i = 0; i < 8; ++i) }
{
if(myOldState.PS & (1<<(7-i))) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
myOldState.PSbits.push_back(true); string CpuDebug::toString()
else {
myOldState.PSbits.push_back(false); // TODO - this doesn't seem to be used anywhere ??
} string result;
char buf[255];
const CpuState& state = (CpuState&) getState();
const CpuState& oldstate = (CpuState&) getOldState();
result += "\nPC=";
result += myDebugger.invIfChanged(state.PC, oldstate.PC);
result += " A=";
result += myDebugger.invIfChanged(state.A, oldstate.A);
result += " X=";
result += myDebugger.invIfChanged(state.X, oldstate.X);
result += " Y=";
result += myDebugger.invIfChanged(state.Y, oldstate.Y);
result += " S=";
result += myDebugger.invIfChanged(state.SP, oldstate.SP);
result += " P=";
result += myDebugger.invIfChanged(state.PS, oldstate.PS);
result += "/";
// NV-BDIZC
buf[0] = n() ? 'N' : 'n';
buf[1] = v() ? 'V' : 'v';
buf[2] = '-';
buf[3] = b() ? 'B' : 'b';
buf[4] = d() ? 'D' : 'd';
buf[5] = i() ? 'I' : 'i';
buf[6] = z() ? 'Z' : 'z';
buf[7] = c() ? 'C' : 'c';
buf[8] = '\0';
result += buf;
result += "\n FrameCyc:";
sprintf(buf, "%d", mySystem.cycles());
result += buf;
result += " Frame:";
sprintf(buf, "%d", myDebugger.tiaDebug().frameCount());
result += buf;
result += " ScanLine:";
sprintf(buf, "%d", myDebugger.tiaDebug().scanlines());
result += buf;
result += " Clk/Pix/Cyc:";
int clk = myDebugger.tiaDebug().clocksThisLine();
sprintf(buf, "%d/%d/%d", clk, clk-68, clk/3);
result += buf;
result += " 6502Ins:";
sprintf(buf, "%d", mySystem.m6502().totalInstructionCount());
result += buf;
result += "\n ";
result += myDebugger.disassemble(state.PC, 1);
return result;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -78,7 +122,7 @@ int CpuDebug::disassemble(int address, string& result, EquateList* equateList)
{ {
ostringstream buf; ostringstream buf;
int count = 0; int count = 0;
int opcode = mySystem->peek(address); int opcode = mySystem.peek(address);
switch(M6502::ourAddressingModeTable[opcode]) switch(M6502::ourAddressingModeTable[opcode])
{ {
@ -105,7 +149,7 @@ int CpuDebug::disassemble(int address, string& result, EquateList* equateList)
case M6502::Immediate: case M6502::Immediate:
buf << M6502::ourInstructionMnemonicTable[opcode] << " #$" buf << M6502::ourInstructionMnemonicTable[opcode] << " #$"
<< hex << setw(2) << setfill('0') << (int) mySystem->peek(address + 1) << " ; " << hex << setw(2) << setfill('0') << (int) mySystem.peek(address + 1) << " ; "
<< dec << M6502::ourInstructionProcessorCycleTable[opcode]; << dec << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
@ -125,42 +169,42 @@ int CpuDebug::disassemble(int address, string& result, EquateList* equateList)
case M6502::IndirectX: case M6502::IndirectX:
buf << M6502::ourInstructionMnemonicTable[opcode] << " (" buf << M6502::ourInstructionMnemonicTable[opcode] << " ("
<< equateList->getFormatted(mySystem->peek(address + 1), 2) << ",x) ; " << equateList->getFormatted(mySystem.peek(address + 1), 2) << ",x) ; "
<< M6502::ourInstructionProcessorCycleTable[opcode]; << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
case M6502::IndirectY: case M6502::IndirectY:
buf << M6502::ourInstructionMnemonicTable[opcode] << " (" buf << M6502::ourInstructionMnemonicTable[opcode] << " ("
<< equateList->getFormatted(mySystem->peek(address + 1), 2) << "),y ; " << equateList->getFormatted(mySystem.peek(address + 1), 2) << "),y ; "
<< M6502::ourInstructionProcessorCycleTable[opcode]; << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
case M6502::Relative: case M6502::Relative:
buf << M6502::ourInstructionMnemonicTable[opcode] << " " buf << M6502::ourInstructionMnemonicTable[opcode] << " "
<< equateList->getFormatted(address + 2 + ((Int16)(Int8)mySystem->peek(address + 1)), 4) << equateList->getFormatted(address + 2 + ((Int16)(Int8)mySystem.peek(address + 1)), 4)
<< " ; " << M6502::ourInstructionProcessorCycleTable[opcode]; << " ; " << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
case M6502::Zero: case M6502::Zero:
buf << M6502::ourInstructionMnemonicTable[opcode] << " " buf << M6502::ourInstructionMnemonicTable[opcode] << " "
<< equateList->getFormatted(mySystem->peek(address + 1), 2) << " ; " << equateList->getFormatted(mySystem.peek(address + 1), 2) << " ; "
<< M6502::ourInstructionProcessorCycleTable[opcode]; << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
case M6502::ZeroX: case M6502::ZeroX:
buf << M6502::ourInstructionMnemonicTable[opcode] << " " buf << M6502::ourInstructionMnemonicTable[opcode] << " "
<< equateList->getFormatted(mySystem->peek(address + 1), 2) << ",x ; " << equateList->getFormatted(mySystem.peek(address + 1), 2) << ",x ; "
<< M6502::ourInstructionProcessorCycleTable[opcode]; << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
case M6502::ZeroY: case M6502::ZeroY:
buf << M6502::ourInstructionMnemonicTable[opcode] << " " buf << M6502::ourInstructionMnemonicTable[opcode] << " "
<< equateList->getFormatted(mySystem->peek(address + 1), 2) << ",y ; " << equateList->getFormatted(mySystem.peek(address + 1), 2) << ",y ; "
<< M6502::ourInstructionProcessorCycleTable[opcode]; << M6502::ourInstructionProcessorCycleTable[opcode];
count = 2; count = 2;
break; break;
@ -193,119 +237,119 @@ int CpuDebug::dPeek(int address)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setPC(int pc) void CpuDebug::setPC(int pc)
{ {
mySystem->m6502().PC = pc; mySystem.m6502().PC = pc;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setSP(int sp) void CpuDebug::setSP(int sp)
{ {
mySystem->m6502().SP = sp; mySystem.m6502().SP = sp;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setPS(int ps) void CpuDebug::setPS(int ps)
{ {
mySystem->m6502().PS(ps); mySystem.m6502().PS(ps);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setA(int a) void CpuDebug::setA(int a)
{ {
mySystem->m6502().A = a; mySystem.m6502().A = a;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setX(int x) void CpuDebug::setX(int x)
{ {
mySystem->m6502().X = x; mySystem.m6502().X = x;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setY(int y) void CpuDebug::setY(int y)
{ {
mySystem->m6502().Y = y; mySystem.m6502().Y = y;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setN(bool on) void CpuDebug::setN(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 7, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 7, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setV(bool on) void CpuDebug::setV(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 6, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 6, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setB(bool on) void CpuDebug::setB(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 4, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 4, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setD(bool on) void CpuDebug::setD(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 3, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 3, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setI(bool on) void CpuDebug::setI(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 2, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 2, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setZ(bool on) void CpuDebug::setZ(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 1, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 1, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::setC(bool on) void CpuDebug::setC(bool on)
{ {
setPS( set_bit(mySystem->m6502().PS(), 0, on) ); setPS( Debugger::set_bit(mySystem.m6502().PS(), 0, on) );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleN() void CpuDebug::toggleN()
{ {
setPS( mySystem->m6502().PS() ^ 0x80 ); setPS( mySystem.m6502().PS() ^ 0x80 );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleV() void CpuDebug::toggleV()
{ {
setPS( mySystem->m6502().PS() ^ 0x40 ); setPS( mySystem.m6502().PS() ^ 0x40 );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleB() void CpuDebug::toggleB()
{ {
setPS( mySystem->m6502().PS() ^ 0x10 ); setPS( mySystem.m6502().PS() ^ 0x10 );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleD() void CpuDebug::toggleD()
{ {
setPS( mySystem->m6502().PS() ^ 0x08 ); setPS( mySystem.m6502().PS() ^ 0x08 );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleI() void CpuDebug::toggleI()
{ {
setPS( mySystem->m6502().PS() ^ 0x04 ); setPS( mySystem.m6502().PS() ^ 0x04 );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleZ() void CpuDebug::toggleZ()
{ {
setPS( mySystem->m6502().PS() ^ 0x02 ); setPS( mySystem.m6502().PS() ^ 0x02 );
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CpuDebug::toggleC() void CpuDebug::toggleC()
{ {
setPS( mySystem->m6502().PS() ^ 0x01 ); setPS( mySystem.m6502().PS() ^ 0x01 );
} }

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: CpuDebug.hxx,v 1.12 2008-04-02 01:54:31 stephena Exp $ // $Id: CpuDebug.hxx,v 1.13 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#ifndef CPU_DEBUG_HXX #ifndef CPU_DEBUG_HXX
@ -41,34 +41,35 @@ class CpuState : public DebuggerState
class CpuDebug : public DebuggerSystem class CpuDebug : public DebuggerSystem
{ {
public: public:
CpuDebug(Debugger* dbg, Console* console); CpuDebug(Debugger& dbg, Console& console);
DebuggerState& getState(); const DebuggerState& getState();
DebuggerState& getOldState() { return myOldState; } const DebuggerState& getOldState() { return myOldState; }
void saveOldState(); void saveOldState();
string toString();
// I know, we ain't supposed to do this... // I know, we ain't supposed to do this...
M6502 &m6502() { return mySystem->m6502(); } M6502 &m6502() { return mySystem.m6502(); }
int disassemble(int address, string& result, EquateList* equateList); int disassemble(int address, string& result, EquateList* equateList);
int dPeek(int address); int dPeek(int address);
int getBank(); int getBank();
int pc() { return mySystem->m6502().PC; } int pc() { return mySystem.m6502().PC; }
int sp() { return mySystem->m6502().SP; } int sp() { return mySystem.m6502().SP; }
int a() { return mySystem->m6502().A; } int a() { return mySystem.m6502().A; }
int x() { return mySystem->m6502().X; } int x() { return mySystem.m6502().X; }
int y() { return mySystem->m6502().Y; } int y() { return mySystem.m6502().Y; }
// these return int, not boolean! // these return int, not boolean!
int n() { return mySystem->m6502().N; } int n() { return mySystem.m6502().N; }
int v() { return mySystem->m6502().V; } int v() { return mySystem.m6502().V; }
int b() { return mySystem->m6502().B; } int b() { return mySystem.m6502().B; }
int d() { return mySystem->m6502().D; } int d() { return mySystem.m6502().D; }
int i() { return mySystem->m6502().I; } int i() { return mySystem.m6502().I; }
int z() { return !mySystem->m6502().notZ; } int z() { return !mySystem.m6502().notZ; }
int c() { return mySystem->m6502().C; } int c() { return mySystem.m6502().C; }
void setPC(int pc); void setPC(int pc);
void setSP(int sp); void setSP(int sp);
@ -94,24 +95,14 @@ class CpuDebug : public DebuggerSystem
void toggleC(); void toggleC();
private: private:
static unsigned char set_bit(unsigned char input, int bit, bool on) static int dpeek(System& system, int address)
{ {
if(on) return system.peek(address) | (system.peek(address + 1) << 8);
return input | (1 << bit);
else
return input & (~(1 << bit));
}
static int dpeek(System* system, int address)
{
return system->peek(address) | (system->peek(address + 1) << 8);
} }
private: private:
CpuState myState; CpuState myState;
CpuState myOldState; CpuState myOldState;
System* mySystem;
}; };
#endif #endif

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: Debugger.cxx,v 1.122 2008-04-02 01:54:31 stephena Exp $ // $Id: Debugger.cxx,v 1.123 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#include "bspf.hxx" #include "bspf.hxx"
@ -38,6 +38,7 @@
#include "EquateList.hxx" #include "EquateList.hxx"
#include "CpuDebug.hxx" #include "CpuDebug.hxx"
#include "RamDebug.hxx" #include "RamDebug.hxx"
#include "RiotDebug.hxx"
#include "TIADebug.hxx" #include "TIADebug.hxx"
#include "TiaInfoWidget.hxx" #include "TiaInfoWidget.hxx"
@ -95,6 +96,7 @@ Debugger::Debugger(OSystem* osystem)
myParser(NULL), myParser(NULL),
myCpuDebug(NULL), myCpuDebug(NULL),
myRamDebug(NULL), myRamDebug(NULL),
myRiotDebug(NULL),
myTiaDebug(NULL), myTiaDebug(NULL),
myTiaInfo(NULL), myTiaInfo(NULL),
myTiaOutput(NULL), myTiaOutput(NULL),
@ -137,6 +139,7 @@ Debugger::~Debugger()
delete myCpuDebug; delete myCpuDebug;
delete myRamDebug; delete myRamDebug;
delete myRiotDebug;
delete myTiaDebug; delete myTiaDebug;
delete myEquateList; delete myEquateList;
@ -183,13 +186,16 @@ void Debugger::setConsole(Console* console)
// Create debugger subsystems // Create debugger subsystems
delete myCpuDebug; delete myCpuDebug;
myCpuDebug = new CpuDebug(this, myConsole); myCpuDebug = new CpuDebug(*this, *myConsole);
delete myRamDebug; delete myRamDebug;
myRamDebug = new RamDebug(this, myConsole); myRamDebug = new RamDebug(*this, *myConsole);
delete myRiotDebug;
myRiotDebug = new RiotDebug(*this, *myConsole);
delete myTiaDebug; delete myTiaDebug;
myTiaDebug = new TIADebug(this, myConsole); myTiaDebug = new TIADebug(*this, *myConsole);
// Initialize equates and breakpoints to known state // Initialize equates and breakpoints to known state
delete myEquateList; delete myEquateList;
@ -410,136 +416,6 @@ const string Debugger::invIfChanged(int reg, int oldReg)
return ret; return ret;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string Debugger::cpuState()
{
string result;
char buf[255];
CpuState state = (CpuState&) myCpuDebug->getState();
CpuState oldstate = (CpuState&) myCpuDebug->getOldState();
result += "\nPC=";
result += invIfChanged(state.PC, oldstate.PC);
result += " A=";
result += invIfChanged(state.A, oldstate.A);
result += " X=";
result += invIfChanged(state.X, oldstate.X);
result += " Y=";
result += invIfChanged(state.Y, oldstate.Y);
result += " S=";
result += invIfChanged(state.SP, oldstate.SP);
result += " P=";
result += invIfChanged(state.PS, oldstate.PS);
result += "/";
formatFlags(state.PSbits, buf);
result += buf;
result += "\n FrameCyc:";
sprintf(buf, "%d", mySystem->cycles());
result += buf;
result += " Frame:";
sprintf(buf, "%d", myTiaDebug->frameCount());
result += buf;
result += " ScanLine:";
sprintf(buf, "%d", myTiaDebug->scanlines());
result += buf;
result += " Clk/Pix/Cyc:";
int clk = myTiaDebug->clocksThisLine();
sprintf(buf, "%d/%d/%d", clk, clk-68, clk/3);
result += buf;
result += " 6502Ins:";
sprintf(buf, "%d", mySystem->m6502().totalInstructionCount());
result += buf;
result += "\n ";
result += disassemble(state.PC, 1);
return result;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/* The timers, joysticks, and switches can be read via peeks, so
I didn't write a separate RIOTDebug class. */
const string Debugger::riotState()
{
string ret;
// TODO: inverse video for changed regs. Core needs to track this.
// TODO: keyboard controllers?
for(int i=0x280; i<0x284; i++)
{
ret += valueToString(i);
ret += "/";
ret += equates().getFormatted(i, 2);
ret += "=";
ret += valueToString(mySystem->peek(i));
ret += " ";
}
ret += "\n";
// These are squirrely: some symbol files will define these as
// 0x284-0x287. Doesn't actually matter, these registers repeat
// every 16 bytes.
ret += valueToString(0x294);
ret += "/TIM1T=";
ret += valueToString(mySystem->peek(0x294));
ret += " ";
ret += valueToString(0x295);
ret += "/TIM8T=";
ret += valueToString(mySystem->peek(0x295));
ret += " ";
ret += valueToString(0x296);
ret += "/TIM64T=";
ret += valueToString(mySystem->peek(0x296));
ret += " ";
ret += valueToString(0x297);
ret += "/TIM1024T=";
ret += valueToString(mySystem->peek(0x297));
ret += "\n";
ret += "Left/P0diff: ";
ret += (mySystem->peek(0x282) & 0x40) ? "hard/A" : "easy/B";
ret += " ";
ret += "Right/P1diff: ";
ret += (mySystem->peek(0x282) & 0x80) ? "hard/A" : "easy/B";
ret += "\n";
ret += "TVType: ";
ret += (mySystem->peek(0x282) & 0x8) ? "Color" : "B&W";
ret += " Switches: ";
ret += (mySystem->peek(0x282) & 0x2) ? "-" : "+";
ret += "select ";
ret += (mySystem->peek(0x282) & 0x1) ? "-" : "+";
ret += "reset";
ret += "\n";
// Yes, the fire buttons are in the TIA, but we might as well
// show them here for convenience.
ret += "Left/P0 stick: ";
ret += (mySystem->peek(0x280) & 0x80) ? "" : "right ";
ret += (mySystem->peek(0x280) & 0x40) ? "" : "left ";
ret += (mySystem->peek(0x280) & 0x20) ? "" : "down ";
ret += (mySystem->peek(0x280) & 0x10) ? "" : "up ";
ret += ((mySystem->peek(0x280) & 0xf0) == 0xf0) ? "(no directions) " : "";
ret += (mySystem->peek(0x03c) & 0x80) ? "" : "(button) ";
ret += "\n";
ret += "Right/P1 stick: ";
ret += (mySystem->peek(0x280) & 0x08) ? "" : "right ";
ret += (mySystem->peek(0x280) & 0x04) ? "" : "left ";
ret += (mySystem->peek(0x280) & 0x02) ? "" : "down ";
ret += (mySystem->peek(0x280) & 0x01) ? "" : "up ";
ret += ((mySystem->peek(0x280) & 0x0f) == 0x0f) ? "(no directions) " : "";
ret += (mySystem->peek(0x03d) & 0x80) ? "" : "(button) ";
//ret += "\n"; // caller will add
return ret;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::reset() void Debugger::reset()
{ {
@ -547,21 +423,6 @@ void Debugger::reset()
myCpuDebug->setPC(pc); myCpuDebug->setPC(pc);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::formatFlags(BoolArray& b, char *out)
{
// NV-BDIZC
out[0] = myCpuDebug->n() ? 'N' : 'n';
out[1] = myCpuDebug->v() ? 'V' : 'v';
out[2] = '-';
out[3] = myCpuDebug->b() ? 'B' : 'b';
out[4] = myCpuDebug->d() ? 'D' : 'd';
out[5] = myCpuDebug->i() ? 'I' : 'i';
out[6] = myCpuDebug->z() ? 'Z' : 'z';
out[7] = myCpuDebug->c() ? 'C' : 'c';
out[8] = '\0';
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/* Element 0 of args is the address. The remaining elements are the data /* Element 0 of args is the address. The remaining elements are the data
to poke, starting at the given address. to poke, starting at the given address.
@ -584,73 +445,6 @@ const string Debugger::setRAM(IntArray& args)
return ret; return ret;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/* Warning: this method really is for dumping *RAM*, not ROM or I/O! */
const string Debugger::dumpRAM()
{
string result;
char buf[128];
int bytesPerLine;
int start = kRamStart, len = kRamSize;
switch(myParser->base())
{
case kBASE_16:
case kBASE_10:
bytesPerLine = 0x10;
break;
case kBASE_2:
bytesPerLine = 0x04;
break;
case kBASE_DEFAULT:
default:
return DebuggerParser::red("invalid base, this is a BUG");
}
RamState state = (RamState&) myRamDebug->getState();
RamState oldstate = (RamState&) myRamDebug->getOldState();
for (uInt8 i = 0x00; i < len; i += bytesPerLine)
{
sprintf(buf, "%.2x: ", start+i);
result += buf;
for (uInt8 j = 0; j < bytesPerLine; j++)
{
result += invIfChanged(state.ram[i+j], oldstate.ram[i+j]);
result += " ";
if(j == 0x07) result += " ";
}
result += "\n";
}
return result;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string Debugger::dumpTIA()
{
string result;
char buf[128];
sprintf(buf, "%.2x: ", 0);
result += buf;
for (uInt8 j = 0; j < 0x010; j++)
{
sprintf(buf, "%.2x ", mySystem->peek(j));
result += buf;
if(j == 0x07) result += "- ";
}
result += "\n";
result += myTiaDebug->state();
return result;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::saveState(int state) void Debugger::saveState(int state)
{ {
@ -935,6 +729,7 @@ void Debugger::saveOldState()
{ {
myCpuDebug->saveOldState(); myCpuDebug->saveOldState();
myRamDebug->saveOldState(); myRamDebug->saveOldState();
myRiotDebug->saveOldState();
myTiaDebug->saveOldState(); myTiaDebug->saveOldState();
} }

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: Debugger.hxx,v 1.92 2008-03-23 17:43:21 stephena Exp $ // $Id: Debugger.hxx,v 1.93 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#ifndef DEBUGGER_HXX #ifndef DEBUGGER_HXX
@ -24,6 +24,7 @@ class Console;
class System; class System;
class CpuDebug; class CpuDebug;
class RamDebug; class RamDebug;
class RiotDebug;
class TIADebug; class TIADebug;
class TiaInfoWidget; class TiaInfoWidget;
class TiaOutputWidget; class TiaOutputWidget;
@ -69,7 +70,7 @@ typedef uInt16 (Debugger::*DEBUGGER_WORD_METHOD)();
for all debugging operations in Stella (parser, 6502 debugger, etc). for all debugging operations in Stella (parser, 6502 debugger, etc).
@author Stephen Anthony @author Stephen Anthony
@version $Id: Debugger.hxx,v 1.92 2008-03-23 17:43:21 stephena Exp $ @version $Id: Debugger.hxx,v 1.93 2008-04-19 21:11:52 stephena Exp $
*/ */
class Debugger : public DialogContainer class Debugger : public DialogContainer
{ {
@ -143,6 +144,11 @@ class Debugger : public DialogContainer
*/ */
RamDebug& ramDebug() const { return *myRamDebug; } RamDebug& ramDebug() const { return *myRamDebug; }
/**
The debugger subsystem responsible for all RIOT state
*/
RiotDebug& riotDebug() const { return *myRiotDebug; }
/** /**
The debugger subsystem responsible for all TIA state The debugger subsystem responsible for all TIA state
*/ */
@ -163,17 +169,6 @@ class Debugger : public DialogContainer
*/ */
const string run(const string& command); const string run(const string& command);
/**
Give the contents of the CPU registers and disassembly of
next instruction.
*/
const string cpuState();
/**
Get contents of RIOT switch & timer registers
*/
const string riotState();
/** /**
The current cycle count of the System. The current cycle count of the System.
*/ */
@ -249,6 +244,41 @@ class Debugger : public DialogContainer
else return -1; else return -1;
} }
/* Convenience methods to get/set bit(s) in an 8-bit register */
static uInt8 set_bit(uInt8 input, uInt8 bit, bool on)
{
if(on)
return input | (1 << bit);
else
return input & ~(1 << bit);
}
static void set_bits(uInt8 reg, BoolArray& bits)
{
bits.clear();
for(int i = 0; i < 8; ++i)
{
if(reg & (1<<(7-i)))
bits.push_back(true);
else
bits.push_back(false);
}
}
static uInt8 get_bits(BoolArray& bits)
{
uInt8 result = 0x0;
for(int i = 0; i < 8; ++i)
{
if(bits[i])
result |= (1<<(7-i));
else
return result &= ~(1<<(7-i));
}
return result;
}
/* Invert given input if it differs from its previous value */
const string invIfChanged(int reg, int oldReg);
/** /**
This is used when we want the debugger from a class that can't This is used when we want the debugger from a class that can't
receive the debugger object in any other way. receive the debugger object in any other way.
@ -322,21 +352,13 @@ class Debugger : public DialogContainer
void reloadROM(); void reloadROM();
/** // Set a bunch of RAM locations at once
Return a formatted string containing the contents of the specified
device.
*/
const string dumpRAM();
const string dumpTIA();
// set a bunch of RAM locations at once
const string setRAM(IntArray& args); const string setRAM(IntArray& args);
void reset(); void reset();
void autoLoadSymbols(string file); void autoLoadSymbols(string file);
void clearAllBreakPoints(); void clearAllBreakPoints();
void formatFlags(BoolArray& b, char *out);
PromptWidget *prompt() { return myPrompt; } PromptWidget *prompt() { return myPrompt; }
void addLabel(string label, int address); void addLabel(string label, int address);
@ -344,8 +366,6 @@ class Debugger : public DialogContainer
void saveState(int state); void saveState(int state);
void loadState(int state); void loadState(int state);
const string invIfChanged(int reg, int oldReg);
private: private:
typedef multimap<string,string> ListFile; typedef multimap<string,string> ListFile;
typedef ListFile::const_iterator ListIter; typedef ListFile::const_iterator ListIter;
@ -356,6 +376,7 @@ class Debugger : public DialogContainer
DebuggerParser* myParser; DebuggerParser* myParser;
CpuDebug* myCpuDebug; CpuDebug* myCpuDebug;
RamDebug* myRamDebug; RamDebug* myRamDebug;
RiotDebug* myRiotDebug;
TIADebug* myTiaDebug; TIADebug* myTiaDebug;
TiaInfoWidget* myTiaInfo; TiaInfoWidget* myTiaInfo;

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: DebuggerParser.cxx,v 1.104 2008-04-02 21:22:16 stephena Exp $ // $Id: DebuggerParser.cxx,v 1.105 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#include <fstream> #include <fstream>
@ -23,6 +23,9 @@
#include "Dialog.hxx" #include "Dialog.hxx"
#include "Debugger.hxx" #include "Debugger.hxx"
#include "CpuDebug.hxx" #include "CpuDebug.hxx"
#include "RamDebug.hxx"
#include "RiotDebug.hxx"
#include "TIADebug.hxx"
#include "DebuggerParser.hxx" #include "DebuggerParser.hxx"
#include "YaccParser.hxx" #include "YaccParser.hxx"
#include "M6502.hxx" #include "M6502.hxx"
@ -1093,7 +1096,7 @@ void DebuggerParser::executePrint()
void DebuggerParser::executeRam() void DebuggerParser::executeRam()
{ {
if(argCount == 0) if(argCount == 0)
commandResult = debugger->dumpRAM(); commandResult = debugger->ramDebug().toString();
else else
commandResult = debugger->setRAM(args); commandResult = debugger->setRAM(args);
} }
@ -1110,7 +1113,7 @@ void DebuggerParser::executeReset()
// "riot" // "riot"
void DebuggerParser::executeRiot() void DebuggerParser::executeRiot()
{ {
commandResult = debugger->riotState(); commandResult = debugger->riotDebug().toString();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -1257,7 +1260,7 @@ void DebuggerParser::executeStep()
// "tia" // "tia"
void DebuggerParser::executeTia() void DebuggerParser::executeTia()
{ {
commandResult = debugger->dumpTIA(); commandResult = debugger->tiaDebug().toString();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: DebuggerSystem.hxx,v 1.6 2008-02-06 13:45:20 stephena Exp $ // $Id: DebuggerSystem.hxx,v 1.7 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#ifndef DEBUGGER_SYSTEM_HXX #ifndef DEBUGGER_SYSTEM_HXX
@ -42,16 +42,20 @@ class DebuggerState
class DebuggerSystem class DebuggerSystem
{ {
public: public:
DebuggerSystem(Debugger* dbg, Console* console) { myDebugger = dbg; } DebuggerSystem(Debugger& dbg, Console& console) :
myDebugger(dbg), myConsole(console), mySystem(console.system()) { }
virtual ~DebuggerSystem() { } virtual ~DebuggerSystem() { }
virtual DebuggerState& getState() = 0; virtual const DebuggerState& getState() = 0;
virtual DebuggerState& getOldState() = 0; virtual const DebuggerState& getOldState() = 0;
virtual void saveOldState() = 0; virtual void saveOldState() = 0;
virtual string toString() = 0;
protected: protected:
Debugger* myDebugger; Debugger& myDebugger;
Console& myConsole;
System& mySystem;
}; };
#endif #endif

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: RamDebug.cxx,v 1.7 2008-02-06 13:45:20 stephena Exp $ // $Id: RamDebug.cxx,v 1.8 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#include "Array.hxx" #include "Array.hxx"
@ -21,14 +21,13 @@
#include "RamDebug.hxx" #include "RamDebug.hxx"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
RamDebug::RamDebug(Debugger* dbg, Console* console) RamDebug::RamDebug(Debugger& dbg, Console& console)
: DebuggerSystem(dbg, console), : DebuggerSystem(dbg, console)
mySystem(&(console->system()))
{ {
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
DebuggerState& RamDebug::getState() const DebuggerState& RamDebug::getState()
{ {
myState.ram.clear(); myState.ram.clear();
for(int i=0; i<0x80; i++) for(int i=0; i<0x80; i++)
@ -49,12 +48,56 @@ void RamDebug::saveOldState()
int RamDebug::read(int offset) int RamDebug::read(int offset)
{ {
offset &= 0x7f; // there are only 128 bytes offset &= 0x7f; // there are only 128 bytes
return mySystem->peek(offset + 0x80); return mySystem.peek(offset + 0x80);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void RamDebug::write(int offset, int value) void RamDebug::write(int offset, int value)
{ {
offset &= 0x7f; // there are only 128 bytes offset &= 0x7f; // there are only 128 bytes
mySystem->poke(offset + 0x80, value); mySystem.poke(offset + 0x80, value);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RamDebug::toString()
{
string result;
char buf[128];
int bytesPerLine;
int start = kRamStart, len = kRamSize;
switch(myDebugger.parser().base())
{
case kBASE_16:
case kBASE_10:
bytesPerLine = 0x10;
break;
case kBASE_2:
bytesPerLine = 0x04;
break;
case kBASE_DEFAULT:
default:
return DebuggerParser::red("invalid base, this is a BUG");
}
const RamState& state = (RamState&) getState();
const RamState& oldstate = (RamState&) getOldState();
for (uInt8 i = 0x00; i < len; i += bytesPerLine)
{
sprintf(buf, "%.2x: ", start+i);
result += buf;
for (uInt8 j = 0; j < bytesPerLine; j++)
{
result += myDebugger.invIfChanged(state.ram[i+j], oldstate.ram[i+j]);
result += " ";
if(j == 0x07) result += " ";
}
result += "\n";
}
return result;
} }

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: RamDebug.hxx,v 1.6 2008-02-06 13:45:20 stephena Exp $ // $Id: RamDebug.hxx,v 1.7 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#ifndef RAM_DEBUG_HXX #ifndef RAM_DEBUG_HXX
@ -33,12 +33,13 @@ class RamState : public DebuggerState
class RamDebug : public DebuggerSystem class RamDebug : public DebuggerSystem
{ {
public: public:
RamDebug(Debugger* dbg, Console* console); RamDebug(Debugger& dbg, Console& console);
DebuggerState& getState(); const DebuggerState& getState();
DebuggerState& getOldState() { return myOldState; } const DebuggerState& getOldState() { return myOldState; }
void saveOldState(); void saveOldState();
string toString();
int read(int offset); int read(int offset);
void write(int offset, int value); void write(int offset, int value);
@ -46,8 +47,6 @@ class RamDebug : public DebuggerSystem
private: private:
RamState myState; RamState myState;
RamState myOldState; RamState myOldState;
System* mySystem;
}; };
#endif #endif

View File

@ -0,0 +1,281 @@
//============================================================================
//
// SSSS tt lll lll
// SS SS tt ll ll
// SS tttttt eeee ll ll aaaa
// SSSS tt ee ee ll ll aa
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
// SS SS tt ee ll ll aa aa
// SSSS ttt eeeee llll llll aaaaa
//
// Copyright (c) 1995-2008 by Bradford W. Mott and the Stella team
//
// See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
//
// $Id: RiotDebug.cxx,v 1.1 2008-04-19 21:11:52 stephena Exp $
//============================================================================
#include <sstream>
#include "System.hxx"
#include "Debugger.hxx"
#include "RiotDebug.hxx"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
RiotDebug::RiotDebug(Debugger& dbg, Console& console)
: DebuggerSystem(dbg, console)
{
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const DebuggerState& RiotDebug::getState()
{
// Port A & B registers
myState.SWCHA = swcha();
myState.SWCHB = swchb();
myState.SWACNT = swacnt();
myState.SWBCNT = swbcnt();
Debugger::set_bits(swcha(), myState.swchaBits);
Debugger::set_bits(swchb(), myState.swchbBits);
Debugger::set_bits(swacnt(), myState.swacntBits);
Debugger::set_bits(swbcnt(), myState.swbcntBits);
// Timer registers
myState.TIM1T = tim1T();
myState.TIM8T = tim8T();
myState.TIM64T = tim64T();
myState.TIM1024T = tim1024T();
myState.INTIM = intim();
myState.TIMINT = timint();
myState.TIMCLKS = timClocks();
return myState;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void RiotDebug::saveOldState()
{
// Port A & B registers
myOldState.SWCHA = swcha();
myOldState.SWCHB = swchb();
myOldState.SWACNT = swacnt();
myOldState.SWBCNT = swbcnt();
Debugger::set_bits(swcha(), myOldState.swchaBits);
Debugger::set_bits(swchb(), myOldState.swchbBits);
Debugger::set_bits(swacnt(), myOldState.swacntBits);
Debugger::set_bits(swbcnt(), myOldState.swbcntBits);
// Timer registers
myOldState.TIM1T = tim1T();
myOldState.TIM8T = tim8T();
myOldState.TIM64T = tim64T();
myOldState.TIM1024T = tim1024T();
myOldState.INTIM = intim();
myOldState.TIMINT = timint();
myOldState.TIMCLKS = timClocks();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::swcha(int newVal)
{
if(newVal > -1)
mySystem.poke(0x280, newVal);
return mySystem.peek(0x280);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::swchb(int newVal)
{
// TODO: directly access the Switches class to change this
// if(newVal > -1)
// mySystem.poke(0x282, newVal);
return mySystem.peek(0x282);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::swacnt(int newVal)
{
if(newVal > -1)
mySystem.poke(0x281, newVal);
return mySystem.peek(0x281);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::swbcnt(int newVal)
{
// This is read-only on a real system; it makes no sense to change it
return mySystem.peek(0x283);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::tim1T(int newVal)
{
if(newVal > -1)
mySystem.poke(0x294, newVal);
return mySystem.m6532().myOutTimer[0];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::tim8T(int newVal)
{
if(newVal > -1)
mySystem.poke(0x295, newVal);
return mySystem.m6532().myOutTimer[1];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::tim64T(int newVal)
{
if(newVal > -1)
mySystem.poke(0x296, newVal);
return mySystem.m6532().myOutTimer[2];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::tim1024T(int newVal)
{
if(newVal > -1)
mySystem.poke(0x297, newVal);
return mySystem.m6532().myOutTimer[3];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::intim()
{
return mySystem.peek(0x284);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 RiotDebug::timint()
{
return mySystem.peek(0x285);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Int32 RiotDebug::timClocks()
{
return mySystem.m6532().timerClocks();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::dirP0String()
{
uInt8 reg = swcha();
ostringstream buf;
buf << (reg & 0x80 ? "" : "right ")
<< (reg & 0x40 ? "" : "left ")
<< (reg & 0x20 ? "" : "left ")
<< (reg & 0x10 ? "" : "left ")
<< (reg & 0xf0 == 0xf0 ? "(no directions) " : "");
return buf.str();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::dirP1String()
{
uInt8 reg = swcha();
ostringstream buf;
buf << (reg & 0x08 ? "" : "right ")
<< (reg & 0x04 ? "" : "left ")
<< (reg & 0x02 ? "" : "left ")
<< (reg & 0x01 ? "" : "left ")
<< (reg & 0x0f == 0x0f ? "(no directions) " : "");
return buf.str();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::diffP0String()
{
return (swchb() & 0x40) ? "hard/A" : "easy/B";
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::diffP1String()
{
return (swchb() & 0x80) ? "hard/A" : "easy/B";
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::tvTypeString()
{
return (swchb() & 0x8) ? "Color" : "B&W";
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::switchesString()
{
ostringstream buf;
buf << (swchb() & 0x2 ? "-" : "+") << "select " <<
(swchb() & 0x1 ? "-" : "+") << "reset";
return buf.str();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string RiotDebug::toString()
{
// TODO: keyboard controllers?
const RiotState& state = (RiotState&) getState();
const RiotState& oldstate = (RiotState&) getOldState();
string ret;
ret += myDebugger.valueToString(0x280) + "/" +
myDebugger.equates().getFormatted(0x280, 2) + "=" +
myDebugger.invIfChanged(state.SWCHA, oldstate.SWCHA) + " ";
ret += myDebugger.valueToString(0x281) + "/" +
myDebugger.equates().getFormatted(0x281, 2) + "=" +
myDebugger.invIfChanged(state.SWCHB, oldstate.SWCHB) + " ";
ret += myDebugger.valueToString(0x282) + "/" +
myDebugger.equates().getFormatted(0x282, 2) + "=" +
myDebugger.invIfChanged(state.SWACNT, oldstate.SWACNT) + " ";
ret += myDebugger.valueToString(0x283) + "/" +
myDebugger.equates().getFormatted(0x283, 2) + "=" +
myDebugger.invIfChanged(state.SWBCNT, oldstate.SWBCNT) + " ";
ret += "\n";
// These are squirrely: some symbol files will define these as
// 0x284-0x287. Doesn't actually matter, these registers repeat
// every 16 bytes.
ret += myDebugger.valueToString(0x294) + "/TIM1T=" +
myDebugger.invIfChanged(state.TIM1T, oldstate.TIM1T) + " ";
ret += myDebugger.valueToString(0x295) + "/TIM8T=" +
myDebugger.invIfChanged(state.TIM8T, oldstate.TIM8T) + " ";
ret += myDebugger.valueToString(0x296) + "/TIM64T=" +
myDebugger.invIfChanged(state.TIM64T, oldstate.TIM64T) + " ";
ret += myDebugger.valueToString(0x297) + "/TIM1024T=" +
myDebugger.invIfChanged(state.TIM1024T, oldstate.TIM1024T) + " ";
ret += "\n";
ret += myDebugger.valueToString(0x284) + "/INTIM=" +
myDebugger.invIfChanged(state.INTIM, oldstate.INTIM) + " ";
ret += myDebugger.valueToString(0x285) + "/TIMINT=" +
myDebugger.invIfChanged(state.TIMINT, oldstate.TIMINT) + " ";
ret += "Timer_Clocks=" +
myDebugger.invIfChanged(state.TIMCLKS, oldstate.TIMCLKS) + " ";
ret += "\n";
ret += "Left/P0diff: " + diffP0String() + " Right/P1diff: " + diffP0String();
ret += "\n";
ret += "TVType: " + tvTypeString() + " Switches: " + switchesString();
ret += "\n";
// Yes, the fire buttons are in the TIA, but we might as well
// show them here for convenience.
ret += "Left/P0 stick: " + dirP0String();
ret += (mySystem.peek(0x03c) & 0x80) ? "" : "(button) ";
ret += "\n";
ret += "Right/P1 stick: " + dirP1String();
ret += (mySystem.peek(0x03d) & 0x80) ? "" : "(button) ";
return ret;
}

View File

@ -0,0 +1,82 @@
//============================================================================
//
// SSSS tt lll lll
// SS SS tt ll ll
// SS tttttt eeee ll ll aaaa
// SSSS tt ee ee ll ll aa
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
// SS SS tt ee ll ll aa aa
// SSSS ttt eeeee llll llll aaaaa
//
// Copyright (c) 1995-2008 by Bradford W. Mott and the Stella team
//
// See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
//
// $Id: RiotDebug.hxx,v 1.1 2008-04-19 21:11:52 stephena Exp $
//============================================================================
#ifndef RIOT_DEBUG_HXX
#define RIOT_DEBUG_HXX
class Debugger;
class RiotDebug;
#include "Array.hxx"
#include "DebuggerSystem.hxx"
class RiotState : public DebuggerState
{
public:
uInt8 SWCHA, SWCHB, SWACNT, SWBCNT;
BoolArray swchaBits;
BoolArray swchbBits;
BoolArray swacntBits;
BoolArray swbcntBits;
uInt8 TIM1T, TIM8T, TIM64T, TIM1024T, INTIM, TIMINT;
Int32 TIMCLKS;
};
class RiotDebug : public DebuggerSystem
{
public:
RiotDebug(Debugger& dbg, Console& console);
const DebuggerState& getState();
const DebuggerState& getOldState() { return myOldState; }
void saveOldState();
string toString();
/* Port A and B registers */
uInt8 swcha(int newVal = -1);
uInt8 swchb(int newVal = -1);
uInt8 swacnt(int newVal = -1);
uInt8 swbcnt(int newVal = -1);
/* Timer registers & associated clock */
uInt8 tim1T(int newVal = -1);
uInt8 tim8T(int newVal = -1);
uInt8 tim64T(int newVal = -1);
uInt8 tim1024T(int newVal = -1);
uInt8 intim();
uInt8 timint();
Int32 timClocks();
/* Port A description */
string dirP0String();
string dirP1String();
/* Port B description */
string diffP0String();
string diffP1String();
string tvTypeString();
string switchesString();
private:
RiotState myState;
RiotState myOldState;
};
#endif

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: TIADebug.cxx,v 1.26 2008-02-06 13:45:20 stephena Exp $ // $Id: TIADebug.cxx,v 1.27 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#include "System.hxx" #include "System.hxx"
@ -22,10 +22,9 @@
#include "TIADebug.hxx" #include "TIADebug.hxx"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
TIADebug::TIADebug(Debugger* dbg, Console* console) TIADebug::TIADebug(Debugger& dbg, Console& console)
: DebuggerSystem(dbg, console), : DebuggerSystem(dbg, console),
mySystem(&console->system()), myTIA((TIA&)console.mediaSource())
myTIA((TIA*)&console->mediaSource())
{ {
nusizStrings[0] = "size=8 copy=1"; nusizStrings[0] = "size=8 copy=1";
nusizStrings[1] = "size=8 copy=2 spac=8"; nusizStrings[1] = "size=8 copy=2 spac=8";
@ -38,11 +37,11 @@ TIADebug::TIADebug(Debugger* dbg, Console* console)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
DebuggerState& TIADebug::getState() const DebuggerState& TIADebug::getState()
{ {
myState.ram.clear(); myState.ram.clear();
for(int i = 0; i < 0x010; ++i) for(int i = 0; i < 0x010; ++i)
myState.ram.push_back(myTIA->peek(i)); myState.ram.push_back(myTIA.peek(i));
// Color registers // Color registers
myState.coluRegs.clear(); myState.coluRegs.clear();
@ -103,7 +102,7 @@ void TIADebug::saveOldState()
{ {
myOldState.ram.clear(); myOldState.ram.clear();
for(int i = 0; i < 0x010; ++i) for(int i = 0; i < 0x010; ++i)
myOldState.ram.push_back(myTIA->peek(i)); myOldState.ram.push_back(myTIA.peek(i));
// Color registers // Color registers
myOldState.coluRegs.clear(); myOldState.coluRegs.clear();
@ -157,7 +156,7 @@ void TIADebug::saveOldState()
myOldState.aud.push_back(audV1()); myOldState.aud.push_back(audV1());
} }
/* the set methods now use mySystem->poke(). This will save us the /* the set methods now use mySystem.poke(). This will save us the
trouble of masking the values here, since TIA::poke() will do it trouble of masking the values here, since TIA::poke() will do it
for us. for us.
@ -187,90 +186,90 @@ void TIADebug::saveOldState()
bool TIADebug::vdelP0(int newVal) bool TIADebug::vdelP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(VDELP0, ((bool)newVal)); mySystem.poke(VDELP0, ((bool)newVal));
return myTIA->myVDELP0; return myTIA.myVDELP0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::vdelP1(int newVal) bool TIADebug::vdelP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(VDELP1, ((bool)newVal)); mySystem.poke(VDELP1, ((bool)newVal));
return myTIA->myVDELP1; return myTIA.myVDELP1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::vdelBL(int newVal) bool TIADebug::vdelBL(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(VDELBL, ((bool)newVal)); mySystem.poke(VDELBL, ((bool)newVal));
return myTIA->myVDELBL; return myTIA.myVDELBL;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::enaM0(int newVal) bool TIADebug::enaM0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(ENAM0, ((bool)newVal) << 1); mySystem.poke(ENAM0, ((bool)newVal) << 1);
return myTIA->myENAM0; return myTIA.myENAM0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::enaM1(int newVal) bool TIADebug::enaM1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(ENAM1, ((bool)newVal) << 1); mySystem.poke(ENAM1, ((bool)newVal) << 1);
return myTIA->myENAM1; return myTIA.myENAM1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::enaBL(int newVal) bool TIADebug::enaBL(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(ENABL, ((bool)newVal) << 1); mySystem.poke(ENABL, ((bool)newVal) << 1);
return myTIA->myENABL; return myTIA.myENABL;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::resMP0(int newVal) bool TIADebug::resMP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(RESMP0, ((bool)newVal) << 1); mySystem.poke(RESMP0, ((bool)newVal) << 1);
return myTIA->myRESMP0; return myTIA.myRESMP0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::resMP1(int newVal) bool TIADebug::resMP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(RESMP1, ((bool)newVal) << 1); mySystem.poke(RESMP1, ((bool)newVal) << 1);
return myTIA->myRESMP1; return myTIA.myRESMP1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::refP0(int newVal) bool TIADebug::refP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(REFP0, ((bool)newVal) << 3); mySystem.poke(REFP0, ((bool)newVal) << 3);
return myTIA->myREFP0; return myTIA.myREFP0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::refP1(int newVal) bool TIADebug::refP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(REFP1, ((bool)newVal) << 3); mySystem.poke(REFP1, ((bool)newVal) << 3);
return myTIA->myREFP1; return myTIA.myREFP1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -278,15 +277,15 @@ bool TIADebug::refPF(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
int tmp = myTIA->myCTRLPF; int tmp = myTIA.myCTRLPF;
if(newVal) if(newVal)
tmp |= 0x01; tmp |= 0x01;
else else
tmp &= ~0x01; tmp &= ~0x01;
mySystem->poke(CTRLPF, tmp); mySystem.poke(CTRLPF, tmp);
} }
return myTIA->myCTRLPF & 0x01; return myTIA.myCTRLPF & 0x01;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -294,15 +293,15 @@ bool TIADebug::scorePF(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
int tmp = myTIA->myCTRLPF; int tmp = myTIA.myCTRLPF;
if(newVal) if(newVal)
tmp |= 0x02; tmp |= 0x02;
else else
tmp &= ~0x02; tmp &= ~0x02;
mySystem->poke(CTRLPF, tmp); mySystem.poke(CTRLPF, tmp);
} }
return myTIA->myCTRLPF & 0x02; return myTIA.myCTRLPF & 0x02;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -310,15 +309,15 @@ bool TIADebug::priorityPF(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
int tmp = myTIA->myCTRLPF; int tmp = myTIA.myCTRLPF;
if(newVal) if(newVal)
tmp |= 0x04; tmp |= 0x04;
else else
tmp &= ~0x04; tmp &= ~0x04;
mySystem->poke(CTRLPF, tmp); mySystem.poke(CTRLPF, tmp);
} }
return myTIA->myCTRLPF & 0x04; return myTIA.myCTRLPF & 0x04;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -329,147 +328,147 @@ bool TIADebug::collision(int collID, int newVal)
if(newVal > -1) if(newVal > -1)
{ {
if(newVal) if(newVal)
myTIA->myCollision |= mask; myTIA.myCollision |= mask;
else else
myTIA->myCollision &= ~mask; myTIA.myCollision &= ~mask;
} }
return myTIA->myCollision & mask; return myTIA.myCollision & mask;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::audC0(int newVal) uInt8 TIADebug::audC0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(AUDC0, newVal); mySystem.poke(AUDC0, newVal);
return myTIA->myAUDC0; return myTIA.myAUDC0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::audC1(int newVal) uInt8 TIADebug::audC1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(AUDC1, newVal); mySystem.poke(AUDC1, newVal);
return myTIA->myAUDC1; return myTIA.myAUDC1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::audV0(int newVal) uInt8 TIADebug::audV0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(AUDV0, newVal); mySystem.poke(AUDV0, newVal);
return myTIA->myAUDV0; return myTIA.myAUDV0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::audV1(int newVal) uInt8 TIADebug::audV1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(AUDV1, newVal); mySystem.poke(AUDV1, newVal);
return myTIA->myAUDV1; return myTIA.myAUDV1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::audF0(int newVal) uInt8 TIADebug::audF0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(AUDF0, newVal); mySystem.poke(AUDF0, newVal);
return myTIA->myAUDF0; return myTIA.myAUDF0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::audF1(int newVal) uInt8 TIADebug::audF1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(AUDF1, newVal); mySystem.poke(AUDF1, newVal);
return myTIA->myAUDF1; return myTIA.myAUDF1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::pf0(int newVal) uInt8 TIADebug::pf0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(PF0, newVal << 4); mySystem.poke(PF0, newVal << 4);
return myTIA->myPF & 0x0f; return myTIA.myPF & 0x0f;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::pf1(int newVal) uInt8 TIADebug::pf1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(PF1, newVal); mySystem.poke(PF1, newVal);
return (myTIA->myPF & 0xff0) >> 4; return (myTIA.myPF & 0xff0) >> 4;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::pf2(int newVal) uInt8 TIADebug::pf2(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(PF2, newVal); mySystem.poke(PF2, newVal);
return (myTIA->myPF & 0xff000) >> 12; return (myTIA.myPF & 0xff000) >> 12;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::coluP0(int newVal) uInt8 TIADebug::coluP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(COLUP0, newVal); mySystem.poke(COLUP0, newVal);
return myTIA->myCOLUP0 & 0xff; return myTIA.myCOLUP0 & 0xff;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::coluP1(int newVal) uInt8 TIADebug::coluP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(COLUP1, newVal); mySystem.poke(COLUP1, newVal);
return myTIA->myCOLUP1 & 0xff; return myTIA.myCOLUP1 & 0xff;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::coluPF(int newVal) uInt8 TIADebug::coluPF(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(COLUPF, newVal); mySystem.poke(COLUPF, newVal);
return myTIA->myCOLUPF & 0xff; return myTIA.myCOLUPF & 0xff;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::coluBK(int newVal) uInt8 TIADebug::coluBK(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(COLUBK, newVal); mySystem.poke(COLUBK, newVal);
return myTIA->myCOLUBK & 0xff; return myTIA.myCOLUBK & 0xff;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::nusiz0(int newVal) uInt8 TIADebug::nusiz0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(NUSIZ0, newVal); mySystem.poke(NUSIZ0, newVal);
return myTIA->myNUSIZ0; return myTIA.myNUSIZ0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::nusiz1(int newVal) uInt8 TIADebug::nusiz1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(NUSIZ1, newVal); mySystem.poke(NUSIZ1, newVal);
return myTIA->myNUSIZ1; return myTIA.myNUSIZ1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -477,12 +476,12 @@ uInt8 TIADebug::nusizP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
uInt8 tmp = myTIA->myNUSIZ0 & ~0x07; uInt8 tmp = myTIA.myNUSIZ0 & ~0x07;
tmp |= (newVal & 0x07); tmp |= (newVal & 0x07);
mySystem->poke(NUSIZ0, tmp); mySystem.poke(NUSIZ0, tmp);
} }
return myTIA->myNUSIZ0 & 0x07; return myTIA.myNUSIZ0 & 0x07;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -490,12 +489,12 @@ uInt8 TIADebug::nusizP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
uInt8 tmp = myTIA->myNUSIZ1 & ~0x07; uInt8 tmp = myTIA.myNUSIZ1 & ~0x07;
tmp |= newVal & 0x07; tmp |= newVal & 0x07;
mySystem->poke(NUSIZ1, tmp); mySystem.poke(NUSIZ1, tmp);
} }
return myTIA->myNUSIZ1 & 0x07; return myTIA.myNUSIZ1 & 0x07;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -503,12 +502,12 @@ uInt8 TIADebug::nusizM0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
uInt8 tmp = myTIA->myNUSIZ0 & ~0x30; uInt8 tmp = myTIA.myNUSIZ0 & ~0x30;
tmp |= (newVal & 0x04) << 4; tmp |= (newVal & 0x04) << 4;
mySystem->poke(NUSIZ0, tmp); mySystem.poke(NUSIZ0, tmp);
} }
return (myTIA->myNUSIZ0 & 0x30) >> 4; return (myTIA.myNUSIZ0 & 0x30) >> 4;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -516,46 +515,46 @@ uInt8 TIADebug::nusizM1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
uInt8 tmp = myTIA->myNUSIZ1 & ~0x30; uInt8 tmp = myTIA.myNUSIZ1 & ~0x30;
tmp |= (newVal & 0x04) << 4; tmp |= (newVal & 0x04) << 4;
mySystem->poke(NUSIZ1, tmp); mySystem.poke(NUSIZ1, tmp);
} }
return (myTIA->myNUSIZ1 & 0x30) >> 4; return (myTIA.myNUSIZ1 & 0x30) >> 4;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::grP0(int newVal) uInt8 TIADebug::grP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(GRP0, newVal); mySystem.poke(GRP0, newVal);
return myTIA->myGRP0; return myTIA.myGRP0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::grP1(int newVal) uInt8 TIADebug::grP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(GRP1, newVal); mySystem.poke(GRP1, newVal);
return myTIA->myGRP1; return myTIA.myGRP1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::posP0(int newVal) uInt8 TIADebug::posP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
myTIA->myPOSP0 = newVal; myTIA.myPOSP0 = newVal;
return myTIA->myPOSP0; return myTIA.myPOSP0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::posP1(int newVal) uInt8 TIADebug::posP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
myTIA->myPOSP1 = newVal; myTIA.myPOSP1 = newVal;
return myTIA->myPOSP1; return myTIA.myPOSP1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -563,9 +562,9 @@ uInt8 TIADebug::posM0(int newVal)
{ {
/* FIXME /* FIXME
if(newVal > -1) if(newVal > -1)
mySystem->poke(???, newVal); mySystem.poke(???, newVal);
*/ */
return myTIA->myPOSM0; return myTIA.myPOSM0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -573,9 +572,9 @@ uInt8 TIADebug::posM1(int newVal)
{ {
/* FIXME /* FIXME
if(newVal > -1) if(newVal > -1)
mySystem->poke(???, newVal); mySystem.poke(???, newVal);
*/ */
return myTIA->myPOSM1; return myTIA.myPOSM1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -583,18 +582,18 @@ uInt8 TIADebug::posBL(int newVal)
{ {
/* FIXME /* FIXME
if(newVal > -1) if(newVal > -1)
mySystem->poke(???, newVal); mySystem.poke(???, newVal);
*/ */
return myTIA->myPOSBL; return myTIA.myPOSBL;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::ctrlPF(int newVal) uInt8 TIADebug::ctrlPF(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(CTRLPF, newVal); mySystem.poke(CTRLPF, newVal);
return myTIA->myCTRLPF; return myTIA.myCTRLPF;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -602,87 +601,87 @@ uInt8 TIADebug::sizeBL(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
{ {
uInt8 tmp = myTIA->myCTRLPF & ~0x30; uInt8 tmp = myTIA.myCTRLPF & ~0x30;
tmp |= (newVal & 0x04) << 4; tmp |= (newVal & 0x04) << 4;
mySystem->poke(CTRLPF, tmp); mySystem.poke(CTRLPF, tmp);
} }
return (myTIA->myCTRLPF & 0x30) >> 4; return (myTIA.myCTRLPF & 0x30) >> 4;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::hmP0(int newVal) uInt8 TIADebug::hmP0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(HMP0, newVal << 4); mySystem.poke(HMP0, newVal << 4);
return myTIA->myHMP0; return myTIA.myHMP0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::hmP1(int newVal) uInt8 TIADebug::hmP1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(HMP1, newVal << 4); mySystem.poke(HMP1, newVal << 4);
return myTIA->myHMP1; return myTIA.myHMP1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::hmM0(int newVal) uInt8 TIADebug::hmM0(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(HMM0, newVal << 4); mySystem.poke(HMM0, newVal << 4);
return myTIA->myHMM0; return myTIA.myHMM0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::hmM1(int newVal) uInt8 TIADebug::hmM1(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(HMM1, newVal << 4); mySystem.poke(HMM1, newVal << 4);
return myTIA->myHMM1; return myTIA.myHMM1;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 TIADebug::hmBL(int newVal) uInt8 TIADebug::hmBL(int newVal)
{ {
if(newVal > -1) if(newVal > -1)
mySystem->poke(HMBL, newVal << 4); mySystem.poke(HMBL, newVal << 4);
return myTIA->myHMBL; return myTIA.myHMBL;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int TIADebug::frameCount() int TIADebug::frameCount()
{ {
return myTIA->myFrameCounter; return myTIA.myFrameCounter;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int TIADebug::scanlines() int TIADebug::scanlines()
{ {
return myTIA->scanlines(); return myTIA.scanlines();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int TIADebug::clocksThisLine() int TIADebug::clocksThisLine()
{ {
return myTIA->clocksThisLine(); return myTIA.clocksThisLine();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::vsync() bool TIADebug::vsync()
{ {
return (myTIA->myVSYNC & 2) == 2; return (myTIA.myVSYNC & 2) == 2;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TIADebug::vblank() bool TIADebug::vblank()
{ {
return (myTIA->myVBLANK & 2) == 2; return (myTIA.myVBLANK & 2) == 2;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -713,7 +712,7 @@ const string audFreq(uInt8 div)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string booleanWithLabel(string label, bool value) string TIADebug::booleanWithLabel(string label, bool value)
{ {
char buf[64]; char buf[64];
string ret; string ret;
@ -733,20 +732,33 @@ const string booleanWithLabel(string label, bool value)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string TIADebug::state() string TIADebug::toString()
{ {
string ret; string ret;
char buf[128];
sprintf(buf, "%.2x: ", 0);
ret += buf;
for (uInt8 j = 0; j < 0x010; j++)
{
sprintf(buf, "%.2x ", mySystem.peek(j));
ret += buf;
if(j == 0x07) ret += "- ";
}
ret += "\n";
// TODO: inverse video for changed regs. Core needs to track this. // TODO: inverse video for changed regs. Core needs to track this.
// TODO: strobes? WSYNC RSYNC RESP0/1 RESM0/1 RESBL HMOVE HMCLR CXCLR // TODO: strobes? WSYNC RSYNC RESP0/1 RESM0/1 RESBL HMOVE HMCLR CXCLR
TiaState state = (TiaState&) getState(); const TiaState& state = (TiaState&) getState();
// FIXME - change tracking TiaState oldstate = (TiaState&) getOldState(); // const TiaState& oldstate = (TiaState&) getOldState();
// build up output, then return it. // build up output, then return it.
ret += "scanline "; ret += "scanline ";
ret += myDebugger->valueToString(myTIA->scanlines()); ret += myDebugger.valueToString(myTIA.scanlines());
ret += " "; ret += " ";
ret += booleanWithLabel("vsync", vsync()); ret += booleanWithLabel("vsync", vsync());
@ -755,38 +767,38 @@ string TIADebug::state()
ret += booleanWithLabel("vblank", vblank()); ret += booleanWithLabel("vblank", vblank());
ret += "\n"; ret += "\n";
ret += booleanWithLabel("inpt0", myTIA->peek(0x08) & 0x80); ret += booleanWithLabel("inpt0", myTIA.peek(0x08) & 0x80);
ret += " "; ret += " ";
ret += booleanWithLabel("inpt1", myTIA->peek(0x09) & 0x80); ret += booleanWithLabel("inpt1", myTIA.peek(0x09) & 0x80);
ret += " "; ret += " ";
ret += booleanWithLabel("inpt2", myTIA->peek(0x0a) & 0x80); ret += booleanWithLabel("inpt2", myTIA.peek(0x0a) & 0x80);
ret += " "; ret += " ";
ret += booleanWithLabel("inpt3", myTIA->peek(0x0b) & 0x80); ret += booleanWithLabel("inpt3", myTIA.peek(0x0b) & 0x80);
ret += " "; ret += " ";
ret += booleanWithLabel("inpt4", myTIA->peek(0x0c) & 0x80); ret += booleanWithLabel("inpt4", myTIA.peek(0x0c) & 0x80);
ret += " "; ret += " ";
ret += booleanWithLabel("inpt5", myTIA->peek(0x0d) & 0x80); ret += booleanWithLabel("inpt5", myTIA.peek(0x0d) & 0x80);
ret += " "; ret += " ";
ret += booleanWithLabel("dump_gnd_0123", myTIA->myDumpEnabled); ret += booleanWithLabel("dump_gnd_0123", myTIA.myDumpEnabled);
ret += "\n"; ret += "\n";
ret += "COLUP0: "; ret += "COLUP0: ";
ret += myDebugger->valueToString(state.coluRegs[0]); ret += myDebugger.valueToString(state.coluRegs[0]);
ret += "/"; ret += "/";
ret += colorSwatch(state.coluRegs[0]); ret += colorSwatch(state.coluRegs[0]);
ret += "COLUP1: "; ret += "COLUP1: ";
ret += myDebugger->valueToString(state.coluRegs[1]); ret += myDebugger.valueToString(state.coluRegs[1]);
ret += "/"; ret += "/";
ret += colorSwatch(state.coluRegs[1]); ret += colorSwatch(state.coluRegs[1]);
ret += "COLUPF: "; ret += "COLUPF: ";
ret += myDebugger->valueToString(state.coluRegs[2]); ret += myDebugger.valueToString(state.coluRegs[2]);
ret += "/"; ret += "/";
ret += colorSwatch(state.coluRegs[2]); ret += colorSwatch(state.coluRegs[2]);
ret += "COLUBK: "; ret += "COLUBK: ";
ret += myDebugger->valueToString(state.coluRegs[3]); ret += myDebugger.valueToString(state.coluRegs[3]);
ret += "/"; ret += "/";
ret += colorSwatch(state.coluRegs[3]); ret += colorSwatch(state.coluRegs[3]);
@ -795,11 +807,11 @@ string TIADebug::state()
ret += "P0: GR="; ret += "P0: GR=";
ret += Debugger::to_bin_8(state.gr[P0]); ret += Debugger::to_bin_8(state.gr[P0]);
ret += "/"; ret += "/";
ret += myDebugger->valueToString(state.gr[P0]); ret += myDebugger.valueToString(state.gr[P0]);
ret += " pos="; ret += " pos=";
ret += myDebugger->valueToString(state.pos[P0]); ret += myDebugger.valueToString(state.pos[P0]);
ret += " HM="; ret += " HM=";
ret += myDebugger->valueToString(state.hm[P0]); ret += myDebugger.valueToString(state.hm[P0]);
ret += " "; ret += " ";
ret += nusizP0String(); ret += nusizP0String();
ret += " "; ret += " ";
@ -811,11 +823,11 @@ string TIADebug::state()
ret += "P1: GR="; ret += "P1: GR=";
ret += Debugger::to_bin_8(state.gr[P1]); ret += Debugger::to_bin_8(state.gr[P1]);
ret += "/"; ret += "/";
ret += myDebugger->valueToString(state.gr[P1]); ret += myDebugger.valueToString(state.gr[P1]);
ret += " pos="; ret += " pos=";
ret += myDebugger->valueToString(state.pos[P1]); ret += myDebugger.valueToString(state.pos[P1]);
ret += " HM="; ret += " HM=";
ret += myDebugger->valueToString(state.hm[P1]); ret += myDebugger.valueToString(state.hm[P1]);
ret += " "; ret += " ";
ret += nusizP1String(); ret += nusizP1String();
ret += " "; ret += " ";
@ -825,37 +837,37 @@ string TIADebug::state()
ret += "\n"; ret += "\n";
ret += "M0: "; ret += "M0: ";
ret += (myTIA->myENAM0 ? " ENABLED" : "disabled"); ret += (myTIA.myENAM0 ? " ENABLED" : "disabled");
ret += " pos="; ret += " pos=";
ret += myDebugger->valueToString(state.pos[M0]); ret += myDebugger.valueToString(state.pos[M0]);
ret += " HM="; ret += " HM=";
ret += myDebugger->valueToString(state.hm[M0]); ret += myDebugger.valueToString(state.hm[M0]);
ret += " size="; ret += " size=";
ret += myDebugger->valueToString(state.size[M0]); ret += myDebugger.valueToString(state.size[M0]);
ret += " "; ret += " ";
ret += booleanWithLabel("reset", resMP0()); ret += booleanWithLabel("reset", resMP0());
ret += "\n"; ret += "\n";
ret += "M1: "; ret += "M1: ";
ret += (myTIA->myENAM1 ? " ENABLED" : "disabled"); ret += (myTIA.myENAM1 ? " ENABLED" : "disabled");
ret += " pos="; ret += " pos=";
ret += myDebugger->valueToString(state.pos[M1]); ret += myDebugger.valueToString(state.pos[M1]);
ret += " HM="; ret += " HM=";
ret += myDebugger->valueToString(state.hm[M1]); ret += myDebugger.valueToString(state.hm[M1]);
ret += " size="; ret += " size=";
ret += myDebugger->valueToString(state.size[M1]); ret += myDebugger.valueToString(state.size[M1]);
ret += " "; ret += " ";
ret += booleanWithLabel("reset", resMP1()); ret += booleanWithLabel("reset", resMP1());
ret += "\n"; ret += "\n";
ret += "BL: "; ret += "BL: ";
ret += (myTIA->myENABL ? " ENABLED" : "disabled"); ret += (myTIA.myENABL ? " ENABLED" : "disabled");
ret += " pos="; ret += " pos=";
ret += myDebugger->valueToString(state.pos[BL]); ret += myDebugger.valueToString(state.pos[BL]);
ret += " HM="; ret += " HM=";
ret += myDebugger->valueToString(state.hm[BL]); ret += myDebugger.valueToString(state.hm[BL]);
ret += " size="; ret += " size=";
ret += myDebugger->valueToString(state.size[BL]); ret += myDebugger.valueToString(state.size[BL]);
ret += " "; ret += " ";
ret += booleanWithLabel("delay", vdelBL()); ret += booleanWithLabel("delay", vdelBL());
ret += "\n"; ret += "\n";
@ -863,15 +875,15 @@ string TIADebug::state()
ret += "PF0: "; ret += "PF0: ";
ret += Debugger::to_bin_8(state.pf[0]); ret += Debugger::to_bin_8(state.pf[0]);
ret += "/"; ret += "/";
ret += myDebugger->valueToString(state.pf[0]); ret += myDebugger.valueToString(state.pf[0]);
ret += " PF1: "; ret += " PF1: ";
ret += Debugger::to_bin_8(state.pf[1]); ret += Debugger::to_bin_8(state.pf[1]);
ret += "/"; ret += "/";
ret += myDebugger->valueToString(state.pf[1]); ret += myDebugger.valueToString(state.pf[1]);
ret += " PF2: "; ret += " PF2: ";
ret += Debugger::to_bin_8(state.pf[2]); ret += Debugger::to_bin_8(state.pf[2]);
ret += "/"; ret += "/";
ret += myDebugger->valueToString(state.pf[2]); ret += myDebugger.valueToString(state.pf[2]);
ret += "\n "; ret += "\n ";
ret += booleanWithLabel("reflect", refPF()); ret += booleanWithLabel("reflect", refPF());
ret += " "; ret += " ";
@ -900,31 +912,31 @@ string TIADebug::state()
ret += "\n"; ret += "\n";
ret += "AUDF0: "; ret += "AUDF0: ";
ret += myDebugger->valueToString(myTIA->myAUDF0); ret += myDebugger.valueToString(myTIA.myAUDF0);
ret += "/"; ret += "/";
ret += audFreq(myTIA->myAUDF0); ret += audFreq(myTIA.myAUDF0);
ret += " "; ret += " ";
ret += "AUDC0: "; ret += "AUDC0: ";
ret += myDebugger->valueToString(myTIA->myAUDC0); ret += myDebugger.valueToString(myTIA.myAUDC0);
ret += " "; ret += " ";
ret += "AUDV0: "; ret += "AUDV0: ";
ret += myDebugger->valueToString(myTIA->myAUDV0); ret += myDebugger.valueToString(myTIA.myAUDV0);
ret += "\n"; ret += "\n";
ret += "AUDF1: "; ret += "AUDF1: ";
ret += myDebugger->valueToString(myTIA->myAUDF1); ret += myDebugger.valueToString(myTIA.myAUDF1);
ret += "/"; ret += "/";
ret += audFreq(myTIA->myAUDF1); ret += audFreq(myTIA.myAUDF1);
ret += " "; ret += " ";
ret += "AUDC1: "; ret += "AUDC1: ";
ret += myDebugger->valueToString(myTIA->myAUDC1); ret += myDebugger.valueToString(myTIA.myAUDC1);
ret += " "; ret += " ";
ret += "AUDV1: "; ret += "AUDV1: ";
ret += myDebugger->valueToString(myTIA->myAUDV1); ret += myDebugger.valueToString(myTIA.myAUDV1);
//ret += "\n"; //ret += "\n";
// note: last "ret +=" line should not contain \n, caller will add. // note: last "ret +=" line should not contain \n, caller will add.

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: TIADebug.hxx,v 1.22 2008-02-06 13:45:20 stephena Exp $ // $Id: TIADebug.hxx,v 1.23 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#ifndef TIA_DEBUG_HXX #ifndef TIA_DEBUG_HXX
@ -102,12 +102,13 @@ class TiaState : public DebuggerState
class TIADebug : public DebuggerSystem class TIADebug : public DebuggerSystem
{ {
public: public:
TIADebug(Debugger* dbg, Console* console); TIADebug(Debugger& dbg, Console& console);
DebuggerState& getState(); const DebuggerState& getState();
DebuggerState& getOldState() { return myOldState; } const DebuggerState& getOldState() { return myOldState; }
void saveOldState(); void saveOldState();
string toString();
/* TIA byte (or part of a byte) registers */ /* TIA byte (or part of a byte) registers */
uInt8 nusiz0(int newVal = -1); uInt8 nusiz0(int newVal = -1);
@ -187,16 +188,16 @@ class TIADebug : public DebuggerSystem
bool collM0_M1(int newVal = -1) { return collision(14, newVal); } bool collM0_M1(int newVal = -1) { return collision(14, newVal); }
/* TIA strobe registers */ /* TIA strobe registers */
void strobeWsync() { mySystem->poke(WSYNC, 0); } void strobeWsync() { mySystem.poke(WSYNC, 0); }
void strobeRsync() { mySystem->poke(RSYNC, 0); } // not emulated! void strobeRsync() { mySystem.poke(RSYNC, 0); } // not emulated!
void strobeResP0() { mySystem->poke(RESP0, 0); } void strobeResP0() { mySystem.poke(RESP0, 0); }
void strobeResP1() { mySystem->poke(RESP1, 0); } void strobeResP1() { mySystem.poke(RESP1, 0); }
void strobeResM0() { mySystem->poke(RESM0, 0); } void strobeResM0() { mySystem.poke(RESM0, 0); }
void strobeResM1() { mySystem->poke(RESM1, 0); } void strobeResM1() { mySystem.poke(RESM1, 0); }
void strobeResBL() { mySystem->poke(RESBL, 0); } void strobeResBL() { mySystem.poke(RESBL, 0); }
void strobeHmove() { mySystem->poke(HMOVE, 0); } void strobeHmove() { mySystem.poke(HMOVE, 0); }
void strobeHmclr() { mySystem->poke(HMCLR, 0); } void strobeHmclr() { mySystem.poke(HMCLR, 0); }
void strobeCxclr() { mySystem->poke(CXCLR, 0); } void strobeCxclr() { mySystem.poke(CXCLR, 0); }
/* read-only internal TIA state */ /* read-only internal TIA state */
int scanlines(); int scanlines();
@ -204,7 +205,6 @@ class TIADebug : public DebuggerSystem
int clocksThisLine(); int clocksThisLine();
bool vsync(); bool vsync();
bool vblank(); bool vblank();
string state();
private: private:
/** Display a color patch for color at given index in the palette */ /** Display a color patch for color at given index in the palette */
@ -213,12 +213,13 @@ class TIADebug : public DebuggerSystem
/** Get/set specific bits in the collision register (used by collXX_XX) */ /** Get/set specific bits in the collision register (used by collXX_XX) */
bool collision(int collID, int newVal); bool collision(int collID, int newVal);
string booleanWithLabel(string label, bool value);
private: private:
TiaState myState; TiaState myState;
TiaState myOldState; TiaState myOldState;
System* mySystem; TIA& myTIA;
TIA* myTIA;
string nusizStrings[8]; string nusizStrings[8];
}; };

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: TiaWidget.cxx,v 1.10 2008-03-23 17:43:22 stephena Exp $ // $Id: TiaWidget.cxx,v 1.11 2008-04-19 21:11:52 stephena Exp $
// //
// Based on code from ScummVM - Scumm Interpreter // Based on code from ScummVM - Scumm Interpreter
// Copyright (C) 2002-2004 The ScummVM project // Copyright (C) 2002-2004 The ScummVM project
@ -272,17 +272,6 @@ TiaWidget::TiaWidget(GuiObject* boss, const GUI::Font& font,
"CxClr", kCxclrCmd); "CxClr", kCxclrCmd);
b->setTarget(this); b->setTarget(this);
// Set the strings to be used in the grPx registers
// We only do this once because it's the state that changes, not the strings
const char* offstr[] = { "0", "0", "0", "0", "0", "0", "0", "0" };
const char* onstr[] = { "1", "1", "1", "1", "1", "1", "1", "1" };
StringList off, on;
for(int i = 0; i < 8; ++i)
{
off.push_back(offstr[i]);
on.push_back(onstr[i]);
}
//////////////////////////// ////////////////////////////
// P0 register info // P0 register info
//////////////////////////// ////////////////////////////
@ -931,8 +920,8 @@ void TiaWidget::fillGrid()
Debugger& dbg = instance()->debugger(); Debugger& dbg = instance()->debugger();
TIADebug& tia = dbg.tiaDebug(); TIADebug& tia = dbg.tiaDebug();
TiaState state = (TiaState&) tia.getState(); TiaState& state = (TiaState&) tia.getState();
TiaState oldstate = (TiaState&) tia.getOldState(); TiaState& oldstate = (TiaState&) tia.getOldState();
// TIA RAM // TIA RAM
alist.clear(); vlist.clear(); changed.clear(); alist.clear(); vlist.clear(); changed.clear();

View File

@ -8,6 +8,7 @@ MODULE_OBJS := \
src/debugger/PackedBitArray.o \ src/debugger/PackedBitArray.o \
src/debugger/CpuDebug.o \ src/debugger/CpuDebug.o \
src/debugger/RamDebug.o \ src/debugger/RamDebug.o \
src/debugger/RiotDebug.o \
src/debugger/TIADebug.o src/debugger/TIADebug.o
MODULE_DIRS += \ MODULE_DIRS += \

View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: M6532.cxx,v 1.18 2008-04-17 13:39:14 stephena Exp $ // $Id: M6532.cxx,v 1.19 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#include <assert.h> #include <assert.h>
@ -61,6 +61,9 @@ void M6532::reset()
myOutA = 0x00; myOutA = 0x00;
myDDRA = 0x00; myDDRA = 0x00;
myDDRB = 0x00; myDDRB = 0x00;
// Zero the timer registers
myOutTimer[0] = myOutTimer[1] = myOutTimer[2] = myOutTimer[3] = 0x0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -164,7 +167,7 @@ uInt8 M6532::peek(uInt16 addr)
case 0x04: // Timer Output case 0x04: // Timer Output
case 0x06: case 0x06:
{ {
uInt32 timer = myTimer - (mySystem->cycles() - myCyclesWhenTimerSet); uInt32 timer = timerClocks();
// See if the timer has expired yet? // See if the timer has expired yet?
// Note that this constant comes from z26, and corresponds to // Note that this constant comes from z26, and corresponds to
@ -184,9 +187,7 @@ uInt8 M6532::peek(uInt16 addr)
case 0x05: // Interrupt Flag case 0x05: // Interrupt Flag
case 0x07: case 0x07:
{ {
Int32 timer = myTimer - (mySystem->cycles() - myCyclesWhenTimerSet); if((timerClocks() >= 0) || myTimerReadAfterInterrupt)
if((timer >= 0) || myTimerReadAfterInterrupt)
return 0x00; return 0x00;
else else
return 0x80; return 0x80;
@ -273,29 +274,33 @@ void M6532::poke(uInt16 addr, uInt8 value)
} }
else if((addr & 0x17) == 0x14) // Write timer divide by 1 else if((addr & 0x17) == 0x14) // Write timer divide by 1
{ {
myOutTimer[0] = value;
myIntervalShift = 0; myIntervalShift = 0;
myTimer = value << myIntervalShift; myTimer = myOutTimer[0] << myIntervalShift;
myCyclesWhenTimerSet = mySystem->cycles(); myCyclesWhenTimerSet = mySystem->cycles();
myTimerReadAfterInterrupt = false; myTimerReadAfterInterrupt = false;
} }
else if((addr & 0x17) == 0x15) // Write timer divide by 8 else if((addr & 0x17) == 0x15) // Write timer divide by 8
{ {
myOutTimer[1] = value;
myIntervalShift = 3; myIntervalShift = 3;
myTimer = value << myIntervalShift; myTimer = myOutTimer[1] << myIntervalShift;
myCyclesWhenTimerSet = mySystem->cycles(); myCyclesWhenTimerSet = mySystem->cycles();
myTimerReadAfterInterrupt = false; myTimerReadAfterInterrupt = false;
} }
else if((addr & 0x17) == 0x16) // Write timer divide by 64 else if((addr & 0x17) == 0x16) // Write timer divide by 64
{ {
myOutTimer[2] = value;
myIntervalShift = 6; myIntervalShift = 6;
myTimer = value << myIntervalShift; myTimer = myOutTimer[2] << myIntervalShift;
myCyclesWhenTimerSet = mySystem->cycles(); myCyclesWhenTimerSet = mySystem->cycles();
myTimerReadAfterInterrupt = false; myTimerReadAfterInterrupt = false;
} }
else if((addr & 0x17) == 0x17) // Write timer divide by 1024 else if((addr & 0x17) == 0x17) // Write timer divide by 1024
{ {
myOutTimer[3] = value;
myIntervalShift = 10; myIntervalShift = 10;
myTimer = value << myIntervalShift; myTimer = myOutTimer[3] << myIntervalShift;
myCyclesWhenTimerSet = mySystem->cycles(); myCyclesWhenTimerSet = mySystem->cycles();
myTimerReadAfterInterrupt = false; myTimerReadAfterInterrupt = false;
} }
@ -338,6 +343,10 @@ bool M6532::save(Serializer& out) const
out.putByte((char)myOutA); out.putByte((char)myOutA);
out.putByte((char)myDDRA); out.putByte((char)myDDRA);
out.putByte((char)myDDRB); out.putByte((char)myDDRB);
out.putByte((char)myOutTimer[0]);
out.putByte((char)myOutTimer[1]);
out.putByte((char)myOutTimer[2]);
out.putByte((char)myOutTimer[3]);
} }
catch(char *msg) catch(char *msg)
{ {
@ -376,6 +385,11 @@ bool M6532::load(Deserializer& in)
myOutA = (uInt8) in.getByte(); myOutA = (uInt8) in.getByte();
myDDRA = (uInt8) in.getByte(); myDDRA = (uInt8) in.getByte();
myDDRB = (uInt8) in.getByte(); myDDRB = (uInt8) in.getByte();
myOutTimer[0] = (uInt8) in.getByte();
myOutTimer[1] = (uInt8) in.getByte();
myOutTimer[2] = (uInt8) in.getByte();
myOutTimer[3] = (uInt8) in.getByte();
} }
catch(char *msg) catch(char *msg)
{ {

View File

@ -13,28 +13,35 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: M6532.hxx,v 1.9 2008-04-17 13:39:14 stephena Exp $ // $Id: M6532.hxx,v 1.10 2008-04-19 21:11:52 stephena Exp $
//============================================================================ //============================================================================
#ifndef M6532_HXX #ifndef M6532_HXX
#define M6532_HXX #define M6532_HXX
class Console; class Console;
class System; class RiotDebug;
class Serializer; class Serializer;
class Deserializer; class Deserializer;
#include "bspf.hxx" #include "bspf.hxx"
#include "Device.hxx" #include "Device.hxx"
#include "System.hxx"
/** /**
RIOT RIOT
@author Bradford W. Mott @author Bradford W. Mott
@version $Id: M6532.hxx,v 1.9 2008-04-17 13:39:14 stephena Exp $ @version $Id: M6532.hxx,v 1.10 2008-04-19 21:11:52 stephena Exp $
*/ */
class M6532 : public Device class M6532 : public Device
{ {
public:
/**
The RIOT debugger class is a friend who needs special access
*/
friend class RiotDebug;
public: public:
/** /**
Create a new 6532 for the specified console Create a new 6532 for the specified console
@ -119,6 +126,10 @@ class M6532 : public Device
*/ */
virtual void poke(uInt16 address, uInt8 value); virtual void poke(uInt16 address, uInt8 value);
private:
inline Int32 timerClocks()
{ return myTimer - (mySystem->cycles() - myCyclesWhenTimerSet); }
private: private:
// Reference to the console // Reference to the console
const Console& myConsole; const Console& myConsole;
@ -147,6 +158,9 @@ class M6532 : public Device
// Data Direction Register for Port B // Data Direction Register for Port B
uInt8 myDDRB; uInt8 myDDRB;
// Last value written to the timer registers
uInt8 myOutTimer[4];
private: private:
// Copy constructor isn't supported by this class so make it private // Copy constructor isn't supported by this class so make it private
M6532(const M6532&); M6532(const M6532&);