DIRECTORY
Environment USING [bytesPerPage, wordsPerPage],
FileIO USING [Open, OpenFailed],
IO USING [STREAM, Close, GetIndex, GetLength, UnsafeBlock, SetIndex, UnsafeGetBlock],
PressFormat,
PressReader,
RealConvert USING [BcplToIeee],
Rope USING [ROPE, FromProc];
PressReaderImpl: PROGRAM
IMPORTS FileIO, IO, PF: PressFormat, RealConvert, Rope
EXPORTS PressReader = BEGIN

OPEN PressReader;
ROPE: TYPE = Rope.ROPE;

bytesPerPressRecord: CARDINAL = 512;
indexDistanceThreshold: INT _ 500;

Handle: PUBLIC TYPE = REF PressReaderRec;
PressReaderRec: PUBLIC TYPE = RECORD [
stream1: IO.STREAM _ NIL,
stream2: IO.STREAM _ NIL,
nRecs: INT _ 0,
nParts: INT _ 0,
pdStart: INT _ 0,
pdRecs: INT _ 0,
currentPart: INT  _ 0,
pType: PartType,
pStart: INT _ 0,
pRecs: INT _ 0,
padding: INT _ 0,
atObject: BOOL _ FALSE,
atDots: BOOL _ FALSE,
dataPlace, dataLength: INT,
entityStack: REF EntityStack _ NIL];

PressReaderError: PUBLIC ERROR [errorCode: ErrorCode] = CODE;

bcplMaxLength: CARDINAL = 255; -- maximum length of a BCPL string
BcplString: TYPE = LONG POINTER TO BcplStringBody;
BcplStringBody: TYPE = MACHINE DEPENDENT RECORD [
body: PACKED ARRAY[0..0) OF CHARACTER ];

BcplReal: TYPE = MACHINE DEPENDENT RECORD [
sign: [0..1], exp: [0..377B], sigbit: [0..1], topmantissa: [0..77B], restofmantissa: [0..177777B] ];

