DIRECTORY
FS,
Imager USING [Context, DoSave, DoSaveAll, ShowText],
ImagerFont USING [MapText, XStringProc],
Interpress,
IO,
IPInterpreter,
IPMaster USING [Block, Body, BodyRep, BYTE, GetHeader, GetSkeleton, GetToken, IntFromSequenceData, Node, NodeRep, RealFromSequenceData, SequenceType, Skeleton, SkipBytes, SkipToEndOfBody, Token],
RefText USING [ReserveChars],
RopeFile,
Rope;

IPExecImpl: CEDAR PROGRAM
IMPORTS FS, IO, Imager, ImagerFont, IPInterpreter, IPMaster, RefText, Rope, RopeFile
EXPORTS Interpress, IPInterpreter
~ BEGIN OPEN IPInterpreter, IPMaster;

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;

Token: TYPE ~ IPMaster.Token;
Body: TYPE ~ IPMaster.Body;
Block: TYPE ~ IPMaster.Block;
Node: TYPE ~ IPMaster.Node;
NodeRep: TYPE ~ IPMaster.NodeRep;
BYTE: TYPE ~ IPMaster.BYTE;

MarkRecovery: PUBLIC ERROR ~ CODE;
Bug: PUBLIC ERROR ~ CODE;

contextFreeCountMax: INT _ 8;

AllocContext: PROC [self: Ref] RETURNS [context: Context] ~ {
IF self.contextFreeCount>0 THEN {
context _ self.contextFree;
self.contextFree _ context.caller;
self.contextFreeCount _ self.contextFreeCount-1;
}
ELSE context _ NEW [ContextRep];
};

FreeContext: PROC [self: Ref, context: Context] ~ {
IF self.contextFreeCount<contextFreeCountMax THEN {
context.caller _ self.contextFree;
context.initialFrame _ NIL;
context.frame _ NIL;
context.env _ NIL;
self.contextFree _ context;
self.contextFreeCount _ self.contextFreeCount+1;
};
};

Call: PUBLIC PROC[self: Ref, action: PROC, frame: Vector, env: Vector] ~ {
context: Context ~ AllocContext[self];
context^ _ [caller: self.context, marker: self.lastMarker+1, 
token: [], initialFrame: frame, frame: NIL, env: env];
self.lastMarker _ context.marker;
self.context _ context;
action[! UNWIND => { self.context _ context.caller; FreeContext[self, context] }];
IF self.context=context THEN { self.context _ context.caller; FreeContext[self, context] }
ELSE ERROR Bug;
};


Frame: PUBLIC PROC[self: Ref] RETURNS[Vector] ~ {
context: Context ~ self.context;
IF context.frame=NIL THEN RETURN[context.initialFrame]
ELSE RETURN[VectorFromArray[context.frame]];
};

FGet: PUBLIC PROC[self: Ref, i: Cardinal] RETURNS[Any] ~ {
context: Context ~ self.context;
IF context.frame=NIL THEN RETURN[Get[context.initialFrame, i]]
ELSE { array: Array ~ context.frame; RETURN[array[i-array.lowerBound]] };
};

FSet: PUBLIC PROC[self: Ref, x: Any, i: Cardinal] ~ {
context: Context ~ self.context;
IF context.frame=NIL THEN context.frame _ ArrayFromVector[context.initialFrame];
{ array: Array ~ context.frame; array[i-array.lowerBound] _ x };
};

Env: PUBLIC PROC[self: Ref] RETURNS[Vector] ~ {
context: Context ~ self.context;
RETURN[context.env];
};


DoSave: PUBLIC PROC[self: Ref, action: PROC] ~ {
Imager.DoSave[self.imager, action];
};

DoSaveAll: PUBLIC PROC[self: Ref, action: PROC] ~ {
Imager.DoSaveAll[self.imager, action];
};


Run: TYPE ~ RECORD[start, len: INT];
RunList: TYPE ~ LIST OF Run;
DoString: PROC [self: Ref, text: REF TEXT] ~ {
string: ImagerFont.XStringProc ~ { ImagerFont.MapText[text: text, charAction: charAction] };
PushVector[self, VectorFromString[string]];
};

DoIdentifier: PROC [self: Ref, text: REF TEXT] ~ {
len: NAT ~ text.length;
warn: BOOL _ FALSE;
FOR i: NAT IN[0..len) DO
char: CHAR ~ text[i];
SELECT char FROM
IN['a..'z], IN['A..'Z] => NULL;
IN['0..'9], '- => IF i=0 THEN warn _ TRUE;
ENDCASE => warn _ TRUE;
ENDLOOP;
IF len=0 THEN warn _ TRUE;
PushIdentifier[self, Rope.FromRefText[text]];
IF warn THEN MasterWarning[$invalidEncoding, "Invalid Identifier"];
};

DoCardinal: PROC [self: Ref, text: REF TEXT] ~ {
len: NAT ~ text.length;
IF len<=4 THEN {
val: INT ~ IPMaster.IntFromSequenceData[text];
PushNum[self, [int[val]]];
}
ELSE {
val: REAL ~ IPMaster.RealFromSequenceData[text];
PushNum[self, [real[val]]];
};
};

