[Cyan]<CedarPS>PSExec>PSExecInitImpl.mesa!1

PSExecInitImpl.mesa

Last edited by Jacks 19-May-86 10:38:46

Initialization code for Services Executive interface to the Print Service.

DIRECTORY

BootSwitch USING [promptForInitializationParameters, Set],

Environment USING [PageCount],

Heap USING [Create, FreeNode, MakeNode],

Message USING [Expand, StringArray],

MiscUtilities USING [CalcPagesForBandBuffers, CalcRMPagesForMarker, pagesPerBandBuffer],

NetMgtServiceSupport USING [UnRegisterService],

NSExec USING [AddClientCommands, BroadcastAsyncMessage, ClientID, ClientStatus, Command, DestroyClient, Error, ExecProc, GetTTY, Handle, localExec, OutputHandle, Predicate, Run, StopMode, SystemFilingSession, UserAServerSA, UserLoggedOn, UserName, WorkingDirectory],

NSFile USING [Attributes, AttributesProc, DeleteByName, Error, GetAttributesByName, GetAttributesRecord, Handle, List, noSelections, ReleaseAttributesRecord, Selections, Session],

NSName USING [Name, NameRecord, nullNameRecord],

NSString USING [EquivalentStrings, FreeString, nullString, String, StringFromMesaString],

PaperTypes USING [PaperMMDimension],

PrintingTypes USING [Option, RavenBuild],

ProductFactoring USING [Enabled],

PS USING [bansheeConfigName, d1ConfigName, faxConfigName, fepsConfigName, fx3500ConfigName, ravenConfigName, reservedMemSaved],

PSAsyncMsg USING [nullInsertArray, nullMsg, Proc],

PSCommand USING [GetPrintServiceActivity, GetPrintServiceStatus, RegisterAsyncMessageProc, Start, Stop, StopPrinting, StopQueuing],

PSCommandExtras USING [ServiceState],

PSExec USING [GetClientID],

PSExecInternal,

PSExecMessages USING [Key],

PSInit USING [calculateDefaultBBAllocation, calculateDefaultRMAllocation, ExpungePrintService, InitializePrintService, InitializeState, OptionalParms, RequiredParms, unlimitedPrintingCutOffMemSize],

PSKMessages USING [DestroyMsgs, GetHandle],

PSState USING [CurrentActivity, StateHandle],

Runtime USING [VersionMismatch],

ServicesError USING [Catch, Caught, SetCatching],

ServicesPFOptions USING [psFax, psLowSpeed],

ServicesPFOptionsExtrasExtras USING [psFormatting, psLaserCP],

SpecialSpace USING [realMemorySize],

String USING [AppendLongDecimal],

TextInput USING [ChoiceIndex, Confirm, GetChoice, GetLongDecimal, GetTimedYesNo, nilChoice, nilDecimal, nilLongDecimal, nilYesNo],

Time USING [Unpack, Unpacked],

TTY USING [Handle, Rubout],

XFormat USING [Blanks, Handle, NSLine, NSString],

XMessage USING [Get, Handle, MsgKey],

XString USING [ReaderBody];

PSExecInitImpl: CEDAR PROGRAM

IMPORTS BootSwitch, Heap, Message, MiscUtilities, NetMgtServiceSupport, NSExec, NSFile, NSString, ProductFactoring, PS, PSCommand, PSCommandExtras, PSExec, PSExecInternal, PSInit, PSKMessages, Runtime, ServicesError, String, SpecialSpace, TextInput, Time, TTY, XFormat, XMessage

EXPORTS PSExecInternal

SHARES XString = BEGIN

NonNormalInitType: TYPE = {configure, deleteBackingFiles};

execHeap: PUBLIC UNCOUNTED ZONE ← Heap.Create[initial: 4]; --Heap used by PSExec*Impls for miscellaneous strings, etc; exported by PSExecInternal.

developmentMode: PUBLIC BOOLEAN ←

BootSwitch.Set[BootSwitch.promptForInitializationParameters];

boot switch determines if we're in development mode

psClientID: NSExec.ClientID ← PSExec.GetClientID[];

Message domain handles:

execMsgs: XMessage.Handle ← PSKMessages.GetHandle[exec];

************************************************

SERVICES EXECUTIVE INITIALIZATION PROCEDURES:

These procedures are exported by the PSExec

interface and used in the PSExecControlImpl module

in the call to NSExec.CreateClient.

************************************************

Initialize: PUBLIC PROCEDURE [exec: NSExec.Handle, normal: BOOLEAN] = BEGIN

nonNormalInit: NonNormalInitType ← configure;

engineFakerName: NSString.String = Str["EngineFakerConfig.bcd"L];

This is the name of the module that fakes the engine drivers when we run the PS in Tajo.

runningInTajo: BOOLEAN ← NSString.EquivalentStrings[PS.ravenConfigName, engineFakerName];

outputHandle: XFormat.Handle ← NSExec.OutputHandle[exec];

printingOption, oldPrintingOption: PrintingTypes.Option ← unknown;

state: PSState.StateHandle ← NIL;

newOptionChosen: BOOLEAN ← FALSE;

printServiceName: NSName.Name ← NIL;

requiredParms: PSInit.RequiredParms ← [printingOptionParms: unknown[]];

optionalParms: PSInit.OptionalParms ← [printingOptionParms: unknown[]];

DevelopmentModeInit: PROCEDURE = BEGIN

Sets optional init parameters.

If the user has already selected a new printing option, all the optional parameters

are defaulted to their normal values. If the user has NOT selected a new printing option, all the optional parameters are defaulted to their current values, as found in the state record.

defaultVMPagesForDecomposer: LONG CARDINAL ←

IF newOptionChosen THEN 6000 ELSE state.decomposerVMPages;

defaultDecomposerRMPageLimit: LONG CARDINAL ←

IF newOptionChosen THEN PSInit.calculateDefaultRMAllocation

ELSE state.decomposerRMPagesForMarker;

The defaultDecomposerRMPageLimit must be calculated after

we prompt for the number of band buffers!

defaultSpoolWhileMarking: BOOLEAN ←

IF newOptionChosen THEN TRUE ELSE state.spoolWhileMarking;

defaultBandBufferPages: LONG CARDINAL ←

IF newOptionChosen THEN PSInit.calculateDefaultBBAllocation

ELSE state.markerRMPagesForBands;

defaultDecomposeWhileMarking: BOOLEAN ←

IF newOptionChosen THEN TRUE ELSE state.decomposeWhileMarking;

IF normal THEN

For NORMAL STARTUP IN DEVELOPMENT MODE the user is not prompted to enter optional parameters. It is not usually possible to change the printing option during a normal startup, but if the product factoring has changed, such that the current printing option is no longer enabled, the user will be forced to choose another option. Therefore, the optional parameters are usually set to the current values from the state record or to certain known defaults for this mode--but if a new printing option HAS been chosen, the optional parameters are defaulted to the normal values for the new printing options.

SELECT printingOption FROM

bansheeDl => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: bansheeDl[

spoolWhileMarking: defaultSpoolWhileMarking,

decomposeWhileMarking: defaultDecomposeWhileMarking]

];

d1 => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: d1[

spoolWhileMarking: defaultSpoolWhileMarking,

decomposeWhileMarking: defaultDecomposeWhileMarking]

];

fax295 => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: fax295[

spoolWhileMarking: defaultSpoolWhileMarking,

decomposeWhileMarking: defaultDecomposeWhileMarking]

];

fax495 => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: fax495[

spoolWhileMarking: defaultSpoolWhileMarking,

decomposeWhileMarking: defaultDecomposeWhileMarking]

];

feps9700 => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: feps9700[]];

fx3500 => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: fx3500[

spoolWhileMarking: defaultSpoolWhileMarking,

decomposeWhileMarking: defaultDecomposeWhileMarking]

];

raven => optionalParms ← [

vmPagesForDecomposer: defaultVMPagesForDecomposer,

bandBufferPages: defaultBandBufferPages,

decomposerRMPageLimit: defaultDecomposerRMPageLimit,

deleteIncompatibleFontsandTPs: TRUE,

printingOptionParms: raven[

spoolWhileMarking: defaultSpoolWhileMarking,

decomposeWhileMarking: defaultDecomposeWhileMarking]

];

ENDCASE => ERROR

ELSE BEGIN

For NON-NORMAL STARTUP IN DEVELOPMENT MODE

the user is prompted the enter values for optional parameters.

SELECT printingOption FROM

bansheeDl => optionalParms ←

GetOptionalBansheeInitParms[

exec, requiredParms, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultSpoolWhileMarking,

defaultDecomposeWhileMarking, defaultBandBufferPages];

d1 => optionalParms ←

GetOptionalD1InitParms[exec, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultSpoolWhileMarking,

defaultDecomposeWhileMarking, defaultBandBufferPages];

fax295 => optionalParms ←

GetOptionalFax295InitParms[exec, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultSpoolWhileMarking,

defaultDecomposeWhileMarking, defaultBandBufferPages];

fax495 => optionalParms ←

GetOptionalFax495InitParms[exec, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultSpoolWhileMarking,

defaultDecomposeWhileMarking, defaultBandBufferPages];

feps9700 => optionalParms ←

GetOptionalFEPS9700InitParms[

exec, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultBandBufferPages];

fx3500 => optionalParms ←

GetOptionalFX3500InitParms[exec, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultSpoolWhileMarking,

defaultDecomposeWhileMarking, defaultBandBufferPages];

raven => optionalParms ←

GetOptionalRavenInitParms[

exec, requiredParms, defaultVMPagesForDecomposer,

defaultDecomposerRMPageLimit, defaultSpoolWhileMarking,

defaultDecomposeWhileMarking, defaultBandBufferPages];

ENDCASE => ERROR;

END;

END; --DevelopmentModeInit

*********** MAINLINE OF INITIALIZE ************--

IF ~ProductFactoring.Enabled[ServicesPFOptions.psLowSpeed] AND