EntityStack: TYPE = RECORD[start, length, data: INT _ 0, next: REF EntityStack _ NIL];        
OpenPressFile: PUBLIC PROCEDURE [name: ROPE] RETURNS [handle: Handle] = {
docDirV: PF.DDV;
lengthInBytes: INT;

handle _ NEW[PressReaderRec];
handle.stream1 _ FileIO.Open[fileName: name, accessOptions: read
! FileIO.OpenFailed => CHECKED {ERROR PressReaderError[FileNotAvailableForRead]} ];
handle.stream2 _ FileIO.Open[fileName: name, accessOptions: read
! FileIO.OpenFailed => CHECKED {ERROR PressReaderError[FileNotAvailableForRead]} ];
lengthInBytes _ handle.stream1.GetLength[];

IF lengthInBytes = 0 OR (lengthInBytes MOD bytesPerPressRecord # 0) THEN
ERROR PressReaderError[FileNotAPressFile]; --bad length

ReadBlock[handle, lengthInBytes-bytesPerPressRecord, [@docDirV, 0, SIZE[PF.DDV]*2]];
IF docDirV.Passwd # PF.PressPasswd THEN ERROR PressReaderError[FileNotAPressFile]; -- bad password

handle.nRecs _ lengthInBytes/bytesPerPressRecord;
IF docDirV.nRecs # handle.nRecs THEN ERROR PressReaderError[FileNotAPressFile]; --bad record count

handle.nParts _ docDirV.nParts;
handle.pdStart _ docDirV.pdStart;
handle.pdRecs _ docDirV.pdRecs;
};  -- OpenPressFile
GetDocumentDirectory: PUBLIC PROCEDURE [handle: Handle] RETURNS [DocumentDirectory] = {
docDirV: PF.DDV;

IF handle = NIL THEN ERROR PressReaderError[BadHandle];
ReadBlock[handle, (handle.nRecs-1)*bytesPerPressRecord, [@docDirV, 0, SIZE[PF.DDV]*2]];
RETURN[NEW[DocumentDirectoryRec _ [
passwd:	docDirV.Passwd,
nRecs:	docDirV.nRecs,
nParts:	docDirV.nParts,
pdStart:	docDirV.pdStart,
pdRecs:	docDirV.pdRecs,
backP:	docDirV.Backp,
date:		PF.DoubleToLC[docDirV.date],
fCopy:	docDirV.fCopy,
lCopy:	docDirV.lCopy,
fPage:		docDirV.fPage,
lPage:		docDirV.lPage,
fileName:	BcplStringToRope[ArrayCardinalToBcplString[@docDirV.FileStr]],
creator:	BcplStringToRope[ArrayCardinalToBcplString[@docDirV.CreatStr]],
dateText:	BcplStringToRope[ArrayCardinalToBcplString[@docDirV.DateStr]]]]];
};  -- GetDocumentDirectory
GetParts: PUBLIC PROCEDURE [handle: Handle, partNumber: INT, pageProc: PageProc _ NIL, fontDirectoryProc: FontDirectoryProc _ NIL] = {
partEntry: PF.PE;
currentPart: INT;
upToPart: INT;

IF handle = NIL THEN ERROR PressReaderError[BadHandle];

IF partNumber = 0 THEN {
currentPart _ 1;
upToPart _ handle.nParts; }
ELSE IF partNumber NOT IN [1..handle.nParts] THEN ERROR PressReaderError[PartNotFound]
ELSE currentPart _ upToPart _ partNumber;

WHILE currentPart <= upToPart DO
ReadBlock[
handle,
handle.pdStart*bytesPerPressRecord+(currentPart-1)*SIZE[PF.PE]*2,
[@partEntry, 0, SIZE[PF.PE]*2]];

handle.pType _ SELECT LOOPHOLE[partEntry.Type, INTEGER] FROM
PF.PETypePage => printedPage,
PF.PETypeFont => fontDirectory,
< 0 => private,
> 1 => other,
ENDCASE => ERROR PressReaderError[BadPartType];

handle.pStart _ partEntry.pStart;
handle.pRecs _ partEntry.pRecs;
handle.padding _ partEntry.Padding;

SELECT handle.pType FROM
printedPage =>
IF pageProc # NIL THEN
pageProc[handle, [printedPage, partEntry.Type, handle.pStart, handle.pRecs,  handle.padding]];
fontDirectory =>
IF fontDirectoryProc # NIL THEN
fontDirectoryProc[handle, [fontDirectory, partEntry.Type, handle.pStart,  handle.pRecs, handle.padding]];
ENDCASE => ERROR PressReaderError[BadPartType];

currentPart _ currentPart+1;
ENDLOOP;
};  -- GetParts
GetFonts: PUBLIC PROCEDURE [handle: Handle, fontEntryProc: FontEntryProc _ NIL] = {
fontEntry: PF.FE;
partEntry: PF.PE;
pStart, currentPart: INT;
fontStart: INT _ 0;

IF handle = NIL THEN ERROR PressReaderError[BadHandle];
IF fontEntryProc = NIL THEN RETURN;

IF handle.pType # fontDirectory THEN { -- search all parts for FontDirectory
FOR currentPart IN [0..handle.nParts) DO
ReadBlock[handle, handle.pdStart*bytesPerPressRecord+currentPart*SIZE[PF.PE]*2,
[@partEntry, 0, SIZE[PF.PE]*2]];
IF partEntry.Type = PF.PETypeFont THEN {pStart _ partEntry.pStart; EXIT;}
REPEAT
FINISHED => ERROR PressReaderError[NoFontDirectoryPart];
ENDLOOP;
}
ELSE pStart _ handle.pStart;

DO
ReadBlock[handle, pStart*bytesPerPressRecord+fontStart, [@fontEntry, 0, SIZE[PF.FE]*2]];
IF fontEntry.length = 0 THEN EXIT;

IF fontEntry.fam[0] = 0 AND fontEntry.fam[1] = 0 AND fontEntry.destn = 255 THEN {
handle.dataLength _ fontEntry.length-4;  -- SIZE[length, set, fno, m, all-ones, zero]
handle.dataPlace _ pStart*bytesPerPressRecord+fontStart+8;
handle.atObject _ TRUE;
fontEntryProc[[
length: fontEntry.length,
fontSet: fontEntry.set,
font: fontEntry.fno,
firstChar: fontEntry.destm,
lastChar: fontEntry.destn,
family: NIL,
face: [0, medium, regular, regular],
source: 0,
size: 0,
rotation: 0 ]];
handle.atObject _ FALSE;
}
ELSE {
fontEntryProc[[
length: fontEntry.length,
fontSet: fontEntry.set,
font: fontEntry.fno,
firstChar: fontEntry.destm,
lastChar: fontEntry.destn,
family: BcplStringToRope[ArrayByteToBcplString[@fontEntry.fam]],
face: DecodeFace[fontEntry.face],
source: fontEntry.source,
size: LOOPHOLE[fontEntry.siz, INTEGER],
rotation: fontEntry.rotn ]];
};
fontStart _ fontStart+fontEntry.length*2;
ENDLOOP;
};  -- GetFonts
GetPage: PUBLIC PROCEDURE [handle:Handle, entityProc: EntityProc _ NIL] = {
temp: REF EntityStack;
length: CARDINAL;
entityTrailer: PF.EH;

IF handle = NIL THEN ERROR PressReaderError[BadHandle];
IF handle.pType # printedPage THEN ERROR PressReaderError[CurrentPartNotAPage];

handle.entityStack _ NEW[EntityStack];
handle.entityStack.start _ (handle.pStart+handle.pRecs)*bytesPerPressRecord-handle.padding*2;
DO
ReadBlock[handle, handle.entityStack.start-SIZE[CARDINAL]*2, [@length, 0, SIZE[CARDINAL]*2]];
IF length = 0 THEN EXIT;
temp _ NEW[EntityStack _ [start: handle.entityStack.start-length*2, next: handle.entityStack]];
handle.entityStack _ temp;
ENDLOOP;

handle.entityStack _ handle.entityStack.next; -- pop the empty entry on top
WHILE handle.entityStack # NIL DO
ReadBlock[handle, handle.entityStack.start-SIZE[PF.EH]*2, [@entityTrailer, 0, SIZE[PF.EH]*2]];
handle.entityStack.length _ entityTrailer.Length;
handle.entityStack.data _ PF.DoubleToLC[entityTrailer.Dstart];

entityProc[handle, [
entityType: entityTrailer.Type,
fontSet: entityTrailer.Fontset,
dataStart: PF.DoubleToLC[entityTrailer.Dstart],
dataLength: PF.DoubleToLC[entityTrailer.Dlength],
Xe: entityTrailer.Xe,
Ye: entityTrailer.Ye,
xLeft: entityTrailer.Xleft,
yBottom: entityTrailer.Ybottom,
width: entityTrailer.Width,
height: entityTrailer.Height,
length: entityTrailer.Length]];

handle.entityStack _ handle.entityStack.next;
ENDLOOP;
};  -- GetPage
GetCommands: PUBLIC PROCEDURE [handle:Handle, commandProcs: CommandProcs] = {
length: CARDINAL;
stringBuffer: PACKED ARRAY [0..256) OF CHARACTER;
integerBuffer: INTEGER _ 0;
value: INTEGER _ 0;
rectangleBuffer: MACHINE DEPENDENT RECORD [width, height: INTEGER];
alternativeBuffer: MACHINE DEPENDENT RECORD [
ELtypes: CARDINAL, ELbytes, DLbytes: PF.Double];
opBuffer: MACHINE DEPENDENT RECORD [opcode: PF.BYTE, byteArg: PF.BYTE];
dataPlace, commandPlace, commandEnd: INT;
dataLength: INT;
dotsLength: PF.Double;

IF handle = NIL THEN ERROR PressReaderError[BadHandle];
IF handle.entityStack = NIL THEN ERROR PressReaderError[NoEntity];

dataPlace _ handle.pStart*bytesPerPressRecord+handle.entityStack.data;
commandPlace _ handle.entityStack.start-handle.entityStack.length*2;
commandEnd _ commandPlace+(handle.entityStack.length-SIZE[PF.EH])*2;

WHILE commandPlace < commandEnd DO
ReadBlock[handle, commandPlace, [@opBuffer, 0, 2]]; -- read Opcode and one byte

BEGIN OPEN opBuffer;
SELECT opcode FROM

IN [PF.EShowShort .. PF.ESkipShort) => {
length _ opcode-PF.EShowShort+1;
IF commandProcs.showCharactersProc # NIL THEN {
stringBuffer[0] _ LOOPHOLE[opcode-PF.EShowShort+1, CHARACTER];
ReadBlock[handle, dataPlace, [@stringBuffer, 1, length+1]];
commandProcs.showCharactersProc[showCharactersShort, length, BcplStringToRope[ArrayCharacterToBcplString[@stringBuffer]]];
};
dataPlace _ dataPlace+length;
commandPlace _ commandPlace+1;
};

