DIRECTORY
Ascii USING [ESC, LF],
Basics,
BasicTime USING [GMT, Now, nullGMT],
Colorize USING [Do],
FS USING [Delete, EnumerateForNames, Error, NameProc, StreamOpen],
Imager USING [Context, Error],
ImagerInterpress USING [Close, Create, DoPage, Ref],
Interpress USING [classAppearanceError, classAppearanceWarning, classComment, classMasterError, classMasterWarning, Close, DoPage, Instructions, LogProc, Master, Open],
IO USING [Close, CreateStreamProcs, CreateStream, EndOfStream, Error, PutFR, PutFR1, PutFWord, PutRope, RopeFromROS, ROS, STREAM, StreamProcs, TIS, TOS, UnsafeGetBlock],
IPInstructions USING [Instructions],
IPMaster USING [Error],
Loader USING [MakeGlobalFrameResident, MakeProcedureResident],
Marker USING [Procs, ProcsRep, RegisterMarkerProcs, Result],
PrincOps USING [PageCount, Priority],
PrintingP4V3 USING [DocumentSubrange, FormatterStatus, MarkingEngineStatus, Option, OptionObject, PrintAttributes, PrintOptions, RequestID],
Process USING [GetPriority, Priority, priorityBackground, SetPriority],
Profiles USING [CreateFromRope, CreateFromSlices, Profile],
PSInstaller USING [InitProc, ps, RegisterInitProc],
Real,
Rope USING [Concat, Equal, Length, ROPE, Substr],
RopeFile USING [FromStream],
RuntimeError,
SafeStorage,
ServicesExec,
SoftcardFSAccess USING [RegisterConsoleStreams],
SoftcardRemoteCall USING [CallRProc],
Spooler USING [State],
VM USING [AddressFault, CantAllocate, WriteProtectFault, PageCount];

SoftcardMarkerImpl: CEDAR MONITOR
IMPORTS Basics, BasicTime, Colorize, FS, IO, Imager, ImagerInterpress, Interpress, IPMaster, Loader, Marker, Process, Profiles, PSInstaller, Real, Rope, RopeFile, RuntimeError, SafeStorage, ServicesExec, SoftcardFSAccess, SoftcardRemoteCall, VM
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;
LF: CHAR ~ Ascii.LF;
ESC: CHAR ~ Ascii.ESC;
ps: ATOM ~ PSInstaller.ps;
printing: BOOL _ FALSE;
dontCatch: BOOL _ FALSE;
procs: Marker.Procs;
stopped: BOOL _ FALSE;
change: CONDITION;
formatting: BOOL _ FALSE;

in, out, err, scIn, scOut: STREAM _ NIL;


FindStuff: PROC [option: PrintingP4V3.PrintOptions]
RETURNS [copies: CARDINAL, sub: PrintingP4V3.DocumentSubrange, message: ROPE] = {
copies _ 1;
sub _ [FIRST[CARD16], LAST[CARD16]];
message _ NIL;
FOR i: CARDINAL IN [0 .. option.length) DO
localOption: PrintingP4V3.Option _ option.body[i];
WITH localOption SELECT FROM
l: REF PrintingP4V3.OptionObject[copyCount] => copies _ l.copyCount;
l: REF PrintingP4V3.OptionObject[pagesToPrint] => sub _ l.pagesToPrint;
l: REF PrintingP4V3.OptionObject[message] => message _ l.message;
ENDCASE => NULL;
ENDLOOP;
};

currentID: PrintingP4V3.RequestID _ ALL[0];
Mode: TYPE ~ {sun, sunbeam};
mode: Mode _ sunbeam;
controlProfile: Profiles.Profile ~ Profiles.CreateFromRope[LIST[NIL]];