~ProductFactoring.Enabled[ServicesPFOptions.psFax] AND

~ProductFactoring.Enabled[ServicesPFOptionsExtrasExtras.psFormatting] AND

~ProductFactoring.Enabled[ServicesPFOptionsExtrasExtras.psLaserCP] THEN

BEGIN

outputHandle.NSLine[M[mCannotRunPS]];

outputHandle.NSLine[M[mPSNotProductFactored]];

ERROR NSExec.Error[cannotInitialize];

END;

IF NOT PS.reservedMemSaved THEN BEGIN

outputHandle.NSLine[M[mCannotRunPS]];

outputHandle.NSLine[M[mMemoryNotAvailable]];

outputHandle.NSLine[M[mMeans]];

outputHandle.Blanks[8];

outputHandle.NSLine[M[mDeactivated]];

outputHandle.Blanks[8];

outputHandle.NSLine[M[mActivate]];

outputHandle.Blanks[8];

outputHandle.NSLine[M[mMemoryTaken]];

outputHandle.Blanks[8];

outputHandle.NSLine[M[mRunBeforeOtherServices]];

ERROR NSExec.Error[cannotInitialize];

END;

IF NOT normal THEN BEGIN

nonNormalInit ← GetNonNormalInitType[exec];

IF nonNormalInit = deleteBackingFiles THEN BEGIN

outputHandle.Blanks[8];

outputHandle.NSString[M[mDeletingFiles]];

PSInit.ExpungePrintService[deleteFonts: FALSE];

outputHandle.NSString[M[mFloppyDone]];

END;

PSInit.InitializeState[];

state ← PSCommand.GetPrintServiceStatus[];

oldPrintingOption ← state.option;

If it's a normal init in development mode, we provide a special prompt to determine if it should really be a normal init:

IF normal AND developmentMode THEN

normal ← TextInput.GetTimedYesNo[

tty: NSExec.GetTTY[exec], prompt: M[mRetainParameters],

timeAllotted: 10 --seconds--, valueIfTimedOut: yes] = yes;

****** NOTE: Remove this code in a later release ******

DeleteObsoleteBcds[workingDir: NSExec.WorkingDirectory[],

session: NSExec.SystemFilingSession[]];

printingOption ← GetPrintingOption[exec, normal, state, runningInTajo];

IF NOT runningInTajo THEN

IF NOT LoadAndRunPrintingOptionBcd[exec, printingOption] THEN

ERROR NSExec.Error[cannotInitialize];

newOptionChosen ← printingOption # oldPrintingOption;

requiredParms ← SELECT printingOption FROM

bansheeDl => GetRequiredBansheeInitParms[exec, normal, state, newOptionChosen],

d1 => [printingOptionParms: d1[]], --no required parms for d1

fax295 => GetRequiredFax295InitParms[exec, normal, state, newOptionChosen],

fax495 => GetRequiredFax495InitParms[exec, normal, state, newOptionChosen],

feps9700 => [printingOptionParms: feps9700[]], --no required parms for feps9700

fx3500 => [printingOptionParms: fx3500[]], --no required parms for fx3500

ENDCASE => GetRequiredRavenInitParms[exec, normal, state, newOptionChosen];

IF newOptionChosen THEN requiredParms.newParametersSpecified ← TRUE;

The stmt above must follow the previous calls to "GetRequiredXXXInitParms",

because those procs default newParametersSpecified to FALSE.

IF developmentMode THEN DevelopmentModeInit[]; --this proc sets the optional parameters

[, printServiceName] ← PSExecInternal.RegisterServiceAtClearinghouse[exec];

PSCommand.RegisterAsyncMessageProc[PutAsyncMessage]; --This is called before calling Initialize, since Initialize may generate some asynchronous messages.

PSInit.InitializePrintService[normal, printServiceName, requiredParms, optionalParms];

RegisterCommands[];

If there's a new printing option, may need to stop printing and remind the user to install fonts or set target print service:

IF newOptionChosen THEN SetInitialState[oldOption: oldPrintingOption, newOption: printingOption];

Queuing and printing should be stopped if it's a non-normal PS startup:

IF NOT normal THEN StopQueuingAndPrintingAbnormal[exec];

Start[exec]; --Call start proc.

END; --Initialize

Start: PUBLIC NSExec.ExecProc = {PSCommand.Start[]};

Stop: PUBLIC PROCEDURE [exec: NSExec.Handle, stopMode: NSExec.StopMode] = BEGIN

If not a cold quit and we are in repair mode, the user is prompted to confirm stopping the print service. If for some reason no one can provide confirmation at the TTY window, stopping is aborted.

ENABLE BEGIN

TTY.Rubout => GOTO Exit;

NSExec.Error => IF type = invalidExec THEN GOTO Exit;

END;

IF stopMode = quiesce AND RepairMode[] THEN

IF TextInput.GetTimedYesNo [

tty: NSExec.GetTTY[exec], prompt: M[mPrintServerinRepairMode],

timeAllotted: 60--seconds--, valueIfTimedOut: no] = no

THEN RETURN;

PSCommand.Stop[];

EXITS Exit => NULL;

END; --Stop

Expunge: PUBLIC NSExec.ExecProc = BEGIN

servicesWorkDir: NSFile.Handle ← NSExec.WorkingDirectory[];

servicesSession: NSFile.Session ← NSExec.SystemFilingSession[];

IF TextInput.Confirm[NSExec.GetTTY[exec], M[mExpungeWarning]] THEN BEGIN

[] ← PSExecInternal.DeleteServiceFromClearinghouse[exec];

PSInit.ExpungePrintService[deleteFonts: TRUE];

PSKMessages.DestroyMsgs[];

NetMgtServiceSupport.UnRegisterService[psClientID];

NSExec.DestroyClient[psClientID];

END

ELSE ERROR NSExec.Error[cannotExpunge];

END; --Expunge

Name: PUBLIC PROCEDURE [nameProc: PROCEDURE [clientName: NSString.String]] =

BEGIN

IF PSExecInternal.printServiceName # NIL THEN

nameProc[PSExecInternal.printServiceName.local]

ELSE nameProc[M[mNull]];

END; --Name

Status: PUBLIC PROCEDURE [

statusProc: PROCEDURE [status: NSExec.ClientStatus, comment: NSString.String]] = BEGIN

statusProc[status: SELECT PSCommandExtras.ServiceState[] FROM

starting => starting, stopped => stopped,

stopping => stopping, ENDCASE => started,

comment: NSString.nullString];

END; --Status

PrintServiceCommand: PUBLIC NSExec.ExecProc =

BEGIN --called whenever "Print Service" command is entered

END; --PrintServiceCommand

================================================

Actual Print Service Initialization Routines:

================================================

**** NON NORMAL INIT TYPE ****

GetNonNormalInitType: PROCEDURE [exec: NSExec.Handle]

RETURNS [type: NonNormalInitType] = BEGIN

type ← PromptForNonNormalInitType[exec];

SELECT type FROM

configure => EXIT;

deleteBackingFiles =>

IF TextInput.Confirm[

NSExec.GetTTY[exec], M[mConfirmDeleteBackingFiles]] THEN EXIT;

ENDCASE;

ENDLOOP;

END; -- GetNonNormalInitType

**** ENGINE TYPE ****

GetPrintingOption: PROCEDURE [exec: NSExec.Handle, normal: BOOLEAN,

state: PSState.StateHandle, runningInTajo: BOOLEAN]

RETURNS [option: PrintingTypes.Option] =

Option choices are currently: raven, d1, fx3500, bansheeDl, fax495 and feps9700.

Code for fax295 has been included, but it is not enabled.

BEGIN OPEN S: NSString;

ENABLE {TTY.Rubout => RETRY};

outputHandle: XFormat.Handle ← NSExec.OutputHandle[exec];

optionBcdCount: CARDINAL ← 0; --set to number of printing option bcds installed on working directory

printingOptionCount: CARDINAL ← 0; --set to number of options currently available (bcd installed and product factored)

availablePrintingOptions: LONG DESCRIPTOR FOR ARRAY OF PrintingTypes.Option ← DESCRIPTOR[NIL, 0]; --array of options which are installed and product factored

pfEnabled: ARRAY PrintingTypes.Option OF BOOLEAN ← ALL[FALSE]; --each options may or may not be product factoring enabled

bcdInstalled: ARRAY PrintingTypes.Option OF BOOLEAN ← ALL[FALSE]; --each option may or may not have its bcd installed

FindPrintingOptionBcds: PROCEDURE =

Proc looks for printing option configs installed on the working directory.

BEGIN

selections: NSFile.Selections ← NSFile.noSelections;

CompareBcdNames: NSFile.AttributesProc = BEGIN

IF NSString.EquivalentStrings[attributes.name, PS.ravenConfigName] THEN

{bcdInstalled[raven] ← TRUE; optionBcdCount ← optionBcdCount + 1} ELSE

IF NSString.EquivalentStrings[attributes.name, PS.bansheeConfigName] THEN

{bcdInstalled[bansheeDl] ← TRUE; optionBcdCount ← optionBcdCount + 1} ELSE

IF NSString.EquivalentStrings[attributes.name, PS.faxConfigName] THEN

{bcdInstalled[fax495] ← TRUE; optionBcdCount ← optionBcdCount + 1} ELSE

IF NSString.EquivalentStrings[attributes.name, PS.fepsConfigName] THEN

{bcdInstalled[feps9700] ← TRUE; optionBcdCount ← optionBcdCount + 1} ELSE

IF NSString.EquivalentStrings[attributes.name, PS.fx3500ConfigName] THEN

{bcdInstalled[fx3500] ← TRUE; optionBcdCount ← optionBcdCount + 1} ELSE

IF NSString.EquivalentStrings[attributes.name, PS.d1ConfigName] THEN

{bcdInstalled[d1] ← TRUE; optionBcdCount ← optionBcdCount + 1};

END;

IF runningInTajo THEN

BEGIN --If we are running in Tajo, we don't

