DIRECTORY
AMBridge USING [TVForReferent],
CedarVersion USING [major, minor, patch],
Commander,
Directory USING [Lookup],
ExecOps USING [Outcome],
Feedback USING [BeginItemProc, CreateProc, DestroyProc, FinishItemProc, NoteProgressProc,
Procs],
File USING [Capability],
IO USING [STREAM, string, rope, time, int, RIS, PutF, PutRope, PutTV, PutText, Put, UserAbort, ResetUserAbort, UserAborted, GetInt, NewLine],
List USING [CompareProc, Sort],
Loader USING [Start, Instantiate],
Process USING [Priority, GetPriority, SetPriority, priorityBackground],
Resource USING [Acquire, Release, AbortProc],
Rope USING [Compare, Concat, IsEmpty, Length, ROPE, ToRefText, Cat],
Runtime USING [GetBuildTime, IsBound],
TemporarySpecialExecOps USING [BindUsingFeedback, CompileUsingFeedback],
TiogaMenuOps USING [Open],
UECP USING [Argv, Parse],
UserCredentials USING [GetUserCredentials],
UserProfile USING [Boolean, Token],
ViewerClasses USING [Viewer],
ViewerOps USING [CreateViewer];

InitialCommandsA: CEDAR PROGRAM
IMPORTS AMBridge, CedarVersion, Commander, Directory, IO, List, Loader, Process, Resource, Rope, Runtime, TemporarySpecialExecOps, TiogaMenuOps, UserProfile, UECP, UserCredentials, ViewerOps =
BEGIN
compilerSwitches, binderSwitches: Rope.ROPE _ NIL;
destroyLogOnSuccess: BOOL _ FALSE;


abortProc: Resource.AbortProc = TRUSTED{
in: IO.STREAM = NARROW[data, IO.STREAM];
abort _ in.UserAbort[];
IF abort THEN in.ResetUserAbort[];
};

Bind: PROC[args: Rope.ROPE, in, out: IO.STREAM]
RETURNS[outCome: ExecOps.Outcome] = TRUSTED {
priority: Process.Priority = Process.GetPriority[];
success: BOOL _ FALSE;
otherOwner: Rope.ROPE _ NIL;
aborted: BOOL _ FALSE;

BCreate: Feedback.CreateProc = {RETURN[NIL]};
BDestroy: Feedback.DestroyProc = {
out.Put[IO.string[trailer] ! IO.UserAborted => {aborted _ TRUE; CONTINUE}]};
BBeginItem: Feedback.BeginItemProc = {
out.Put[IO.string[item] ! IO.UserAborted => {aborted _ TRUE; CONTINUE}]};
BFinishItem: Feedback.FinishItemProc = {
out.PutF[" %g\n", IO.string[trailer] ! IO.UserAborted => {aborted _ TRUE; CONTINUE}]};
BNoteProgress: Feedback.NoteProgressProc = {
out.PutRope[" ." ! IO.UserAborted => {aborted _ TRUE; CONTINUE}];
IF aborted OR in.UserAbort[] THEN {
in.ResetUserAbort[];
ERROR IO.UserAborted;
};
};
binderProcs: Feedback.Procs _ [BCreate, BDestroy, BBeginItem, BNoteProgress, BFinishItem];

[success, otherOwner] _ Resource.Acquire[resource: $Binder,
	                                              owner: "Commander",
	                                              waitForIt: FALSE];
IF NOT success
THEN {
out.PutRope[Rope.Cat["Waiting for ", otherOwner, " to finish..."]];
[success, ] _ Resource.Acquire
				[resource: $Binder,
				 owner: "Commander",
				 waitForIt: TRUE,
				 abortProc: abortProc,
				 abortProcData: in
				];
IF NOT success THEN {
out.PutRope["ABORTED\n"];
RETURN;
} ELSE out.PutRope["proceeding\n"];
};

BEGIN ENABLE UNWIND => {Process.SetPriority[priority]; [] _ Resource.Release[$Binder]};
cmdText: REF StringBody;
cmd: LONG POINTER TO PACKED ARRAY [0..0) OF CHARACTER;

IF ~Runtime.IsBound[TemporarySpecialExecOps.BindUsingFeedback]
THEN {
ENABLE ANY => {out.PutText["Failed\n"]; GOTO Errors};
out.PutText["Loading and Starting Binder.bcd...\n"];
Loader.Start[Loader.Instantiate[Directory.Lookup["Binder.bcd"], 1, TRUE].cm];
};
cmdText _ LOOPHOLE[Rope.ToRefText[Rope.Concat[binderSwitches, args]], REF StringBody];
cmd _ LOOPHOLE[@(cmdText.text)];
Process.SetPriority[Process.priorityBackground];
outCome _ TemporarySpecialExecOps.BindUsingFeedback[cmd, @binderProcs];
EXITS
Errors => outCome _ errors;
END;  -- ENABLE UNWIND
Process.SetPriority[priority];
[] _ Resource.Release[$Binder];
};  -- end Bind