DoRational: PROC [self: Ref, text: REF TEXT] ~ {
len: NAT ~ text.length;
half: NAT ~ len/2;
IF half<=4 THEN {
n: INT ~ IPMaster.IntFromSequenceData[text: text, start: 0, len: half];
d: INT ~ IPMaster.IntFromSequenceData[text: text, start: half, len: half];
IF n IN INTEGER AND d IN INTEGER THEN PushNum[self, [rational[n: n, d: d]]]
ELSE PushNum[self, [real[REAL[n]/REAL[d]]]];
}
ELSE {
n: REAL ~ IPMaster.RealFromSequenceData[text: text, start: 0, len: half];
d: REAL ~ IPMaster.RealFromSequenceData[text: text, start: half, len: half];
PushNum[self, [real[n/d]]];
};
IF (half+half)#len THEN MasterWarning[$invalidEncoding, 
IO.PutFR1["Invalid sequenceRational (length=%g)", IO.int[len]]];
};

DoInsertFile: PROC [self: Ref, text: REF TEXT] ~ {
MasterWarning[$unimplemented, "Not implemented: sequenceInsertFile"];
};

Fetch16: PROC [rope: ROPE, startByte: INT] RETURNS [CARDINAL] ~ {
b0: CARDINAL ~ Rope.Fetch[rope, startByte]-'\000;
b1: CARDINAL ~ Rope.Fetch[rope, startByte+1]-'\000;
RETURN [b0*256+b1];
};

OpenFileFromStream: PROC [stream: IO.STREAM] RETURNS [FS.OpenFile] ~ {
openFile: FS.OpenFile _ FS.nullOpenFile;
name: ROPE _ NIL;
ok: BOOL _ TRUE;
openFile _ FS.OpenFileFromStream[stream ! FS.Error, IO.Error => {ok _ FALSE; CONTINUE}];
name _ FS.GetName[openFile ! FS.Error => {ok _ FALSE; CONTINUE}].fullFName;
IF ok THEN openFile _ FS.Open[
name: name,
wantedCreatedTime: FS.GetInfo[openFile].created,
remoteCheck: FALSE
! FS.Error => {ok _ FALSE; CONTINUE}
];
RETURN [IF ok THEN openFile ELSE FS.nullOpenFile]
};

smallish: INT _ 30000;
maxChunkSize: INT ~ LAST[NAT]-SIZE[TEXT[0]]*2-4;
maxRopeStreams: NAT ~ 4;
nRopeStreams: NAT _ 3;
ropeBuffers: NAT _ 1;
pagesPerFileBuffer: NAT _ 10;
numberOfFilebuffers: NAT _ 2;
ropeFileStreamOptions: FS.StreamOptions ~ [
tiogaRead: FALSE,
commitAndReopenTransOnFlush: FALSE,
truncatePagesOnClose: FALSE,
finishTransOnClose: FALSE,
closeFSOpenFileOnClose: FALSE
];
RopeFromRuns: PROC [stream: IO.STREAM, runs: LIST OF Run, sequenceLength: INT] RETURNS [rope: ROPE _ NIL] ~ {
size: INT _ 0;
openFile: FS.OpenFile ~ IF sequenceLength > smallish THEN OpenFileFromStream[stream] ELSE FS.nullOpenFile;
IF openFile # FS.nullOpenFile THEN {
ropes: ARRAY [0..maxRopeStreams) OF ROPE _ ALL[NIL];
FOR i: NAT IN [0..nRopeStreams) DO
ropeFile: ROPE ~ RopeFile.FromStream[stream: FS.StreamFromOpenFile[openFile: openFile, streamOptions: ropeFileStreamOptions, streamBufferParms: [vmPagesPerBuffer: pagesPerFileBuffer, nBuffers: numberOfFilebuffers]], buffers: ropeBuffers];
t: ROPE _ NIL;
size _ 0;
FOR r: LIST OF Run _ runs, r.rest UNTIL r = NIL DO
run: Run ~ r.first;
t _ Rope.Concat[t, Rope.Substr[ropeFile, run.start, run.len]];
size _ size + run.len;
ENDLOOP;
ropes[i] _ t;
ENDLOOP;
FOR i: NAT IN [0..nRopeStreams) DO
start: INT ~ size*i/nRopeStreams;
end: INT ~ size*(i+1)/nRopeStreams;
rope _ Rope.Concat[rope, Rope.Substr[ropes[i], start, end-start]];
ENDLOOP;
}
ELSE {
saveIndex: INT ~ IO.GetIndex[stream];
FOR r: LIST OF Run _ runs, r.rest UNTIL r = NIL DO
run: Run _ r.first;
UNTIL run.len = 0 DO
chunkSize: NAT ~ MIN[run.len, maxChunkSize];
text: Rope.Text ~ Rope.NewText[chunkSize];
zero: [0..0];
IO.SetIndex[stream, run.start];
TRUSTED {zero _ IO.GetBlock[stream, LOOPHOLE[text], 0, chunkSize]-chunkSize};
rope _ Rope.Concat[rope, text];
size _ size + chunkSize;
run.start _ run.start + chunkSize;
run.len _ run.len - chunkSize;
ENDLOOP;
ENDLOOP;
IO.SetIndex[stream, saveIndex];
};
IF Rope.Size[rope] # sequenceLength THEN ERROR;
IF size # sequenceLength THEN ERROR;
};