IN [PF.ESkipShort..PF.EShowSkip) => {
length _ opcode-PF.ESkipShort+1;
IF commandProcs.skipProc # NIL THEN 
commandProcs.skipProc[skipCharactersShort, length];
dataPlace _ dataPlace+length;
commandPlace _ commandPlace+1;
};

IN [PF.EShowSkip..PF.ESpaceXShort) => {
length _ opcode-PF.EShowShort+1;
IF commandProcs.showCharactersProc # NIL THEN {
stringBuffer[0] _ LOOPHOLE[opcode-PF.EShowShort+1, CHARACTER];
ReadBlock[handle, dataPlace, [@stringBuffer, 1, length+1]];
commandProcs.showCharactersProc[showCharactersAndSkip, length, BcplStringToRope[ArrayCharacterToBcplString[@stringBuffer]]];
};
dataPlace _ dataPlace+length+1;  -- skip byte
commandPlace _ commandPlace+1;
};

IN [PF.ESpaceXShort..PF.ESpaceYShort) => {
IF commandProcs.spacingProc # NIL THEN
commandProcs.spacingProc[setSpaceXShort, (opcode-PF.ESpaceXShort)*256+byteArg];
commandPlace _ commandPlace+2;
};

IN [PF.ESpaceYShort..PF.EFont) => { 
IF commandProcs.spacingProc # NIL THEN
commandProcs.spacingProc[setSpaceYShort, (opcode-PF.ESpaceXShort)*256+byteArg];
commandPlace _ commandPlace+2;
};

IN [PF.EFont..PF.EShortMax] => {
IF commandProcs.fontProc # NIL THEN {
value _ opcode-PF.EFont;
commandProcs.fontProc[value];
};
commandPlace _ commandPlace+1;
};

PF.ENop, IN (PF.EShortMax..PF.ESkipControlImmediate) => { --available and spare
IF commandProcs.noOpProc # NIL THEN
commandProcs.noOpProc;
commandPlace _ commandPlace+1;
};

PF.ESkipControlImmediate => {
IF commandProcs.skipProc # NIL THEN
commandProcs.skipProc[skipControlBytesImmediate, byteArg];
commandPlace _ commandPlace+2+byteArg;
};

PF.EAlternative => {
IF commandProcs.alternativeProc # NIL THEN {
ReadBlock[handle, commandPlace+1, [@alternativeBuffer, 0, 10]];
commandProcs.alternativeProc[alternativeBuffer.ELtypes, PF.DoubleToLC[alternativeBuffer.ELbytes], PF.DoubleToLC[alternativeBuffer.DLbytes]];
};
commandPlace _ commandPlace+11;
};

PF.EOnlyOnCopy => {
IF commandProcs.copyProc # NIL THEN commandProcs.copyProc[byteArg];
commandPlace _ commandPlace+2;
};

PF.ESetX, PF.ESetY => {
IF commandProcs.positionProc # NIL THEN {
ReadBlock[handle, commandPlace+1, [@integerBuffer, 0, 2]];
commandProcs.positionProc[
SELECT opcode FROM
PF.ESetX => setX,
PF.ESetY => setY,
ENDCASE => ERROR,
integerBuffer];
};
commandPlace _ commandPlace+3;
};

