DIRECTORY
Basics,
IO,
PDInterpBasic,
PDFileFormat,
PDInterpBitmap,
PDInterpReader,
PDInterpSysCalls,
PrincOpsUtils USING [LongCopy],
UnsafeStorage USING [GetSystemUZone];

PDInterpReaderImpl: PROGRAM
IMPORTS Basics, IO, PDInterpBitmap, PDInterpSysCalls, PrincOpsUtils, UnsafeStorage
EXPORTS PDInterpReader
= BEGIN OPEN PDInterpReader;

bitsPerWord: NAT = Basics.bitsPerWord;
zone: UNCOUNTED ZONE = UnsafeStorage.GetSystemUZone[];

CheckHerald: PROC [herald: PDFileFormat.Herald] = {
status: PDInterpBasic.Status _ nil;
IF herald.maxLoadWord > 200000 THEN status _ unreasonableLoadSize;
IF NOT (herald.copies IN [1..1000]) THEN
status _ unreasonableNumberOfCopies;
IF NOT (herald.imageSSize IN [80..32767])
OR NOT (herald.imageFSize IN [80..32767]) THEN status _ unreasonableImageSize;
IF NOT (herald.bandSSize IN [8..32767]) THEN status _ unreasonableBandSSize;
IF NOT (herald.sResolution IN [10..10000])
OR NOT (herald.fResolution IN [10..10000]) THEN status _ unreasonableResolution;
IF herald.version # PDFileFormat.versionValue THEN status _ wrongFormatVersion;
IF herald.password # PDFileFormat.passwordValue THEN status _ invalidPassword;
IF status # nil THEN Error[NIL, status, 0, SIZE[PDFileFormat.Herald]];
};

AllocateSpace: PROC [handle: Handle] = {
private: Private _ handle.private;
bufferWords: INT _ (Basics.LongMult[handle.herald.bandSSize, (handle.herald.imageFSize+bitsPerWord-1)/bitsPerWord]+100)*2;
private.loadPointer _ PDInterpSysCalls.AllocateSpace[handle.herald.maxLoadWord+bufferWords];
private.loadWordsAllocated _ handle.herald.maxLoadWord;
private.bufferOriginPointer _ private.loadPointer + private.loadWordsAllocated;
private.bufferWordsAllocated _ bufferWords;
private.bufferWordCount _ 0;
};

Open: PUBLIC PROC [stream: IO.STREAM] RETURNS [handle: Handle] = {
bytesTransferred: INT;
herald: PDFileFormat.Herald;
heraldPtr: LONG POINTER = @herald;
bytesTransferred _ IO.UnsafeGetBlock[stream, [base: heraldPtr, startIndex: 0, count: Basics.bytesPerWord*SIZE[PDFileFormat.Herald]]];
IF bytesTransferred < Basics.bytesPerWord*SIZE[PDFileFormat.Herald] THEN Error[NIL, unexpectedEOF, 0, SIZE[PDFileFormat.Herald]];
CheckHerald[herald];
BEGIN
private: Private _ zone.NEW[PrivateRep];
handle _ zone.NEW[Rep _ [
stream: stream,
herald: herald,
image: [0, FALSE, FALSE, FALSE, black, 0, 0, 0, 0],
bandNumber: 0,
sMinBand: 0,
sSizeBand: 0,
colorType: none,
colorTileLoadAddress: -1,
priority: 0,
loadWords: 0,
private: private,
index: 0,
page: 0,
pass: 0,
status: nil,
warningCount: 0
]];
handle.index _ SIZE[PDFileFormat.Herald];
handle.sSizeBand _ herald.bandSSize;
{ENABLE
UNWIND => {
zone.FREE[@private];
zone.FREE[@handle];
};
AllocateSpace[handle];
};
END;
};

Close: PUBLIC PROC [handle: Handle] RETURNS [stream: IO.STREAM] = {
private: Private _ handle.private;
stream _ handle.stream;
IF private.loadPointer # NIL THEN PDInterpSysCalls.FreeSpace[private.loadPointer];
zone.FREE[@private];
zone.FREE[@handle];
};

ColorTileFromLoad: PUBLIC PROC [handle: Handle, colorTileLoadAddress: INT, scratchPointer: LONG POINTER, scratchWords: INT] RETURNS [PDInterpBitmap.Tile] = {
private: Private = handle.private;
tile: LONG POINTER TO PDFileFormat.Tile = private.loadPointer + colorTileLoadAddress;
words: INT = Basics.LongMult[tile.sSize, (tile.fSize+(bitsPerWord-1))/bitsPerWord];
bitmap: PDInterpBitmap.BitmapDesc_ PDInterpBitmap.Reshape[
tile + SIZE[PDFileFormat.Tile],
words,
[tile.sMin, tile.fMin, tile.sSize, tile.fSize]
];
RETURN [PDInterpBitmap.CreateTile[
rectangle: [tile.sMin, tile.fMin, tile.sSize, tile.fSize],
phase: tile.phase,
rasterPointer: tile + SIZE[PDFileFormat.Tile],
scratchPointer: scratchPointer,
scratchWords: scratchWords
]];
};