ExecuteToEndOfBody: PROC [self: Ref] ~ {
stream: STREAM ~ self.stream;
sequenceData: {nil, text, runs, skip} _ nil;
sequenceType: SequenceType _ nil;
sequenceLength: INT _ 0;
sequenceRuns: INT _ 0;
text: REF TEXT _ NIL;
buffer: REF TEXT ~ self.buffer;
runsHead, runsTail: LIST OF Run _ NIL;
BeginSequence: PROC [seq: SequenceType] ~ {
SELECT sequenceType _ seq FROM
sequenceString, sequenceIdentifier, sequenceInsertFile, sequenceComment, 
sequenceInteger, sequenceRational => sequenceData _ text;
sequenceLargeVector, sequencePackedPixelVector, sequenceCompressedPixelVector, sequenceAdaptivePixelVector => sequenceData _ runs;
ENDCASE => sequenceData _ skip;
SELECT sequenceData FROM
text => { text _ buffer; text.length _ 0 };
runs => { runsHead _ runsTail _ NIL };
ENDCASE;
sequenceLength _ 0;
};
ExtendSequence: PROC [length: INT] ~ {
SELECT sequenceData FROM
nil => {
MasterWarning[$invalidEncoding, "Misplaced sequenceContinued"];
SkipBytes[stream, length];
};
text => {
len: NAT ~ length;
nBytesRead: NAT _ 0;
IF (text.maxLength-text.length)<len THEN text _ RefText.ReserveChars[text, len];
nBytesRead _ IO.GetBlock[self: stream, block: text, startIndex: text.length, count: len];
IF nBytesRead#len THEN ERROR IO.EndOfStream[stream];
};
runs => {
prevTail: LIST OF Run ~ runsTail;
runsTail _ LIST[[start: IO.GetIndex[stream], len: length]];
IF prevTail=NIL THEN runsHead _ runsTail ELSE prevTail.rest _ runsTail;
SkipBytes[stream, length];
};
skip => SkipBytes[stream, length];
ENDCASE => ERROR;
sequenceRuns _ sequenceRuns+1;
sequenceLength _ sequenceLength+length;
};
FinishSequence: PROC ~ {
SELECT sequenceType FROM
sequenceString => DoString[self, text];
sequenceIdentifier => DoIdentifier[self, text];
sequenceInteger => DoCardinal[self, text];
sequenceRational => DoRational[self, text];
sequenceInsertFile => DoInsertFile[self, text];
sequenceComment => NULL;
sequenceLargeVector => {
rope: ROPE ~ RopeFromRuns[self.stream, runsHead, sequenceLength];
b: NAT ~ Rope.Fetch[rope, 0]-'\000;
vector: Vector ~ VectorFromBytes[bytes: Rope.Substr[rope, 1], bytesPerElement: b, signed: TRUE];
PushVector[self, vector];
};
sequencePackedPixelVector => {
rope: ROPE ~ RopeFromRuns[self.stream, runsHead, sequenceLength];
bitsPerSample: [1..1] ~ Fetch16[rope, 0]; -- only one bit per sample supported here
scanLength: NAT ~ Fetch16[rope, 2];
dataBitsPerLine: NAT ~ bitsPerSample*scanLength;
padBitsPerLine: NAT ~ NAT[32 - (dataBitsPerLine MOD 32)] MOD 32;
vector: Vector ~ VectorFromBits[bytes: Rope.Substr[rope, 4], dataBitsPerLine: dataBitsPerLine, padBitsPerLine: padBitsPerLine];
PushVector[self, vector];
};
sequenceCompressedPixelVector => MasterWarning[$unimplemented, 
"Not implemented: sequenceCompressedPixelVector"];
sequenceAdaptivePixelVector => MasterWarning[$unimplemented, 
"Not implemented: sequenceAdaptivePixelVector"];
sequenceContinued => MasterWarning[$invalidEncoding, 
"Misplaced sequenceContinued"];
ENDCASE => MasterWarning[$invalidEncoding, 
IO.PutFR1["Invalid sequence type (%g)", IO.int[ORD[sequenceType]]]];
sequenceData _ nil;
sequenceType _ nil;
};
DO -- for each Token
token: Token ~ GetToken[stream: self.stream, flushComments: FALSE];
IF token.seq=sequenceContinued THEN { ExtendSequence[token.len]; LOOP };
self.context.token _ token;
IF sequenceType=sequenceString THEN {
done: BOOL _ TRUE;
SELECT token.op FROM
show => Imager.ShowText[context: self.imager, text: text];
showandxrel => Imager.ShowText[context: self.imager, text: text, xrel: TRUE];
ENDCASE => done _ FALSE;
IF done THEN { sequenceData _ nil; LOOP };
};
IF sequenceData#nil THEN FinishSequence[];
IF token.op=endBody THEN EXIT;
SELECT token.type FROM
op => Apply[self, token.op];
num => PushNum[self, [int[token.num]]];
seq => { BeginSequence[token.seq]; ExtendSequence[token.len] };
ENDCASE => ERROR;
ENDLOOP;
};