Compile: PROC[args: Rope.ROPE, in, out: IO.STREAM]
RETURNS[outCome: ExecOps.Outcome] = TRUSTED {
priority: Process.Priority = Process.GetPriority[];
success: BOOL _ FALSE;
otherOwner: Rope.ROPE _ NIL;
aborted: BOOL _ FALSE;

CCreate: Feedback.CreateProc = {RETURN[NIL]};
CDestroy: Feedback.DestroyProc = {
out.Put[IO.string[trailer] ! IO.UserAborted => {aborted _ TRUE; CONTINUE}]};
CBeginItem: Feedback.BeginItemProc = {
out.Put[IO.string[item] ! IO.UserAborted => {aborted _ TRUE; CONTINUE}]};
CFinishItem: Feedback.FinishItemProc = {
out.PutF[" %g\n", IO.string[trailer] ! IO.UserAborted => {aborted _ TRUE; CONTINUE}]};
CNoteProgress: Feedback.NoteProgressProc = {
out.PutRope[" ." ! IO.UserAborted => {aborted _ TRUE; CONTINUE}];
IF aborted OR in.UserAbort[] THEN {
in.ResetUserAbort[];
ERROR IO.UserAborted;
};
};
compilerProcs: Feedback.Procs _ [CCreate, CDestroy, CBeginItem, CNoteProgress, CFinishItem];

[success, otherOwner] _ Resource.Acquire[resource: $Compiler,
	                                              owner: "Commander",
	                                              waitForIt: FALSE];
IF NOT success
THEN {
out.PutRope[Rope.Cat["Waiting for ", otherOwner, " to finish..."]];
[success, ] _ Resource.Acquire
				[resource: $Compiler,
				 owner: "Commander",
				 waitForIt: TRUE,
				 abortProc: abortProc,
				 abortProcData: in
				];
IF NOT success THEN {
out.PutRope["ABORTED\n"];
RETURN;
} ELSE out.PutRope["proceeding\n"];
};

BEGIN ENABLE UNWIND => {Process.SetPriority[priority]; [] _ Resource.Release[$Compiler]};
cmdText: REF StringBody;
cmd: LONG POINTER TO PACKED ARRAY [0..0) OF CHARACTER;

IF ~Runtime.IsBound[TemporarySpecialExecOps.CompileUsingFeedback]
THEN {
ENABLE ANY => {out.PutText["Failed\n"]; GOTO Errors};
out.PutText["Loading and Starting Compiler.bcd...\n"];
Loader.Start[Loader.Instantiate[Directory.Lookup["Compiler.bcd"], 1, TRUE].cm];
};
cmdText _ LOOPHOLE[Rope.ToRefText[Rope.Concat[compilerSwitches, args]], REF StringBody];
cmd _ LOOPHOLE[@(cmdText.text)];
Process.SetPriority[Process.priorityBackground];
outCome _ TemporarySpecialExecOps.CompileUsingFeedback[cmd, @compilerProcs];
EXITS
Errors => outCome _ errors;
END;  -- ENABLE UNWIND
Process.SetPriority[priority];
[] _ Resource.Release[$Compiler];
};  -- end Compile