need to check for option configs on the working directory.

bcdInstalled ← ALL[TRUE];

optionBcdCount ← 6; --UPDATE this number when adding options!

END

ELSE BEGIN

selections.interpreted[name] ← TRUE;

NSFile.List[

directory: NSExec.WorkingDirectory[], proc: CompareBcdNames,

selections: selections, session: NSExec.SystemFilingSession[]];

END;

END; -- of FindPrintingOptionBcds

FillProductFactoringArray: PROCEDURE = BEGIN

Proc checks product factoring for all printing options.

pfEnabled[d1] ← pfEnabled[fx3500] ← pfEnabled[raven] ←

ProductFactoring.Enabled[ServicesPFOptions.psLowSpeed];

pfEnabled[bansheeDl] ← ProductFactoring.Enabled[

ServicesPFOptionsExtrasExtras.psLaserCP];

pfEnabled[fax495] ← ProductFactoring.Enabled[ServicesPFOptions.psFax];

pfEnabled[feps9700] ← ProductFactoring.Enabled[

ServicesPFOptionsExtrasExtras.psFormatting];

END; -- of FillProductFactoringArray

FillPrintingOptionArray: PROCEDURE = BEGIN

optionUnused: PACKED ARRAY PrintingTypes.Option OF BOOLEAN ← ALL[TRUE]; --array element for a given option becomes false when option is put into the array

availablePrintingOptions ← DESCRIPTOR[Heap.MakeNode[

execHeap, SIZE[PrintingTypes.Option] * printingOptionCount], printingOptionCount];

FOR i: CARDINAL IN [0..printingOptionCount) DO

SELECT TRUE FROM

These select arms are in the specific order that the user will see the options displayed:

pfEnabled[raven] AND bcdInstalled[raven] AND optionUnused[raven] => availablePrintingOptions[i] ← raven;

pfEnabled[bansheeDl] AND bcdInstalled[bansheeDl] AND optionUnused[bansheeDl] => availablePrintingOptions[i] ← bansheeDl;

pfEnabled[fx3500] AND bcdInstalled[fx3500] AND optionUnused[fx3500] => availablePrintingOptions[i] ← fx3500;

pfEnabled[d1] AND bcdInstalled[d1] AND optionUnused[d1] => availablePrintingOptions[i] ← d1;

pfEnabled[fax295] AND bcdInstalled[fax295] AND optionUnused[fax295] => availablePrintingOptions[i] ← fax295;

pfEnabled[fax495] AND bcdInstalled[fax495] AND optionUnused[fax495] => availablePrintingOptions[i] ← fax495;

pfEnabled[feps9700] AND bcdInstalled[feps9700] AND optionUnused[feps9700] => availablePrintingOptions[i] ← feps9700;

ENDCASE => ERROR; --something's very wrong

optionUnused[availablePrintingOptions[i]] ← FALSE;

ENDLOOP;

END; -- of FillPrintingOptionArray

Mainline code for GetPrintingOption:

BEGIN

FillProductFactoringArray[]; --see which options are product factored

FindPrintingOptionBcds[]; --see which options are installed

IF optionBcdCount = 0 THEN BEGIN

outputHandle.NSLine[M[mCannotRunPS]];

outputHandle.NSLine[M[mNoPrintingOptionSoftware]];

GOTO cannotInitialize;

END;

FOR option: PrintingTypes.Option IN PrintingTypes.Option DO

IF pfEnabled[option] AND bcdInstalled[option] THEN

printingOptionCount ← printingOptionCount + 1;

ENDLOOP;

IF printingOptionCount = 0 THEN BEGIN

outputHandle.NSLine[M[mCannotRunPS]];

outputHandle.NSLine[M[mOptionsNotProductFactored]];

GOTO cannotInitialize;

END;

FillPrintingOptionArray[]; --Stores printing options currently enabled into availablePrintingOptions array.

IF NOT normal OR state.option = unknown OR

NOT pfEnabled[state.option] OR

NOT bcdInstalled[state.option] THEN

option ← PromptForPrintingOption[

exec: exec,

currentOption: state.option,

optionCount: printingOptionCount,

optionChoices: availablePrintingOptions

]

ELSE option ← state.option;

Heap.FreeNode[execHeap, BASE[availablePrintingOptions]];

EXITS cannotInitialize => BEGIN

Heap.FreeNode[execHeap, BASE[availablePrintingOptions]];

ERROR NSExec.Error[cannotInitialize];

END;

END; --GetPrintingOption

**** REQUIRED ENGINE INITIALIZATION PARAMETERS ****

GetRequiredBansheeInitParms: PROCEDURE [exec: NSExec.Handle, normal: BOOLEAN,

state: PSState.StateHandle, newOptionChosen: BOOLEAN]

RETURNS [bansheeParms: bansheeDl PSInit.RequiredParms] = BEGIN

bansheeParms.invertingPaperTrayAttached ← FALSE; --not currently used

SELECT TRUE FROM

newOptionChosen => BEGIN

bansheeParms.enableUnlimitedPrinting ←

IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize THEN

PromptAboutUnlimitedPrinting[exec: exec, useDefault: FALSE]

ELSE FALSE;

bansheeParms.newParametersSpecified ← TRUE;

END;

NOT normal => WITH s: state SELECT FROM

bansheeDl => BEGIN

bansheeParms.enableUnlimitedPrinting ←

IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize THEN

PromptAboutUnlimitedPrinting[

exec: exec, useDefault: TRUE,

defaultToTrue: s.enableUnlimitedPrinting]

ELSE FALSE;

bansheeParms.newParametersSpecified ← TRUE; --set true whether the version really changed or not

END;

ENDCASE => ERROR;

ENDCASE => WITH s: state SELECT FROM

bansheeDl =>

IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize THEN

bansheeParms.enableUnlimitedPrinting ← s.enableUnlimitedPrinting

ELSE BEGIN

IF s.enableUnlimitedPrinting THEN

mem size changed; unlimited printing no longer available

bansheeParms.newParametersSpecified ← TRUE;

bansheeParms.enableUnlimitedPrinting ← FALSE;

END;

ENDCASE => ERROR;

END; --GetRequiredBansheeInitParms

GetRequiredFax295InitParms: PROCEDURE [exec: NSExec.Handle, normal: BOOLEAN,

state: PSState.StateHandle, newOptionChosen: BOOLEAN]

RETURNS [fax295Parms: fax295 PSInit.RequiredParms] = BEGIN

SELECT TRUE FROM

newOptionChosen => BEGIN

fax295Parms.paperWidth ← PromptForFaxPaperWidth[

exec: exec, useDefault: FALSE];

fax295Parms.newParametersSpecified ← TRUE;

END;

NOT normal => WITH s: state SELECT FROM

fax295 => BEGIN

fax295Parms.paperWidth ← PromptForFaxPaperWidth[

exec: exec, useDefault: TRUE, defaultWidth: s.paperWidth];

fax295Parms.newParametersSpecified ← TRUE; --set true whether the version really changed or not

END;

ENDCASE => ERROR;

ENDCASE => WITH s: state SELECT FROM

fax295 => fax295Parms.paperWidth ← s.paperWidth; --keep same value as before

ENDCASE => ERROR;

END; --GetRequiredFax295InitParms

GetRequiredFax495InitParms: PROCEDURE [exec: NSExec.Handle, normal: BOOLEAN,

state: PSState.StateHandle, newOptionChosen: BOOLEAN]

RETURNS [fax495Parms: fax495 PSInit.RequiredParms] = BEGIN

SELECT TRUE FROM

newOptionChosen => BEGIN

fax495Parms.paperWidth ← PromptForFaxPaperWidth[

exec: exec, useDefault: FALSE];

fax495Parms.supportFineResolution ← PromptForFaxTransmissionResolution[

exec: exec, useDefault: FALSE];

fax495Parms.newParametersSpecified ← TRUE;

END;

NOT normal => WITH s: state SELECT FROM

fax495 => BEGIN

fax495Parms.paperWidth ← PromptForFaxPaperWidth[

exec: exec, useDefault: TRUE, defaultWidth: s.paperWidth];

fax495Parms.supportFineResolution ← PromptForFaxTransmissionResolution[

exec: exec, useDefault: TRUE, defaultToFine: s.fineResolutionSupported];

fax495Parms.newParametersSpecified ← TRUE; --set true whether the version really changed or not

END;

ENDCASE => ERROR;

ENDCASE => WITH s: state SELECT FROM

fax495 => BEGIN --keep same values as before

fax495Parms.paperWidth ← s.paperWidth;

fax495Parms.supportFineResolution ← s.fineResolutionSupported;

END;

ENDCASE => ERROR;

END; --GetRequiredFax295InitParms

GetRequiredRavenInitParms: PROCEDURE [exec: NSExec.Handle, normal: BOOLEAN,

state: PSState.StateHandle, newOptionChosen: BOOLEAN]

RETURNS [ravenParms: raven PSInit.RequiredParms] = BEGIN

SELECT TRUE FROM

newOptionChosen => BEGIN

ravenParms.version ←

PromptForRavenVersion[exec: exec, useDefault: FALSE];

ravenParms.enableUnlimitedPrinting ←

IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize THEN

PromptAboutUnlimitedPrinting[exec: exec, useDefault: FALSE]

ELSE FALSE;

ravenParms.newParametersSpecified ← TRUE;

END;

NOT normal => WITH s: state SELECT FROM

raven => BEGIN

ravenParms.version ←

PromptForRavenVersion[exec: exec, useDefault: TRUE, defaultVersion: s.engineBuild];

ravenParms.enableUnlimitedPrinting ←

IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize THEN

PromptAboutUnlimitedPrinting[

exec: exec, useDefault: TRUE, defaultToTrue: s.enableUnlimitedPrinting]

ELSE FALSE;

ravenParms.newParametersSpecified ← TRUE; --set true whether the version really changed or not

END;

ENDCASE => ERROR;