LongBlockTransfer: PROC [source: LONG POINTER, count: INT, dest: LONG POINTER] = {
WHILE count > LAST[CARDINAL] DO
PrincOpsUtils.LongCopy[source, LAST[CARDINAL], dest];
source _ source + LAST[CARDINAL];
dest _ dest + LAST[CARDINAL];
count _ count - LAST[CARDINAL];
ENDLOOP;
PrincOpsUtils.LongCopy[source, count, dest];
};

Private: TYPE = LONG POINTER TO PrivateRep;
PrivateRep: PUBLIC TYPE = RECORD [
loadPointer: LONG POINTER _ NIL,
loadWordsAllocated: INT _ 0,
bufferOriginPointer: LONG POINTER _ NIL,
bufferWordsAllocated: INT _ 0,
bufferWordCount: INT _ 0
];

BlockDescription: TYPE = RECORD [pointer: LONG POINTER, words: CARDINAL];
ReadLocate: PROC [handle: Handle, words: INT]
RETURNS [blockDescription: BlockDescription] = {
private: Private _ handle.private;
bytesWanted: CARDINAL _ Basics.bytesPerWord*MIN[words, private.bufferWordsAllocated];
bytesTransferred: CARDINAL;
bytesTransferred _ IO.UnsafeGetBlock[handle.stream, [base: private.bufferOriginPointer, startIndex: 0, count: bytesWanted]];
IF bytesTransferred < bytesWanted THEN {handle.status _ unexpectedEOF; Error[handle, unexpectedEOF, handle.index, words]};
blockDescription.pointer _ private.bufferOriginPointer;
blockDescription.words _ private.bufferWordCount _ bytesTransferred/Basics.bytesPerWord;
handle.index _ handle.index + blockDescription.words;
};

ReadBlock: PROC [handle: Handle, dest: LONG POINTER, words: INT] = {
bytesWanted: CARDINAL _ Basics.bytesPerWord*words;
bytesTransferred: CARDINAL;
bytesTransferred _ IO.UnsafeGetBlock[handle.stream, [base: dest, startIndex: 0, count: bytesWanted]];
IF bytesTransferred < bytesWanted THEN {handle.status _ unexpectedEOF; Error[handle, unexpectedEOF, handle.index, words]};
handle.index _ handle.index + bytesTransferred/Basics.bytesPerWord;
};

CheckBB: PROC [handle: Handle, sMin, fMin, sSize, fSize: CARDINAL, errorWordCount: INT] = {
IF LONG[sMin] + sSize > handle.herald.imageSSize
OR LONG[fMin] + fSize > handle.herald.imageFSize
OR fMin < handle.image.fMinPage
OR fMin + fSize > handle.image.fMinPage + handle.image.fSizePage
THEN RaisePDError[handle, objectOutOfBounds, errorWordCount];
IF sMin + sSize <= handle.sMinBand
OR sMin >= handle.sMinBand+handle.sSizeBand THEN {
RaisePDWarning[handle, objectOutOfBand, errorWordCount];
};
};