PrintResult: PROC [result: ExecOps.Outcome, out: IO.STREAM] = {
SELECT result FROM
warnings => out.PutRope[". . . warnings\n"];
errors => out.PutRope[". . . errors\n"];
errorsAndWarnings => out.PutRope[". . . errorsAndWarnings\n"];
aborted => out.PutRope[". . . aborted\n"]
ENDCASE;
};

MyCompile: Commander.CommandProc = {
PrintResult[result: Compile[args: cmd.commandLine, in: cmd.in, out: cmd.out], out: cmd.out];
};

MyBind: Commander.CommandProc = {
PrintResult[result: Bind[args: cmd.commandLine, in: cmd.in, out: cmd.out], out: cmd.out];
};

SetDefaultSwitches: Commander.CommandProc =
{
SetDefaultSwitchesInternal[];
IF compilerSwitches.Length[] > 0 THEN cmd.out.PutF["Compiler Switches now %g\n", IO.rope[compilerSwitches]]
ELSE cmd.out.PutRope["No compiler switches,\n"];
IF binderSwitches.Length[] > 0 THEN cmd.out.PutF["Binder Switches now %g\n", IO.rope[binderSwitches]]
ELSE cmd.out.PutRope["No binder switches,\n"];
};

SetDefaultSwitchesInternal: PROC = {
compilerSwitches _ UserProfile.Token["Compiler.Switches"];
IF UserProfile.Boolean["Compiler.SeparateLogs", FALSE] THEN compilerSwitches _ Rope.Concat["/-g", compilerSwitches];
binderSwitches _ UserProfile.Token["Binder.Switches"];
destroyLogOnSuccess _ UserProfile.Boolean["Compiler.DestroyLogOnSuccess", TRUE];
};

Date: Commander.CommandProc = {
cmd.out.PutF["  %t\n", IO.time[]];
};

User: Commander.CommandProc = {
user: Rope.ROPE _ UserCredentials.GetUserCredentials[].name;
IF user.Length[] = 0 THEN user _ "NIL";
cmd.out.PutF["User: %g\n", IO.rope[user]];
};

Version: Commander.CommandProc = {
cmd.out.PutF["Cedar %g.%g", IO.int[CedarVersion.major], IO.int[CedarVersion.minor]];
IF CedarVersion.patch # 0 THEN cmd.out.PutF[".%g", IO.int[CedarVersion.patch]];
cmd.out.PutF[" of %t\n", IO.time[Runtime.GetBuildTime[]]];
};

Properties: Commander.CommandProc = TRUSTED {
argStream: IO.STREAM _ IO.RIS[cmd.commandLine];
depth, width: INT;
depth _ argStream.GetInt[ ! ANY => {
depth _ 4;
CONTINUE;
}];
width _ argStream.GetInt[ ! ANY => {
width _ 32;
CONTINUE;
}];
cmd.out.PutRope["propertyList = "];
cmd.out.PutTV[tv: AMBridge.TVForReferent[NEW[REF ANY _ cmd.propertyList]], depth: depth, width: width];
cmd.out.NewLine[];
};

ECell: TYPE = RECORD [name, doc: Rope.ROPE];

EnumerateCommands: Commander.CommandProc = {
el: LIST OF REF ANY;
eCell: REF ECell;
EProc: PROC[name: Rope.ROPE, proc: Commander.CommandProc, doc: Rope.ROPE] RETURNS[stop: BOOL] = {
IF proc # NIL THEN el _ CONS[NEW[ECell _ [name: name, doc: doc]], el];
RETURN[FALSE];
};
MyCompare: List.CompareProc = {
a, b: REF ECell;
a _ NARROW[ref1];
b _ NARROW[ref2];
RETURN[Rope.Compare[a.name, b.name]];
};
cmd.out.PutRope["Registered commands:\n"];
[] _ Commander.Enumerate[EProc];
el _ List.Sort[list: el, compareProc: MyCompare];
WHILE el # NIL DO
eCell _ NARROW[el.first];
cmd.out.PutF["%-20g %g\n", IO.rope[eCell.name], IO.rope[eCell.doc]];
el _ el.rest;
ENDLOOP;
};