ENDCASE => WITH s: state SELECT FROM

raven => BEGIN --keep same values as before

ravenParms.version ← s.engineBuild;

IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize THEN

ravenParms.enableUnlimitedPrinting ← s.enableUnlimitedPrinting

ELSE BEGIN

IF s.enableUnlimitedPrinting THEN

mem size changed; unlimited printing no longer available

ravenParms.newParametersSpecified ← TRUE;

ravenParms.enableUnlimitedPrinting ← FALSE;

END;

ENDCASE => ERROR;

END; --GetRequiredRavenInitParms

**** OPTIONAL ENGINE INITIALIZATION PARAMETERS ****

GetOptionalBansheeInitParms: PROCEDURE [exec: NSExec.Handle,

requiredParms: PSInit.RequiredParms,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultSpoolWhileMarking: BOOLEAN,

defaultDecomposeWhileMarking: BOOLEAN,

defaultBBPages: LONG CARDINAL]

RETURNS [bansheeParms: bansheeDl PSInit.OptionalParms] = BEGIN

normalBBPages, normalRMPageLimit: LONG CARDINAL ← 0;

bansheeParms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

bansheeParms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

bansheeParms.spoolWhileMarking ← PromptForSpoolWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultSpoolWhileMarking];

bansheeParms.decomposeWhileMarking ← PromptForDecomposeWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultDecomposeWhileMarking];

WITH r: requiredParms SELECT FROM

bansheeDl => BEGIN

normalBBPages ← MiscUtilities.CalcPagesForBandBuffers[

bansheeDl, r.enableUnlimitedPrinting];

bansheeParms.bandBufferPages ← PromptForBandBufferPages[

exec: exec, useDefault: TRUE, normalValue: normalBBPages,

minValue: 3, maxValue: 7,

defaultValue: IF defaultBBPages = PSInit.calculateDefaultBBAllocation

THEN normalBBPages ELSE defaultBBPages];

END;

ENDCASE => ERROR;

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[bansheeParms.bandBufferPages];

bansheeParms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit

];

END; --GetOptionalBansheeInitParms

GetOptionalD1InitParms: PROCEDURE [exec: NSExec.Handle,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultSpoolWhileMarking: BOOLEAN,

defaultDecomposeWhileMarking: BOOLEAN,

defaultBBPages: LONG CARDINAL]

RETURNS [d1Parms: d1 PSInit.OptionalParms] = BEGIN

normalBBPages, normalRMPageLimit: LONG CARDINAL ← 0;

d1Parms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

d1Parms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

d1Parms.spoolWhileMarking ← PromptForSpoolWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultSpoolWhileMarking];

d1Parms.decomposeWhileMarking ← PromptForDecomposeWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultDecomposeWhileMarking];

normalBBPages ← MiscUtilities.CalcPagesForBandBuffers[d1];

d1Parms.bandBufferPages ← PromptForBandBufferPages[

exec: exec, useDefault: TRUE, normalValue: normalBBPages,

minValue: 3, maxValue: 8,

defaultValue: IF defaultBBPages = PSInit.calculateDefaultBBAllocation

THEN normalBBPages ELSE defaultBBPages];

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[d1Parms.bandBufferPages];

d1Parms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit

];

END; --GetOptionalD1InitParms

GetOptionalFax295InitParms: PROCEDURE [exec: NSExec.Handle,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultSpoolWhileMarking: BOOLEAN,

defaultDecomposeWhileMarking: BOOLEAN,

defaultBBPages: LONG CARDINAL]

RETURNS [fax295Parms: fax295 PSInit.OptionalParms] = BEGIN

normalBBPages, normalRMPageLimit: LONG CARDINAL ← 0;

fax295Parms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

fax295Parms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

fax295Parms.spoolWhileMarking ← PromptForSpoolWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultSpoolWhileMarking];

fax295Parms.decomposeWhileMarking ← PromptForDecomposeWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultDecomposeWhileMarking];

normalBBPages ← MiscUtilities.CalcPagesForBandBuffers[fax295];

fax295Parms.bandBufferPages ← PromptForBandBufferPages[

exec: exec, useDefault: TRUE, normalValue: normalBBPages,

minValue: 3, maxValue: 7,

defaultValue: IF defaultBBPages = PSInit.calculateDefaultBBAllocation

THEN normalBBPages ELSE defaultBBPages];

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[fax295Parms.bandBufferPages];

fax295Parms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit];

END; --GetOptionalFax295InitParms

GetOptionalFax495InitParms: PROCEDURE [exec: NSExec.Handle,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultSpoolWhileMarking: BOOLEAN,

defaultDecomposeWhileMarking: BOOLEAN,

defaultBBPages: LONG CARDINAL]

RETURNS [fax495Parms: fax495 PSInit.OptionalParms] = BEGIN

normalBBPages, normalRMPageLimit: LONG CARDINAL ← 0;

fax495Parms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

fax495Parms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

fax495Parms.spoolWhileMarking ← PromptForSpoolWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultSpoolWhileMarking];

fax495Parms.decomposeWhileMarking ← PromptForDecomposeWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultDecomposeWhileMarking];

normalBBPages ← MiscUtilities.CalcPagesForBandBuffers[fax495];

fax495Parms.bandBufferPages ← PromptForBandBufferPages[

exec: exec, useDefault: TRUE, normalValue: normalBBPages,

minValue: 3, maxValue: 7,

defaultValue: IF defaultBBPages = PSInit.calculateDefaultBBAllocation

THEN normalBBPages ELSE defaultBBPages];

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[fax495Parms.bandBufferPages];

fax495Parms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit];

END; --GetOptionalFax495InitParms

GetOptionalFEPS9700InitParms: PROCEDURE [exec: NSExec.Handle,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultBBPages: LONG CARDINAL]

RETURNS [feps9700Parms: feps9700 PSInit.OptionalParms] = BEGIN

normalRMPageLimit: LONG CARDINAL ← 0;

feps9700Parms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

feps9700Parms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

feps9700Parms.bandBufferPages ← MiscUtilities.CalcPagesForBandBuffers[feps9700];

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[feps9700Parms.bandBufferPages];

feps9700Parms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit];

END; --GetOptionalFEPS9700Parms

GetOptionalFX3500InitParms: PROCEDURE [exec: NSExec.Handle,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultSpoolWhileMarking: BOOLEAN,

defaultDecomposeWhileMarking: BOOLEAN,

defaultBBPages: LONG CARDINAL]

RETURNS [fx3500Parms: fx3500 PSInit.OptionalParms] = BEGIN

normalBBPages, normalRMPageLimit: LONG CARDINAL ← 0;

fx3500Parms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

fx3500Parms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

fx3500Parms.spoolWhileMarking ← PromptForSpoolWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultSpoolWhileMarking];

fx3500Parms.decomposeWhileMarking ← PromptForDecomposeWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultDecomposeWhileMarking];

normalBBPages ← MiscUtilities.CalcPagesForBandBuffers[fx3500];

fx3500Parms.bandBufferPages ← PromptForBandBufferPages[

exec: exec, useDefault: TRUE, normalValue: normalBBPages,

minValue: 3, maxValue: 7,

defaultValue: IF defaultBBPages = PSInit.calculateDefaultBBAllocation

THEN normalBBPages ELSE defaultBBPages];

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[fx3500Parms.bandBufferPages];

fx3500Parms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit];

END; --GetOptionalFX3500InitParms

GetOptionalRavenInitParms: PROCEDURE [exec: NSExec.Handle,

requiredParms: PSInit.RequiredParms,

defaultVMPagesForDecomposer: LONG CARDINAL,

defaultDecomposerRMPageLimit: LONG CARDINAL,

defaultSpoolWhileMarking: BOOLEAN,

defaultDecomposeWhileMarking: BOOLEAN,

defaultBBPages: LONG CARDINAL]

RETURNS [ravenParms: raven PSInit.OptionalParms] = BEGIN

normalBBPages, normalRMPageLimit: LONG CARDINAL ← 0;

ravenParms.vmPagesForDecomposer ← PromptForVMPagesForDecomposer[

exec: exec, useDefault: TRUE, defaultValue: defaultVMPagesForDecomposer];

ravenParms.deleteIncompatibleFontsandTPs ← PromptWithFontDeletionQuestion[

exec: exec, useDefault: TRUE, defaultToTrue: TRUE];

ravenParms.spoolWhileMarking ← PromptForSpoolWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultSpoolWhileMarking];

ravenParms.decomposeWhileMarking ← PromptForDecomposeWhileMarking[

exec: exec, useDefault: TRUE, defaultToTrue: defaultDecomposeWhileMarking];

WITH r: requiredParms SELECT FROM

raven => BEGIN

normalBBPages ← MiscUtilities.CalcPagesForBandBuffers[

raven, r.enableUnlimitedPrinting];

ravenParms.bandBufferPages ← PromptForBandBufferPages[

exec: exec, useDefault: TRUE, normalValue: normalBBPages,

minValue: 3, maxValue: 7,

defaultValue: IF defaultBBPages = PSInit.calculateDefaultBBAllocation

THEN normalBBPages ELSE defaultBBPages];

END;

ENDCASE => ERROR;

Must prompt for RM page limit after prompting for band buffer pages, since the number of band buffer pages is a parameter for calculating the RM limit:

normalRMPageLimit ← MiscUtilities.CalcRMPagesForMarker[ravenParms.bandBufferPages];

ravenParms.decomposerRMPageLimit ← PromptForRMAllocation[

exec: exec, useDefault: TRUE, normalValue: normalRMPageLimit,

defaultValue:

IF defaultDecomposerRMPageLimit = PSInit.calculateDefaultRMAllocation

THEN normalRMPageLimit ELSE defaultDecomposerRMPageLimit];

END; --GetOptionalRavenInitParms

==============================

SUPPORT ROUTINES

==============================

DeleteObsoleteBcds: PROCEDURE [

workingDir: NSFile.Handle, session: NSFile.Session] =