Get: PUBLIC PROC [handle: Handle] RETURNS [CommandBuffer] = {
private: Private _ handle.private;
command: PDFileFormat.Command;
BadLoadReference: PROC [dataWords: INT] = {
RaisePDError[handle, badLoadReference, SIZE[PDFileFormat.Command]+dataWords];
};
IF handle.priority = LAST[INT] THEN {
ans: CommandBuffer.stateChange;
ans.loadChangeStart _ ans.loadChangeLength _ 0;
handle.sMinBand _ handle.sMinBand + handle.sSizeBand;
handle.bandNumber _ handle.bandNumber + 1;
handle.priority _ 0;
handle.colorType _ ink;
ans.whatChanged _ bandChange;
IF handle.bandNumber = handle.image.nBands THEN {
ans.whatChanged _ imageEnd;
handle.colorType _ none;
handle.status _ betweenPages;
};
RETURN [ans];
};
ReadBlock[handle, @command, SIZE[PDFileFormat.Command]];
WITH command SELECT FROM
imagingCommand: PDFileFormat.Command.imaging => {
IF handle.colorType = none THEN {
RaisePDError[handle, missingStartImage, SIZE[PDFileFormat.Command]];
ERROR
};
SELECT imagingCommand.com FROM
maskSamplesRef => {
ans: CommandBuffer.maskSamples;
maskSamplesRef: PDFileFormat.MaskSamplesRef;
loadAddress: Basics.LongNumber;
samples: LONG POINTER TO PDFileFormat.SampleArray;
words: INT;
ReadBlock[handle, @maskSamplesRef, SIZE[PDFileFormat.MaskSamplesRef]];
loadAddress.highbits _ imagingCommand.addrHighBits;
loadAddress.lowbits _ maskSamplesRef.addrLowBits;
ans.loadAddress _ loadAddress.li;
IF ans.loadAddress < 0 OR ans.loadAddress + SIZE[PDFileFormat.SampleArray] > handle.loadWords THEN BadLoadReference[SIZE[PDFileFormat.MaskSamplesRef]];
samples _ private.loadPointer + loadAddress.li;
words _ Basics.LongMult[samples.sSize, (samples.fSize+(bitsPerWord-1))/bitsPerWord];
IF ans.loadAddress + SIZE[PDFileFormat.SampleArray] + words > handle.loadWords THEN BadLoadReference[SIZE[PDFileFormat.MaskSamplesRef]];
CheckBB[handle, maskSamplesRef.sMin, maskSamplesRef.fMin, samples.sSize, samples.fSize, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskSamplesRef]];
ans.samples _ [sOrigin: maskSamplesRef.sMin, fOrigin: maskSamplesRef.fMin, sMin: 0, fMin: 0, sSize: samples.sSize, fSize: samples.fSize, pointer: samples+SIZE[PDFileFormat.SampleArray], rast: (samples.fSize+(bitsPerWord-1))/bitsPerWord, lines: samples.sSize];
RETURN [ans]
};
maskRunGroupRef => {
ans: CommandBuffer.maskRunGroup;
maskRunGroupRef: PDFileFormat.MaskRunGroupRef;
loadAddress: Basics.LongNumber;
runGroup: LONG POINTER TO PDFileFormat.RunGroup;
run: LONG POINTER TO PDFileFormat.Run;
s: CARDINAL _ 0;
runCount: CARDINAL _ 0;
words: INT _ 0;
fSize: CARDINAL _ 0;
ReadBlock[handle, @maskRunGroupRef, SIZE[PDFileFormat.MaskRunGroupRef]];
loadAddress.highbits _ imagingCommand.addrHighBits;
loadAddress.lowbits _ maskRunGroupRef.addrLowBits;
ans.loadAddress _ loadAddress.li;
IF ans.loadAddress < 0 OR ans.loadAddress + SIZE[PDFileFormat.RunGroup] > handle.loadWords THEN BadLoadReference[SIZE[PDFileFormat.MaskRunGroupRef]];
runGroup _ private.loadPointer + loadAddress.li;
ans.pointer _ run _ private.loadPointer + loadAddress.li + SIZE[PDFileFormat.RunGroup];
WHILE s < runGroup.sSize DO
IF INT[run-private.loadPointer] >= handle.loadWords THEN BadLoadReference[SIZE[PDFileFormat.MaskRunGroupRef]];
IF LONG[run.fMin] + run.fSize > fSize THEN fSize _ LONG[run.fMin] + run.fSize;
IF run.lastRun THEN s _ s + 1;
run _ run + SIZE[PDFileFormat.Run];
ENDLOOP;
ans.runCount _ runCount;
CheckBB[handle, maskRunGroupRef.sMin, maskRunGroupRef.fMin, runGroup.sSize, fSize, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskRunGroupRef]];
ans.sMin _ maskRunGroupRef.sMin;
ans.fMin _ ans.fOffset _ maskRunGroupRef.fMin;
ans.sSize _ runGroup.sSize;
ans.fSize _ fSize;
RETURN [ans]
};
maskRectangle => {
ans: CommandBuffer.maskRectangle;
maskRectangle: PDFileFormat.MaskRectangle;
ReadBlock[handle, @maskRectangle, SIZE[PDFileFormat.MaskRectangle]];
CheckBB[handle, maskRectangle.sMin, maskRectangle.fMin, maskRectangle.sSize, maskRectangle.fSize, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskRectangle]];
ans.sMin _ maskRectangle.sMin;
ans.fMin _ maskRectangle.fMin;
ans.sSize _ maskRectangle.sSize;
ans.fSize _ maskRectangle.fSize;
RETURN [ans]
};
maskTrapezoid => {
ans: CommandBuffer.maskTrapezoid;
maskTrapezoid: PDFileFormat.MaskTrapezoid;
fMin, fMax: INT;
ReadBlock[handle, @maskTrapezoid, SIZE[PDFileFormat.MaskTrapezoid]];
fMin _ MIN[maskTrapezoid.fMin, maskTrapezoid.fMinLast];
fMax _ MAX[LONG[maskTrapezoid.fMin] + maskTrapezoid.fSize, LONG[maskTrapezoid.fMinLast] + maskTrapezoid.fSizeLast];
CheckBB[handle, maskTrapezoid.sMin, fMin, maskTrapezoid.sSize, fMax-fMin, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskTrapezoid]];
ans.sMin _ maskTrapezoid.sMin;
ans.fMin _ maskTrapezoid.fMin;
ans.fMinLast _ maskTrapezoid.fMinLast;
ans.sSize _ maskTrapezoid.sSize;
ans.fSize _ maskTrapezoid.fSize;
ans.fSizeLast _ maskTrapezoid.fSizeLast;
RETURN [ans]
};
maskRunGroup => {
ans: CommandBuffer.maskRunGroup;
maskRunGroup: PDFileFormat.MaskRunGroup;
runGroup: PDFileFormat.RunGroup;
s: CARDINAL _ 0;
runCount: INT _ 0;
words: INT _ 0;
fMin: CARDINAL _ LAST[CARDINAL];
fMax: CARDINAL _ FIRST[CARDINAL];
run: LONG POINTER TO PDFileFormat.Run;
ReadBlock[handle, @maskRunGroup, SIZE[PDFileFormat.MaskRunGroup]];
ReadBlock[handle, @runGroup, SIZE[PDFileFormat.RunGroup]];
run _ private.bufferOriginPointer;
private.bufferWordCount _ 0;
WHILE s < runGroup.sSize DO
IF runCount*SIZE[PDFileFormat.Run] >= private.bufferWordCount THEN {
words: CARDINAL _ (runGroup.sSize-s)*SIZE[PDFileFormat.Run];
IF words + private.bufferWordCount > private.bufferWordsAllocated THEN RaisePDError[handle, runGroupTooLong, private.bufferWordCount];
ReadBlock[handle, run, words];
private.bufferWordCount _ private.bufferWordCount + words;
};
IF run.fMin < fMin THEN fMin _ run.fMin;
IF LONG[run.fMin] + run.fSize > fMax THEN fMax _ LONG[run.fMin] + run.fSize;
IF run.lastRun THEN s _ s + 1;
runCount _ runCount + 1;
run _ run + SIZE[PDFileFormat.Run];
ENDLOOP;
IF runCount*SIZE[PDFileFormat.Run] # private.bufferWordCount THEN ERROR;
ans.runCount _ runCount;
ans.loadAddress _ -1;
IF runCount = 0 THEN {
ans.pointer _ NIL;
RaisePDWarning[handle, emptyRunGroup, SIZE[PDFileFormat.MaskRunGroup]+SIZE[PDFileFormat.RunGroup]];
fMin _ fMax;
}
ELSE {
ans.pointer _ private.bufferOriginPointer;
CheckBB[handle, maskRunGroup.sMin, fMin, runGroup.sSize, fMax-fMin, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskRunGroup]+private.bufferWordCount]
};
ans.sMin _ maskRunGroup.sMin;
ans.fMin _ fMin;
ans.fOffset _ 0;
ans.sSize _ runGroup.sSize;
ans.fSize _ fMax;
RETURN [ans];
};
maskSamples => {
ans: CommandBuffer.maskSamples;
maskSamples: PDFileFormat.MaskSamples;
samples: PDFileFormat.SampleArray;
ReadBlock[handle, @maskSamples, SIZE[PDFileFormat.MaskSamples]];
ReadBlock[handle, @samples, SIZE[PDFileFormat.SampleArray]];
CheckBB[handle, maskSamples.sMin, maskSamples.fMin, samples.sSize, samples.fSize, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskSamples]+SIZE[PDFileFormat.SampleArray]];
ans.loadAddress _ -1;
{raster: BlockDescription
_ ReadLocate[
handle,
Basics.LongMult[samples.sSize, (samples.fSize+(bitsPerWord-1))/bitsPerWord]
];
ans.samples _ PDInterpBitmap.Reshape[
raster.pointer,
raster.words,
[maskSamples.sMin, maskSamples.fMin, samples.sSize, samples.fSize]
! PDInterpBitmap.InsufficientSpace => {
RaisePDError[handle, bitmapTooBig, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskSamples]+SIZE[PDFileFormat.SampleArray]];
ERROR
}
];
};
RETURN [ans];
};
colorSamples => {
ans: CommandBuffer.colorSamples;
colorSamples: PDFileFormat.ColorSamples;
samples: PDFileFormat.SampleArray;
ReadBlock[handle, @colorSamples, SIZE[PDFileFormat.ColorSamples]];
ReadBlock[handle, @samples, SIZE[PDFileFormat.SampleArray]];
CheckBB[handle, colorSamples.sMin, colorSamples.fMin, samples.sSize, samples.fSize, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.ColorSamples]+SIZE[PDFileFormat.SampleArray]];
{raster: BlockDescription
_ ReadLocate[
handle,
Basics.LongMult[samples.sSize, (samples.fSize+(bitsPerWord-1))/bitsPerWord]
];
ans.samples _ PDInterpBitmap.Reshape[
raster.pointer,
raster.words,
[colorSamples.sMin, colorSamples.fMin, samples.sSize, samples.fSize]
! PDInterpBitmap.InsufficientSpace => {
RaisePDError[handle, bitmapTooBig, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.MaskSamples]+SIZE[PDFileFormat.SampleArray]];
ERROR
}
];
};
RETURN [ans];
};
ENDCASE => {
RaisePDError[handle, unrecognisedImagingCommand, SIZE[PDFileFormat.Command]]; ERROR};
};
controlCommand: PDFileFormat.Command.control => {
ans: CommandBuffer.stateChange;
ans.loadChangeStart _ ans.loadChangeLength _ 0;
IF handle.colorType = none THEN SELECT controlCommand.com FROM
startImage, deviceCommand, storeLoad, endDocument => NULL;
ENDCASE => {
RaisePDError[handle, missingStartImage, SIZE[PDFileFormat.Command]];
ERROR
};
SELECT controlCommand.com FROM
startImage => {
startImage: PDFileFormat.StartImage;
ReadBlock[handle, @startImage, SIZE[PDFileFormat.StartImage]];
IF startImage.filler # 0 THEN {
RaisePDWarning[handle, nonZeroFill, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.StartImage]];
};
IF (LONG[startImage.passBands]+startImage.nBands)*handle.sSizeBand >= handle.herald.imageSSize+handle.sSizeBand
OR LONG[startImage.fMinPage]+startImage.fSizePage > handle.herald.imageFSize THEN {
RaisePDWarning[handle, imageBoundsExceedPageBounds, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.StartImage]];
};
IF handle.colorType # none AND handle.bandNumber < handle.image.nBands THEN
RaisePDWarning[handle, tooFewBands, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.StartImage]];
handle.image _ startImage;
ans.whatChanged _ imageStart;
handle.priority _ 0;
handle.colorType _ ink;
handle.bandNumber _ 0;
handle.sMinBand _ startImage.passBands*handle.sSizeBand;
IF NOT startImage.strip THEN {handle.pass _ handle.pass + 1};
IF startImage.feed THEN {handle.page _ handle.page + 1; handle.pass _ 1};
handle.status _ constructingImage;
RETURN [ans]
};
setPriority => {
priorityLow: PDFileFormat.Priority;
priority: Basics.LongNumber;
ReadBlock[handle, @priorityLow, SIZE[PDFileFormat.Priority]];
priority.highbits _ controlCommand.rest;
priority.lowbits _ priorityLow;
handle.priority _ priority.li;
ans.whatChanged _ priorityChange;
RETURN [ans]
};
setColorInk => {
handle.colorType _ ink;
ans.whatChanged _ colorChange;
RETURN [ans]
};
setColorClear => {
handle.colorType _ clear;
ans.whatChanged _ colorChange;
RETURN [ans]
};
setColorTile => {
setColorTile: PDFileFormat.SetColorTile;
ReadBlock[handle, @setColorTile, SIZE[PDFileFormat.SetColorTile]];
handle.colorTileLoadAddress _ setColorTile.addr;
SELECT controlCommand.rest FROM
0 => handle.colorType _ opaqueTile;
1 => handle.colorType _ transparentTile;
ENDCASE => {
handle.colorType _ opaqueTile;
RaisePDWarning[handle, unknownColorTileFlag, SIZE[PDFileFormat.Command]];
};
ans.whatChanged _ colorChange;
RETURN [ans];
};
endBand => {
handle.priority _ LAST[INT];
ans.whatChanged _ priorityChange;
RETURN [ans];
};
endDocument => {
ans.whatChanged _ documentEnd;
handle.status _ transmissionComplete;
RETURN [ans];
};
storeLoad => {
storeLoad: PDFileFormat.StoreLoad;
loadWordsAllocated: LONG CARDINAL _ private.loadWordsAllocated;
ReadBlock[handle, @storeLoad, SIZE[PDFileFormat.StoreLoad]];
IF storeLoad.firstAddress > loadWordsAllocated
OR storeLoad.firstAddress + storeLoad.wordCount > loadWordsAllocated
OR storeLoad.firstAddress + storeLoad.wordCount > handle.herald.maxLoadWord THEN
{RaisePDError[handle, loadOutOfBounds, SIZE[PDFileFormat.Command]+SIZE[PDFileFormat.StoreLoad]]; ERROR};
ReadBlock[handle, private.loadPointer+storeLoad.firstAddress, storeLoad.wordCount];
ans.whatChanged _ loadChange;
ans.loadChangeStart _ storeLoad.firstAddress;
ans.loadChangeLength _ storeLoad.wordCount;
handle.loadWords _ MAX[handle.loadWords, ans.loadChangeStart + ans.loadChangeLength];
handle.colorTileLoadAddress _ -1;
RETURN [ans];
};
deviceCommand => {
deviceCommand: CommandBuffer.deviceCommand;
wordCount: CARDINAL;
block: BlockDescription;
ReadBlock[handle, @wordCount, SIZE[CARDINAL]];
block _ ReadLocate[handle, wordCount];
IF block.words < wordCount THEN RaisePDError[handle, unexpectedEOF, block.words+SIZE[CARDINAL]];
deviceCommand.deviceCommandPointer _ block.pointer;
deviceCommand.deviceCommandWords _ block.words;
RETURN [deviceCommand];
};
ENDCASE => {RaisePDError[handle, unrecognisedControlCommand, SIZE[PDFileFormat.Command]]; ERROR};
};
ENDCASE => {RaisePDError[handle, unrecognisedCommandType, SIZE[PDFileFormat.Command]]; ERROR};
};

