element to receive tape data
var x = 0; // image data index
doc = win.document;
doc.title = "B5500 " + mt.mnemonic + " Unload Tape";
tape = doc.getElementById("Paper");
while (tape.firstChild) { // delete any existing content
tape.removeChild(tape.firstChild);
}
c = image[x];
do {
c &= 0x7F; // clear the start-of-block bit
table = (mt.bcdXlateInEven[c] < 0xFF ? mt.bcdXlateInEven : mt.bcdXlateInOdd);
bufIndex = 0;
do {
if (bufIndex >= bufLength) { // ASCII block size exceeded
tape.appendChild(doc.createTextNode(
String.fromCharCode.apply(null, buf.subarray(0, bufIndex))));
bufIndex = 0;
}
if (c > 0) { // drop any unrecorded tape frames
buf[bufIndex++] = table[c];
}
if (++x < imgLength) {
c = image[x];
} else {
break;
}
} while (c < 0x80);
buf[bufIndex++] = 0x0A;
tape.appendChild(doc.createTextNode(
String.fromCharCode.apply(null, buf.subarray(0, bufIndex))));
} while (x < imgLength);
mt.setTapeUnloaded();
}
function unloadSetup() {
/* Loads a status message into the "paper" rendering area, then calls
unloadDriver after a short wait to allow the message to appear */
win.document.getElementById("Paper").appendChild(
win.document.createTextNode("Rendering tape image... please wait..."));
setTimeout(unloadDriver, 50);
}
// Outer block of unloadTape
win.moveTo((screen.availWidth-win.outerWidth)/2, (screen.availHeight-win.outerHeight)/2);
win.focus();
win.addEventListener("load", unloadSetup, false);
};
/**************************************/
B5500MagTapeDrive.prototype.tapeRewind = function tapeRewind(makeReady) {
/* Rewinds the tape. Makes the drive not-ready and delays for an appropriate amount
of time depending on how far up-tape we are. If makeReady is true [valid only when
called from this.rewind()], then readies the unit again when the rewind is complete */
var lastStamp;
function rewindFinish() {
this.timer = 0;
this.busy = false;
B5500Util.removeClass(this.$$("MTRewindingLight"), "annunciatorLit");
if (makeReady && this.tapeState == this.tapeRemote) {
this.ready = true;
this.statusChange(1);
}
}
function rewindDelay() {
var inches;
var stamp = performance.now();
var interval = stamp - lastStamp;
if (interval <= 0) {
interval = this.spinUpdateInterval/2;
}
if (this.tapeInches <= 0) {
this.setAtBOT(true);
this.botSensed = true;
this.timer = setCallback(this.mnemonic, this, 2000, rewindFinish);
} else {
inches = interval/1000*this.rewindSpeed;
this.tapeInches -= inches;
lastStamp = stamp;
this.timer = setCallback(this.mnemonic, this, this.spinUpdateInterval, rewindDelay);
this.spinReel(-inches);
}
}
function rewindStart() {
lastStamp = performance.now();
this.timer = setCallback(this.mnemonic, this, this.spinUpdateInterval, rewindDelay);
}
if (this.timer) {
clearCallback(this.timer);
this.timer = 0;
}
if (this.tapeState != this.tapeUnloaded && !this.atBOT) {
this.busy = true;
this.ready = false;
this.statusChange(0);
this.setAtEOT(false);
B5500Util.addClass(this.$$("MTRewindingLight"), "annunciatorLit");
this.timer = setCallback(this.mnemonic, this, 1000, rewindStart);
}
};
/**************************************/
B5500MagTapeDrive.prototype.MTUnloadBtn_onclick = function MTUnloadBtn_onclick(ev) {
/* Handle the click event for the UNLOAD button */
if (this.imgWritten && this.window.confirm(
"Do you want to save the tape image data?\n(CANCEL discards the image)")) {
this.unloadTape(); // it will do setTapeUnloaded() afterwards
} else {
this.setTapeUnloaded();
}
};
/**************************************/
B5500MagTapeDrive.prototype.MTLoadBtn_onclick = function MTLoadBtn_onclick(ev) {
/* Handle the click event for the LOAD button */
this.loadTape();
};
/**************************************/
B5500MagTapeDrive.prototype.MTRemoteBtn_onclick = function MTRemoteBtn_onclick(ev) {
/* Handle the click event for the REMOTE button */
this.setTapeRemote(true);
};
/**************************************/
B5500MagTapeDrive.prototype.MTLocalBtn_onclick = function MTLocalBtn_onclick(ev) {
/* Handle the click event for the LOCAL button */
this.setTapeRemote(false);
};
/**************************************/
B5500MagTapeDrive.prototype.MTWriteRingBtn_onclick = function MTWriteRingBtn_onclick(ev) {
/* Handle the click event for the WRITE RING button */
this.setWriteRing(!this.writeRing);
};
/**************************************/
B5500MagTapeDrive.prototype.MTRewindBtn_onclick = function MTRewindBtn(ev) {
/* Handle the click event for the REWIND button */
if (!this.busy) {
this.tapeRewind(false);
}
};
/**************************************/
B5500MagTapeDrive.prototype.buildErrorMask = function buildErrorMask(chars) {
/* Constructs the final error mask from this.errorMask, the number of residual
characters in the last word, and the current drive state */
var mask = this.errorMask & 0x01FC7FFF; // clear out the char count bits
mask |= (chars & 0x07) << 15;
if (this.botSensed) {
mask |= 0x80000; // tape at BOT
}
this.errorMask = mask;
return mask;
};
/**************************************/
B5500MagTapeDrive.prototype.bcdSpaceForward = function bcdSpaceForward(checkEOF) {
/* Spaces over the next block (or the remainder of the current block) from the
.bcd tape (this.image) in a forward direction. No data transfer to the IOUnit buffer
takes place, and no parity detection is made. A block is terminated when the next
frame has its high-order bit set, or the end of the tape image data is reached.
checkEOF true=> check for an EOF frame (i.e., we're not spacing the rest of a block)
Exits with the image index pointing to the first frame of the next block (or beyond
the end of the image blob if at EOT) */
var blankCount = 0; // blank tape frame counter
var c; // current character (tape image frame)
var image = this.image; // tape image
var imgLength = this.imgLength; // tape image length
var imgIndex = this.imgIndex; // current tape image offset
if (imgIndex >= imgLength) {
this.errorMask |= 0x30; // report EOF & parity error if beyond end of tape
} else {
if (this.atBOT) {
this.setAtBOT(false);
}
c = image[imgIndex];
if (checkEOF && c == this.bcdTapeMark && (imgIndex+1 >= imgLength || image[imgIndex+1] >= 0x80)) {
this.errorMask |= 0x20; // EOF
imgIndex++;
} else {
do {
if (c == 0x00) {
if (++blankCount > this.maxBlankFrames) {
this.errorMask |= 0x100000; // blank tape timeout
break; // kill the read loop
}
} else {
blankCount = 0;
}
if (++imgIndex < imgLength) {
c = image[imgIndex]; // get next char frame
} else {
break; // at end of tape, kill the read loop
}
} while (c < 0x80);
}
}
this.imgIndex = imgIndex;
};
/**************************************/
B5500MagTapeDrive.prototype.bcdSpaceBackward = function bcdSpaceBackward(checkEOF) {
/* Spaces over the next block (or the remainder of the current block) from the
.bcd tape (this.image) in a backward direction. No data transfer to the IOUnit buffer
takes place, and no parity detection is made. A block is terminated when the next
frame has its high-order bit set, or the beginning of the tape image data is reached.
checkEOF true=> check for an EOF frame (i.e., we're not spacing the rest of a block)
Exits with the image index pointing to the first frame of THIS block (or at 0 if
at BOT). This arrangement allows changes between forward/reverse motion to work */
var blankCount = 0; // blank tape frame counter
var c; // current character (tape image frame)
var image = this.image; // tape image
var imgLength = this.imgLength; // tape image length
var imgIndex = this.imgIndex; // current tape image offset
if (imgIndex <= 0) {
this.setAtBOT(true);
if (this.botSensed) {
this.errorMask |= 0x100000; // set blank-tape bit
} else {
this.botSensed = true;
}
} else {
if (this.atEOT) {
this.setAtEOT(false);
}
c = image[--imgIndex];
if (checkEOF && c == this.bcdTapeMark) {
this.errorMask |= 0x20; // EOF
} else {
do {
if (c == 0x00) {
if (++blankCount > this.maxBlankFrames) {
this.errorMask |= 0x100000; // blank tape timeout
break; // kill the read loop
}
} else {
blankCount = 0;
}
if (--imgIndex >= 0) {
c = image[imgIndex]; // get next char frame
} else {
break; // at start of tape, kill the read loop
}
} while (c < 0x80);
}
}
this.imgIndex = imgIndex;
};
/**************************************/
B5500MagTapeDrive.prototype.bcdReadForward = function bcdReadForward(oddParity) {
/* Reads the next block from the .bcd tape (this.image) in a forward direction,
translating the character frames to ANSI character codes based on the translation
table "xlate". The translated data is stored in this.buffer. A block is terminated
when the next frame has its high-order bit set, or the end of the tape image data
is reached. The resulting buffer is always at least one character in length, unless
the block is a tapeMark or the end of the data has been reached.
oddParity: 0=Alpha (even parity), 1=Binary (odd parity) read
Exits with the image index pointing to the first frame of the next block (or beyond
the end of the image blob if at EOT). Returns the number of characters read into the
IOUnit buffer */
var blankCount = 0; // blank tape frame counter
var buffer = this.buffer; // IOUnit buffer
var bufLength = this.bufLength // IOUnit buffer length
var bufIndex = 0; // current IOUnit buffer offset
var c; // current character (tape image frame)
var cx; // current character translated to ASCII
var image = this.image; // tape image
var imgLength = this.imgLength; // tape image length
var imgIndex = this.imgIndex; // current tape image offset
var xlate = (oddParity ? this.bcdXlateInOdd : this.bcdXlateInEven);
if (imgIndex >= imgLength) {
this.errorMask |= 0x30; // report EOF & parity error if beyond end of tape
} else {
if (this.atBOT) {
this.setAtBOT(false);
}
c = image[imgIndex];
if (c == this.bcdTapeMark && (imgIndex+1 >= imgLength || image[imgIndex+1] >= 0x80)) {
this.errorMask |= 0x20; // EOF
imgIndex++;
} else {
c &= 0x7F; // zap the start-of-block bit
do {
if (c == 0x00) {
if (++blankCount > this.maxBlankFrames) {
this.errorMask |= 0x100000; // blank tape timeout
break; // kill the read loop
} else if (++imgIndex < imgLength) {
c = image[imgIndex]; // get next char frame
} else {
break; // at end of tape, kill the read loop
}
} else {
blankCount = 0;
cx = xlate[c];
if (cx >= 0xFF) {
this.errorMask |= 0x10; // parity error
this.imgIndex = imgIndex;
this.bcdSpaceForward(false);
imgIndex = this.imgIndex;
break; // kill the read loop
} else {
if (bufIndex < bufLength) {
buffer[bufIndex++] = cx; // store the ANSI character
if (++imgIndex < imgLength) {
c = image[imgIndex]; // get next char frame
} else {
break; // at end of tape, kill the read loop
}
} else {
this.imgIndex = imgIndex; // IOUnit buffer overflow
this.bcdSpaceForward(false);
imgIndex = this.imgIndex;
break; // kill the read loop
}
}
}
} while (c < 0x80);
}
}
this.imgIndex = imgIndex;
this.bufIndex = bufIndex;
return bufIndex;
};
/**************************************/
B5500MagTapeDrive.prototype.bcdReadBackward = function bcdReadBackward(oddParity) {
/* Reads the next block from the .bcd tape (this.image) in a backward direction,
translating the character frames to ANSI character codes based on the translation
table "xlate". The translated data is stored in this.buffer. A block is terminated
when the next frame has its high-order bit set, or the beginning of the tape image
data is reached. The resulting buffer is always at least one character in length,
unless the block is a tapeMark or the end of the data has been reached.
oddParity: 0=Alpha (even parity), 1=Binary (odd parity) read
Note that the characters are stored in this.buffer in ascending order as they are
being read backwards; thus the buffer is in reverse order with respect to how the
data will be stored in memory. The IOUnit will unravel this at finish.
Exits with the image index pointing to the first frame of THIS block (or at 0 if
at BOT). This arrangement allows changes between forward/reverse motion to work */
var blankCount = 0; // blank tape frame counter
var buffer = this.buffer; // IOUnit buffer
var bufLength = this.bufLength // IOUnit buffer length
var bufIndex = 0; // current IOUnit buffer offset
var c; // current character (tape image frame)
var cx; // current character translated to ASCII
var image = this.image; // tape image
var imgLength = this.imgLength; // tape image length
var imgIndex = this.imgIndex; // current tape image offset
var xlate = (oddParity ? this.bcdXlateInOdd : this.bcdXlateInEven);
if (imgIndex <= 0) {
this.setAtBOT(true);
if (this.botSensed) {
this.errorMask |= 0x100000; // set blank-tape bit
} else {
this.botSensed = true;
}
} else {
if (this.atEOT) {
this.setAtEOT(false);
}
c = image[--imgIndex];
if (c == this.bcdTapeMark) {
this.errorMask |= 0x20; // EOF
} else {
do {
if (c == 0x00) {
if (++blankCount > this.maxBlankFrames) {
this.errorMask |= 0x100000; // blank tape timeout
break; // kill the read loop
} else if (imgIndex > 0) {
c = image[--imgIndex]; // get next char frame
} else {
break; // at end of tape, kill the read loop
}
} else {
blankCount = 0;
cx = xlate[c & 0x7F];
if (cx >= 0xFF) {
this.errorMask |= 0x10; // parity error
this.imgIndex = imgIndex;
this.bcdSpaceBackward(false);
imgIndex = this.imgIndex;
break; // kill the read loop
} else {
if (bufIndex < bufLength) {
buffer[bufIndex++] = cx; // store the ANSI character
if (c >= 0x80) {
break; // at start of block, kill the read loop
} else if (imgIndex > 0) {
c = image[--imgIndex]; // get next char frame
} else {
break; // at start of tape, kill the read loop
}
} else {
this.imgIndex = imgIndex; // IOUnit buffer overflow
this.bcdSpaceBackward(false);
imgIndex = this.imgIndex;
break; // kill the read loop
}
}
}
} while (true);
}
}
this.imgIndex = imgIndex;
this.bufIndex = bufIndex;
return bufIndex;
};
/**************************************/
B5500MagTapeDrive.prototype.bcdWrite = function bcdWrite(oddParity) {
/* Writes the next block to the .bcd tape (this.image) in memory, translating
the character frames from ANSI character codes based on the translation
table "xlate". The translated data is stored at the current offset in
this.buffer. The start of a block is indicated by setting its high-order bit set.
oddParity 0=Alpha (even parity), 1=Binary (odd parity) write
Exits with the image index pointing beyond the last frame of the block (or beyond
the end of the image blob if at the end). Returns the number of characters written
to the IOUnit buffer */
var buffer = this.buffer; // IOUnit buffer
var bufLength = this.bufLength // IOUnit buffer length
var bufIndex = 0; // current IOUnit buffer offset
var image = this.image; // tape image
var imgLength = this.imgLength; // tape image length
var imgIndex = this.imgIndex; // current tape image offset
var xlate = (oddParity ? this.bcdXlateOutOdd : this.bcdXlateOutEven);
if (imgIndex >= imgLength) {
this.errorMask |= 0x04; // report not ready if beyond end of tape
} else {
if (this.atBOT) {
this.setAtBOT(false);
}
image[imgIndex++] = xlate[buffer[bufIndex++] & 0x7F] | 0x80;
while (bufIndex < bufLength) {
if (imgIndex >= imgLength) {
this.errorMask |= 0x04; // report not ready beyond end of tape
break;
} else {
image[imgIndex++] = xlate[buffer[bufIndex++] & 0x7F];
}
} // while
}
this.imgIndex = imgIndex;
this.bufIndex = bufIndex;
if (imgIndex > this.imgTopIndex) {
this.imgTopIndex = imgIndex;
}
return bufIndex;
};
/**************************************/
B5500MagTapeDrive.prototype.beforeUnload = function beforeUnload(ev) {
var msg = "Closing this window will make the device unusable.\n" +
"Suggest you stay on the page and minimize this window instead";
ev.preventDefault();
ev.returnValue = msg;
return msg;
};
/**************************************/
B5500MagTapeDrive.prototype.tapeDriveOnload = function tapeDriveOnload() {
/* Initializes the reader window and user interface */
var de;
this.doc = this.window.document;
de = this.doc.documentElement;
this.doc.title = "retro-B5500 Tape Drive " + this.mnemonic;
this.reelBar = this.$$("MTReelBar");
this.reelIcon = this.$$("MTReel");
this.tapeState = this.tapeLocal; // setTapeUnloaded() requires it to be in local
this.atBOT = true; // and also at BOT
this.setTapeUnloaded();
this.window.addEventListener("beforeunload",
B5500MagTapeDrive.prototype.beforeUnload, false);
this.$$("MTUnloadBtn").addEventListener("click",
B5500CentralControl.bindMethod(this, B5500MagTapeDrive.prototype.MTUnloadBtn_onclick), false);
this.$$("MTLoadBtn").addEventListener("click",
B5500CentralControl.bindMethod(this, B5500MagTapeDrive.prototype.MTLoadBtn_onclick), false);
this.$$("MTRemoteBtn").addEventListener("click",
B5500CentralControl.bindMethod(this, B5500MagTapeDrive.prototype.MTRemoteBtn_onclick), false);
this.$$("MTLocalBtn").addEventListener("click",
B5500CentralControl.bindMethod(this, B5500MagTapeDrive.prototype.MTLocalBtn_onclick), false);
this.$$("MTWriteRingBtn").addEventListener("click",
B5500CentralControl.bindMethod(this, B5500MagTapeDrive.prototype.MTWriteRingBtn_onclick), false);
this.$$("MTRewindBtn").addEventListener("click",
B5500CentralControl.bindMethod(this, B5500MagTapeDrive.prototype.MTRewindBtn_onclick), false);
this.window.resizeBy(de.scrollWidth - this.window.innerWidth + 4, // kludge for right-padding/margin
de.scrollHeight - this.window.innerHeight);
};
/**************************************/
B5500MagTapeDrive.prototype.read = function read(finish, buffer, length, mode, control) {
/* Initiates a read operation on the unit. If the drive is busy or not ready,
returns those conditions. Otherwise, attempts to read the next block from the tape.
mode 0=Alpha (even parity), 1=Binary (odd parity) read
control 0=forward, 1=backward read
*/
var count; // number of characters read into IOUnit buffer
var imgCount = this.imgIndex; // number of characters passed on tape
var inches = 0; // block length including gap [inches]
var residue; // residual characters in last word read
this.errorMask = 0;
if (this.busy) {
finish(0x01, 0); // report unit busy
} else if (!this.ready) {
finish(0x04, 0); // report unit not ready
} else {
this.busy = true;
this.buffer = buffer;
this.bufLength = length;
this.bufIndex = 0;
if (control) {
count = this.bcdReadBackward(mode);
residue = 7 - count % 8;
imgCount -= this.imgIndex;
inches = (imgCount > 0 ? -imgCount/this.density - this.gapLength : 0);
this.tapeInches += inches;
if (this.atEOT && this.tapeInches < this.imgEOTInches) {
this.setAtEOT(false);
}
} else {
count = this.bcdReadForward(mode);
residue = count % 8;
imgCount = this.imgIndex - imgCount;
inches = (imgCount > 0 ? imgCount/this.density + this.gapLength : 0);
this.tapeInches += inches;
if (!this.atEOT && this.tapeInches > this.imgEOTInches) {
this.setAtEOT(true);
this.errorMask |= 0x40020; // tape at EOT
}
}
this.buildErrorMask(residue);
this.moveTape(inches,
(imgCount/this.charsPerSec + this.startStopTime)*1000 + this.initiateStamp - performance.now(),
function readDelay() {
this.busy = false;
finish(this.errorMask, count);
});
this.buffer = null;
}
//console.log(this.mnemonic + " read: c=" + control + ", length=" + length + ", mode=" + mode +
// ", count=" + count + ", inches=" + this.tapeInches +
// ", index=" + this.imgIndex + ", mask=" + this.errorMask.toString(8));
//console.log(String.fromCharCode.apply(null, buffer.subarray(0, 80)).substring(0, count));
};
/**************************************/
B5500MagTapeDrive.prototype.space = function space(finish, length, control) {
/* Initiates a space operation on the unit. If the drive is busy or not ready,
returns those conditions. Otherwise, attempts to space over the next block
from the tape. Parity errors are ignored.
control 0=forward, 1=backward space
*/
var imgCount = this.imgIndex; // number of characters passed on tape
var inches = 0; // block length including gap [inches]
this.errorMask = 0;
if (this.busy) {
finish(0x01, 0); // report unit busy
} else if (!this.ready) {
finish(0x04, 0); // report unit not ready
} else {
this.busy = true;
if (control) {
this.bcdSpaceBackward(true);
imgCount -= this.imgIndex;
inches = (imgCount > 0 ? -imgCount/this.density - this.gapLength : 0);
this.tapeInches += inches;
if (this.atEOT && this.tapeInches < this.imgEOTInches) {
this.setAtEOT(false);
}
} else {
this.bcdSpaceForward(true);
imgCount = this.imgIndex - imgCount;
inches = (imgCount > 0 ? imgCount/this.density + this.gapLength : 0);
this.tapeInches += inches;
if (!this.atEOT && this.tapeInches > this.imgEOTInches) {
this.setAtEOT(true);
this.errorMask |= 0x40020; // tape at EOT
}
}
this.buildErrorMask(0);
this.moveTape(inches,
(imgCount/this.charsPerSec + this.startStopTime)*1000 + this.initiateStamp - performance.now(),
function readDelay() {
this.busy = false;
finish(this.errorMask, 0);
});
}
//console.log(this.mnemonic + " space: c=" + control + ", length=" + length +
// ", count=" + imgCount + ", inches=" + this.tapeInches +
// ", index=" + this.imgIndex + ", mask=" + this.errorMask.toString(8));
};
/**************************************/
B5500MagTapeDrive.prototype.write = function write(finish, buffer, length, mode, control) {
/* Initiates a write operation on the unit. If the drive is busy, not ready or has
no write ring, returns those conditions. Otherwise, attempts to write the next block
to the tape. mode 0=Alpha (even parity), 1=Binary (odd parity) write */
var count; // number of characters read into IOUnit buffer
var imgCount = this.imgIndex; // number of characters passed on tape
var inches = 0; // block length including gap [inches]
var residue; // residual characters in last word read
this.errorMask = 0;
if (this.busy) {
finish(0x01, 0); // report unit busy
} else if (!this.ready) {
finish(0x04, 0); // report unit not ready
} else if (!this.writeRing) {
finish(0x50, 0); // RD bits 26 & 28 => no write ring, don't return Mod III bits
} else {
this.busy = true;
this.buffer = buffer;
this.bufLength = length;
this.bufIndex = 0;
count = this.bcdWrite(mode);
residue = count % 8;
imgCount = this.imgIndex - imgCount;
inches = imgCount/this.density + this.gapLength;
this.tapeInches += inches;
if (!this.atEOT && this.tapeInches > this.imgEOTInches) {
this.setAtEOT(true);
this.errorMask |= 0x40020; // tape at EOT
}
this.imgWritten = true;
this.buildErrorMask(residue);
this.moveTape(inches,
(imgCount/this.charsPerSec + this.startStopTime)*1000 + this.initiateStamp - performance.now(),
function writeDelay() {
this.busy = false;
finish(this.errorMask, count);
});
this.buffer = null;
}
//console.log(this.mnemonic + " write: c=" + control + ", length=" + length + ", mode=" + mode +
// ", count=" + count + ", inches=" + this.tapeInches +
// ", index=" + this.imgIndex + ", mask=" + this.errorMask.toString(8));
//console.log(String.fromCharCode.apply(null, buffer.subarray(0, 80)).substring(0, count));
};
/**************************************/
B5500MagTapeDrive.prototype.erase = function erase(finish, length) {
/* Initiates an erase operation on the unit. If the drive is busy, not ready,
or has no write ring, then returns those conditions. Otherwise, does nothing
to the tape image, as lengths of blank tape less than 9 feet in length are
not "seen" by the I/O Unit. Delays an appropriate amount of time for the
length of the erasure */
var inches; // erase length [inches]
this.errorMask = 0;
if (this.busy) {
finish(0x01, 0); // report unit busy
} else if (!this.ready) {
finish(0x04, 0); // report unit not ready
} else if (!this.writeRing) {
finish(0x50, 0); // RD bits 26 & 28 => no write ring, don't return Mod III bits
} else {
this.busy = true;
inches = length/this.density;
this.tapeInches += inches;
if (!this.atEOT && this.tapeInches > this.imgEOTInches) {
this.setAtEOT(true);
this.errorMask |= 0x40020; // tape at EOT
}
this.imgWritten = true;
this.buildErrorMask(0);
this.moveTape(inches,
(length/this.charsPerSec + this.startStopTime)*1000 + this.initiateStamp - performance.now(),
function eraseDelay() {
this.busy = false;
finish(this.errorMask, 0);
});
}
//console.log(this.mnemonic + " erase: c=" + control + ", length=" + length +
// ", inches=" + this.tapeInches +
// ", index=" + this.imgIndex + ", mask=" + this.errorMask.toString(8));
};
/**************************************/
B5500MagTapeDrive.prototype.rewind = function rewind(finish) {
/* Initiates a rewind operation on the unit. If the drive is busy or not ready,
returns those conditions. Otherwise, makes the drive not-ready, delays for an
appropriate amount of time depending on how far up-tape we are, then readies the
unit again */
this.errorMask = 0;
if (this.busy) {
finish(0x01, 0); // report unit busy
} else if (!this.ready) {
finish(0x04, 0); // report unit not ready
} else {
this.tapeRewind(true);
this.buildErrorMask(0);
finish(this.errorMask, 0);
}
//console.log(this.mnemonic + " rewind: mask=" + this.errorMask.toString(8));
};
/**************************************/
B5500MagTapeDrive.prototype.readCheck = function readCheck(finish, length, control) {
/* Initiates a read check operation on the unit */
finish(0x04, 0); // report unit not ready
};
/**************************************/
B5500MagTapeDrive.prototype.readInterrogate = function readInterrogate(finish, control) {
/* Initiates a read interrogate operation on the unit */
finish(0x04, 0); // report unit not ready
};
/**************************************/
B5500MagTapeDrive.prototype.writeInterrogate = function writeInterrogate(finish, control) {
/* Initiates a write interrogate operation on the unit. This is actually a write
of zero length, typically used to determine ready and BOT/EOT status for the drive */
this.errorMask = 0;
if (this.busy) {
finish(0x01, 0); // report unit busy
} else if (!this.ready) {
finish(0x04, 0); // report unit not ready
} else {
if (!this.writeRing) {
this.errorMask |= 0x50; // RD bits 26 & 28 => no write ring
}
this.buildErrorMask(0);
/* For some reason the MCP does not like the BOT status being reported in
the result descriptor for a write interrogate. The I/O Control Unit flows
clearly show the Mod-III I/O Unit bits being set, but the MCP error mask
causes them to be seen as fatal errors. For now, we'll unconditionally
eliminate the BOT result bit in the error mask, although that just doesn't
seem right */
this.errorMask &= 0xFF7FFFF;
finish(this.errorMask, 0);
}
//console.log(this.mnemonic + " writeInterrogate: c=" + control + ", mask=" + this.errorMask.toString(8));
};
/**************************************/
B5500MagTapeDrive.prototype.shutDown = function shutDown() {
/* Shuts down the device */
if (this.timer) {
clearCallback(this.timer);
}
this.window.removeEventListener("beforeunload", B5500MagTapeDrive.prototype.beforeUnload, false);
this.window.close();
if (this.loadWindow && !this.loadWindow.closed) {
this.loadWindow.close();
}
};