BeginBody: PROC [self: Ref] RETURNS [INT] ~ {
token: Token ~ IPMaster.GetToken[self.stream];
self.context.token _ token;
IF NOT token.op=beginBody THEN MasterError[$missingBody, "Missing body"];
RETURN[token.index];
};

SkipInlineBody: PUBLIC PROC [self: Ref] ~ {
index: INT ~ BeginBody[self];
IPMaster.SkipToEndOfBody[self.stream];
};

GetInlineBody: PUBLIC PROC [self: Ref] RETURNS [Body] ~ {
start, stop: INT _ 0;
start _ BeginBody[self];
IPMaster.SkipToEndOfBody[self.stream];
stop _ IO.GetIndex[self.stream];
RETURN[NEW[IPMaster.BodyRep _ [index: start, length: stop-start]]];
};

ExecuteInlineBody: PROC [self: Ref] ~ {
index: INT ~ BeginBody[self];
DO error: BOOL _ FALSE;
ExecuteToEndOfBody[self ! MarkRecovery => { error _ TRUE; CONTINUE }];
IF error THEN { -- do mark recovery
marker: Marker ~ PopToActiveMark[self];
IF marker=self.context.marker THEN {
IO.SetIndex[self.stream, self.context.token.index];
DO token: Token ~ IPMaster.GetToken[self.stream];
SELECT token.op FROM
endBody => ERROR MarkRecovery; -- end of body
beginBody => IPMaster.SkipToEndOfBody[self.stream]; -- skip body literal
unmark0 => { IO.SetIndex[self.stream, token.index]; EXIT }; -- found UNMARK0
ENDCASE;
IF token.type=seq THEN IPMaster.SkipBytes[self.stream, token.len];
ENDLOOP;
}
ELSE ERROR MarkRecovery; -- not this context's marker
}
ELSE EXIT; -- normal completion
ENDLOOP;
};


CallInlineBody: PUBLIC PROC [self: Ref, frame: Vector, env: Vector] ~ {
action: PROC ~ { ExecuteInlineBody[self] };
Call[self: self, action: action, frame: frame, env: env];
};

CallBody: PROC [self: Ref, body: Body, frame: Vector, env: Vector] ~ {
stream: STREAM ~ self.stream;
next: INT ~ IO.GetIndex[stream];
IO.SetIndex[stream, body.index];
CallInlineBody[self: self, frame: frame, env: env ! UNWIND => IO.SetIndex[stream, next]];
IO.SetIndex[stream, next];
};


DoWithMarkProtection: PUBLIC PROC [self: Ref, action: PROC] ~ {
error: BOOL _ FALSE;
inner: PROC ~ { Mark[self, 0]; action[]; Unmark[self, 0] };
inner[! MarkRecovery => { error _ TRUE; CONTINUE}];
IF error THEN { -- do mark recovery
marker: Marker ~ PopToActiveMark[self];
IF marker=self.context.marker THEN Unmark[self, 0]
ELSE ERROR MarkRecovery;
};
};


Do: PUBLIC PROC [self: Ref, op: Operator] ~ { op.class.do[op, self] };

composedClass: OperatorClass ~ NEW[OperatorClassRep _ [
type: $Composed, do: ComposedDo]];

ComposedData: TYPE ~ REF ComposedDataRep;
ComposedDataRep: TYPE ~ RECORD[
frame: Vector, -- initial frame
env: Vector, -- environment
body: Body -- body of the operator
];

ComposedDo: PROC [op: Operator, state: Ref] ~ {
data: ComposedData ~ NARROW[op.data];
CallBody[self: state, body: data.body, frame: data.frame, env: data.env];
};

MakeCO: PUBLIC PROC [frame: Vector, env: Vector, body: Body] 
RETURNS [Operator] ~ {
data: ComposedData ~ NEW[ComposedDataRep _ [frame: frame, env: env, body: body]];
RETURN[NEW[OperatorRep _ [class: composedClass, data: data]]];
};


CallPreamble: PROC [self: Ref, node: Node, frame: Vector, env: Vector] ~ {
WITH node SELECT FROM
node: REF NodeRep.body => {
preamble: PROC ~ {
Mark[self, 0];
ExecuteInlineBody[self];
IF Count[self]<1 THEN PushVector[self, Env[self]];
IF Count[self]<2 THEN PushVector[self, Frame[self]];
Unmark[self, 2];
};
IO.SetIndex[self.stream, node.body.index];
Call[self: self, action: preamble, frame: frame, env: env];
};
ENDCASE => ERROR;
};