Error: PUBLIC ERROR [handle: Handle, code: PDInterpBasic.PDErrorCode, wordIndex, wordCount: INT] = CODE;

Warning: PUBLIC SIGNAL [handle: Handle, code: PDInterpBasic.PDWarningCode, wordIndex, wordCount: INT] = CODE;

RaisePDError: PROC [handle: Handle, code: PDInterpBasic.PDErrorCode, words: INT] = {
handle.status _ code;
ERROR Error[handle, code, handle.index-words, words];
};

RaisePDWarning: PROC [handle: Handle, code: PDInterpBasic.PDWarningCode, words: INT] = {
handle.warningCount _ handle.warningCount + 1;
handle.status _ code;
SIGNAL Warning[handle, code, handle.index-words, words];
};

END.

βPDInterpReaderImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Michael Plass, December 2, 1983 5:11 pm
Last Edited by: Pier, November 22, 1983 2:45 pm
Last Edited by: Lamming, December 9, 1983 1:27 pm
Tim Diebert: September 19, 1985 3:13:28 pm PDT
PDInterpSysCalls.SetDisplayLights[107];
PDInterpSysCalls.SetDisplayLights[109];
The buffer storage may get re-used with the next ReadLocate or ReadBlock;
Read a chunk, assuming one run group per scan line.
ΚQ˜
codeš
œ™Kšœ
Οm
œ1™<K™'K™/K™1K™.—K˜š
Οk	˜	Kš
œ˜Kšžœ
˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ˜Kšœžœ˜%—K˜šΟnœž˜Kšžœ	žœ@˜RKšžœ˜Kšœžœ
žœ˜—˜Kšœ
žœ˜&šœž	œ
žœ"˜6K˜—šŸœžœ"˜3Kš
œ#˜#Kšžœžœ˜Bšžœ
žœžœž˜(Kš
œ$˜$—Kšžœ
žœžœ
˜)Kšžœ
žœžœžœ ˜NKšžœ
žœžœ
žœ ˜LKšžœ
žœžœ
˜*Kšžœ
žœžœžœ!˜PKšžœ,žœ˜OKšžœ.žœ˜NKšžœžœžœ
žœ˜FKš
œ˜K˜—šŸ
œžœ˜(Kš
œ"˜"Kšœ
žœj˜zKš
œ\˜\Kš
œ7˜7Kš
œO˜OKš
œ+˜+Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœ
žœ
žœžœ˜BKšœžœ
˜Kš
œ˜Kšœžœ
žœ˜"KšœžœTžœ˜…
Kš
žœ(žœžœžœžœ˜
Kš
œ˜š
ž˜Kšœžœ
˜(šœžœ˜Kš
œ˜Kš
œ˜Kšœžœžœžœ˜3Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ˜—Kšœžœ˜)Kš
œ$˜$šœ
ž˜šžœ˜Kšœžœ˜Kšœžœ
˜Kš
œ˜—Kš
œ˜K˜—Kšžœ
˜—Kš
œ'™'K˜K˜—šŸœžœ
žœžœ
žœ
žœ˜CKš
œ"˜"Kš
œ˜Kšžœžœ
žœ1˜RKšœžœ˜Kšœžœ
˜Kš
œ'™'Kš
œ˜K˜—šŸœžœ
žœ(žœžœ
žœžœžœ˜
Kš
œ"˜"Kšœžœ
žœ
žœ@˜UKšœžœI˜Sš
œ:˜:Kšœžœ˜Kš
œ˜Kš
œ.˜.K˜—šžœ˜"Kš
œ:˜:Kš
œ˜Kšœžœ˜.Kš
œ˜Kš
œ˜Kš
œ˜—K˜K˜—šŸœžœ
žœ
žœ	žœžœ
žœ˜Ršžœ	žœ
žœž˜Kšœžœ
žœ	˜5Kšœžœ
žœ˜!Kšœžœ
žœ˜Kšœžœ
žœ˜Kšžœ
˜—Kš
œ,˜,Kš
œ˜K˜—Kš	œ	žœžœ
žœ
žœ˜+šœžœ
žœžœ˜"Kšœ
žœ
ž
œ
˜ Kšœžœ˜Kšœžœ
ž
œ
˜(Kšœžœ˜Kšœžœ˜Kš
œ˜K˜—Kšœžœžœžœ
žœ	žœ˜IšŸ
œžœžœ
˜-Kšžœ)˜0Kš
œI™IKš
œ"˜"Kšœ
žœžœ&˜UKšœžœ
˜Kš
œ|˜|Kšžœ žœT˜zKš
œ7˜7Kš
œX˜XKš
œ5˜5Kš
œ˜K˜—šŸ	œžœžœ	žœ˜DKšœ
žœ˜2Kšœžœ
˜KšœžœP˜eKšžœ žœT˜zKš
œC˜CKš
œ˜K˜—šŸœžœ,žœžœ˜[Kšžœ
žœ)˜0Kšžœ
žœ)˜0Kšžœ˜Kšžœ>˜@Kšžœ9˜=Kšžœ ˜"šžœ*žœ˜2Kš
œ8˜8Kš
œ˜—Kš
œ˜K˜—šŸœžœ
žœžœ˜=Kš
œ"˜"Kš
œ˜šŸœžœ
žœ˜+Kšœ'žœ"˜MKš
œ˜—šžœžœ
žœžœ˜%Kš
œ˜Kš
œ/˜/Kš
œ5˜5Kš
œ*˜*Kš
œ˜Kš
œ˜Kš
œ˜šžœ)žœ˜1Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšžœ˜
Kš
œ˜—Kšœžœ˜8šžœ	žœ
ž˜šŸœ#˜1šžœžœ˜!Kšœ(žœ˜DKš
ž˜Kš
œ˜—šžœž˜šŸœ˜Kš
œ˜Kš
œ,˜,K˜Kšœ	žœ
žœ
žœ˜2Kšœžœ
˜Kšœ#žœ˜FKš
œ3˜3Kš
œ1˜1Kš
œ!˜!Kš
žœžœžœ.žœžœ˜—
Kš
œ/˜/Kš
œT˜TKšžœžœ6žœžœ˜ˆ
KšœXžœžœ˜–
Kšœš
žœe˜ƒKšžœ˜Kš
œ˜—šŸœ˜Kš
œ ˜ Kš
œ.˜.K˜Kšœ
žœ
žœ
žœ˜0Kšœžœ
žœ
žœ˜&Kšœžœ˜Kšœ
žœ˜Kšœžœ˜Kšœžœ˜Kšœ$žœ ˜HKš
œ3˜3Kš
œ2˜2Kš
œ!˜!Kš
žœžœžœ+žœžœ ˜•
Kš
œ0˜0Kšœ;žœ˜Wšžœž˜Kšžœ
žœ.žœžœ ˜nKšžœ
žœžœ	žœ˜NKšžœ
žœ˜Kšœžœ˜#Kšžœ
˜—Kš
œ˜KšœSžœžœ ˜’
Kš
œ ˜ Kš
œ.˜.Kš
œ˜Kš
œ˜Kšžœ˜Kš
œ˜—šŸ
œ˜Kš
œ!˜!Kš
œ*˜*Kšœ"žœ˜DKšœbžœžœ˜Ÿ
Kš
œ˜Kš
œ˜Kš
œ ˜ Kš
œ ˜ Kšžœ˜Kš
œ˜—šŸ
œ˜Kš
œ!˜!Kš
œ*˜*Kšœžœ
˜Kšœ"žœ˜DKšœžœ-˜7Kšœžœ
žœ,žœ4˜sKšœJžœžœ˜‡
Kš
œ˜Kš
œ˜Kš
œ&˜&Kš
œ ˜ Kš
œ ˜ Kš
œ(˜(Kšžœ˜Kš
œ˜—šŸœ˜Kšœž
œ
˜ Kš
œ(˜(Kš
œ ˜ Kšœžœ˜Kšœ
žœ˜Kšœžœ˜Kšœžœžœ
žœ˜ Kšœžœžœ
žœ˜!Kšœžœ
žœ
žœ˜&Kšœ!žœ˜BKšœžœ˜:Kš
œ"˜"Kš
œ˜šžœž˜šžœ
žœ.žœ˜DK™3Kšœžœžœ˜<Kšžœ@žœ@˜†
Kš
œ˜Kš
œ:˜:Kš
œ˜—Kšžœžœ˜(Kšžœ
žœžœžœ˜LKšžœ
žœ˜Kš
œ˜Kšœžœ˜#Kšžœ
˜—Kšžœ
žœ-žœ
žœ
˜HKš
œ˜Kš
œ˜šžœžœ˜Kšœžœ
˜Kšœ&žœžœ˜cKš
œ˜Kš
œ
˜
—šžœ˜Kš
œ*˜*KšœDžœžœ4˜—
Kš
œ˜—Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ˜Kšžœ˜
Kš
œ˜—šŸœ˜Kš
œ˜Kš
œ&˜&Kš
œ"˜"Kšœ žœ˜@Kšœžœ˜<KšœRžœžœžœ˜¬
Kš
œ˜š
œ˜š
œ
˜
Kš
œ˜Kš
œK˜KKš
œ˜—š
œ%˜%Kš
œ˜Kš
œ
˜
Kš
œB˜Bš
œ'˜'Kšœ#žœžœžœ˜}Kš
ž˜Kš
œ
˜
—Kš
œ˜—K˜—Kšžœ˜
Kš
œ˜—šŸœ˜Kš
œ ˜ Kš
œ(˜(Kš
œ"˜"Kšœ!žœ˜BKšœžœ˜<KšœTžœžœžœ˜―
š
œ˜š
œ
˜
Kš
œ˜Kš
œK˜KKš
œ˜—š
œ%˜%Kš
œ˜Kš
œ
˜
Kš
œD˜Dš
œ'˜'Kšœ#žœžœžœ˜}Kš
ž˜Kš
œ
˜
—Kš
œ˜—K˜—Kšžœ˜
Kš
œ˜—šžœ˜Kšœ1žœžœ˜U——Kš
œ˜—šŸœ#˜1Kš
œ˜Kš
œ/˜/šžœžœž˜>Kšœ5žœ
˜:šžœ˜Kšœ(žœ˜DKš
ž˜Kš
œ˜——šžœž˜šŸ
œ˜Kš
œ$˜$Kšœžœ˜>šžœžœ˜Kšœ$žœžœ˜^Kš
œ˜—Kšžœžœg˜ošžœ
žœFžœ˜SKšœ4žœžœ˜nKš
œ˜—šžœžœ)ž˜KKšœ$žœžœ˜^—Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ8˜8Kšžœ
žœžœ!˜=Kšžœžœ2˜IK˜"Kšžœ˜Kš
œ˜—šŸœ˜Kš
œ#˜#Kš
œ˜Kšœ žœ˜=Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ!˜!Kšžœ˜Kš
œ˜—šŸœ˜K˜Kš
œ˜Kšžœ˜Kš
œ˜—šŸ
œ˜K˜Kš
œ˜Kšžœ˜Kš
œ˜—šŸœ˜Kš
œ(˜(Kšœ!žœ˜BKš
œ0˜0šžœž˜K˜#Kš
œ(˜(šžœ˜K˜Kšœ-žœ˜IKš
œ˜——Kš
œ˜Kšžœ˜
Kš
œ˜—šŸœ˜Kšœžœ
žœ˜Kš
œ!˜!Kšžœ˜
Kš
œ˜—šŸœ˜Kš
œ˜K˜%Kšžœ˜
Kš
œ˜—šŸ	œ˜Kš
œ"˜"Kšœžœ
žœ˜?Kšœžœ˜<Kšžœ,˜.KšžœB˜DšžœJž˜PKšœ'žœžœžœ˜h—Kš
œS˜SKš
œ˜Kš
œ-˜-Kš
œ+˜+Kšœžœ?˜UKš
œ!˜!Kšžœ˜
Kš
œ˜—šŸ
œ˜Kš
œ+˜+Kšœžœ
˜Kš
œ˜Kšœžœ
žœ˜.Kš
œ&˜&Kšžœžœ1žœ
žœ˜`Kš
œ3˜3Kš
œ/˜/Kšžœ˜Kš
œ˜—Kšžœ6žœžœ˜a—Kš
œ˜—Kšžœ3žœžœ˜^—Kš
œ˜K˜—š
Ÿœžœ
žœIžœžœ
˜hK˜—š
Ÿœžœ
žœKžœžœ
˜mK˜—šŸœžœ:žœ˜TKš
œ˜Kšžœ0˜5Kš
œ˜K˜—šŸœžœ<žœ˜XKš
œ.˜.Kš
œ˜Kšžœ2˜8Kš
œ˜K˜—Kšžœ
˜——…—J2_e