Deletes obsolete bcds from the working directory. This proc is currently backwards compatible to Services 8.0. NOTE: Update or delete the proc in a later release.

BEGIN

Delete the old loadable engine config used for Print Service 8 and 9, but obsolete in 10.0.

oldEngineConfigName: NSString.String = Str["PSEngineConfig.bcd"L];

NSFile.DeleteByName[workingDir, oldEngineConfigName, session

! NSFile.Error => GOTO NoEngineConfig];

If engine config isn't there, don't bother looking for RS232CCommon.

BEGIN

Delete RS232CCommon.bcd, used for Print Service 8 and 9, but obsolete in 10.0. Must check create date of file, so we don't delete it if it is a current version that may be used by other services.

rs232CCommonName: NSString.String = Str["RS232CCommon.bcd"L];

selections: NSFile.Selections ← NSFile.noSelections;

attribute: NSFile.Attributes ← NSFile.GetAttributesRecord[];

fileDate: Time.Unpacked;

BEGIN

selections.interpreted[createdOn] ← TRUE;

NSFile.GetAttributesByName[workingDir, rs232CCommonName, selections,

attribute, session ! NSFile.Error => GOTO NoRS232CCommon];

fileDate ← Time.Unpack[attribute.createdOn];

IF fileDate.year = 1984 THEN

NSFile.DeleteByName[workingDir, rs232CCommonName, session];

NSFile.ReleaseAttributesRecord[attribute];

EXITS NoRS232CCommon => NSFile.ReleaseAttributesRecord[attribute];

END;

EXITS NoEngineConfig => NULL;

END; -- of DeleteObsoleteBcds

LoadAndRunPrintingOptionBcd: PROCEDURE [

exec: NSExec.Handle, option: PrintingTypes.Option]

RETURNS [success: BOOLEAN] = BEGIN

runFailed: BOOLEAN ← FALSE;

bcdToRun: NSString.String ← SELECT option FROM

bansheeDl => PS.bansheeConfigName,

d1 => PS.d1ConfigName,

fax295, fax495 => PS.faxConfigName,

feps9700 => PS.fepsConfigName,

fx3500 => PS.fx3500ConfigName,

ENDCASE => PS.ravenConfigName;

VersionMismatchError: PROCEDURE RETURNS [resume: BOOLEAN ← FALSE] = BEGIN

stringArray: ARRAY [0..1) OF NSString.String ← [bcdToRun];

freeThisString: NSString.String ← Message.Expand[

M[mContinueToRun], DESCRIPTOR[stringArray], execHeap];

resume ← TextInput.Confirm[NSExec.GetTTY[exec], freeThisString];

NSString.FreeString[execHeap, freeThisString];

IF NOT resume THEN BEGIN

outputHandle: XFormat.Handle ← NSExec.OutputHandle[exec];

stringArray[0] ← bcdToRun;

freeThisString ← Message.Expand[

M[mNotRun], DESCRIPTOR[stringArray], execHeap];

outputHandle.Blanks[8];

outputHandle.NSLine[freeThisString];

NSString.FreeString[execHeap, freeThisString];

runFailed ← TRUE;

END;

END; --VersionMismatchError

Run: PROCEDURE = BEGIN

resume: BOOLEAN ← FALSE;

ServicesError.SetCatching[on: TRUE];

NSExec.Run[bcdToRun, exec, --codeLinks: -- TRUE!

ServicesError.Caught => {

IF (resume ← VersionMismatchError[]) THEN {

ServicesError.SetCatching[on: FALSE]; RETRY}

ELSE CONTINUE};

Runtime.VersionMismatch =>

IF resume THEN {

resume ← FALSE; -- allows subsequent version mismatches to be flagged to the user

ServicesError.SetCatching[on: TRUE];

RESUME}

ELSE REJECT];

END; -- Run

ServicesError.Catch[Run, LOOPHOLE[exec]];

RETURN [success ← NOT runFailed];

END; -- of LoadAndRunPrintingOptionBcd

PromptAboutUnlimitedPrinting: PROCEDURE [

exec: NSExec.Handle, useDefault: BOOLEAN, defaultToTrue: BOOLEAN ← TRUE]

RETURNS [enableUnlimitedPrinting: BOOLEAN] = BEGIN

enableUnlimitedPrinting ← TextInput.Confirm[

tty: NSExec.GetTTY[exec], prompt: M[mUnlimitedPrintingPrompt],

default: IF useDefault THEN

IF defaultToTrue THEN yes ELSE no

ELSE TextInput.nilYesNo];

END; --PromptAboutUnlimitedPrinting

PromptForBandBufferPages: PROCEDURE [

exec: NSExec.Handle, useDefault: BOOLEAN,

normalValue, minValue, maxValue: LONG CARDINAL,

defaultValue: LONG CARDINAL ← 0] RETURNS [bandBufferPages: LONG CARDINAL] = BEGIN

NOTE: See MiscUtilitiesImpl.mesa for detailed explanation of band buffer allocation, including the min, max and normal values.

normalCount: LONG CARDINAL ← normalValue/MiscUtilities.pagesPerBandBuffer;

bandBuffers: LONG CARDINAL ← 0;

sNormalCount: LONG STRING ← [10];

sBBPages: LONG STRING ← [10];

freeThisString: NSString.String;

stringArray: ARRAY [0..2) OF NSString.String;

String.AppendLongDecimal[sNormalCount, normalCount];

stringArray[0] ← Str[sNormalCount];

String.AppendLongDecimal[sBBPages, MiscUtilities.pagesPerBandBuffer];

stringArray[1] ← Str[sBBPages];

freeThisString ← Message.Expand[

M[mBandBuffersPrompt], DESCRIPTOR[stringArray], execHeap];

bandBuffers ← TextInput.GetLongDecimal[

tty: NSExec.GetTTY[exec], prompt: freeThisString,

min: minValue, max: maxValue,

default: IF useDefault THEN defaultValue/MiscUtilities.pagesPerBandBuffer ELSE TextInput.nilDecimal];

bandBufferPages ← bandBuffers * MiscUtilities.pagesPerBandBuffer;

NSString.FreeString[execHeap, freeThisString];

END; --PromptForBandBufferPages

PromptForDecomposeWhileMarking: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

defaultToTrue: BOOLEAN] RETURNS [decomposeWhileMarking: BOOLEAN] = BEGIN

decomposeWhileMarking ← TextInput.Confirm[

tty: NSExec.GetTTY[exec], prompt: M[mDecomposeWhileMarkingPrompt],

default: IF useDefault THEN

IF defaultToTrue THEN yes ELSE no

ELSE TextInput.nilYesNo];

END; --PromptForDecomposeWhileMarking

PromptForNonNormalInitType: PROCEDURE [exec: NSExec.Handle]

RETURNS [type: NonNormalInitType] = BEGIN

choices: CARDINAL = 2;

typeMsgKeys: ARRAY [0..choices) OF PSExecMessages.Key ← [mConfigure, mDeleteBackingFiles];

typeChoices: ARRAY [0..choices) OF NSString.String;

PSExecInternal.GetList[choices, DESCRIPTOR[typeMsgKeys], DESCRIPTOR[typeChoices]];

type ← SELECT TextInput.GetChoice[tty: NSExec.GetTTY[exec],

prompt: M[mSpecifyNonNormalOption],

choices: DESCRIPTOR[typeChoices]] FROM

1 => deleteBackingFiles, ENDCASE => configure;

END; --PromptForNonNormalInitType

PromptForPrintingOption: PROCEDURE [exec: NSExec.Handle,

currentOption: PrintingTypes.Option,

optionCount: CARDINAL,

optionChoices: LONG DESCRIPTOR FOR ARRAY OF PrintingTypes.Option]

RETURNS [option: PrintingTypes.Option] = BEGIN

tty: TTY.Handle ← NSExec.GetTTY[exec];

outputHandle: XFormat.Handle ← NSExec.OutputHandle[exec];

optionMsgKeys: PSExecInternal.KeyList ← DESCRIPTOR[NIL, 0];

optionStrings: Message.StringArray ← DESCRIPTOR[NIL, 0];

bansheeChoiceIndex, d1ChoiceIndex, --index for each printing option in optionStrings array,

fax295ChoiceIndex, fax495ChoiceIndex, --which is passed to TextInput.GetChoice

feps9700ChoiceIndex, fx3500ChoiceIndex, ravenChoiceIndex,

defaultOption: TextInput.ChoiceIndex ← TextInput.nilChoice;

freeThisString: NSString.String;

stringArray: ARRAY [0..1) OF NSString.String;

ConfirmOptionChange: PROCEDURE [newOption: PrintingTypes.Option]

RETURNS [confirmed: BOOLEAN] = BEGIN

BEGIN

Check if there are fonts installed from the previous printing option and, if so, display a warning that they will be deleted, if appropriate.

SELECT currentOption FROM

bansheeDl => SELECT newOption FROM

bansheeDl, d1 => GOTO noFontMsgNecessary;

Even though font floppies cannot be shared between banshee and d1, fonts already loaded and rotated for banshee may be used for d1. Unrotated banshee fonts will be deleted if option is changed to d1.

ENDCASE;

d1 => SELECT newOption FROM

bansheeDl, d1 => GOTO noFontMsgNecessary;

ENDCASE;

fax295, fax495 => SELECT newOption FROM

fax295, fax495 => GOTO noFontMsgNecessary;

ENDCASE;

feps9700, fx3500, raven => SELECT newOption FROM

bansheeDl, feps9700, fx3500, raven =>

GOTO noFontMsgNecessary; --Raven, fx3500 and feps9700 use same fonts. These fonts are rotated for banshee.

ENDCASE;

ENDCASE => --unknown-- GOTO noFontMsgNecessary;

stringArray[0] ← M[SELECT currentOption FROM

bansheeDl => mBanshee,

d1 => mD1,

fax295 => mTC295,

fax495 => mTC495,

feps9700 => mFEPS,

fx3500 => mFX3500,

ENDCASE => mRaven];