PF.EShow => {
length _ byteArg;
IF commandProcs.showCharactersProc # NIL THEN {
stringBuffer[0] _ LOOPHOLE[byteArg, CHARACTER];
ReadBlock[handle, dataPlace, [@stringBuffer, 1, length+1]];
commandProcs.showCharactersProc[showCharacters, length, BcplStringToRope[ArrayCharacterToBcplString[@stringBuffer]]];
};
dataPlace _ dataPlace+length;
commandPlace _ commandPlace+2;
};

PF.ESkip => {
IF commandProcs.skipProc # NIL THEN
commandProcs.skipProc[skipCharacters, byteArg];
dataPlace _ dataPlace+byteArg;
commandPlace _ commandPlace+2;
};

PF.ESkipControl => { -- should get the type byte too
ReadBlock[handle, commandPlace+1, [@integerBuffer, 0, 2]];
IF commandProcs.skipProc # NIL THEN
commandProcs.skipProc[skipControlBytes, integerBuffer];
dataPlace _ dataPlace+integerBuffer; 
commandPlace _ commandPlace+4;
};

PF.EShowImmediate => {
IF commandProcs.showCharactersProc # NIL THEN {
stringBuffer[0] _ LOOPHOLE[1, CHARACTER];
stringBuffer[1] _ LOOPHOLE[byteArg, CHARACTER];
commandProcs.showCharactersProc[showCharacterImmediate, 1, BcplStringToRope[ArrayCharacterToBcplString[@stringBuffer]]];
};
commandPlace _ commandPlace+2;
};

PF.ESpaceX, PF.ESpaceY => {
IF commandProcs.spacingProc # NIL THEN {
ReadBlock[handle, commandPlace+1, [@integerBuffer, 0, 2]];
commandProcs.spacingProc[
SELECT opcode FROM
PF.ESpaceX => setSpaceX,
PF.ESpaceY => setSpaceY,
ENDCASE => ERROR,
integerBuffer];
};
commandPlace _ commandPlace+3;
};

PF.EResetSpace => {
IF commandProcs.spacingProc # NIL THEN
commandProcs.spacingProc[resetSpace, 0];
commandPlace _ commandPlace+1;
};

PF.ESpace => {
IF commandProcs.spaceProc # NIL THEN commandProcs.spaceProc;
commandPlace _ commandPlace+1;
};

PF.ESetBright, PF.ESetHue, PF.ESetSat => {
IF commandProcs.colorProc # NIL THEN
commandProcs.colorProc[
SELECT opcode FROM
PF.ESetBright => setBrightness,
PF.ESetHue => setHue,
PF.ESetSat => setSaturation,
ENDCASE => ERROR,
byteArg];
commandPlace _ commandPlace+2;
};

PF.EShowObject => {
ReadBlock[handle, commandPlace+1, [@integerBuffer, 0, 2]];
IF commandProcs.showObjectProc # NIL THEN {
handle.atObject _ TRUE;
handle.dataLength _ integerBuffer;
handle.dataPlace _ dataPlace;
commandProcs.showObjectProc[handle, integerBuffer];
};
handle.atObject _ FALSE;
dataPlace _ dataPlace+integerBuffer*2;
commandPlace _ commandPlace+3;
};

PF.EShowDots, PF.EShowDotsOpaque => {
ReadBlock[handle, commandPlace+1, [@dotsLength, 0, 4]];
dataLength _ PF.DoubleToLC[dotsLength];
IF commandProcs.showDotsProc # NIL THEN {
handle.atDots _ TRUE;
handle.dataPlace _ dataPlace;
handle.dataLength _ dataLength;
commandProcs.showDotsProc[
handle,
SELECT opcode FROM
PF.EShowDots => showDots,
PF.EShowDotsOpaque => showDotsOpaque,
ENDCASE => ERROR,
dataLength];
};
dataPlace _ dataPlace+2*dataLength;
commandPlace _ commandPlace+5;
handle.atDots _ FALSE;
};

PF.EShowRectangle => {
IF commandProcs.showRectangleProc # NIL THEN {
ReadBlock[handle, commandPlace+1, [@rectangleBuffer, 0, 4]];
commandProcs.showRectangleProc[rectangleBuffer.width, rectangleBuffer.height];
};
commandPlace _ commandPlace+5;
};

ENDCASE => {
IF commandProcs.badProc # NIL THEN
commandProcs.badProc[opcode, commandPlace, dataPlace];
EXIT;
};