PrintFile: PUBLIC PROC [id: PrintingP4V3.RequestID, fileName: ROPE,
printAttributes: PrintingP4V3.PrintAttributes, printOptions: PrintingP4V3.PrintOptions,
abort: REF BOOL, testPattern: BOOL, copies: CARDINAL,
inst: IPInstructions.Instructions _ NIL] RETURNS [result: Marker.Result] = {
WaitStarted: ENTRY PROC [] = {ENABLE UNWIND => NULL;
UNTIL NOT stopped DO WAIT change ENDLOOP};
old: Process.Priority _ Process.GetPriority[];
aborted: BOOL _ FALSE;
docRange: PrintingP4V3.DocumentSubrange _ [FIRST[CARD16], LAST[CARD16]];
message: ROPE _ NIL;
IF stopped AND NOT testPattern THEN WaitStarted[]; -- don't wait if it's a test pattern
IF NOT testPattern THEN [--copies--, docRange, message] _ FindStuff[printOptions]; -- go ahead and use copies over since this is not a test pattern
Process.SetPriority[Process.priorityBackground];
{
ENABLE RuntimeError.UNCAUGHT => {
LogMessage["UNCAUGHT Error"];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
{ ENABLE { -- for the 2nd ENABLE.  This does most of the catching
FS.Error => {
LogMessage[IO.PutFR1["FS.Error: %g", [rope[error.explanation]]]];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
IO.Error => {
msg2: ROPE ~ SELECT ec FROM
NotImplementedForThisStream => "not implemented",
StreamClosed => "stream closed",
Failure => "failure",
IllegalBackup => "illegal backup",
BufferOverflow => "buffer overflow",
BadIndex => "bad index",
SyntaxError => "syntax error",
Overflow => "overflow",
IN [PFInvalidCode..PFUnprintableValue] => "PF error",
ENDCASE => "unknown error";
LogMessage[IO.PutFR1["IO.Error: %g", [rope[msg2]]]];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
VM.AddressFault => {
LogMessage[IO.PutFR1["AddressFault: %bB", [cardinal[LOOPHOLE[address, CARD]]]]];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
SafeStorage.CantEstablishFinalization => {
LogMessage["SafeStorage.CantEstablishFinalization"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
SafeStorage.InvalidType => {
LogMessage["SafeStorage.InvalidType"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
SafeStorage.NarrowFault => {
LogMessage["NarrowFault"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
SafeStorage.NarrowRefFault => {
LogMessage["NarrowRefFault"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
SafeStorage.UnsafeProcAssignment => {
LogMessage["SafeStorage.UnsafeProcAssignment"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
Real.RealError => {
LogMessage["Real.RealError"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
Real.RealException => TRUSTED {
realFlagsNames: ARRAY Real.Exception OF ROPE = ["fixOverflow", "inexactResult", "invalidOperation", "divisionByZero", "overflow", "underflow"];
msg2: ROPE;
ros: STREAM _ IO.ROS[];
temp: Real.ExceptionFlags _ flags;
IF temp # Real.NoExceptions THEN
FOR flag: Real.Exception IN Real.Exception DO
IF temp[flag] THEN {
temp[flag] _ FALSE;
IO.PutRope[ros, realFlagsNames[flag]];
IF temp = Real.NoExceptions THEN EXIT;
IO.PutRope[ros, ", "];
};
ENDLOOP;
msg2 _ IO.RopeFromROS[ros];
LogMessage[IO.PutFR1["Real.RealException: {%g}", [rope[msg2]]]];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.BoundsFault => {
LogMessage["BoundsFault"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.ControlFault => {
LogMessage["ControlFault"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.DivideCheck => {
LogMessage["DivideCheck"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.PointerFault => {
LogMessage["PointerFault"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.StartFault => { 
LogMessage["StartFault"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.StackError => {
LogMessage["StackError"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.UnboundProcedure => {
LogMessage["UnboundProcedure"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
RuntimeError.ZeroDivisor => {
LogMessage["ZeroDivisor"]; 
IF dontCatch THEN REJECT ELSE GOTO Out;
};
VM.CantAllocate => {
LogMessage[IO.PutFR1["VM.CantAllocate", [integer[bestInterval.count]]]];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
VM.WriteProtectFault => {
LogMessage[IO.PutFR1["WriteProtectFault: %bB", [cardinal[LOOPHOLE[address, CARD]]]]];
IF dontCatch THEN REJECT ELSE GOTO Out;
};
}; -- 2nd ENABLE
currentID _ id; -- set up for the monitor stuff
formatting _ TRUE;
IF NOT testPattern THEN ColorizeIP[id, fileName, message];
aborted _ PrintInterpressFile[id, fileName, docRange, copies, abort, inst, printAttributes, printOptions, testPattern];
IF aborted THEN GOTO Out;
IF NOT testPattern THEN DeleteFile[fileName]; -- don't kill the test patterns
EXITS Out => {IF NOT testPattern THEN DeleteFile[fileName]; -- don't kill the test pattern
Process.SetPriority[old];
jobs _ jobs + 1;
currentID _ ALL[0];
RETURN[aborted]};
};
EXITS Out => {IF NOT testPattern THEN DeleteFile[fileName]; -- don't kill the test pattern
Process.SetPriority[old];
jobs _ jobs + 1;
currentID _ ALL[0];
RETURN[aborted]};
};
Process.SetPriority[old];
jobs _ jobs + 1;
currentID _ ALL[0];
RETURN [IF aborted THEN aborted ELSE complete];
};

DeleteFile: PROC [name: ROPE] = {
Proc: FS.NameProc = -- [fullFName: ROPE] RETURNS [continue: BOOL] -- {
FS.Delete[fullFName ! FS.Error => CONTINUE];
RETURN[TRUE];
};
pattern: ROPE ~ Rope.Concat[base: name, rest: "!*"];
FS.EnumerateForNames[pattern: pattern, proc: Proc ! FS.Error => CONTINUE];
};

PrintInterpressFile: PROC [id: PrintingP4V3.RequestID, fileName: ROPE,
sub: PrintingP4V3.DocumentSubrange, copies: CARDINAL, abort: REF BOOL,
inst: IPInstructions.Instructions _ NIL, printAttributes: PrintingP4V3.PrintAttributes, printOptions: PrintingP4V3.PrintOptions, testPattern: BOOL _ FALSE]
RETURNS [aborted: BOOL] = {
first: CARDINAL _ MAX[1, sub.beginningPageNumber];
last: CARDINAL _ sub.endingPageNumber;
pg: INT _ 1; cpy: INT _ 1;
formatting _ TRUE;
aborted _ FALSE; -- so we can clean up after ourselves
aborted  _ PrintOnSoftcard[file: fileName, copies: copies, first: first, last: last];
formatting _ FALSE;
RETURN[aborted];
};


ColorizeIP: PROC [id: PrintingP4V3.RequestID, fileName, message: ROPE] = {
{ -- for stream protection
ip3Header: ROPE ~ "Interpress/Xerox/3.0";
ip3HeaderLen: INT ~ Rope.Length[base: ip3Header];
stream: STREAM _ FS.StreamOpen[fileName: fileName, accessOptions: read];
masterRope: ROPE _ RopeFile.FromStream[stream: stream];
IF Rope.Length[base: masterRope] < ip3HeaderLen THEN {IO.Close[stream]; RETURN}; -- not interpress
IF Rope.Equal[s1: Rope.Substr[base: masterRope, start: 0, len: ip3HeaderLen], s2: ip3Header, case: FALSE] THEN {IO.Close[stream]; RETURN};
IO.Close[stream];
}; -- for stream protection
{ -- for colorization
master: Interpress.Master _ NIL;
new: ImagerInterpress.Ref _ NIL;
profile: Profiles.Profile _ Profiles.CreateFromSlices[slices: LIST[[file["///7.0/Palettes/DefaultPalette.data"]], [rope[message]]]];
{ -- for enable
ENABLE {
UNWIND => {IF master # NIL THEN Interpress.Close[master]; master _ NIL;
IF new # NIL THEN ImagerInterpress.Close[self: new]; new _ NIL};
Imager.Error => {LogMessage[error.explanation]; ERROR ABORTED};
IPMaster.Error => {
LogMessage[Rope.Concat[base: "Master error: ", rest: error.explanation]];
ERROR ABORTED};
IO.EndOfStream, IO.Error => {LogMessage["Unknown IO Error"];
ERROR ABORTED};
};
LogProc: Interpress.LogProc = {
classRope: ROPE _ SELECT class FROM
Interpress.classMasterError => "Master Error",
Interpress.classMasterWarning => "Master Warning",
Interpress.classAppearanceError => "Appearance Error",
Interpress.classAppearanceWarning => "Appearance Warning",
Interpress.classComment => "Comment",
ENDCASE => "Unknown";
rope: ROPE _ IO.PutFR["Colorizer %g %g", [rope[classRope]], [rope[explanation]]];
LogMessage[rope];
};
master _ Interpress.Open[fileName: fileName, log: LogProc];
new _ ImagerInterpress.Create[fileName: fileName];
FOR page: INT IN [1..master.pages] DO
CheckSetting: PROC [key: ROPE] RETURNS [value: BOOL] ~ {RETURN[TRUE]};
ImagePage: PROC [context: Imager.Context] ~ {
WithAmbushedContext: PROC [context: Imager.Context] ~ {
Interpress.DoPage[master: master, page: page, context: context, log: LogProc];
};
Colorize.Do[context: context, proc: WithAmbushedContext, control: controlProfile, color: profile, checkSystemSetting: CheckSetting];
};
ImagerInterpress.DoPage[self: new, action: ImagePage];
ENDLOOP;
IF new # NIL THEN ImagerInterpress.Close[self: new];
IF master # NIL THEN Interpress.Close[master];
}; -- for enable
}; -- for colorization
};

MarkerStatus: PROC [] RETURNS [PrintingP4V3.MarkingEngineStatus] = {
IF stopped THEN RETURN[disabled];
RETURN[available];
};

FormatterStatus: PROC [] RETURNS [PrintingP4V3.FormatterStatus] =
{RETURN[IF formatting THEN busy ELSE available]};

Start: ENTRY PROC [] = {stopped _ FALSE; BROADCAST change};

Stop: ENTRY PROC [] = {stopped _ TRUE; BROADCAST change};

jobs: INT _ 0;
pages: INT _ 0;
booted: BasicTime.GMT _ BasicTime.nullGMT;

Statistics: PROC [] RETURNS [LIST OF Rope.ROPE] = {
l: LIST OF Rope.ROPE _ NIL;
rope: ROPE ~ SELECT mode FROM
sun => "Sun4", sunbeam => "Sunbeam",
ENDCASE => "Guess";
l _ CONS[IO.PutFR1["Maker is a: %g", [rope[rope]]], l];
l _ CONS[IO.PutFR1["Pages printed: %g", [integer[pages]]], l];
l _ CONS[IO.PutFR1["Jobs printed: %g", [integer[jobs]]], l];
l _ CONS[IO.PutFR1["Booted at %t", [time[booted]]], l];
RETURN [l];
};

JobState: PROC [id: PrintingP4V3.RequestID] RETURNS [Spooler.State] = {
IF id = currentID THEN RETURN[printing] ELSE RETURN[unknown];
};

LogMessage: PROC [msg: ROPE] = {
data: ServicesExec.ServiceData ~ ServicesExec.GetServiceData[ps];
message: ROPE ~ Rope.Concat[base: " PS ", rest: msg];
ServicesExec.BroadcastMessage[message: msg, serviceData: data, showTime: FALSE];
};

InitMarker: PSInstaller.InitProc = {
procs _ NEW[Marker.ProcsRep _ [
print: PrintFile,
markerStatus: MarkerStatus,
formatterStatus: FormatterStatus,
jobState: JobState,
start: Start,
stop: Stop,
statistics: Statistics]];
jobs _ 0; pages _ 0;
booted _ BasicTime.Now[];
InitSoftcard[out];
Marker.RegisterMarkerProcs[procs, "Softcard", printer];
LogMessage["Marker ready to print."];
};

PrintOnSoftcard: PROC [file: ROPE, copies: CARD, first: CARD, last: CARD]
RETURNS [aborted: BOOL _ FALSE] ~ {
PutArgs: PROC [ub: Basics.UnsafeBlock] ~ TRUSTED {
t: REF TEXT _ NEW[TEXT[argsByteSize]];
s: IO.STREAM _ IO.TOS[text: t];
IO.PutFWord[s, Basics.FFromCard32[copies]];
IO.PutFWord[s, Basics.FFromCard32[first]];
IO.PutFWord[s, Basics.FFromCard32[last]];
IO.PutRope[s, file];
IO.Close[s];
IF t.length#argsByteSize THEN ERROR;
s _ IO.TIS[t];
[] _ IO.UnsafeGetBlock[s, ub];
};
argsByteSize: CARD32 _ Rope.Length[file]+3*BYTES[CARD];
[] _ SoftcardRemoteCall.CallRProc[$VersacolorPrint, argsByteSize, PutArgs]
};

InitSoftcard: PROC [outStream: STREAM] = {
out _ outStream;
err _ outStream;
[scIn, scOut] _ GetIOStreams[];
SoftcardFSAccess.RegisterConsoleStreams[scIn, out, err];
};

StreamData: TYPE ~ REF StreamDataRep;
StreamDataRep: TYPE ~ RECORD [
buffer: CHAR,
haveOne: BOOL _ FALSE,
in, out: CONDITION
];
GetIOStreams: PROC [] RETURNS [ioIn, ioOut: STREAM] ~ {
inProcs: REF IO.StreamProcs ~ IO.CreateStreamProcs[variety: input,
class: $BufferedForSoftcard,
getChar: GetChar
];
outProcs: REF IO.StreamProcs ~ IO.CreateStreamProcs[variety: output,
class: $BufferedForSoftcard,
putChar: PutChar
];
data: StreamData ~ NEW[StreamDataRep];
ioIn _ IO.CreateStream[streamProcs: inProcs, streamData: data];
ioOut _ IO.CreateStream[streamProcs: outProcs, streamData: data];
};

GetChar: ENTRY PROC [self: STREAM] RETURNS [c: CHAR] = {
ENABLE UNWIND => NULL;
data: StreamData ~ NARROW [self.streamData];
UNTIL data.haveOne DO
WAIT data.in;
ENDLOOP; 
c _ data.buffer;
data.haveOne _ FALSE;
NOTIFY data.out;
};

PutChar: ENTRY PROC [self: STREAM, char: CHAR] = {
ENABLE UNWIND => NULL;
data: StreamData ~ NARROW [self.streamData];
UNTIL NOT data.haveOne DO
WAIT data.out;
ENDLOOP; 
data.buffer _ char;
data.haveOne _ TRUE;
NOTIFY data.in;
};

InitAll: PROC [] = {
Loader.MakeGlobalFrameResident[InitAll];
Loader.MakeProcedureResident[InitAll];
PSInstaller.RegisterInitProc[InitMarker];
};

InitAll[];

END...
˜SoftcardMarkerImpl.mesa
Copyright Σ 1988 by Xerox Corporation.  All rights reserved.
Tim Diebert: November 1, 1988 9:15:34 am PST
Dave Rumph, August 12, 1988 6:43:11 pm PDT
Christian Le Cocq November 16, 1988 10:51:43 am PST
EXPORTS 
ExportsList
Copied types
Internal types
Constants
Globals
Marker Procedures
error = [code: ATOM, explanation: ROPE, index: INT _ 0]
LogProc: TYPE ~ PROC [class: INT, code: ATOM, explanation: ROPE];
[in: STREAM _ NIL, out: STREAM _ NIL, info: ServicesExec.UserInfo _ NIL]
Printer Procedures
PrintArgsRec: TYPE ~ RECORD[copies, first, last: Basics.FWORD, fileName: PACKED SEQUENCE COMPUTED CARD16 OF CHAR];

Start Trap Stuff
Κθ˜š
œ™Icode™<K™,K™*K™3—K˜š
Οk	˜	Kšœœœœ˜K˜Kšœ
œœ˜$Kšœ	œ˜Kšœ
œ:˜BKšœœ˜Kšœœ˜4Kšœœ˜
˜¨
Kšœ
œmœœ)˜©
Kšœœ˜$Kšœ	œ	˜Kšœœ2˜>Kšœœ0˜<Kšœ	œ˜%Kšœ
œz˜Œ
Kšœœ:˜GKšœ	œ-˜;Kšœœ"˜3K˜Kšœœœ
˜1Kšœ	œ˜Kš
œ
˜
K˜K˜
Kšœœ˜0Kšœœ
˜%Kšœœ	˜Kšœ
œ<˜D—K˜KšΠlnœœ
˜!KšœœœΗ
˜τ
Kšœ™šœ˜K˜—
head2™Kšœœœ
˜Kšœœœ
œ
˜—L™™	Kšœœ	œ
˜Kšœœ	œ
˜Kšœœ˜—™Kšœ
œœ
˜Kšœœœ
˜K˜Kšœ	œœ
˜Kšœ	œ
˜Kšœœœ
˜K˜Kšœœœ
˜(K˜K˜—™š
Οn	œœ%œ
œ/œ˜…
Kš
œ˜Kš	œœ
œœ
œ˜$Kšœ
œ
˜šœœ
œ˜*Kš
œ2˜2šœœ
˜Kšœœ>˜DKšœœA˜GKšœœ;˜AKšœœ
˜—Kšœ
˜—Kš
œ˜—K˜Kšœ$œ˜+Kšœœ˜K˜Kšœ;œ
œ˜FK˜šŸ	œœ
œ(œaœ
œœ
œ&œœ˜žšŸœœ
œœ
œœ
˜4Kš
œ
œ	œ
œœ˜*—K˜.Kšœ	œœ
˜Kš	œ+œ
œœ
œ˜HKšœ	œœ
˜Kš	œ	œ
œ
œΟc$˜WKš	œ
œ
œ 
œ0 @˜“
K˜0š
œ
˜
šœœ˜!Kš
œ˜Kš
œœ
œ
œ
œ˜'Kš
œ˜—šœœ Πck !˜Ašœ˜
Kšœœ4˜AKš
œœ
œ
œ
œ˜'Kš
œ˜—šœ˜
šœœœ˜Kš
œ1˜1Kš
œ ˜ Kš
œ˜Kš
œ"˜"Kš
œ$˜$Kš
œ˜Kš
œ˜Kš
œ˜Kšœ3˜5Kšœ˜—Kšœœ'˜4Kš
œœ
œ
œ
œ˜'K˜—šœ˜Kšœœ'œ
œ˜PKš
œœ
œ
œ
œ˜'Kš
œ˜—š
œ*˜*Kš
œ5˜5Kš
œœ
œ
œ
œ˜'Kš
œ˜—˜Kš
œ'˜'Kš
œœ
œ
œ
œ˜'Kš
œ˜—š
œ˜Kš
œ˜Kš
œœ
œ
œ
œ˜'Kš
œ˜—š
œ˜Kš
œ˜Kš
œœ
œ
œ
œ˜'Kš
œ˜—š
œ%˜%Kš
œ0˜0Kš
œœ
œ
œ
œ˜'Kš
œ˜—˜Kš
œ˜Kš
œœ
œ
œ
œ˜'Kš
œ˜—šœœ˜Kšœœœ
œc˜
Kšœœ
˜Kšœœœ
œ˜Kš
œ"˜"šœ˜ šœœ˜-šœœ˜Kšœ
œ
˜Kšœ$˜&Kšœœ
œ
˜&Kšœ˜K˜—Kšœ
˜——Jšœœ˜Kšœœ3˜@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šœœ;˜HKš
œœ
œ
œ
œ˜'Kš
œ˜—šœ˜Kšœœ,œ
œ˜UKš
œœ
œ
œ
œ˜'Kš
œ˜—Kšœ 
˜Kšœ ˜/Kšœ
œ
˜Kšœ
œ
œ#˜:Kš
œw˜wKšœ	œ
œ˜Kšœ
œ
œ ˜Mš	œ	œ
œ
œ ˜ZKš
œ˜K˜Kšœœ˜Kšœ˜—Kš
œ˜—š	œ	œ
œ
œ ˜ZKš
œ˜K˜Kšœœ˜Kšœ˜—K˜—Kš
œ˜K˜Kšœœ˜Kšœœ	œ	œ˜/Kš
œ˜—K˜šŸ
œœœ˜!•StartOfExpansion. -- [fullFName: ROPE] RETURNS [continue: BOOL]šŸœœ 0œ˜FKšœ 	œœ
œ˜,Kšœ
œ˜
K˜—K–([base: 
ROPE _ NIL, rest: 
ROPE _ NIL]šœ	œ'˜4K–:[pattern: 
ROPE, proc: 
FS.NameProc, wDir: 
ROPE _ NIL]šœ2œ
œ˜JKš
œ˜—K˜šŸœœ(œ.œ	œ
œ&œgœœœœ˜ΕKšœœ˜2Kšœœ
˜&Kšœœœ˜Kšœ
œ
˜Kšœ
œ %˜6K˜UKšœ
œ
˜Kšœ
˜Kš
œ˜—K˜K˜šŸ
œœ1œ˜Jšœ ˜Kšœœ˜)K–[base: 
ROPE]šœœ ˜1K–Κ[fileName: 
ROPE, accessOptions: 
FS.AccessOptions _ read, streamOptions: 
FS.StreamOptions _ (3)[TRUE, TRUE, TRUE], keep: 
CARDINAL _ 1B (1), createByteCount: 
FS.ByteCount _ 2560, streamBufferParms: 
FS.StreamBufferParms _ [vmPagesPerBuffer: 
8, nBuffers: 
2], extendFileProc: 
FS.ExtendFileProc, wantedCreatedTime: 
GMT _ nullGMT, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL, checkFileType: 
BOOL _ FALSE, fileType: 
FS.FileType _ [0B (0)]]šœœœ5˜HK–g[stream: 
STREAM, start: 
INT _ 0, len: 
INT _ 2147483647, bufSize: 
INT _ 512, buffers: 
NAT _ 4]šœœ'˜7Kš	œ-œœœ ˜bK–9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]š
œaœœœœ˜Š
Kšœ˜Kšœ ˜—šœ ˜K–Η
[fileName: 
ROPE, log: 
Interpress.LogProc, credentials: 
Interpress.Credentials _ NIL, externalInstructions: 
Interpress.Instructions _ NIL, defaultInstructions: 
Interpress.Instructions _ NIL]šœœ
˜ K–([fileName: 
ROPE, header: 
ROPE _ NIL]šœœ
˜ K–1[files: 
LIST OF ROPE, keepFresh: 
BOOL _ TRUE]šœ>œB˜„
šœ 
˜šœ˜š	œœ
œ
œ$˜GKšœœ
œ*œ˜@—Kšœ0œ
œ˜?–3 -- [code: ATOM, explanation: ROPE, index: INT _ 0]š
œ˜Kšœ‘2™7K–([base: 
ROPE _ NIL, rest: 
ROPE _ NIL]š
œI˜IKšœ
œ˜—šœœ*˜<Kšœ
œ˜—Kš
œ˜—šŸœ˜Kšœ	œœ	œœœ™A–%[context: 
Imager.Context, p: 
VEC]šœœœ˜#Kš
œ.˜.Kš
œ2˜2Kš
œ6˜6Kš
œ:˜:Kš
œ%˜%Kšœ˜—KšœœœB˜QKš
œ˜Kš
œ˜—K–Η
[fileName: 
ROPE, log: 
Interpress.LogProc, credentials: 
Interpress.Credentials _ NIL, externalInstructions: 
Interpress.Instructions _ NIL, defaultInstructions: 
Interpress.Instructions _ NIL]š
œ;˜;K–([fileName: 
ROPE, header: 
ROPE _ NIL]š
œ2˜2šœœ
œ˜%K–[]šŸœœœœ	œœ
œ˜F–I[self: 
ImagerInterpress.Ref, action: 
PROC [...], scale: 
REAL _ 1.0]šŸ	œœ˜-šŸœœ˜7Kš
œN˜NK˜—K–~[context: Imager.Context, proc: PROC [...], control: Profiles.Profile, color: Profiles.Profile, checkSystemSetting: PROC [...]˜„
K˜—K˜6Kšœ
˜—K–[self: 
ImagerInterpress.Ref]šœœ
œ#˜4Kšœ
œ
œ˜.Kšœ 
˜—Kšœ ˜—Kš
œ˜—K˜šŸœœœ'˜DKšœ	œ
œ˜!Kšœ˜Kš
œ˜—K˜KšŸœœœ#œ
œœœ
˜sK˜Kš
Ÿœœ
œœ	œ	˜;K˜Kš
Ÿœœ
œœ	œ	˜9K˜Kšœœ˜Kšœœ˜Kšœœ˜*K˜šŸ
œœœœ
œœ˜3Kš	œœ
œœœ
˜šœœœ˜K˜$Kšœ˜—Kšœœ
œ,˜7Kšœœ
œ3˜>Kšœœ
œ1˜<Kšœœ
œ,˜7Kšœ˜Kš
œ˜—K˜šŸœœœ˜GKš
œœ
œœ
œ
˜=Kš
œ˜—K˜šŸ
œœœ˜ K–S[message: 
ROPE, serviceData: 
ServicesExec.ServiceData, showTime: 
BOOL _ TRUE]š
œA˜AK–([base: 
ROPE _ NIL, rest: 
ROPE _ NIL]šœ	œ(˜5KšœIœ˜PKš
œ˜—K˜šŸ
œ˜$Kš
‘H™Hšœœ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜—K˜K˜Kš
œ˜Kš
œ7˜7Kš
œ%˜%Kš
œ˜—K˜—™šœœœœœ
œ
œ
œ
œ
œ™rK™—šŸœœœ
œ	œœœœœ˜mšŸœœœ˜2Jš	œœ
œœ
œ˜&J–3[text: 
REF TEXT _ NIL, oldStream: 
STREAM _ NIL]š	œœ
œœ
œ
˜Jšœ)˜+Jšœ(˜*Jšœ'˜)Jšœ˜Jšœ
˜Jšœœ
œ
˜$Jšœœ
œ˜Jšœœ˜Kš
œ˜—Kšœœœ
œ˜7Kš
œJ˜JK˜—K˜šŸœœ
œ˜*Kš
œ˜K˜K˜Kš
œ8˜8Kš
œ˜—K˜Kšœœœ˜%šœœœ˜Kšœœ
˜
Kšœ	œœ
˜Kšœ		˜Kš
œ˜—šŸœœœœ˜7K–<[variety: IO.StreamVariety, class: ATOM, getChar: PROC [...]šœ	œ
œœS˜sK–<[variety: IO.StreamVariety, class: ATOM, getChar: PROC [...]šœ
œ
œœT˜uKšœœ˜&K–Y[streamProcs: 
REF IO.StreamProcs, streamData: 
REF ANY, backingStream: 
STREAM _ NIL]šœœ6˜?K–Y[streamProcs: 
REF IO.StreamProcs, streamData: 
REF ANY, backingStream: 
STREAM _ NIL]šœœ7˜AK˜—K˜šŸœœ
œœœœ˜8Kšœ
œœ
˜Kšœœ˜,šœ˜Kšœ	˜
Kšœ˜	—K˜Jšœœ
˜Jšœ
˜Kš
œ˜—K˜š
Ÿœœ
œœœ˜2Kšœ
œœ
˜Kšœœ˜,šœ
œ˜Kšœ
˜Kšœ˜	—Kš
œ˜Jšœœ
˜Jšœ	˜Kš
œ˜—K˜—™šŸœœ˜Kš
œ(˜(Kš
œ&˜&Kš
œ)˜)Kš
œ˜——˜K˜
—K˜Kšœ˜—…—9€X$