outputHandle.Blanks[8];

freeThisString ← Message.Expand[

M[mDeleteOldFonts], DESCRIPTOR[stringArray], execHeap];

outputHandle.NSLine[freeThisString];

NSString.FreeString[execHeap, freeThisString];

EXITS

noFontMsgNecessary => NULL;

END;

stringArray[0] ← M[SELECT newOption FROM

bansheeDl => mShortBanshee,

d1 => mD1,

fax295 => mTC295,

fax495 => mTC495,

feps9700 => mFEPS,

fx3500 => mFX3500,

ENDCASE => mRaven];

freeThisString ← Message.Expand[

M[mConfirmOption], DESCRIPTOR[stringArray], execHeap];

confirmed ← TextInput.Confirm[tty: tty, prompt: freeThisString];

NSString.FreeString[execHeap, freeThisString];

END; --ConfirmOptionChange

Mainline of PromptForPrintingOption:

optionMsgKeys ← DESCRIPTOR[Heap.MakeNode[

execHeap, SIZE[PSExecMessages.Key] * optionCount], optionCount];

optionStrings ← DESCRIPTOR[Heap.MakeNode[

execHeap, SIZE[NSString.String] * optionCount], optionCount];

Store appropriate values in optionMsgKeys array and set indices. If a certain printing option is not among the current choices, its index will remain nil.

FOR i: CARDINAL IN [0..optionCount) DO

SELECT optionChoices[i] FROM

bansheeDl => BEGIN

optionMsgKeys[i] ← mBanshee;

bansheeChoiceIndex ← i;

END;

d1 => BEGIN

optionMsgKeys[i] ← mD1;

d1ChoiceIndex ← i;

END;

fax295 => BEGIN

optionMsgKeys[i] ← mTC295;

fax295ChoiceIndex ← i;

END;

fax495 => BEGIN

optionMsgKeys[i] ← mTC495;

fax495ChoiceIndex ← i;

END;

feps9700 => BEGIN

optionMsgKeys[i] ← mFEPS;

feps9700ChoiceIndex ← i;

END;

fx3500 => BEGIN

optionMsgKeys[i] ← mFX3500;

fx3500ChoiceIndex ← i;

END;

raven => BEGIN

optionMsgKeys[i] ← mRaven;

ravenChoiceIndex ← i;

END;

ENDCASE => ERROR;

ENDLOOP;

PSExecInternal.GetList[LENGTH[optionMsgKeys], optionMsgKeys, optionStrings];

IF currentOption # unknown THEN --use current printing option as default when prompting for option

defaultOption ← SELECT currentOption FROM --defaultOption will be nilChoice, if current printing option is unknown

bansheeDl => bansheeChoiceIndex, d1 => d1ChoiceIndex,

fax295 => fax295ChoiceIndex, fax495 => fax495ChoiceIndex,

feps9700 => feps9700ChoiceIndex, fx3500 => fx3500ChoiceIndex,

ENDCASE => ravenChoiceIndex;

DO --Loop until a printing option is selected and confirmed...

SELECT TextInput.GetChoice[tty: tty,

prompt: M[mSpecifyOption],

choices: optionStrings, default: defaultOption] FROM

bansheeChoiceIndex => option ← bansheeDl;

d1ChoiceIndex => option ← d1;

fax295ChoiceIndex => option ← fax295;

fax495ChoiceIndex => option ← fax495;

feps9700ChoiceIndex => option ← feps9700;

fx3500ChoiceIndex => option ← fx3500;

ravenChoiceIndex => option ← raven;

ENDCASE => ERROR;

If a new printing option is selected, confirm the change:

SELECT currentOption FROM

option, unknown => EXIT;

ENDCASE => IF ConfirmOptionChange[option] THEN EXIT;

If option change isn't confirmed, loop and display the selections again.

ENDLOOP;

Heap.FreeNode[execHeap, BASE[optionMsgKeys]];

Heap.FreeNode[execHeap, BASE[optionStrings]];

END; --PromptForPrintingOption

PromptForFaxPaperWidth: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

defaultWidth: CARDINAL ← 0] RETURNS [width: CARDINAL] = BEGIN

choices: CARDINAL = 2;

widthMsgKeys: ARRAY [0..choices) OF PSExecMessages.Key ← [

mLetterLegalWidth, mA4Width];

widthChoices: ARRAY [0..choices) OF NSString.String;

defaultChoice: TextInput.ChoiceIndex ← IF useDefault THEN

SELECT defaultWidth FROM

PaperTypes.PaperMMDimension[a4].short => 1,

ENDCASE --letter/legal-- => 0

ELSE TextInput.nilChoice;

PSExecInternal.GetList[choices, DESCRIPTOR[widthMsgKeys], DESCRIPTOR[widthChoices]];

RETURN [SELECT TextInput.GetChoice[tty: NSExec.GetTTY[exec], prompt: M[mSpecifyFaxPaperWidth], choices: DESCRIPTOR[widthChoices], default: defaultChoice] FROM

0 => PaperTypes.PaperMMDimension[letter].short,

ENDCASE => PaperTypes.PaperMMDimension[a4].short];

END; --PromptForFaxPaperWidth

PromptForFaxTransmissionResolution: PROCEDURE [exec: NSExec.Handle,

useDefault: BOOLEAN, defaultToFine: BOOLEAN ← TRUE]

RETURNS [supportFineResolution: BOOLEAN] = BEGIN

choices: CARDINAL = 2;

resolutionMsgKeys: ARRAY [0..choices) OF PSExecMessages.Key ← [

mStandard, mFine];

resolutionChoices: ARRAY [0..choices) OF NSString.String;

defaultChoice: TextInput.ChoiceIndex ← IF useDefault THEN

IF defaultToFine THEN 1 ELSE 0

ELSE TextInput.nilChoice;

PSExecInternal.GetList[choices, DESCRIPTOR[resolutionMsgKeys], DESCRIPTOR[resolutionChoices]];

RETURN [SELECT TextInput.GetChoice[tty: NSExec.GetTTY[exec], prompt: M[mSpecifyFaxResolution], choices: DESCRIPTOR[resolutionChoices], default: defaultChoice] FROM

0 => FALSE,

ENDCASE => TRUE];

END; --PromptForFaxTransmissionResolution

PromptForRavenVersion: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

defaultVersion: PrintingTypes.RavenBuild ← b1]

RETURNS [version: PrintingTypes.RavenBuild] = BEGIN

choices: CARDINAL = 2;

ravenMsgKeys: ARRAY [0..choices) OF PSExecMessages.Key ← [

mRavenB1, mRavenB2];

ravenChoices: ARRAY [0..choices) OF NSString.String;

defaultChoice: TextInput.ChoiceIndex ← IF useDefault THEN

SELECT defaultVersion FROM

b2 => 1, ENDCASE --b1-- => 0

ELSE TextInput.nilChoice;

PSExecInternal.GetList[choices, DESCRIPTOR[ravenMsgKeys], DESCRIPTOR[ravenChoices]];

RETURN [

SELECT TextInput.GetChoice[

tty: NSExec.GetTTY[exec], prompt: M[mSpecifyRavenBuild],

choices: DESCRIPTOR[ravenChoices],

default: defaultChoice] FROM

0 => b1,

ENDCASE => b2];

END; --PromptForRavenVersion

PromptForRMAllocation: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

normalValue: LONG CARDINAL, defaultValue: LONG CARDINAL ← 0]

RETURNS [rmAllocation: LONG CARDINAL] = BEGIN

outputHandle: XFormat.Handle ← NSExec.OutputHandle[exec];

rmAllocation ← TextInput.GetLongDecimal[

tty: NSExec.GetTTY[exec], prompt: M[mRMLimitPrompt],

min: 100, max: normalValue,

default: IF useDefault THEN defaultValue ELSE TextInput.nilLongDecimal];

END; --PromptForRMAllocation

PromptForSpoolWhileMarking: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

defaultToTrue: BOOLEAN] RETURNS [spoolWhileMarking: BOOLEAN] = BEGIN

spoolWhileMarking ← TextInput.Confirm[

tty: NSExec.GetTTY[exec], prompt: M[mSpoolWhileMarkingPrompt],

default: IF useDefault THEN

IF defaultToTrue THEN yes ELSE no

ELSE TextInput.nilYesNo];

END; --PromptForSpoolWhileMarking

PromptForVMPagesForDecomposer: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

defaultValue: LONG CARDINAL ← 0] RETURNS [vmPagesForDecomposer: LONG CARDINAL] =

BEGIN

vmPagesForDecomposer ← TextInput.GetLongDecimal[

tty: NSExec.GetTTY[exec], prompt: M[mVMLimitPrompt],

min: 100, max: 12000,

default: IF useDefault THEN defaultValue ELSE TextInput.nilLongDecimal];

END; --PromptForVMPagesForDecomposer

PromptWithFontDeletionQuestion: PROCEDURE [exec: NSExec.Handle, useDefault: BOOLEAN,

defaultToTrue: BOOLEAN] RETURNS [deleteIncompatibleFontsandTPs: BOOLEAN] = BEGIN

deleteIncompatibleFontsandTPs ← TextInput.Confirm[

tty: NSExec.GetTTY[exec], prompt: M[mDeleteObsoleteFonts],

default: IF useDefault THEN

IF defaultToTrue THEN yes ELSE no

ELSE TextInput.nilYesNo];

END; --PromptWithFontDeletionQuestion

PutAsyncMessage: PSAsyncMsg.Proc

[msg: PSAsyncMsg.Message,

--insertArray: PSAsyncMsg.InsertArray ← PSAsyncMsg.nullInsertArray]-- = BEGIN

Get: PROCEDURE [domain: XMessage.Handle, key: XMessage.MsgKey]

RETURNS [string: NSString.String] = {

r: XString.ReaderBody ← XMessage.Get[domain, key];

string ← [bytes: LOOPHOLE[r.bytes], length: r.limit, maxlength: r.limit]};