END;
ENDLOOP; -- opcode
};  -- GetCommands
GetObject: PUBLIC PROCEDURE [handle: Handle, objectProcs: ObjectProcs] = {
dataLength: INT _ handle.dataLength;
dataPlace: INT _ handle.dataPlace;
objectBuffer: MACHINE DEPENDENT RECORD [command: CARDINAL, arg1, arg2: INTEGER];
curveBuffer: MACHINE DEPENDENT RECORD [cX, cY, bX, bY, aX, aY: BcplReal];

IF NOT handle.atObject THEN ERROR PressReaderError[NotAtObject];
WHILE dataLength > 0 DO
ReadBlock[handle, dataPlace, [@objectBuffer, 0, 6]];
SELECT objectBuffer.command FROM
PF.DMoveTo => {
IF objectProcs.moveToProc # NIL THEN
objectProcs.moveToProc[objectBuffer.arg1, objectBuffer.arg2];
dataPlace _ dataPlace+6;
dataLength _ dataLength-3;
};

PF.DDrawTo => {
IF objectProcs.drawToProc # NIL THEN
 objectProcs.drawToProc[objectBuffer.arg1, objectBuffer.arg2];
dataPlace _ dataPlace+6;
dataLength _ dataLength-3;
};

PF.DDrawCurve => {
IF objectProcs.drawCurveProc # NIL THEN {
ReadBlock[handle, dataPlace+2, [@curveBuffer, 0, 24]];
objectProcs.drawCurveProc[
BcplToMesaReal[curveBuffer.cX],
BcplToMesaReal[curveBuffer.cY],
BcplToMesaReal[curveBuffer.bX],
BcplToMesaReal[curveBuffer.bY],
BcplToMesaReal[curveBuffer.aX],
BcplToMesaReal[curveBuffer.aY]];
};
dataPlace _ dataPlace+26;
dataLength _ dataLength-13;
};
ENDCASE;
ENDLOOP;
};  -- GetObject
GetDots: PUBLIC PROCEDURE [handle: Handle, dotProcs: DotProcs] = {
dataLength: INT _ handle.dataLength;
dataPlace: INT _ handle.dataPlace;
opBuffer: MACHINE DEPENDENT RECORD [opcode: PF.BYTE, byteArg: PF.BYTE];
dotsLength: PF.Double;
windowBuffer: MACHINE DEPENDENT RECORD [one, two, three, four: CARDINAL];
numberPages, pageNumber, byteOffset: INT;

IF NOT handle.atDots THEN ERROR PressReaderError[NotAtDots];
WHILE dataLength > 0 DO
ReadBlock[handle, dataPlace, [@opBuffer, 0, 2]];
SELECT opBuffer.opcode FROM
1 => { -- PF.DDotCode
IF dotProcs.setCoding # NIL THEN {
ReadBlock[handle, dataPlace+2, [@dotsLength, 0, 4]];
dotProcs.setCoding[opBuffer.byteArg, dotsLength.high, dotsLength.low];
};
dataPlace _ dataPlace+6;
dataLength _ dataLength-3;
};

2 => { -- PF.DDotMode
IF dotProcs.setMode # NIL THEN
dotProcs.setMode[opBuffer.byteArg];
dataPlace _ dataPlace+2;
dataLength _ dataLength-1;
};

0 => SELECT opBuffer.byteArg FROM
PF.DDotWindow => {
IF dotProcs.setWindow # NIL THEN {
ReadBlock[handle, dataPlace+2, [@windowBuffer, 0, 8]];
dotProcs.setWindow[windowBuffer.one, windowBuffer.two, windowBuffer.three, windowBuffer.four];
};
dataPlace _ dataPlace+10;
dataLength _ dataLength-5;
};

PF.DDotSize => {
IF dotProcs.setSize # NIL THEN {
ReadBlock[handle, dataPlace+2, [@windowBuffer, 0, 4]];
dotProcs.setSize[windowBuffer.one, windowBuffer.two];
};
dataPlace _ dataPlace+6;
dataLength _ dataLength-3;
};

PF.DDotsFollow => {
dataPlace _ dataPlace+2;
dataLength _ dataLength-1;
IF dotProcs.dotsFollow # NIL THEN {
pageNumber _ dataPlace/Environment.bytesPerPage;
byteOffset _ dataPlace MOD Environment.bytesPerPage;
numberPages _ (dataLength+byteOffset+Environment.wordsPerPage-1) / Environment.wordsPerPage;
dotProcs.dotsFollow[[file: handle.stream1, numberPages: numberPages, pageNumber: pageNumber, byteOffset: byteOffset, length: dataLength]];
};
dataLength _ 0;
};

PF.DDotsFromFile => ERROR;
PF.DDotsFromPressFile => ERROR;
PF.DSampleProps => ERROR;
ENDCASE => ERROR;