Alias: Commander.CommandProc = {
argv: UECP.Argv _ UECP.Parse[cmd.commandLine];
oldProc: Commander.CommandProc;
doc: Rope.ROPE;
IF argv.argc > 2 THEN {
[proc: oldProc, doc: doc] _ Commander.Lookup[argv[2]];
IF oldProc # NIL THEN Commander.Register[key: argv[1], proc: oldProc, doc: doc]
ELSE cmd.out.PutF["Alias: %g not found\n", IO.rope[argv[2]]];
}
ELSE cmd.out.PutRope["Usage: Alias newname oldname\n"];
};

Unregister: Commander.CommandProc = {
argv: UECP.Argv _ UECP.Parse[cmd.commandLine];
IF argv.argc = 2 THEN {
IF Commander.Lookup[argv[1]].proc # NIL THEN Commander.Register[key: argv[1], proc: NIL, doc: NIL]
ELSE cmd.out.PutF["Unregister: %g not found\n", IO.rope[argv[1]]];
}
ELSE cmd.out.PutRope["Usage: Unregister commandname\n"];
};

SetProperty: Commander.CommandProc = {
argv: UECP.Argv _ UECP.Parse[cmd.commandLine];
IF argv.argc # 3 THEN cmd.out.PutRope["Usage: SetProperty key value\n"]
ELSE [] _ Commander.PutProperty[key: argv[1], val: argv[2], aList: cmd.propertyList];
};

Open: Commander.CommandProc = {
argv: UECP.Argv _ UECP.Parse[cmd.commandLine];
IF argv.argc # 2 THEN {
cmd.out.PutRope["Usage: Open filename\n"];
RETURN;
};
OpenViewer[argv[1], FALSE, cmd.out];
};

New: Commander.CommandProc = {
OpenViewer[NIL, TRUE, cmd.out];
};

Comment: Commander.CommandProc = {
};

OpenViewer: PROC [name: Rope.ROPE, newViewer: BOOLEAN _ FALSE, out: IO.STREAM]  = { 
viewer: ViewerClasses.Viewer;
IF newViewer THEN viewer _ ViewerOps.CreateViewer[flavor: $Text, info: [name: IF  Rope.IsEmpty[name] THEN "No Name" ELSE name,
file: name, iconic: FALSE]]
ELSE viewer _ TiogaMenuOps.Open[name];  -- workaround
IF viewer = NIL THEN out.PutF["\tViewer file not found: %g\n", IO.rope[name]]
ELSE out.PutF["\tCreated Viewer: %g\n", IO.rope[viewer.name]];
};

Init: PROC = {
SetDefaultSwitchesInternal[];
Commander.Register[key: "Compile", proc: MyCompile, doc: "Compile programs"];
Commander.Register[key: "Bind", proc: MyBind, doc: "Bind configurations"];
Commander.Register[key: "SetCompilerSwitchesFromProfile", proc: SetDefaultSwitches, doc: "Read compiler and binder switches from user profile"];
Commander.Register[key: "Date", proc: Date, doc: "Print date and time"];
Commander.Register[key: "User", proc: User, doc: "Print name of logged in user"];
Commander.Register[key: "Version", proc: Version, doc: "Print Cedar version number"];
Commander.Register[key: "GetProperties", proc: Properties, doc: "Display command tool property list"];
Commander.Register[key: "Alias", proc: Alias, doc: "Alias newName oldName - Attach a new name to an existing command"];
Commander.Register[key: "?", proc: EnumerateCommands, doc: "List registered commands"];
Commander.Register[key: "SetProperty", proc: SetProperty, doc: "SetProperty propertyName value - change or add to the command tool property list"];
Commander.Register[key: "Open", proc: Open, doc: "Open fileName - open a viewer"];
Commander.Register[key: "New", proc: New, doc: "Open an empty viewer"];
Commander.Register[key: "Unregister", proc: Unregister, doc: "Unregister a command"];
Commander.Register[key: "/", proc: Comment, doc: "Comment"];
Commander.Register[key: "-", proc: Comment, doc: "Comment"];
};