IF insertArray = PSAsyncMsg.nullInsertArray THEN

NSExec.BroadcastAsyncMessage[Get[msg.domain, msg.key], psClientID] --output msg to all active execs

ELSE BEGIN

stringCount: CARDINAL ← LENGTH[insertArray];

freeThisStringArray: Message.StringArray ←

DESCRIPTOR[Heap.MakeNode[execHeap, SIZE[NSString.String] * stringCount], stringCount];

FOR i: CARDINAL IN [0..stringCount) DO

IF insertArray[i].m # PSAsyncMsg.nullMsg THEN

freeThisStringArray[i] ← Get[

insertArray[i].m.domain, insertArray[i].m.key]

ELSE

freeThisStringArray[i] ← insertArray[i].s;

ENDLOOP;

PSExecInternal.ExpandArrayAndPrintAsync[

Get[msg.domain, msg.key], freeThisStringArray];

Heap.FreeNode[execHeap, BASE[freeThisStringArray]];

END;

END; --PutAsyncMessage

SetInitialState: PROCEDURE [oldOption, newOption: PrintingTypes.Option] = BEGIN

This procedure compares the old printing option to the new printing option. If different fonts are required for the new printing option, printing is stopped with the message to check that fonts have been installed. Or, if the new printing option is the feps9700, the message is that the target print service should be set.

StopMessage: TYPE = {checkFonts, setTargetPS, setTargetPSAndCheckFonts};

StopPrinting: PROCEDURE [message: StopMessage] = TRUSTED BEGIN

systemName: NSName.NameRecord ← NSName.nullNameRecord;

systemName.local ← M[mSystemControl];

PSCommand.StopPrinting[

user: @systemName, reason: M[

SELECT message FROM

setTargetPS => mSetTarget,

setTargetPSAndCheckFonts => mSetTargetAndCheckFonts,

ENDCASE => mCheckFonts]

];

END; --StopPrinting

SELECT oldOption FROM

bansheeDl, d1 => SELECT newOption FROM

bansheeDl, d1 => NULL;

fax295, fax495, fx3500, raven => StopPrinting[checkFonts]; --banshee fonts cannot be rotated back for raven or fx3500

feps9700 => StopPrinting[setTargetPSAndCheckFonts];

ENDCASE => ERROR;

fax295, fax495 => SELECT newOption FROM

raven, fx3500, bansheeDl, d1 => StopPrinting[checkFonts];

fax295, fax495 => NULL;

feps9700 => StopPrinting[setTargetPSAndCheckFonts];

ENDCASE => ERROR;

feps9700 => SELECT newOption FROM

raven, fx3500, bansheeDl, d1, fax295, fax495 => StopPrinting[checkFonts];

feps9700 => NULL;

ENDCASE => ERROR;

fx3500, raven => SELECT newOption FROM

raven, fx3500, bansheeDl => NULL; --fx3500/raven fonts are rotated for banshee

d1, fax295, fax495 => StopPrinting[checkFonts];

feps9700 => StopPrinting[setTargetPS];

ENDCASE => ERROR;

unknown => SELECT newOption FROM

raven, d1, fx3500, bansheeDl, fax295, fax495 => StopPrinting[checkFonts];

feps9700 => StopPrinting[setTargetPSAndCheckFonts];

ENDCASE => ERROR;

END; --SetInitialState

StopQueuingAndPrintingAbnormal: PROCEDURE [exec: NSExec.Handle] = BEGIN

name: NSName.Name ← NSExec.UserName[exec

! NSExec.Error => GOTO noUser];

PSCommand.StopQueuing[

user: name, reason: M[mAbnormalStartup]];

PSCommand.StopPrinting[

user: name, reason: M[mAbnormalStartup]];

EXITS

noUser => BEGIN

systemName: NSName.NameRecord ← NSName.nullNameRecord;

systemName.local ← M[mSystemControl];

PSCommand.StopQueuing[

user: @systemName, reason: M[mAbnormalStartup]];

PSCommand.StopPrinting[

user: @systemName, reason: M[mAbnormalStartup]];

END;

END; --StopQueuingAndPrintingAbnormal

=====================================================

RegisterCommands: PROCEDURE =

=====================================================

BEGIN

commands: ARRAY [0..27) OF NSExec.Command ← [

Command Phrase, Command Processor, Activity Check & Help Proc

for each command:

--List Documents:-- [

M[mListDocs], PSExecInternal.DisplayDocuments],

--Cancel Documents:-- [

M[mCancelDoc], PSExecInternal.CancelDocuments, AllowCancelDocuments],

--List Fonts:-- [

M[mListFonts], PSExecInternal.DisplayFonts],

--List Test Patterns:-- [

M[mListTPs], PSExecInternal.DisplayTestPatterns],

--Delete Fonts:-- [

M[mDeleteFonts], PSExecInternal.DeleteFonts, AllowDeleteFonts],

--Delete Test Patterns:-- [

M[mDeleteTPs], PSExecInternal.DeleteTestPatterns, AllowDeleteTestPatterns],

--Install From Floppy (Fonts & Test Patterns):-- [

M[mInstallFonts], PSExecInternal.InstallFromFloppy, AllowInstallFromFloppy],

--Print Test Pattern:-- [

M[mPrintTP], PSExecInternal.PrintTestPattern, AllowPrintTestPattern],

--Set Parameters:-- [

M[mSetParameters], PSExecInternal.SetParameters, AllowSetParameters],

--Set Banner:-- [

M[mSetBanner], PSExecInternal.SetParameters, AllowSetBanner],

--Show Status:-- [

M[mShowStatus], PSExecInternal.DisplayPrintServiceStatus],

--Start:-- [

M[mStart], PSExecInternal.StartQueuingAndPrinting, AllowStartQueuingAndPrinting],

--Stop:-- [

M[mStop], PSExecInternal.StopQueuingAndPrinting, AllowStopQueuingAndPrinting],

--Start Printing:-- [

M[mStartPrinting], PSExecInternal.StartPrinting, AllowStartPrinting],

--Stop Printing:-- [

M[mStopPrinting], PSExecInternal.StopPrinting, AllowStopPrinting],

--Start Queuing:-- [

M[mStartSpooling], PSExecInternal.StartQueuing, AllowStartQueuing],

--Stop Queuing:-- [

M[mStopSpooling], PSExecInternal.StopQueuing, AllowStopQueuing],

--Start Diagnostic:-- [

M[mStartDiagnostic], PSExecInternal.StartDiagnostic, AllowStartDiagnostic],

--WakeUp Printer:-- [

M[mWakeupRaven], PSExecInternal.WakeUpPrinter, AllowWakeUpPrinter],

--ShutDown Printer:-- [

M[mShutdownRaven], PSExecInternal.ShutDownPrinter, AllowShutDownPrinter],

--Reset Statistics:-- [

M[mResetStats], PSExecInternal.ResetStatistics, AllowResetStatistics],

--Rename Print Service: -- [

M[mRenamePrintService], PSExecInternal.RenamePrintService, AllowRenamePrintService],

--Put Display:-- [

M[mPutDisplay], PSExecInternal.PutPrinterDisplay, AllowPutDisplay],

--Get Display:-- [

M[mGetDisplay], PSExecInternal.GetPrinterDisplay, AllowGetDisplay],

--Set Trace:-- [

M[mSetTrace], PSExecInternal.SetTrace, AllowSetTrace],

--Set Target Print Service:-- [

M[mSetTargetPS], PSExecInternal.SetTargetPrintService, AllowSetTargetPS],

--Query Target Print Service:-- [

M[mQueryTargetPS], PSExecInternal.QueryTargetPrintService, AllowQueryTargetPS]

];

NSExec.AddClientCommands[

id: psClientID, commands: DESCRIPTOR[commands]];

END; --RegisterCommands

Allow Procs all return BOOLEAN indicating whether command is currently valid:

AllowRenamePrintService: NSExec.Predicate = BEGIN

RETURN [NSExec.UserAServerSA[exec] AND PSStopped[]];

END; --AllowRenamePrintService

AllowCancelDocuments, AllowResetStatistics: NSExec.Predicate = BEGIN

RETURN [NSExec.UserAServerSA[exec] AND PSStarted[]];

END; -- AllowCancelDocuments

AllowPrintTestPattern: NSExec.Predicate = BEGIN

state: PSState.StateHandle ← PSCommand.GetPrintServiceStatus[];

RETURN [PSStarted[] AND

(state.mode.current = normal OR state.mode.current = repair)];

Don't allow PrintTestPattern when installing/deleting fonts.

END; --AllowPrintTestPattern

AllowInstallFromFloppy, AllowDeleteFonts,

AllowDeleteTestPatterns: NSExec.Predicate = BEGIN

RETURN [

NSExec.UserAServerSA[exec] AND PSStarted[] AND

PSCommand.GetPrintServiceStatus[].mode.current = normal];

Mode must be normal to insure that other fonts are not being installed or deleted at the same time. (If PS is not running mode would be notStarted or shutDown.)

END; --AllowInstallFromFloppy

AllowSetParameters: NSExec.Predicate = BEGIN

state: PSState.StateHandle ← PSCommand.GetPrintServiceStatus[];

RETURN [

state.option # feps9700 AND state.option # bansheeDl AND

NSExec.UserAServerSA[exec] AND PSStarted[]];

END; --AllowSetParameters

AllowSetBanner: NSExec.Predicate =

Banshee only has one operation parameter, so the command

Set Banner is used rather than the menu oriented

Set Parameters. The same proc implements Set Banner and

Set Parameters.

BEGIN

RETURN [

PSCommand.GetPrintServiceStatus[].option = bansheeDl AND

NSExec.UserAServerSA[exec] AND PSStarted[]];

END; --AllowSetBanner

AllowStartDiagnostic: NSExec.Predicate =

BEGIN --Only allowed for raven and fx3500 engines from the LOCAL EXEC ONLY.

state: PSState.StateHandle ← PSCommand.GetPrintServiceStatus[];

