Retro/pcjs
Watch
1
0
Fork
You've already forked pcjs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Tidy up some Memory-related interfaces

Browse source
This commit is contained in:
Jeff Parsons 2015-07-28 09:52:08 -07:00
commit a061c16392
3 changed files with 48 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

2
modules/pcjs/lib/bus.js
View file

@ -551,7 +551,7 @@ Bus.prototype.setMemoryAccess = function(addr, size, afn)
if (!block.controller) { if (!block.controller) {
return this.reportError(5, addr, size); return this.reportError(5, addr, size);
} }
block.setAccess(afn); block.setAccess(afn, true);
size -= this.nBlockSize; size -= this.nBlockSize;
iBlock++; iBlock++;
} }

18
modules/pcjs/lib/memory.js
View file

@ -421,11 +421,10 @@ Memory.prototype = {
* @param {boolean} [fDirect] * @param {boolean} [fDirect]
*/ */
setReadAccess: function(afn, fDirect) { setReadAccess: function(afn, fDirect) {
var afnChecked = this.cReadBreakpoints? Memory.afnChecked : afn; if (!fDirect || !this.cReadBreakpoints) {
if (!fDirect) { this.readByte = afn[0] || this.readNone;
this.readByte = afnChecked[0] || this.readNone; this.readShort = afn[1] || this.readShortDefault;
this.readShort = afnChecked[1] || this.readShortDefault; this.readLong = afn[2] || this.readLongDefault;
this.readLong = afnChecked[2] || this.readLongDefault;
} }
if (fDirect || fDirect === undefined) { if (fDirect || fDirect === undefined) {
this.readByteDirect = afn[0] || this.readNone; this.readByteDirect = afn[0] || this.readNone;
@ -441,11 +440,10 @@ Memory.prototype = {
* @param {boolean} [fDirect] * @param {boolean} [fDirect]
*/ */
setWriteAccess: function(afn, fDirect) { setWriteAccess: function(afn, fDirect) {
var afnChecked = this.cWriteBreakpoints? Memory.afnChecked : afn; if (!fDirect || !this.cWriteBreakpoints) {
if (!fDirect) { this.writeByte = !this.fReadOnly && afn[3] || this.writeNone;
this.writeByte = !this.fReadOnly && afnChecked[3] || this.writeNone; this.writeShort = !this.fReadOnly && afn[4] || this.writeShortDefault;
this.writeShort = !this.fReadOnly && afnChecked[4] || this.writeShortDefault; this.writeLong = !this.fReadOnly && afn[5] || this.writeLongDefault;
this.writeLong = !this.fReadOnly && afnChecked[5] || this.writeLongDefault;
} }
if (fDirect || fDirect === undefined) { if (fDirect || fDirect === undefined) {
this.writeByteDirect = afn[3] || this.writeNone; this.writeByteDirect = afn[3] || this.writeNone;

75
modules/pcjs/lib/video.js
View file

@ -1599,10 +1599,10 @@ if (DEBUGGER) Card.GRC.REGS = ["SRESET","ESRESET","COLORCMP","DATAROT","READMAP"
*/ */
/* /*
* Values returned by getAccess(); the high byte describes the read mode, and the low byte describes the write mode. * Values returned by getCardAccess(); the high byte describes the read mode, and the low byte describes the write mode.
* *
* V2 should never appear in any values used by getAccess() or setAccess()/setMemoryAccess(); the sole purpose of V2 is * V2 should never appear in any values used by getCardAccess() or setCardAccess(); the sole purpose of V2 is to
* to distinguish newer (V2) access values from older (V1) access values in saved contexts. It's set when the context * distinguish newer (V2) access values from older (V1) access values in saved contexts. It's set when the context
* is saved, and cleared when the context is restored. Thus, if V2 is not set on restore, we assume we're dealing with * is saved, and cleared when the context is restored. Thus, if V2 is not set on restore, we assume we're dealing with
* a V1 value, so we run it through the V1 table (below) to produce a V2 value. Hopefully at some point V1 contexts * a V1 value, so we run it through the V1 table (below) to produce a V2 value. Hopefully at some point V1 contexts
* can be deprecated, and the V2 bit can be eliminated/repurposed. * can be deprecated, and the V2 bit can be eliminated/repurposed.
@ -1693,7 +1693,7 @@ Card.ACCESS.readByteMode0Chain4 = function readByteMode0Chain4(off, addr)
Card.ACCESS.readByteMode0EvenOdd = function readByteMode0EvenOdd(off, addr) Card.ACCESS.readByteMode0EvenOdd = function readByteMode0EvenOdd(off, addr)
{ {
/* /*
* TODO: As discussed in getAccess(), we need to run some tests on real EGA/VGA hardware to determine * TODO: As discussed in getCardAccess(), we need to run some tests on real EGA/VGA hardware to determine
* exactly what gets latched (ie, from which address) when EVENODD is in effect. Whatever we learn may * exactly what gets latched (ie, from which address) when EVENODD is in effect. Whatever we learn may
* also dictate a special EVENODD function for READ.MODE1 as well. * also dictate a special EVENODD function for READ.MODE1 as well.
*/ */
@ -1759,7 +1759,7 @@ Card.ACCESS.readByteMode1 = function readByteMode1(off, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0 = function writeByteMode0(off, b, addr) Card.ACCESS.writeByteMode0 = function writeByteMode0(off, b, addr)
@ -1810,7 +1810,7 @@ Card.ACCESS.writeByteMode0 = function writeByteMode0(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0Chain4 = function writeByteMode0Chain4(off, b, addr) Card.ACCESS.writeByteMode0Chain4 = function writeByteMode0Chain4(off, b, addr)
@ -1836,7 +1836,7 @@ Card.ACCESS.writeByteMode0Chain4 = function writeByteMode0Chain4(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0EvenOdd = function writeByteMode0EvenOdd(off, b, addr) Card.ACCESS.writeByteMode0EvenOdd = function writeByteMode0EvenOdd(off, b, addr)
@ -1865,7 +1865,7 @@ Card.ACCESS.writeByteMode0EvenOdd = function writeByteMode0EvenOdd(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0Rot = function writeByteMode0Rot(off, b, addr) Card.ACCESS.writeByteMode0Rot = function writeByteMode0Rot(off, b, addr)
@ -1890,7 +1890,7 @@ Card.ACCESS.writeByteMode0Rot = function writeByteMode0Rot(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0And = function writeByteMode0And(off, b, addr) Card.ACCESS.writeByteMode0And = function writeByteMode0And(off, b, addr)
@ -1916,7 +1916,7 @@ Card.ACCESS.writeByteMode0And = function writeByteMode0And(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0Or = function writeByteMode0Or(off, b, addr) Card.ACCESS.writeByteMode0Or = function writeByteMode0Or(off, b, addr)
@ -1942,7 +1942,7 @@ Card.ACCESS.writeByteMode0Or = function writeByteMode0Or(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode0Xor = function writeByteMode0Xor(off, b, addr) Card.ACCESS.writeByteMode0Xor = function writeByteMode0Xor(off, b, addr)
@ -1995,7 +1995,7 @@ Card.ACCESS.writeByteMode1 = function writeByteMode1(off, b, addr)
Card.ACCESS.writeByteMode1EvenOdd = function writeByteMode1EvenOdd(off, b, addr) Card.ACCESS.writeByteMode1EvenOdd = function writeByteMode1EvenOdd(off, b, addr)
{ {
/* /*
* TODO: As discussed in getAccess(), we need to run some tests on real EGA/VGA hardware to * TODO: As discussed in getCardAccess(), we need to run some tests on real EGA/VGA hardware to
* determine exactly where latches are written (ie, to which address) when EVENODD is in effect. * determine exactly where latches are written (ie, to which address) when EVENODD is in effect.
*/ */
off += this.offset; off += this.offset;
@ -2020,7 +2020,7 @@ Card.ACCESS.writeByteMode1EvenOdd = function writeByteMode1EvenOdd(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode2 = function writeByteMode2(off, b, addr) Card.ACCESS.writeByteMode2 = function writeByteMode2(off, b, addr)
@ -2043,7 +2043,7 @@ Card.ACCESS.writeByteMode2 = function writeByteMode2(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode2And = function writeByteMode2And(off, b, addr) Card.ACCESS.writeByteMode2And = function writeByteMode2And(off, b, addr)
@ -2067,7 +2067,7 @@ Card.ACCESS.writeByteMode2And = function writeByteMode2And(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode2Or = function writeByteMode2Or(off, b, addr) Card.ACCESS.writeByteMode2Or = function writeByteMode2Or(off, b, addr)
@ -2091,7 +2091,7 @@ Card.ACCESS.writeByteMode2Or = function writeByteMode2Or(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode2Xor = function writeByteMode2Xor(off, b, addr) Card.ACCESS.writeByteMode2Xor = function writeByteMode2Xor(off, b, addr)
@ -2121,7 +2121,7 @@ Card.ACCESS.writeByteMode2Xor = function writeByteMode2Xor(off, b, addr)
* *
* @this {Memory} * @this {Memory}
* @param {number} off * @param {number} off
* @param {number} b (which should already be pre-masked to 8 bits; see Bus.prototype.setByteDirect) * @param {number} b (which should already be pre-masked to 8 bits; see cpu.setByte())
* @param {number} [addr] * @param {number} [addr]
*/ */
Card.ACCESS.writeByteMode3 = function writeByteMode3(off, b, addr) Card.ACCESS.writeByteMode3 = function writeByteMode3(off, b, addr)
@ -2142,7 +2142,7 @@ Card.ACCESS.writeByteMode3 = function writeByteMode3(off, b, addr)
}; };
/* /*
* Mappings from getAccess() values to access functions above * Mappings from getCardAccess() values to access functions above
*/ */
Card.ACCESS.afn = []; Card.ACCESS.afn = [];
@ -2528,6 +2528,9 @@ Card.prototype.getMemoryBuffer = function(addr)
/** /**
* getMemoryAccess() * getMemoryAccess()
* *
* WARNING: This is a public method, whereas most Card methods are private to the Video component;
* because a Card also acts as a Memory controller, it must provide getMemoryAccess() to the Memory component.
*
* Return the last set of memory access functions recorded by setMemoryAccess(). * Return the last set of memory access functions recorded by setMemoryAccess().
* *
* @this {Card} * @this {Card}
@ -2541,7 +2544,7 @@ Card.prototype.getMemoryAccess = function()
/** /**
* setMemoryAccess(nAccess) * setMemoryAccess(nAccess)
* *
* This transforms the memory access value that getAccess() returns into the best available set of * This transforms the memory access value that getCardAccess() returns into the best available set of
* memory access functions, which are then returned via getMemoryAccess() to any memory blocks we allocate * memory access functions, which are then returned via getMemoryAccess() to any memory blocks we allocate
* or modify. * or modify.
* *
@ -2564,7 +2567,7 @@ Card.prototype.setMemoryAccess = function(nAccess)
* clears SEQ.MEMMODE.SEQUENTIAL, we will briefly be in an "odd" (unsupported) state. * clears SEQ.MEMMODE.SEQUENTIAL, we will briefly be in an "odd" (unsupported) state.
* *
* This didn't used to occur when we relied on the GRC.MODE register instead of the SEQ.MEMMODE for * This didn't used to occur when we relied on the GRC.MODE register instead of the SEQ.MEMMODE for
* determining the EVENODD state. But, as explained in getAccess(), we've run into inconsistencies in * determining the EVENODD state. But, as explained in getCardAccess(), we've run into inconsistencies in
* how GRC.MODE.EVENODD is programmed, so we must live with this warning. * how GRC.MODE.EVENODD is programmed, so we must live with this warning.
* *
* The ultimate solution is to provide a EVENODD handler for READ.MODE1, since there is the remote * The ultimate solution is to provide a EVENODD handler for READ.MODE1, since there is the remote
@ -2589,7 +2592,7 @@ Card.prototype.setMemoryAccess = function(nAccess)
* clears SEQ.MEMMODE.SEQUENTIAL, we will briefly be in an "odd" (unsupported) state. * clears SEQ.MEMMODE.SEQUENTIAL, we will briefly be in an "odd" (unsupported) state.
* *
* This didn't used to occur when we relied on the GRC.MODE register instead of the SEQ.MEMMODE for * This didn't used to occur when we relied on the GRC.MODE register instead of the SEQ.MEMMODE for
* determining the EVENODD state. But, as explained in getAccess(), we've run into inconsistencies in * determining the EVENODD state. But, as explained in getCardAccess(), we've run into inconsistencies in
* how GRC.MODE.EVENODD is programmed, so we must live with this warning. * how GRC.MODE.EVENODD is programmed, so we must live with this warning.
* *
* The ultimate solution is to provide EVENODD handlers for all modes other than WRITE.MODE0, since there * The ultimate solution is to provide EVENODD handlers for all modes other than WRITE.MODE0, since there
@ -4170,12 +4173,12 @@ Video.prototype.removeCursor = function()
}; };
/** /**
* getAccess() * getCardAccess()
* *
* @this {Video} * @this {Video}
* @return {number|undefined} current memory access setting, or undefined if unknown * @return {number|undefined} current memory access setting, or undefined if unknown
*/ */
Video.prototype.getAccess = function() Video.prototype.getCardAccess = function()
{ {
var nAccess; var nAccess;
var card = this.cardActive; var card = this.cardActive;
@ -4234,7 +4237,7 @@ Video.prototype.getAccess = function()
break; break;
default: default:
if (DEBUG && this.messageEnabled()) { if (DEBUG && this.messageEnabled()) {
this.printMessage("getAccess(): invalid GRC mode (" + str.toHexByte(regGRCMode) + ")"); this.printMessage("getCardAccess(): invalid GRC mode (" + str.toHexByte(regGRCMode) + ")");
} }
break; break;
} }
@ -4287,18 +4290,18 @@ Video.prototype.getAccess = function()
}; };
/** /**
* setAccess(nAccess) * setCardAccess(nAccess)
* *
* @this {Video} * @this {Video}
* @param {number|undefined} nAccess (one of the Card.ACCESS.* constants) * @param {number|undefined} nAccess (one of the Card.ACCESS.* constants)
*/ */
Video.prototype.setAccess = function(nAccess) Video.prototype.setCardAccess = function(nAccess)
{ {
var card = this.cardActive; var card = this.cardActive;
if (card && nAccess != null && nAccess != card.nAccess) { if (card && nAccess != null && nAccess != card.nAccess) {
if (MAXDEBUG && this.messageEnabled()) { if (MAXDEBUG && this.messageEnabled()) {
this.printMessage("setAccess(" + str.toHexWord(nAccess) + ")"); this.printMessage("setCardAccess(" + str.toHexWord(nAccess) + ")");
} }
card.setMemoryAccess(nAccess); card.setMemoryAccess(nAccess);
@ -4622,7 +4625,7 @@ Video.prototype.checkMode = function(fForce)
} }
} }
nAccess = this.getAccess(); nAccess = this.getCardAccess();
} }
} }
else if (card.regMode & Card.CGA.MODE.VIDEO_ENABLE) { else if (card.regMode & Card.CGA.MODE.VIDEO_ENABLE) {
@ -4642,19 +4645,19 @@ Video.prototype.checkMode = function(fForce)
} }
/* /*
* NOTE: If setMode() remaps the video memory, that will trigger calls to getMemoryAccess() to also update the * NOTE: If setMode() remaps the video memory, that will trigger calls to setCardAccess() to also update the
* memory's access functions. However, if the memory access setting (nAccess) is about to change as well, those * memory's access functions. However, if the memory access setting (nAccess) is about to change as well, those
* changes will be moot until the setAccess() call that follows. Basically, whenever both memory mapping AND access * changes will be moot until the setCardAccess() call that follows. Basically, whenever both memory mapping AND
* functions are changing, the memory will be in an inconsistent state until both setMode() and setAccess() are * access functions are changing, the memory will be in an inconsistent state until both setMode() and setCardAccess()
* finished. * are finished.
* *
* The setMode() call takes precedence; if we called setAccess() first, it might attempt to modify memory access * The setMode() call takes precedence; if we called setCardAccess() first, it might attempt to modify memory access
* functions based on the card's addrBuffer setting, and if that doesn't match what's currently mapped, assertions * functions based on the card's addrBuffer setting, and if that doesn't match what's currently mapped, assertions
* will be triggered (probably not fatal, but it would defeat the point of the assertions). * will be triggered (probably not fatal, but it would defeat the point of the assertions).
*/ */
if (!this.setMode(nMode, fForce)) return false; if (!this.setMode(nMode, fForce)) return false;
this.setAccess(nAccess); this.setCardAccess(nAccess);
return true; return true;
}; };
@ -5902,7 +5905,7 @@ Video.prototype.outSEQData = function(port, bOut, addrFrom)
this.cardEGA.nSeqMapMask = Video.aEGAByteToDW[bOut & Card.SEQ.MAPMASK.MAPS]; this.cardEGA.nSeqMapMask = Video.aEGAByteToDW[bOut & Card.SEQ.MAPMASK.MAPS];
break; break;
case Card.SEQ.MEMMODE.INDX: case Card.SEQ.MEMMODE.INDX:
this.setAccess(this.getAccess()); this.setCardAccess(this.getCardAccess());
break; break;
default: default:
break; break;
@ -6192,7 +6195,7 @@ Video.prototype.outGRCData = function(port, bOut, addrFrom)
break; break;
case Card.GRC.DATAROT.INDX: case Card.GRC.DATAROT.INDX:
case Card.GRC.MODE.INDX: case Card.GRC.MODE.INDX:
this.setAccess(this.getAccess()); this.setCardAccess(this.getCardAccess());
break; break;
case Card.GRC.READMAP.INDX: case Card.GRC.READMAP.INDX:
this.cardEGA.nReadMapShift = (bOut & Card.GRC.READMAP.NUM) << 3; this.cardEGA.nReadMapShift = (bOut & Card.GRC.READMAP.NUM) << 3;