Init[];

END.
March 27, 1983 3:27 pm, Stewart, Created
April 3, 1983 12:56 pm, Stewart, combined CompileAndBindImpl.mesa







ÔInitialCommandsA.mesa
Last editted: April 14, 1983 12:16 pm by L. Stewart
Last editted: April 19, 1983 3:10 pm by Paul Rovner
connecting concrete and opaque types
PROC [data: REF ANY] RETURNS[abort: BOOL];
�Ê˜Jš
œ™J™3J™3J˜š
Ïk	˜	Jšœ	�œ˜Jšœ
�œ˜)J˜
Jšœ
�œ
˜Jšœ�œ˜šœ	�œK˜YJ˜—Jšœ�œ˜Jš�œ
�œ�œ�œ_˜�
Jšœ�œ˜Jšœ�œ˜"Jšœ�œ:˜GJšœ	�œ˜-Jšœ�œ$�œ˜DJšœ�œ˜&Jšœ�œ+˜HJšœ
�œ˜Jš�œ
�œ˜Jšœ�œ˜+Jšœ�œ˜#Jšœ�œ
˜Jšœ
�œ˜—J˜Jšœ�œ
�˜Jš�œ/�œf�œ˜À
Jš
�˜Jšœ'�œ�œ
˜2Jšœ�œ�œ
˜"J˜Jš
œ$™$J˜Jšœ �œ
˜(š
œ*™*Jšœ�œ
�œ�œ�œ
�œ˜(Jš
œ˜Jš�œ�œ˜"Jš
œ˜—J˜š
Ïnœ�œ�œ�œ
�œ
˜/š�œ�œ˜-J˜3Jšœ	�œ�œ
˜Jšœ�œ�œ
˜Jšœ	�œ�œ
˜J˜Jšœ �œ
�œ˜-š
œ"˜"Jš	œ�œ�œ�œ�œ˜L—š
œ&˜&Jš	œ�œ�œ�œ�œ˜I—š
œ(˜(Jš	œ�œ�œ�œ�œ˜V—˜,Jšœ�œ�œ�œ˜Aš�œ	�œ�œ˜#Jš
œ˜Jš�œ
�œ
˜J˜—Jš
œ˜—J˜ZJ˜Jšœ¹
�œ˜À
Jš�œ
�œ˜š�œ˜Jš
œC˜Cš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜—š�œ
�œ	�œ˜Jš
œ˜Jš�œ
˜Jšœ�œ˜#—Jš
œ˜—J˜Jš�œ
�œD˜WJšœ	�œ˜Jšœ�œ
�œ
�œ
�œ
�œ�œ
�	œ
˜6J˜š�œ<˜>š�œ˜Jš�œ
�œ�œ	˜5J˜4JšœC�œ˜MJ˜——Jšœ
�œ4�œ
˜VJšœ�œ˜ J˜0J˜GJš
�˜J˜Jš�œÏc˜J˜Jš
œ˜JšœŸ˜J˜——š
žœ�œ�œ�œ
�œ
˜2š�œ�œ˜-J˜3Jšœ	�œ�œ
˜Jšœ�œ�œ
˜Jšœ	�œ�œ
˜J˜Jšœ �œ
�œ˜-š
œ"˜"Jš	œ�œ�œ�œ�œ˜L—š
œ&˜&Jš	œ�œ�œ�œ�œ˜I—š
œ(˜(Jš	œ�œ�œ�œ�œ˜V—š
œ,˜,Jšœ�œ�œ�œ˜Aš�œ	�œ�œ˜#Jš
œ˜Jš�œ
�œ
˜J˜—Jš
œ˜—J˜\J˜Jšœ»
�œ˜Â
Jš�œ
�œ˜š�œ˜Jš
œC˜Cš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜—š�œ
�œ	�œ˜Jš
œ˜Jš�œ
˜Jšœ�œ˜#—Jš
œ˜—J˜Jš�œ
�œF˜YJšœ	�œ˜Jšœ�œ
�œ
�œ
�œ
�œ�œ
�	œ
˜6J˜š�œ?˜Aš�œ˜Jš�œ
�œ�œ	˜5J˜6JšœE�œ˜OJš
œ˜——Jšœ
�œ6�œ
˜XJšœ�œ˜ J˜0J˜LJš
�˜J˜Jš�œŸ˜J˜Jš
œ!˜!JšœŸ˜——J˜šžœ�œ �œ
�œ˜?š�œ�˜J˜,J˜(J˜>J˜)Jš�œ
˜—˜J˜——˜$Jš
œ\˜\J˜—J˜˜!Jš
œY˜YJ˜—J˜˜+J˜
J˜Jš�œ�œ,�œ˜kJš�œ,˜0Jš�œ�œ*�œ˜eJš�œ*˜.J˜—J˜šžœ�œ˜$J˜:Jš�œ.�œ�œ9˜tJ˜6JšœJ�œ˜PJ˜—J˜š
œ˜Jšœ�œ	˜"J˜—J˜š
œ˜Jšœ�œ-˜<Jš�œ�œ˜'Jšœ�œ
˜*J˜—J˜š
œ"˜"Jšœ�œ�œ˜TJš�œ�œ�œ˜OJšœ�œ˜:J˜—J˜šœ$�œ˜-Jš	œ�œ
�œ�œ
�œ˜/Jšœ�œ
˜šœ�œ˜$Jš
œ
˜
Jš�œ
˜	Jš
œ˜—šœ�œ˜$Jš
œ˜Jš�œ
˜	Jš
œ˜—Jš
œ#˜#Jšœ)�œ
�œ
�œ3˜gJ˜J˜—J˜Jšœ�œ�œ�œ˜,J˜š
œ,˜,Jš	œ�œ
�œ
�œ
�œ
˜Jšœ�œ˜šžœ�œ�œ)�œ�œ�œ˜aJš
�œ�œ
�œ�œ
�œ&˜FJš�œ
�œ˜J˜—š
œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jš�œ˜%J˜—J˜*J˜ Jš
œ1˜1š�œ�œ
�˜Jšœ�œ˜Jšœ�œ�œ˜DJ˜
Jš�œ
˜—J˜—J˜š
œ ˜ Jšœ�œ�œ˜.Jš
œ˜Jšœ
�œ
˜š�œ�œ˜Jš
œ6˜6Jš�œ�œ
�œ:˜OJš�œ'�œ˜=J˜
—Jš�œ3˜7J˜—J˜š
œ%˜%Jšœ�œ�œ˜.š�œ�œ˜Jš
�œ"�œ
�œ(�œ�œ
˜bJš�œ,�œ˜BJ˜
—Jš�œ4˜8J˜J˜—š
œ&˜&Jšœ�œ�œ˜.Jš�œ�œ2˜GJš�œQ˜UJ˜—J˜š
œ˜Jšœ�œ�œ˜.š�œ�œ˜Jš
œ*˜*Jš�œ
˜J˜—Jšœ�œ˜$J˜—J˜š
œ˜Jšœ�œ�œ˜J˜—J˜š
œ"˜"J˜—J˜šž
œ�œ
�œ
�œ�œ�œ
�œ˜TJš
œ˜š
�œ�œ=�œ�œ�œ˜~Jšœ�œ˜—Jš�œ$Ðbc
˜5Jš�œ
�œ
�œ+�œ˜MJš�œ$�œ˜>J˜—J˜šžœ�œ˜J˜J˜MJ˜JJ˜�
J˜HJ˜QJ˜UJ˜fJ˜wJ˜WJ˜“
J˜RJ˜GJš
œU˜UJš
œ<˜<Jš
œ<˜<J˜—J˜J˜J˜Jš�œ
˜J˜(Jš
œA˜AJ˜J˜J˜J˜J˜J˜J˜—…—/¢<Š