IF exec # NSExec.localExec THEN RETURN [FALSE];

IF NOT PSStarted[] THEN RETURN [FALSE];

WITH s: state SELECT FROM

Mode must be normal so that we're not in repair mode or already in diagnostic mode and we're not installing or deleting fonts.

bansheeDl, d1, fax295, fax495, fx3500, raven =>

RETURN [s.mode.current = normal];

ENDCASE => RETURN [FALSE];

END; --AllowStartDiagnostic

AllowStartQueuingAndPrinting: NSExec.Predicate = BEGIN

state: PSState.StateHandle ← PSCommand.GetPrintServiceStatus[];

RETURN [

NSExec.UserLoggedOn[exec] AND

NOT state.clientControl.markerEnabled AND

state.clientControl.spooler # enabled AND

PSStarted[]];

END; --AllowStartQueuingAndPrinting

AllowStopQueuingAndPrinting: NSExec.Predicate = BEGIN

state: PSState.StateHandle ← PSCommand.GetPrintServiceStatus[];

RETURN [

NSExec.UserAServerSA[exec] AND

state.clientControl.markerEnabled AND

state.clientControl.spooler = enabled AND

PSStarted[]];

END; --AllowStopQueuingAndPrinting

AllowStartPrinting: NSExec.Predicate = BEGIN

RETURN [

NSExec.UserLoggedOn[exec] AND

NOT PSCommand.GetPrintServiceStatus[].clientControl.markerEnabled AND

PSStarted[]];

END; -- AllowStartPrinting

AllowStopPrinting: NSExec.Predicate = BEGIN

RETURN [

NSExec.UserAServerSA[exec] AND

PSCommand.GetPrintServiceStatus[].clientControl.markerEnabled AND

PSStarted[]];

END; -- AllowStopPrinting

AllowStartQueuing: NSExec.Predicate = BEGIN

RETURN [

NSExec.UserLoggedOn[exec] AND

PSCommand.GetPrintServiceStatus[].clientControl.spooler # enabled AND

PSStarted[]];

END; -- AllowStartQueuing

AllowStopQueuing: NSExec.Predicate = BEGIN

RETURN [

NSExec.UserAServerSA[exec] AND

PSCommand.GetPrintServiceStatus[].clientControl.spooler = enabled AND

PSStarted[]];

END; -- AllowStopQueuing

AllowWakeUpPrinter: NSExec.Predicate = BEGIN

activity: PSState.CurrentActivity ← PSCommand.GetPrintServiceActivity[];

WITH a: activity SELECT FROM

raven => RETURN [

NSExec.UserAServerSA[exec] AND NOT RepairMode[] AND

a.ravenStatus = aboutToDozeOff AND PSStarted[]];

ENDCASE => RETURN [FALSE];

END; -- AllowWakeUpPrinter

AllowShutDownPrinter: NSExec.Predicate = BEGIN

state: PSState.StateHandle ← PSCommand.GetPrintServiceStatus[];

WITH s: state SELECT FROM

raven =>

IF NSExec.UserAServerSA[exec] AND NOT RepairMode[] AND

PSStarted[] AND s.engineBuild > b1 THEN BEGIN

activity: PSState.CurrentActivity ← PSCommand.GetPrintServiceActivity[];

WITH a: activity SELECT FROM

raven => RETURN [a.ravenStatus = okay AND

a.marker = available];

ENDCASE => RETURN [FALSE]

END

ELSE RETURN [FALSE];

ENDCASE => RETURN [FALSE];

END; -- AllowShutDownPrinter

AllowPutDisplay, AllowGetDisplay: NSExec.Predicate =

BEGIN

RETURN [

PSCommand.GetPrintServiceStatus[].option = fx3500 AND

RepairMode[] AND PSStarted[]];

END; --AllowPutDisplay

AllowSetTrace: NSExec.Predicate =

BEGIN --Allowed in repair mode or development mode

RETURN [PSStarted[] AND (RepairMode[] OR developmentMode)];

END; --AllowSetTrace

AllowSetTargetPS: NSExec.Predicate = BEGIN

RETURN [NSExec.UserAServerSA[exec] AND PSStarted[]

AND PSCommand.GetPrintServiceStatus[].option = feps9700];

END; --AllowSetTargetPS

AllowQueryTargetPS: NSExec.Predicate = BEGIN

RETURN [PSStarted[] AND

PSCommand.GetPrintServiceStatus[].option = feps9700];

END; --AllowQueryTargetPS

RepairMode: PROCEDURE RETURNS [BOOLEAN] = BEGIN

RETURN [PSCommand.GetPrintServiceStatus[].mode.current = repair];

END; --RepairMode

PSStarted: PROCEDURE RETURNS [started: BOOLEAN] = BEGIN

RETURN [PSCommandExtras.ServiceState[] = started];

END; --PSStarted

PSStopped: PROCEDURE RETURNS [stopped: BOOLEAN] = BEGIN

RETURN [PSCommandExtras.ServiceState[] = stopped];

END; --PSStopped

Proc for getting NSString from XMessage key

M: PROCEDURE [key: PSExecMessages.Key]

RETURNS [string: NSString.String] = {

r: XString.ReaderBody ← XMessage.Get[execMsgs, ORD[key]];

string ← [bytes: LOOPHOLE[r.bytes], length: r.limit, maxlength: r.limit]};

Str: PROCEDURE [s: LONG STRING] RETURNS [ns: NSString.String] = INLINE {

RETURN[NSString.StringFromMesaString[s]]};

END.

LOG when/who/what

3-Oct-84 16:01:29 - Jacks - Created. Took code from PSExecAImpl and PSCommandInitImpl and added to it.

22-Oct-84 10:33:59 - Jacks - Now using CalcRMPagesForMarker from new MiscUtilities I/F; added SetInitialState; renamed ttyHeap to execHeap; added two commands for feps9700.

1-Nov-84 17:31:04 - Jacks - Removed fax295 from init engine options; added set target ps stuff to SetInitialState.

14-Nov-84 11:01:34 - Jacks - Put back prompting for fax required init parms.

19-Nov-84 13:44:11 - Jacks - Added Set Banner command for banshee.

13-Dec-84 11:31:38 - Jacks - Changed one development mode prompt string and some msg keys; removed ControlMessagesExtras.

16-Jan-85 15:32:23 - Jacks - Added "ps" prefix to all new message keys for 9.0.

18-Jan-85 16:19:18 - Jacks - Updated product factoring for feps9700.

23-Jan-85 15:13:20 - Jacks - Updated SetInitialState for banshee font situation.

7-Feb-85 9:24:21 - Jacks - Updated to newer version of PSInit.

28-Feb-85 15:22:26 - Jacks - Allow StartDiagnostic for banshee; only allow StartDiagnostic for local exec; fixed space leak in GetPrintingOption; made developmentMode PUBLIC.

19-Jun-85 11:33:29 - Jacks - Added copyright notice; updated to PS Euclid interfaces; turned off public error catching by SCS in all exec procs.

28-Jun-85 13:39:47 - Jacks - Added d1 code; removed SetCatching calls.

18-Jul-85 15:02:19 - Jacks - Updated to Euclid Services interfaces, especially XMessage.

6-Aug-85 17:31:39 - Jacks - Made List Fonts and List Test Patterns client commands; updated ConfirmOptionChange in PromptForPrintingOption for d1; updated DevelopmentModeInit to get more info from state record; made use of new CalcRMPagesForMarker and CalcPagesForBandBuffers.

20-Aug-85 14:07:14 - Jacks - Added correct min/max values to PromptForBandBufferPages and PromptForRMAllocation; added runtime loading of printing option bcds.

28-Aug-85 15:39:23 - Jacks - Enabled StartDiagnostic for fax.

6-Sep-85 15:34:16 - Jacks - Delete PSEngineConfig; one band buffer for feps9700.

9-Sep-85 13:17:48 - Jacks - Changed VM for decomoser max value; added many strings to msg file.

11-Sep-85 11:49:36 - Jacks - Changed developmentMode deleteIncompatibleFontsandTPs default to TRUE.

19-Sep-85 11:13:07 - Jacks - Minor changes.

23-Sep-85 14:00:50 - Jacks - Added GetRequiredBansheeInitParms and PromptAboutUnlimitedPrinting.

27-Sep-85 12:38:11 - Jacks - Fixed some stuff about unlimited printing.

8-Oct-85 13:17:52 - Jacks - Updated to new PSInit with changes to band buffer calculation for unlimited printing; changed spoolWhileMarking default to TRUE for US printers.

15-Oct-85 9:48:00 - Jacks - Expunge now deletes msg files.

6-Nov-85 13:06:17 - Jacks - Expunge DOESN'T delete msg files, but DOES destroy msgs; user must confirm Expunge; call PSKMessages for msg handle; catch PSInit.FontsNotCataloged.

7-Nov-85 11:11:48 - Jacks - Use LSEPFace.MaxBands in PromptForBandBufferPages; got rid of FontsNotCataloged business.

13-Nov-85 10:34:13 - Jacks - Added DeleteObsoleteBcds; default spoolWhileMarking and decomposeWhileMarking to TRUE for FX printers.

27-Nov-85 14:18:51 - Jacks - PSStarted now uses PSCommandExtras.ServiceState; updated to new product factoring bits; use default values in normal startup portion of DevelopmentModeInit.

16-Dec-85 13:00:24 - Jacks - Removed call to DisplayPrintServiceStatus from Start proc.

30-Dec-85 17:39:39 - Jacks - Max band buffers down to 7.

28-Jan-86 14:20:19 - Jacks - Added min and max parms to PromptForBandBufferPages (max for d1 is 8; max for rest is 7).

29-Apr-86 14:11:37 - Jacks - Changed messages displayed when reserved memory is not available.

19-May-86 10:38:42 - Jacks - Don't prompt to confirm printing option change if previously option wasn't set; changed expunge warning prompt; prompt for non-normal startup option (configure or delete backing files).