ENDCASE => ERROR;
ENDLOOP;
};  -- GetDots
ClosePressFile: PUBLIC PROCEDURE [handle: Handle] = {
IF (handle # NIL) AND (handle.stream1 # NIL) THEN handle.stream1.Close[];
IF (handle # NIL) AND (handle.stream2 # NIL) THEN handle.stream2.Close[];
handle _ NIL;
};  -- ClosePressFile
DecodeFace: PROCEDURE [face: INT] RETURNS [fontFace: FontFace] = {
IF face NOT IN [0..18) THEN RETURN [[face, medium, regular, regular]];
fontFace.encoding _ face;
fontFace.slope _ IF (face MOD 2) = 0 THEN regular ELSE italic;
face _ face - (face MOD 2);
fontFace.weight _ SELECT (face MOD 6) FROM
0 => medium,
2 => bold,
4 => light,
ENDCASE => ERROR;
fontFace.expansion _ SELECT face - (face MOD 6) FROM
0 => regular,
6 => condensed,
12 => expanded,
ENDCASE => ERROR;
};  -- DecodeFace
ReadBlock: PROCEDURE [handle: Handle, index: INT, ub: IO.UnsafeBlock] = --INLINE-- {
ix1: INT _ handle.stream1.GetIndex[];
IF ABS[ix1-index] > indexDistanceThreshold THEN {
s: IO.STREAM _ handle.stream1; handle.stream1 _ handle.stream2; handle.stream2 _ s;
};
handle.stream1.SetIndex[index];
IF handle.stream1.UnsafeGetBlock[ub] # (ub.stopIndexPlusOne-ub.startIndex) THEN
ERROR PressReaderError[AbortedBecauseGetFailed];
};
ArrayCardinalToBcplString: PROCEDURE [s: LONG POINTER TO ARRAY [0..0) OF CARDINAL]
RETURNS [BcplString] = INLINE { RETURN[LOOPHOLE[s, BcplString]]; };
ArrayByteToBcplString: PROCEDURE [s: LONG POINTER TO PACKED ARRAY [0..0) OF PF.BYTE]
RETURNS [BcplString] = INLINE { RETURN[LOOPHOLE[s, BcplString]]; };
ArrayCharacterToBcplString: PROCEDURE [s: LONG POINTER TO PACKED ARRAY [0..0) OF CHARACTER]
RETURNS [BcplString] =  INLINE { RETURN[LOOPHOLE[s, BcplString]]; };
BcplStringToRope: PROCEDURE [t: BcplString] RETURNS [ROPE] = {
lengthByte: PF.BYTE _ LOOPHOLE[t[0]];
len: INT _ lengthByte;
i: INT _ 0;
fromProc: SAFE PROCEDURE RETURNS[CHAR] = TRUSTED { RETURN[t.body[i _ i+1]]; };

IF len NOT IN[0..bcplMaxLength] THEN ERROR;
RETURN [Rope.FromProc[len, fromProc]];
};
BcplToMesaReal: PROCEDURE [b: BcplReal] RETURNS [REAL] = INLINE {
RETURN[RealConvert.BcplToIeee[LOOPHOLE[b]]]; };

END.
&PressReaderImpl.mesa
Last Modified by Shore; November 22, 1982 11:51 am
Last Edited by: Beach, September 13, 1983 5:21 pm
a graphically defined font
Change Log
Created by Shore; June 29, 1982 2:56 pm

Changed by Shore; August 22, 1982 4:58 pm
converted to formatted Tioga file
revisions for Cedar 3.3
reduced number of SetIndex instructions

Changed by Shore; August 26, 1982 9:30 am
made Dots and Objects one level deeper to permit exit actions by the show Commands

Changed by Shore; September 2, 1982 9:08 am
made Parts individually gettable (partNumber parameter to GetParts)

Changed by Shore; September 3, 1982 5:08 pm
now pass up Dots

Changed by Shore; October 12, 1982 9:11 pm
updated for Cedar 3.4

Changed by Shore; November 14, 1982 3:02 pm
changed to Cedar.Style and added node formats
Κ/–

"Cedar" style˜
head1š
Οc™Jš
2™2J™1
unitš
Οk	˜	Jšœžœ˜/Jšœžœ˜ Jšžœ
žœžœE˜UJš
œ˜Jš
œ˜Jšœžœ˜Jšœžœžœ˜——šΟnœž˜Jšžœ	žœžœ ˜6Jšžœž˜J˜Jšžœ
˜Jšžœžœžœ
˜J˜Jšœžœ˜$Jšœžœ˜"J˜Jšœžœ
žœžœ˜)šœžœ
žœžœ˜&Jšœ	žœ
žœžœ
˜Jšœ	žœ
žœžœ
˜Jšœžœ˜Jšœžœ˜Jšœ	žœ˜Jšœžœ˜Jšœ
žœ˜Jš
œ˜Jšœžœ˜Jšœžœ˜Jšœ	žœ˜Jšœ
žœžœ
˜Jšœžœžœ
˜Jšœžœ
˜Jšœ
žœžœ˜$—J˜Jšœžœ
žœžœ
˜=J˜Jšœžœ"˜AJš	œžœžœ
žœ
žœ˜2Jš	œžœžœ
ž	œ
žœ˜1Jš	œžœ
žœžœ
ž	œ˜(J˜Jš	œ
žœžœ
ž	œ
žœ˜+Jš
œd˜dJ˜Jšœ
žœžœžœžœžœ
˜^š
Ÿ
œžœ
ž	œžœžœ˜IJšœ	žœ
žœ
˜Jšœžœ
˜J˜Jšœ	žœ˜š
œ@˜@Jšœžœžœ.˜S—š
œ@˜@Jšœžœžœ.˜S—Jš
œ+˜+J˜šžœžœžœž˜HJšžœ&˜7—J˜JšœCžœ
žœ
žœ˜TJš	žœžœ
žœ
žœ&˜bJ˜Jš
œ1˜1Jšžœžœ
žœ&˜bJ˜Jš
œ˜Jš
œ!˜!Jš
œ˜Jšœ˜—šŸœžœ
ž	œžœ˜WJšœ	žœ
žœ
˜J˜Jšžœ
žœ
žœ
žœ˜7JšœFžœ
žœ
žœ˜Wšžœ
žœ˜#Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ˜#Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œH˜HJš
œH˜HJš
œK˜K—Jšœ˜—šŸœžœ
ž	œžœžœ)žœ˜†
Jšœžœ
žœ
˜Jšœ
žœ
˜Jšœ
žœ
˜J˜Jšžœ
žœ
žœ
žœ˜7J˜šžœžœ˜Jš
œ˜Jš
œ˜—Jšžœ
žœžœ
žœžœ
žœ˜VJšžœ%˜)J˜šžœž˜ š
œ
˜
Jš
œ˜Jšœ3žœ
žœ
žœ˜AJšœžœ
žœ
žœ˜ —J˜šœžœ
žœžœž˜<Jšžœ˜Jšžœ˜Jš
œ˜Jš
œ
˜
Jšžœžœ˜/—J˜Jš
œ!˜!Jš
œ˜Jš
œ#˜#J˜šžœž˜š
œ˜šžœžœ
ž˜Jš
œ^˜^——š
œ˜šžœžœ
ž˜Jš
œi˜i——Jšžœžœ˜/—J˜Jš
œ˜Jšžœ
˜—Jšœ˜—šŸœžœ
ž	œ1žœ˜SJšœžœ
žœ
˜Jšœžœ
žœ
˜Jšœžœ
˜Jšœžœ˜J˜Jšžœ
žœ
žœ
žœ˜7Jšžœžœ
žœ
žœ
˜#J˜šžœžœ%˜Lšžœ
žœž˜(šœAžœ
žœ
žœ˜OJšœžœ
žœ
žœ˜ —Jšžœžœžœžœ˜Iš
ž˜Jšžœžœ'˜8—Jšžœ
˜—Jš
œ
˜
—Jšžœ˜J˜š
ž˜JšœHžœ
žœ
žœ˜XJšžœžœ
žœ
˜"J˜šžœžœžœžœ˜QJš
™Jšœ),˜UJš
œ:˜:Jšœžœ
˜š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ
˜Jš
œ$˜$Jš
œ
˜
Jš
œ˜Jš
œ˜—Jšœžœ
˜Jš
œ
˜
—šžœ˜š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ@˜@Jš
œ!˜!Jš
œ˜Jšœžœžœ˜'Jš
œ˜—Jš
œ˜—Jš
œ)˜)Jšžœ
˜—Jšœ˜—šŸœžœ
ž	œ*žœ˜KJšœžœ
˜Jšœžœ
˜Jšœžœ
žœ
˜J˜Jšžœ
žœ
žœ
žœ˜7Jšžœžœ
žœ'˜OJ˜Jšœžœ˜&Jš
œ]˜]š
ž˜Jš	œ+žœ
žœžœ
žœ˜]Jšžœžœ
žœ
˜JšœžœU˜_Jš
œ˜Jšžœ
˜—J˜Jšœ.˜Kšžœžœ
ž˜!Jš
œ+žœ
žœ
žœžœ
žœ
žœ˜^Jš
œ1˜1Jšœžœ"˜>J˜š
œ˜Jš
œ˜Jš
œ˜Jšœžœ"˜/Jšœžœ#˜1Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš
œ-˜-Jšžœ
˜—Jšœ
˜—šŸœžœ
ž	œ0˜MJšœžœ
˜Jš	œžœ
žœ
žœ
ž	œ
˜1Jšœžœ˜Jšœžœ˜Jš	œžœ
ž	œ
žœžœ˜Cšœžœ
ž	œ
žœ˜-Jšœ	žœžœ	˜0—Jšœ
žœ
ž	œ
žœ
žœ
žœžœ
žœ˜GJšœ%žœ
˜)Jšœžœ
˜Jšœžœ˜J˜Jšžœ
žœ
žœ
žœ˜7Jšžœžœ
žœ
žœ˜BJ˜Jš
œF˜FJš
œD˜DJšœ5žœ
žœ
žœ˜DJ˜šžœž˜"Jšœ4˜OJ˜šžœ
žœ
˜šžœž˜J˜šžœžœžœ˜(Jšœžœ˜ šžœ#žœ
žœ˜/Jšœžœžœž	œ˜>Jš
œ;˜;Jš
œz˜zJš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœžœ
žœ˜%Jšœžœ˜ šžœžœ
žœ
˜$Jš
œ3˜3—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœžœžœ˜'Jšœžœ˜ šžœ#žœ
žœ˜/Jšœžœžœž	œ˜>Jš
œ;˜;Jš
œ|˜|Jš
œ˜—Jšœ!˜-Jš
œ˜Jš
œ˜—J˜šžœžœžœ˜*šžœžœ
ž˜&Jšœ1žœ˜O—Jš
œ˜Jš
œ˜—J˜šžœžœžœ
˜$šžœžœ
ž˜&Jšœ1žœ˜O—Jš
œ˜Jš
œ˜—J˜šžœžœžœ˜ šžœžœ
žœ˜%Jšœžœ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜—J˜š	žœžœžœžœ˜Ošžœžœ
ž˜#Jš
œ˜—Jš
œ˜Jš
œ˜—J˜šžœ˜šžœžœ
ž˜#Jš
œ:˜:—Jš
œ&˜&Jš
œ˜—J˜šžœ˜šžœ žœ
žœ˜,Jš
œ?˜?Jšœ8žœ(žœ(˜Œ
Jš
œ˜—Jš
œ˜Jš
œ˜—J˜šžœ˜Jšžœžœ
žœ ˜CJš
œ˜Jš
œ˜—J˜šžœžœ˜šžœžœ
žœ˜)Jš
œ:˜:š
œ˜šžœž˜Jšžœ˜Jšžœ˜Jšžœžœ
˜—Jš
œ˜—Jš
œ˜—Jš
œ˜Jš
œ˜—J˜šžœ˜
Jš
œ˜šžœ#žœ
žœ˜/Jšœžœ
ž	œ˜/Jš
œ;˜;Jš
œu˜uJš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœ˜
šžœžœ
ž˜#Jš
œ/˜/—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœ˜4Jš
œ:˜:šžœžœ
ž˜#Jš
œ7˜7—Jš
œ%˜%Jš
œ˜Jš
œ˜—J˜šžœ˜šžœ#žœ
žœ˜/Jšœžœž	œ˜)Jšœžœ
ž	œ˜/Jš
œx˜xJš
œ˜—Jš
œ˜Jš
œ˜—J˜šžœ
žœ
˜šžœžœ
žœ˜(Jš
œ:˜:š
œ˜šžœž˜Jšžœ˜Jšžœ˜Jšžœžœ
˜—Jš
œ˜—Jš
œ˜—Jš
œ˜Jš
œ˜—J˜šžœ˜šžœžœ
ž˜&Jš
œ(˜(—Jš
œ˜Jš
œ˜—J˜šžœ˜Jšžœžœ
žœ˜<Jš
œ˜Jš
œ˜—J˜šžœ
žœ
žœ
˜*šžœžœ
ž˜$š
œ˜šžœž˜Jšžœ˜Jšžœ˜Jšžœ˜Jšžœžœ
˜—Jš
œ	˜	——Jš
œ˜Jš
œ˜—J˜šžœ˜Jš
œ:˜:šžœžœ
žœ˜+Jšœžœ
˜Jš
œ"˜"J˜Jš
œ3˜3J˜—Jšœžœ
˜Jš
œ&˜&Jš
œ˜J˜—J˜šžœžœ˜%Jš
œ7˜7Jšœ
žœ˜'šžœžœ
žœ˜)Jšœžœ
˜Jš
œ˜Jš
œ˜š
œ˜Jš
œ˜šžœž˜Jšžœ˜Jšžœ#˜%Jšžœžœ
˜—Jš
œ˜—J˜—Jš
œ#˜#Jš
œ˜Jšœžœ
˜J˜—J˜šžœ˜šžœ"žœ
žœ˜.Jš
œ<˜<Jš
œN˜NJš
œ˜—Jš
œ˜Jš
œ˜—J˜šžœ˜šžœžœ
ž˜"Jš
œ6˜6—Jšžœ
˜Jš
œ˜—J˜—Jšžœ
˜—Jšžœ	˜—Jšœ˜—šŸ	œžœ
ž	œ/˜JJšœžœ˜$Jšœžœ˜"Jšœžœ
ž	œ
žœžœžœ˜PJšœ
žœ
ž	œ
žœ$˜IJ˜Jšžœ
žœžœ
žœ˜@šžœž˜Jš
œ4˜4šžœž˜ šžœ
˜šžœžœ
ž˜$Jš
œ=˜=—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœ
˜šžœžœ
ž˜$Jš
œ>˜>—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœ˜šžœžœ
žœ˜)Jš
œ6˜6š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ ˜ —Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ
˜—Jšžœ
˜—Jšœ˜—šŸœžœ
ž	œ)˜BJšœžœ˜$Jšœžœ˜"Jšœ
žœ
ž	œ
žœ
žœ
žœžœ
žœ˜GJšœžœ˜Jš	œžœ
ž	œ
žœžœ˜IJšœ%žœ
˜)J˜Jšžœ
žœžœ
žœ˜<šžœž˜Jš
œ0˜0šžœž˜šœ˜šžœžœ
žœ˜"Jš
œ4˜4Jš
œF˜FJš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šœ˜šžœžœ
ž˜Jš
œ#˜#—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šœžœž˜!šžœ˜šžœžœ
žœ˜"Jš
œ6˜6Jš
œ^˜^Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœ˜šžœžœ
žœ˜ Jš
œ6˜6Jš
œ5˜5Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—J˜šžœ˜Jš
œ˜J˜šžœžœ
žœ˜#Jš
œ0˜0Jšœžœ˜4Jš
œ\˜\Jš
œŠ
˜Š
J˜—Jš
œ˜Jš
œ˜—J˜Jšžœžœ
˜Jšžœžœ
˜Jšžœžœ
˜Jšžœžœ
˜J˜—Jšžœžœ
˜—Jšžœ
˜—Jšœ
˜—šŸœžœ
ž	œ˜5Jš
žœžœžœžœžœ˜IJš
žœžœžœžœžœ˜IJšœ	žœ
˜
Jšœ˜—šŸ
œž	œžœžœ˜BJš
žœžœ
žœ	žœ
žœ$˜FJš
œ˜Jš	œžœžœžœ	žœ˜>Jšœžœ˜šœžœžœž˜*Jš
œ˜Jš
œ
˜
Jš
œ˜Jšžœžœ
˜—šœžœžœž˜4Jš
œ
˜
Jš
œ˜Jš
œ˜Jšžœžœ
˜—Jšœ
˜—š
Ÿ	œž	œžœžœž
œ˜TJšœžœ˜%šžœ
žœ%žœ˜1Jšœžœ
žœG˜SJš
œ˜—Jš
œ˜šžœIž˜OJšžœ+˜0—Jš
œ˜—šŸœž	œžœ
žœ
žœ
žœžœ
žœ
˜RJšžœžœžœ
žœ˜C—šŸœž	œžœ
žœ
žœ
žœ
žœžœ
žœ
žœ
˜TJšžœžœžœ
žœ˜C—šŸœž	œžœ
žœ
žœ
žœ
žœžœ
ž	œ
˜[Jšžœžœžœ
žœ˜D—šŸœž	œžœžœ˜>Jšœžœ
žœžœ˜%Jšœžœ˜Jšœžœ˜Jš
œ
žœ
ž	œ
žœ
žœžœžœ˜NJ˜Jš
žœžœ
žœžœ
žœ
˜+Jšžœ ˜&Jš
œ˜—š
Ÿœž	œžœžœžœ˜AJšžœžœ	˜/—J˜Jšžœ
˜—š

™
Jš
œ'™'J™™)J™!J™J™'—J™™)J™R—J™™+J™C—J™™+J™—J™™*J™—J™™+J™-———…—N$ky