CallNode: PROC [self: Ref, node: Node, frame: Vector, env: Vector] ~ {
WITH node SELECT FROM
node: REF NodeRep.body => {
body: Body ~ node.body;
IO.SetIndex[self.stream, body.index];
CallInlineBody[self: self, frame: frame, env: env];
};
ENDCASE => ERROR;
};

emptyVec: Vector ~ ZeroVec[0];
topFrame: Vector ~ ZeroVec[topFrameSize];
topEnv: Vector ~ emptyVec; -- empty vector, for now

Master: TYPE ~ Interpress.Master;
MasterRep: TYPE ~ Interpress.MasterRep;
MasterImpl: TYPE ~ REF MasterImplRep;
MasterImplRep: PUBLIC TYPE ~ RECORD [ -- exported to Interpress
skeleton: IPMaster.Skeleton,
interpreter: IPInterpreter.Ref
];
LogProc: TYPE ~ Interpress.LogProc;

Error: SIGNAL [class: INT, code: ATOM, explanation: ROPE] ~ CODE;

ReportError: PUBLIC PROC [class: INT, code: ATOM, explanation: ROPE] ~ {
SIGNAL Error[class: class, code: code, explanation: explanation];
IF class=Interpress.classMasterError THEN ERROR MarkRecovery;
};

MasterError: PUBLIC PROC [code: ATOM, explanation: ROPE] ~ {
ReportError[class: Interpress.classMasterError, code: code, explanation: explanation];
};

MasterWarning: PUBLIC PROC [code: ATOM, explanation: ROPE _] ~ {
ReportError[class: Interpress.classMasterWarning, code: code, explanation: explanation];
};

