DIRECTORY
Convert,
Rope,
PrintingP4V3,
PrintingP4V3Aux;

PrintingP4V3AuxImpl: CEDAR PROGRAM
IMPORTS Convert, Rope
EXPORTS PrintingP4V3Aux ~ {
OPEN PrintingP4V3, PrintingP4V3Aux;

ROPE: TYPE ~ Rope.ROPE;

ExposeAttribute: PUBLIC PROC [arg: Attribute, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["Attribute(", ExposeAttributeKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF AttributeObject.printObjectName => {
res _ Rope.Concat[res, it.printObjectName] };
it: REF AttributeObject.printObjectCreateDate => {
res _ Rope.Concat[res, Convert.RopeFromCard[it.printObjectCreateDate]] };
it: REF AttributeObject.senderName => {
res _ Rope.Concat[res, it.senderName] };
ENDCASE => ERROR
};

ExposePrintAttributes: PUBLIC PROC [arg: PrintAttributes, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..arg.length) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeAttribute[arg.body[i], (level+1)]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposeInterpressMasterStatus: PUBLIC PROC [arg: InterpressMasterStatus, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
pending => res _ "pending";
inProgress => res _ "inProgress";
completed => res _ "completed";
completedWithWarning => res _ "completedWithWarning";
unknown => res _ "unknown";
rejected => res _ "rejected";
aborted => res _ "aborted";
canceled => res _ "canceled";
held => res _ "held";
ENDCASE => ERROR
};

ExposeStatusKind: PUBLIC PROC [arg: StatusKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
spooler => res _ "spooler";
formatter => res _ "formatter";
printer => res _ "printer";
media => res _ "media";
ENDCASE => ERROR
};

ExposeJobStatusKind: PUBLIC PROC [arg: JobStatusKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
status => res _ "status";
statusMessage => res _ "statusMessage";
ENDCASE => ERROR
};

ExposeEmptyRecord: PUBLIC PROC [arg: EmptyRecord, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[]";
};

ExposePaperKind: PUBLIC PROC [arg: PaperKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
unknown => res _ "unknown";
knownSize => res _ "knownSize";
otherSize => res _ "otherSize";
ENDCASE => ERROR
};

ExposeTransferProblem: PUBLIC PROC [arg: TransferProblem, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
aborted => res _ "aborted";
formatIncorrect => res _ "formatIncorrect";
noRendezvous => res _ "noRendezvous";
wrongDirection => res _ "wrongDirection";
ENDCASE => ERROR
};

ExposeKnownPaperSize: PUBLIC PROC [arg: KnownPaperSize, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
usLetter => res _ "usLetter";
usLegal => res _ "usLegal";
a0 => res _ "a0";
a1 => res _ "a1";
a2 => res _ "a2";
a3 => res _ "a3";
a4 => res _ "a4";
a5 => res _ "a5";
a6 => res _ "a6";
a7 => res _ "a7";
a8 => res _ "a8";
a9 => res _ "a9";
isoB0 => res _ "isoB0";
isoB1 => res _ "isoB1";
isoB2 => res _ "isoB2";
isoB3 => res _ "isoB3";
isoB4 => res _ "isoB4";
isoB5 => res _ "isoB5";
isoB6 => res _ "isoB6";
isoB7 => res _ "isoB7";
isoB8 => res _ "isoB8";
isoB9 => res _ "isoB9";
isoB10 => res _ "isoB10";
jisB0 => res _ "jisB0";
jisB1 => res _ "jisB1";
jisB2 => res _ "jisB2";
jisB3 => res _ "jisB3";
jisB4 => res _ "jisB4";
jisB5 => res _ "jisB5";
jisB6 => res _ "jisB6";
jisB7 => res _ "jisB7";
jisB8 => res _ "jisB8";
jisB9 => res _ "jisB9";
jisB10 => res _ "jisB10";
a10 => res _ "a10";
ENDCASE => ERROR
};

ExposeOptionKind: PUBLIC PROC [arg: OptionKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
printObjectSize => res _ "printObjectSize";
recipientName => res _ "recipientName";
message => res _ "message";
copyCount => res _ "copyCount";
pagesToPrint => res _ "pagesToPrint";
mediumHint => res _ "mediumHint";
priorityHint => res _ "priorityHint";
releaseKey => res _ "releaseKey";
staple => res _ "staple";
twoSided => res _ "twoSided";
ENDCASE => ERROR
};

ExposeMedia: PUBLIC PROC [arg: Media, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..arg.length) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeMedium[arg.body[i], (level+1)]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposePriority: PUBLIC PROC [arg: Priority, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
low => res _ "low";
normal => res _ "normal";
high => res _ "high";
ENDCASE => ERROR
};

ExposeMarkingEngineStatus: PUBLIC PROC [arg: MarkingEngineStatus, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
available => res _ "available";
busy => res _ "busy";
disabled => res _ "disabled";
needsAttention => res _ "needsAttention";
needsKeyOperator => res _ "needsKeyOperator";
ENDCASE => ERROR
};

ExposeAttributeKind: PUBLIC PROC [arg: AttributeKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
printObjectName => res _ "printObjectName";
printObjectCreateDate => res _ "printObjectCreateDate";
senderName => res _ "senderName";
ENDCASE => ERROR
};

ExposePrintOptions: PUBLIC PROC [arg: PrintOptions, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..arg.length) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeOption[arg.body[i], (level+1)]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposeSpoolerStatus: PUBLIC PROC [arg: SpoolerStatus, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
available => res _ "available";
busy => res _ "busy";
disabled => res _ "disabled";
full => res _ "full";
ENDCASE => ERROR
};

ExposeServiceStatus: PUBLIC PROC [arg: ServiceStatus, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["ServiceStatus(", ExposeStatusKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF ServiceStatusObject.spooler => {
res _ Rope.Concat[res, ExposeSpoolerStatus[it.spooler, (level+1)]] };
it: REF ServiceStatusObject.formatter => {
res _ Rope.Concat[res, ExposeFormatterStatus[it.formatter, (level+1)]] };
it: REF ServiceStatusObject.printer => {
res _ Rope.Concat[res, ExposeMarkingEngineStatus[it.printer, (level+1)]] };
it: REF ServiceStatusObject.media => {
res _ Rope.Concat[res, ExposeMedia[it.media, (level+1)]] };
ENDCASE => ERROR
};

ExposePrinterProperties: PUBLIC PROC [arg: PrinterProperties, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..arg.length) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeProperty[arg.body[i], (level+1)]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposePrinterStatus: PUBLIC PROC [arg: PrinterStatus, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..arg.length) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeServiceStatus[arg.body[i], (level+1)]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposeProperty: PUBLIC PROC [arg: Property, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["Property(", ExposePropertyKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF PropertyObject.ppmedia => {
res _ Rope.Concat[res, ExposeMedia[it.ppmedia, (level+1)]] };
it: REF PropertyObject.ppstaple => {
res _ Rope.Concat[res, Convert.RopeFromBool[it.ppstaple]] };
it: REF PropertyObject.pptwoSided => {
res _ Rope.Concat[res, Convert.RopeFromBool[it.pptwoSided]] };
ENDCASE => ERROR
};

ExposeMediumKind: PUBLIC PROC [arg: MediumKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
paper => res _ "paper";
ENDCASE => ERROR
};

ExposeRequestStatus: PUBLIC PROC [arg: RequestStatus, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..arg.length) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeJobStatus[arg.body[i], (level+1)]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposeRequestID: PUBLIC PROC [arg: RequestID, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
FOR i: CARDINAL IN [0..5) DO
res _ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg[i]]];
ENDLOOP;
res _ Rope.Concat[res, "]"];
};

ExposeJobStatus: PUBLIC PROC [arg: JobStatus, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["JobStatus(", ExposeJobStatusKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF JobStatusObject.status => {
res _ Rope.Concat[res, ExposeInterpressMasterStatus[it.status, (level+1)]] };
it: REF JobStatusObject.statusMessage => {
res _ Rope.Concat[res, it.statusMessage] };
ENDCASE => ERROR
};

ExposeFormatterStatus: PUBLIC PROC [arg: FormatterStatus, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
available => res _ "available";
busy => res _ "busy";
disabled => res _ "disabled";
ENDCASE => ERROR
};

ExposePaper: PUBLIC PROC [arg: Paper, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["Paper(", ExposePaperKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF PaperObject.unknown => {
res _ Rope.Concat[res, ExposeEmptyRecord[it.unknown, (level+1)]] };
it: REF PaperObject.knownSize => {
res _ Rope.Concat[res, ExposeKnownPaperSize[it.knownSize, (level+1)]] };
it: REF PaperObject.otherSize => {
res _ Rope.Concat[res, ExposePaperDimensions[it.otherSize, (level+1)]] };
ENDCASE => ERROR
};

ExposePropertyKind: PUBLIC PROC [arg: PropertyKind, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
ppmedia => res _ "ppmedia";
ppstaple => res _ "ppstaple";
pptwoSided => res _ "pptwoSided";
ENDCASE => ERROR
};

ExposeOption: PUBLIC PROC [arg: Option, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["Option(", ExposeOptionKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF OptionObject.printObjectSize => {
res _ Rope.Concat[res, Convert.RopeFromCard[it.printObjectSize]] };
it: REF OptionObject.recipientName => {
res _ Rope.Concat[res, it.recipientName] };
it: REF OptionObject.message => {
res _ Rope.Concat[res, it.message] };
it: REF OptionObject.copyCount => {
res _ Rope.Concat[res, Convert.RopeFromCard[it.copyCount]] };
it: REF OptionObject.pagesToPrint => {
res _ Rope.Concat[res, ExposeDocumentSubrange[it.pagesToPrint, (level+1)]] };
it: REF OptionObject.mediumHint => {
res _ Rope.Concat[res, ExposeMedium[it.mediumHint, (level+1)]] };
it: REF OptionObject.priorityHint => {
res _ Rope.Concat[res, ExposePriority[it.priorityHint, (level+1)]] };
it: REF OptionObject.releaseKey => {
res _ Rope.Concat[res, Convert.RopeFromCard[it.releaseKey]] };
it: REF OptionObject.staple => {
res _ Rope.Concat[res, Convert.RopeFromBool[it.staple]] };
it: REF OptionObject.twoSided => {
res _ Rope.Concat[res, Convert.RopeFromBool[it.twoSided]] };
ENDCASE => ERROR
};

ExposeConnectionProblem: PUBLIC PROC [arg: ConnectionProblem, level: NAT] RETURNS [res: ROPE] ~ {
SELECT arg FROM
noRoute => res _ "noRoute";
noResponse => res _ "noResponse";
transmissionHardware => res _ "transmissionHardware";
transportTimeout => res _ "transportTimeout";
tooManyLocalConnections => res _ "tooManyLocalConnections";
tooManyRemoteConnections => res _ "tooManyRemoteConnections";
missingCourier => res _ "missingCourier";
missingProgram => res _ "missingProgram";
missingProcedure => res _ "missingProcedure";
protocolMismatch => res _ "protocolMismatch";
parameterInconsistency => res _ "parameterInconsistency";
invalidMessage => res _ "invalidMessage";
returnTimedOut => res _ "returnTimedOut";
otherCallProblem => res _ "otherCallProblem";
ENDCASE => ERROR
};

ExposePaperDimensions: PUBLIC PROC [arg: PaperDimensions, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
res _ Rope.Cat[res, "width~", Convert.RopeFromCard[arg.width], ", "];
res _ Rope.Cat[res, "length~", Convert.RopeFromCard[arg.length], "]"];
};

ExposeMedium: PUBLIC PROC [arg: Medium, level: NAT] RETURNS [res: ROPE] ~ {
res _ Rope.Cat["Medium(", ExposeMediumKind[arg.type, (level+1)], "): "];
WITH arg SELECT FROM
it: REF MediumObject.paper => {
res _ Rope.Concat[res, ExposePaper[it.paper, (level+1)]] };
ENDCASE => ERROR
};

ExposeDocumentSubrange: PUBLIC PROC [arg: DocumentSubrange, level: NAT] RETURNS [res: ROPE] ~ {
res _ "[";
res _ Rope.Cat[res, "beginningPageNumber~", Convert.RopeFromCard[arg.beginningPageNumber], ", "];
res _ Rope.Cat[res, "endingPageNumber~", Convert.RopeFromCard[arg.endingPageNumber], "]"];
};

}...

ÎPrintingP4V3AuxImpl.Mesa
Copyright (C) 1986 by Xerox Corporation.  All rights reserved.
Generated by Demers.pa at January 6, 1987 4:12:28 pm PST
using Sirocco [2.0] of January 6, 1987 4:07:33 pm PST
�Ê«˜š
œ™Jš
œ>™>Jš
œ8™8Jš
œ5™5J˜—š
Ïk	˜	J˜J˜J˜
J˜—J˜šÏnœ�œ
�˜"Jš�œ˜Jš�œ˜Jš�œ˜#J˜Jš�œ�œ�œ
˜J˜šžœ�œ
�œ�œ�œ�œ˜QJ˜Nš�œ�œ
�˜šœ�œ%˜,J˜-—šœ�œ+˜2J˜I—šœ�œ ˜'J˜(—Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜]J˜
š�œ�œ
�œ�˜%Jš	œ�œ�œ�œ
�œ+˜XJš�œ
˜—J˜J˜—J˜šžœ�œ
�œ&�œ�œ�œ˜kš�œ�˜J˜J˜!J˜J˜5J˜J˜J˜J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Sš�œ�˜J˜J˜J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Yš�œ�˜J˜J˜'Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜UJ˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Qš�œ�˜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˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Sš�œ�˜J˜+J˜'J˜J˜J˜%J˜!J˜%J˜!J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜IJ˜
š�œ�œ
�œ�˜%Jš	œ�œ�œ�œ
�œ(˜UJš�œ
˜—J˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Oš�œ�˜J˜J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ#�œ�œ�œ˜eš�œ�˜J˜J˜J˜J˜)J˜-Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Yš�œ�˜J˜+J˜7J˜!Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜WJ˜
š�œ�œ
�œ�˜%Jš	œ�œ�œ�œ
�œ(˜UJš�œ
˜—J˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Yš�œ�˜J˜J˜J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜YJ˜Oš�œ�œ
�˜šœ�œ!˜(J˜E—šœ�œ#˜*J˜I—šœ�œ!˜(J˜K—šœ�œ˜&J˜;—Jš�œ�˜—J˜—J˜šžœ�œ
�œ!�œ�œ�œ˜aJ˜
š�œ�œ
�œ�˜%Jš	œ�œ�œ�œ
�œ*˜WJš�œ
˜—J˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜YJ˜
š�œ�œ
�œ�˜%Jš	œ�œ�œ�œ
�œ/˜\Jš�œ
˜—J˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜OJ˜Lš�œ�œ
�˜šœ�œ˜#J˜=—šœ�œ˜$J˜<—šœ�œ˜&J˜>—Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Sš�œ�˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜YJ˜
š�œ�œ
�œ�˜%Jš	œ�œ�œ�œ
�œ+˜XJš�œ
˜—J˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜QJ˜
š�œ�œ
�œ�˜Jš	œ�œ�œ�œ
�œ ˜MJš�œ
˜—J˜J˜—J˜šžœ�œ
�œ�œ�œ�œ˜QJ˜Nš�œ�œ
�˜šœ�œ˜#J˜M—šœ�œ#˜*J˜+—Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜]š�œ�˜J˜J˜J˜Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜IJ˜Fš�œ�œ
�˜šœ�œ˜ J˜C—šœ�œ˜"J˜H—šœ�œ˜"J˜I—Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜Wš�œ�˜J˜J˜J˜!Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜KJ˜Hš�œ�œ
�˜šœ�œ"˜)J˜C—šœ�œ ˜'J˜+—šœ�œ˜!J˜%—šœ�œ˜#J˜=—šœ�œ˜&J˜M—šœ�œ˜$J˜A—šœ�œ˜&J˜E—šœ�œ˜$J˜>—šœ�œ˜ J˜:—šœ�œ˜"J˜<—Jš�œ�˜—J˜—J˜šžœ�œ
�œ!�œ�œ�œ˜aš�œ�˜J˜J˜!J˜5J˜-J˜;J˜=J˜)J˜)J˜-J˜-J˜9J˜)J˜)J˜-Jš�œ�˜—J˜—J˜šžœ�œ
�œ�œ�œ�œ˜]J˜
J˜EJ˜FJ˜—J˜šžœ�œ
�œ�œ�œ�œ˜KJ˜Hš�œ�œ
�˜šœ�œ˜J˜;—Jš�œ�˜—J˜—J˜šžœ�œ
�œ �œ�œ�œ˜_J˜
J˜aJ˜ZJ˜—J˜—J˜J˜—…—.,:¥