DoTopAction: PROC [self: Ref, action: PROC, log: LogProc] ~ {
protect: PROC ~ { DoWithMarkProtection[self, action] };
call: PROC ~ { Call[self, protect, emptyVec, emptyVec] };
save: PROC ~ { IF self.imager=NIL THEN call[] ELSE DoSaveAll[self, call] };
save[! Error => { IF log#NIL THEN log[class, code, explanation]; RESUME }];
};

DoPreamble: PROC [master: Master, log: LogProc] ~ {
impl: MasterImpl ~ master.impl;
self: Ref ~ impl.interpreter;
block: Block ~ impl.skeleton.topBlock;
action: PROC ~ {
CallPreamble[self: self, node: block.preamble, frame: topFrame, env: topEnv];
self.topFrame _ PopVector[self];
self.topEnv _ PopVector[self];
};
DoTopAction[self, action, log];
};

defaultMaxStackLength: Cardinal ~ 1000;

Open: PUBLIC PROC [fileName: ROPE, log: LogProc] RETURNS [Master] ~ {
stream: STREAM ~ FS.StreamOpen[fileName];
RETURN [FromStream[stream, log]];
};

FromStream: PUBLIC PROC [stream: STREAM, log: LogProc] RETURNS [Master] ~ {
restOfHeader: ROPE ~ IPMaster.GetHeader[stream, "Interpress/Xerox/"];
skeleton: IPMaster.Skeleton ~ IPMaster.GetSkeleton[stream];
self: Ref ~ NEW[Rep _ [stream: stream]];
impl: MasterImpl ~ NEW[MasterImplRep _ [skeleton: skeleton, interpreter: self]];
master: Master ~ NEW[MasterRep _ [pages: skeleton.topBlock.size, impl: impl]];
self.buffer _ NEW[TEXT[200]];
self.stackArray _ NEW[StackArrayRep _ ALL[[zero[]]]];
self.stackCountMax _ defaultMaxStackLength;
DoPreamble[master, log];
RETURN[master];
};

DoPage: PUBLIC PROC [master: Master, page: INT, context: Imager.Context, log: LogProc] ~ {
IF page IN[1..master.pages] THEN {
impl: MasterImpl ~ master.impl;
block: Block ~ impl.skeleton.topBlock;
node: Node ~ block[page-1];
self: Ref ~ impl.interpreter;
action: PROC ~ { CallNode[self: self, node: node, frame: self.topFrame, env: self.topEnv] };
self.imager _ context;
DoTopAction[self, action, log];
self.imager _ NIL;
};
};


END.

	τIPExecImpl.mesa
Copyright c 1984, 1985, 1986 by Xerox Corporation.  All rights reserved.
Michael Plass, February 17, 1986 9:03:24 am PST
Doug Wyatt, October 13, 1986 5:35:40 pm PDT
Someday, this might worry about pools other than the Imager pool
Someday, this might worry about pools other than the Imager pool
Can't just return this openFile, because it can get closed unpredictably.
This is a performance hack to make the rope out out several rope-files, each on a separate stream.  This is so switching between several regions of the file can be done without excessive thrashing of the disk arm.  Ideally, we would have more information about the typical access pattern to make a better decision here.
node: REF NodeRep.block => {
MasterError[$unimplemented, "Preamble cannot be a block."];
ERROR Error;
};
node: REF NodeRep.block => {
block: Block ~ node.block;
pageFrame, pageEnv: Vector;
CallPreamble[self, block.preamble, frame, env];
pageFrame _ PopVector[self];
pageEnv _ PopVector[self];
FOR i: NAT IN[0..block.size) DO
CallNode[self, block[i], pageFrame, pageEnv];
ENDLOOP;
};
self.imager _ imager; -- dummy imager context

ObtainExternalInstructions: PROC [self: Ref] RETURNS [Vector] ~ {
RETURN[VectorFromAny[GetP[Env[self], $externalInstructions]]];
};

AddInstructionDefaults: PROC [self: Ref, computedInstructions, externalInstructions: Vector]
RETURNS [Vector] ~ {
RETURN[computedInstructions]
};

ExecuteInstructionsBody: PROC [self: Ref, externalInstructions: Vector] RETURNS [Vector] ~ {
body: Index ~ self.skeleton.preamble.instructions;
IF body=nullIndex THEN RETURN[externalInstructions]
ELSE {
reader: Reader ~ NARROW[self.reader];
PushVector[self, externalInstructions];
reader.SetIndex[body];
DoBody[self, NoPool[], initialTopFrame, $saveAll];
WHILE Count[self]>1 DO Apply[self, $mergeprop] ENDLOOP;
RETURN[PopVector[self]];
};
};

ComputePrintingInstructions: PROC [self: Ref] ~ {
externalInstructions: Vector ~ ObtainExternalInstructions[self];
instructions: Vector _ emptyVector;

Mark[self, 0];
instructions _ ExecuteInstructionsBody[self, externalInstructions ! Error => CONTINUE];
Unmark0[self];

instructions _ AddInstructionDefaults[self, instructions, externalInstructions];

self.media _ GetP[instructions, $media];
self.copySelect _ GetP[instructions, $copySelect];
self.pageSelect _ GetP[instructions, $pageSelect];
self.onSimplex _ GetP[instructions, $onSimplex];
self.mediaSelect _ GetP[instructions, $mediaSelect];
self.copyName _ GetP[instructions, $copyName];
self.instructions _ instructions;
};

ΚY˜
codeš
œ™Kšœ
Οm
œ=™HK™/Kš
œ+™+—K˜š
Οk	˜	Kšžœ
˜Kšœžœ(˜4Kšœžœ˜(Kš
œ˜Kšžœ
˜Kš
œ˜Kšœ	žœžœ™
˜Γ
Kšœžœ˜K˜	Kš
œ˜—K˜KšΠbl
œžœ
ž˜Kšžœ
žœžœF˜TKšžœ˜!Kšœžœ
žœ˜%K˜Kšžœžœžœ
˜Kšžœžœžœ
žœ
˜K˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜!Kšžœžœžœ
˜K˜Kšœžœ
žœžœ
˜"Kšœžœ
žœžœ
˜K˜Kšœžœ˜K˜šΟnœžœ
žœ˜=šžœžœ˜!Kš
œ˜Kš
œ"˜"Kš
œ0˜0Kš
œ
˜
—Kšžœžœ˜ K˜K˜—š œžœ"˜3šžœ+žœ˜3Kš
œ"˜"Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ0˜0Kš
œ˜—K˜K˜—š œžœ
žœžœ!˜JKš
œ&˜&Kšœežœ˜tKš
œ!˜!K˜Kšœ	žœC˜RKšžœžœ>˜ZKšžœ
žœ˜K˜K˜—K˜š œžœ
žœžœ˜1K˜ Kšžœžœ
žœ
žœ˜6Kšžœ
žœ!˜,K˜K˜—š œžœ
žœžœ	˜:K˜ Kšžœžœ
žœ
žœ˜>Kšžœ!žœ˜IK˜K˜—š œžœ
žœ$˜5K˜ Kšžœžœ
žœ7˜PKš
œ@˜@K˜K˜—š œžœ
žœžœ˜/K˜ Kšžœ˜Kš
œ˜K˜—K˜š œžœ
žœžœ˜0Kš
œ@™@Kš
œ#˜#K˜K˜—š 	œžœ
žœžœ˜3Kš
œ@™@Kš
œ&˜&K˜K˜—K˜Kšœžœžœ
žœ˜$Kšœ	žœžœ
žœ˜š œžœžœ
žœ˜.K˜\Kš
œ+˜+K˜K˜—š œžœžœ
žœ˜2Kšœžœ˜Kšœžœžœ
˜šžœžœ
žœ	ž˜Kšœžœ˜šžœž˜Kšžœ
žœžœ
˜Kšžœžœžœžœ
˜*Kšžœžœ
˜—Kšžœ
˜—Kšžœžœžœ
˜K˜-Kšžœžœ7˜CK˜K˜—š 
œžœžœ
žœ˜0Kšœžœ˜šžœžœ˜Kšœžœ&˜.Kš
œ˜K˜
—šžœ˜Kšœžœ'˜0Kš
œ˜K˜—K˜K˜—š 
œžœžœ
žœ˜0Kšœžœ˜Kšœžœ	˜šžœ	žœ˜KšœžœA˜GKšœžœD˜JKšžœžœ
žœ
žœžœ
žœ
žœ&˜KKšžœžœžœ˜,K˜
—šžœ˜KšœžœB˜IKšœžœE˜LKš
œ˜K˜—Kšžœžœ"žœ0žœ˜yK˜K˜—š œžœžœ
žœ˜2Kš
œE˜EK˜K˜—š œžœžœ
žœžœžœ˜AKšœžœ%˜1Kšœžœ'˜3Kšžœ
˜K˜K˜—š œžœ
žœ
žœžœžœ˜FKšœ
žœžœ˜(Kšœžœžœ
˜Kšœžœžœ
˜Kš	œžœžœžœ
žœ˜XK•StartOfExpansion†
[name: 
ROPE, lock: 
FS.Lock _ read, wantedCreatedTime: 
GMT _ OPAQUE#17777777777B, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL]š
œI™IKš	œžœžœžœžœ
˜Kšžœžœžœ˜Kš
œ˜Kšœžœ˜0Kšœ
ž˜Kšœžœžœžœ
˜$Kš
œ˜—Kš
žœžœžœ
žœ
žœ˜1Kš
œ˜K˜—Kšœ
žœ	˜Kšœžœžœ
žœžœ
žœ	˜0Kšœžœ˜Kšœžœ˜Kšœ
žœ˜Kšœžœ˜Kšœžœ˜šœžœ˜+Kšœžœ
˜Kšœžœ
˜#Kšœžœ
˜Kšœžœ
˜Kšœž˜Kš
œ˜—š œžœ
žœ
žœžœ
žœžœžœžœžœ˜mKšœžœ˜Kš	œ
žœžœžœžœ˜jšžœžœžœ˜$K™ΏKšœžœžœ
žœžœ
žœ˜4šžœžœ
žœž˜"K–¨[openFile: 
FS.OpenFile, accessRights: 
FS.Lock _ read, initialPosition: 
FS.InitialPosition _ start, streamOptions: 
FS.StreamOptions _ (5)[TRUE, TRUE, TRUE, TRUE, TRUE], streamBufferParms: 
FS.StreamBufferParms _ [vmPagesPerBuffer: 
8, nBuffers: 
2], extendFileProc: 
FS.ExtendFileProc]šœ
žœΰ
˜ξ
Kšœžœžœ
˜Kš
œ	˜	šžœžœ
žœžœžœ
ž˜2Kš
œ˜Kš
œ>˜>Kš
œ˜Kšžœ
˜—Kš
œ
˜
Kšžœ
˜—šžœžœ
žœž˜"Kšœžœ˜!Kšœžœ˜#Kš
œB˜BKšžœ
˜—Kš
œ
˜
—šžœ˜Kšœžœžœ˜%šžœžœ
žœžœžœ
ž˜2Kš
œ˜šžœ
ž˜Kšœžœžœ˜,Kš
œ*˜*K˜
Kšžœ˜Jšžœ	žœžœ!˜MKš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜Kš
œ˜—Kšžœ"žœ
žœ
˜/Kšžœžœ
žœ
˜$K˜K˜—š œžœ˜(Kšœžœ˜Kš
œ,˜,K˜!Kšœžœ˜Kšœžœ˜Kšœžœ
žœžœ
˜Kšœžœ
žœ˜Kšœžœ
žœžœ
˜&š 
œžœ˜+šžœž˜Kš
œƒ
˜ƒ
Kš
œ‚
˜‚
Kšžœ˜—šžœž˜K˜+Kšœ žœ˜&Kšžœ
˜—Kš
œ˜K˜—š œžœ
žœ˜&šžœž˜˜Kš
œ?˜?K˜K˜—˜	Kšœžœ
˜Kšœžœ˜Kšžœ"žœ(˜PKšœ
žœJ˜YKšžœžœ
žœ
žœ˜4K˜—˜	Kšœ
žœ
žœ˜!Kšœžœ	žœ!˜;Kšžœ
žœ
žœžœ˜GKš
œ˜K˜—K˜"Kšžœžœ
˜—Kš
œ˜Kš
œ'˜'K˜—š œžœ˜šžœž˜Kš
œ'˜'Kš
œ/˜/Kš
œ*˜*Kš
œ+˜+Kš
œ/˜/Kšœžœ
˜š
œ˜Kšœžœ7˜AKšœžœ˜#KšœZžœ˜`Kš
œ˜K˜—š
œ˜Kšœžœ7˜AKšœ*Οc)˜SKšœžœ˜#Kšœžœ˜0Kš	œžœžœžœžœ˜@Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œr˜rKš
œn˜nKš
œU˜UKšžœ%žœ&žœžœ˜p—Kš
œ˜Kš
œ˜K˜—šžœ
‘˜Kšœ<žœ˜CKšžœžœžœ˜HK˜šžœžœ˜%Kšœžœžœ
˜šžœ
ž˜Kš
œ:˜:KšœGžœ˜MKšžœžœ
˜—Kšžœžœžœ˜*K˜—Kšžœžœ˜*Kšžœžœ
žœ
˜šžœž˜Kš
œ˜Kš
œ'˜'Kš
œ?˜?Kšžœžœ
˜—Kšžœ
˜—K˜K˜—K˜š 	œžœ
žœžœ˜-K˜.K˜Kšžœ
žœžœ+˜IKšžœ˜K˜K˜—š œžœ
žœ˜+Kšœžœ˜K˜&K˜K˜—š 
œžœ
žœ
žœ˜9Kšœ
žœ˜Kš
œ˜Kš
œ&˜&Kšœžœ˜ Kšžœ
žœ9˜CK˜K˜—š œžœ˜'Kšœžœ˜šžœžœžœ
˜Kšœ4žœžœ˜Fšžœžœ‘˜#Kš
œ'˜'šžœžœ˜$Kšžœ1˜3šžœ/˜1šžœ
ž˜Kšœžœ‘˜-Kšœ4‘˜HKšœ
žœ%žœ‘˜LKšžœ
˜—Kšžœžœ,˜BKšžœ
˜—K˜
—Kšžœ
žœ‘˜5K˜
—Kšžœ
žœ‘˜Kšžœ
˜—K˜K˜—K˜š œžœ
žœ,˜GKšœžœ˜+Kš
œ9˜9K˜K˜—š œžœ8˜FKšœžœ˜Kšœžœžœ˜ Kšžœ˜ Kšœ4žœžœ˜YKšžœ˜K˜K˜—K˜š œžœ
žœžœ˜?Kšœžœžœ
˜Kšœžœ0˜;Kšœ"žœžœ˜3šžœžœ‘˜#Kš
œ'˜'Kšžœžœ˜2Kšžœ
žœ˜K˜—K˜K˜—K˜Kš œžœ
žœ7˜FK˜šœžœ˜7Kš
œ"˜"K˜—Kšœžœžœ˜)šœžœžœ
˜Kšœ‘˜Kšœ
‘˜Kšœ‘˜"K˜K˜—š 
œžœ˜/Kšœžœ
˜%Kš
œI˜IK˜K˜—š œžœ
žœ*žœ˜TKšœžœ9˜QKšžœ
žœ4˜>K˜K˜—K˜š œžœ8˜Jšžœžœ
ž˜šœžœ˜šœ
žœ˜K˜Kš
œ˜Kšžœžœ˜2Kšžœžœ˜4K˜Kš
œ˜—Kšžœ(˜*Kš
œ;˜;K˜—šœžœ™K™;Kšžœ™K™—Kšžœžœ
˜—Kš
œ˜K˜—š œžœ8˜Fšžœžœ
ž˜šœžœ˜K˜Kšžœ#˜%Kš
œ3˜3K˜—šœžœ™K™K™K™/K™K™šžœžœ
žœž™K™-Kšžœ
™—K™—Kšžœžœ
˜—Kš
œ˜K˜—Kš
œ˜K˜)Kšœ‘˜3K˜Kšœžœ˜!Kšœžœ˜'Kšœžœžœ˜%šœžœ
žœžœ‘˜?K˜Kš
œ˜K˜—Kšœ	žœ˜#K˜š œžœ	žœžœžœžœ
˜AK˜—š œžœ
žœ	žœžœžœ˜HKšžœ;˜AKšžœ#žœ
žœ˜=K˜K˜—š
 œžœ
žœžœžœ˜<Kš
œV˜VKš
œ˜K˜—š
 
œžœ
žœžœžœ˜@Kš
œX˜XKš
œ˜K˜—š œžœžœ˜=Kšœ	žœ*˜7Kšœžœ/˜9Kšœžœžœ
žœ
žœžœ˜KKš	œžœžœ
žœ žœ˜KK˜K˜—š 
œžœ#˜3Kš
œ˜K˜Kš
œ&˜&šœžœ˜Kš
œM˜MK˜ K˜K˜—Kš
œ˜K˜K˜—K˜'K˜š
 œžœ
žœžœžœ
˜EKšœžœžœ˜)Kšžœ˜!K˜K˜—š
 
œžœ
žœ
žœžœ
˜KKšœžœ3˜EKš
œ;˜;Kšœžœ˜(Kšœžœ:˜PKšœžœ:˜NKšœžœ
žœ˜Kšœžœžœ˜5Kš
œ+˜+Kšœ‘™-Kš
œ˜Kšžœ	˜K˜K˜—š œžœ
žœžœ,˜Zšžœžœžœ˜"K˜K˜&K˜K˜KšœžœP˜\K˜Kš
œ˜Kšœžœ
˜K˜—K˜K˜—K˜Kšžœ
˜K™š œžœ
žœ
™AKšžœ8™>K™K™—š œžœ@™\Kšžœ
™Kšžœ™K™K™—š œžœ+žœ
™\K™2Kšžœžœ
žœ™3šžœ™Kšœžœ™%Kš
œ'™'Kš
œ™K™2Kšžœžœžœ
™7Kšžœ™K™—K™K™—š œžœ™1Kš
œ@™@Kš
œ#™#K™K™KšœMžœ™WK™K™Kš
œP™PK™K™(K™2K™2K™0K™4K™.Kš
œ!™!K™K™—K˜—…—Dδg1