DIRECTORY Atom, BasicTime, Commander, DFUtilities, FS, IO, IOClasses, MakeDo, Process, RedBlackTree, Rope;

MakeDoCmds: CEDAR PROGRAM
IMPORTS Atom, BasicTime, Commander, DFUtilities, FS, IO, IOClasses, MakeDo, Process, RedBlackTree, Rope
EXPORTS MakeDo =

BEGIN

ROPE: TYPE = Rope.ROPE;

GetObjectOrSwitch: PROC [from: IO.STREAM] RETURNS [asAny: REF ANY] = {
SELECT from.PeekChar[] FROM
'- => {
IF from.GetChar[] # '- THEN ERROR;
RETURN[Atom.MakeAtom[from.GetTokenRope[Break].token]];
};
ENDCASE => RETURN [GetObject[from]];
};

Break: PROC [char: CHAR] RETURNS [cc: IO.CharClass] = {
cc _ SELECT char FROM
IN [0C .. ' ] => sepr,
ENDCASE => other;
};

GetObject: PROC [from: IO.STREAM] RETURNS [node: MakeDo.Node] = {
SELECT from.PeekChar[] FROM
'( => {
className, objectName: ROPE;
class: MakeDo.NodeClass;
node: MakeDo.Node;
IF from.GetChar[] # '( THEN ERROR;
className _ from.GetRopeLiteral[];
objectName _ from.GetRopeLiteral[];
[] _ from.SkipWhitespace[];
IF from.GetChar[] # ') THEN {
SIGNAL MakeDo.Warning["Syntax error, you fool"];
RETURN [NIL];
};
class _ MakeDo.LookupNodeClass[className];
IF class = NIL THEN {
SIGNAL MakeDo.Warning[IO.PutFR[
"no such class as %g",
[refAny[className]]
]];
RETURN [NIL];
};
node _ MakeDo.FindNode[objectName, class];
RETURN [node];
};
ENDCASE => {
fileName: ROPE _ from.GetTokenRope[Break].token;
node: MakeDo.Node _ MakeDo.FindNode[fileName, MakeDo.fileClass];
RETURN [node];
};
};

AnalyzeDFFile: PUBLIC PROC [dfName: ROPE, goals: MakeDo.RefTable, modifiable: MakeDo.ModifiabilitySpec, doToVerifyGoals, doToOthers: MakeDo.DoToFile] = {
Consume: PROC [item: REF ANY] RETURNS [stop: BOOL _ FALSE] =
BEGIN
Process.CheckForAbort[];
WITH item SELECT FROM
di: REF DFUtilities.DirectoryItem => NULL;
fi: REF DFUtilities.FileItem => {
cp: FS.ComponentPositions;
full, verless: ROPE;
[full, cp, ] _ FS.ExpandName[fi.name];
verless _ full.Substr[start: 0, len: cp.ext.start + cp.ext.length];
SELECT (IF fi.verifyRoot THEN doToVerifyGoals ELSE doToOthers) FROM
ignore => NULL;
makeGoal => NameAdd[verless, TRUE, TRUE];
makeModifiable => NameAdd[verless, FALSE, TRUE];
ENDCASE => ERROR;
};
ii: REF DFUtilities.ImportsItem => NULL;
ii: REF DFUtilities.IncludeItem => {
dfIn: IO.STREAM _ FS.StreamOpen[ii.path1];
DFUtilities.ParseFromStream[in: dfIn, proc: Consume];
dfIn.Close[]};
ci: REF DFUtilities.CommentItem => NULL;
wi: REF DFUtilities.WhiteSpaceItem => NULL;
ENDCASE => ERROR;
END;
NameAdd: PROC [name: ROPE, goal, mod: BOOL] = {
n: MakeDo.Node _ MakeDo.FindNode[name, MakeDo.fileClass];
NodeAdd[n, goal, mod];
};
NodeAdd: PROC [n: MakeDo.Node, goal, mod: BOOL] = {
IF mod THEN MakeDo.EnsureRefInTable[n, modifiable];
IF goal THEN MakeDo.EnsureRefInTable[n, goals];
};
dfIn: IO.STREAM = FS.StreamOpen[dfName];
DFUtilities.ParseFromStream[in: dfIn, proc: Consume];
dfIn.Close[];
};

DFDontExist: ERROR [fileName: ROPE] = CODE;

CmdMakeDo: PROC [cmd: Commander.Handle] RETURNS [result: REF ANY _ NIL, msg: ROPE _ NIL] --Commander.CommandProc-- =
BEGIN
ENABLE DFDontExist => {msg _ fileName.Concat[" doesn't exist"]; result _ $Failure; CONTINUE};
AddDF: PROC [doToVerifyGoals, doToOthers: MakeDo.DoToFile] =
BEGIN
dfIn: IO.STREAM _ NIL;
IF doToVerifyGoals=makeModifiable OR doToOthers=makeModifiable THEN specModifiable _ TRUE;
[] _ in.SkipWhitespace[];
IF in.EndOf[] THEN {AddMsg["No DF-file name after -whatever"]; RETURN};
dfName _ in.GetTokenRope[Break].token;
IF dfName.Find["."] < 0 THEN dfName _ dfName.Cat[".DF"];
[] _ FS.FileInfo[dfName !FS.Error => IF error.group = user THEN DFDontExist[dfName]];
AnalyzeDFFile[dfName, goals, modifiable, doToVerifyGoals, doToOthers];
END;
NodeAdd: PROC [n: MakeDo.Node, goal, mod: BOOL] = {
IF mod THEN MakeDo.EnsureRefInTable[n, modifiable];
IF goal THEN MakeDo.EnsureRefInTable[n, goals];
};
AddObject: PROC [goal, mod: BOOL] = {
n: MakeDo.Node;
IF mod THEN specModifiable _ TRUE;
[] _ in.SkipWhitespace[];
IF in.EndOf[] THEN {AddMsg["No object after -nm"]; RETURN};
n _ GetObject[in];
NodeAdd[n, goal, mod];
};
AddMsg: PROC [more: ROPE] = {msgout.PutRope[more]; msgout.PutRope["\n"]};
goals: MakeDo.RefTable _ MakeDo.MakeRefTable[];
modifiable: MakeDo.RefTable _ MakeDo.MakeRefTable[];
specModifiable: BOOL _ FALSE;
in: IO.STREAM _ IO.RIS[cmd.commandLine];
msgout, logfileStream: IO.STREAM _ NIL;
logFile: FS.OpenFile;
nArgs: INT _ 0;
rgomd: BOOL _ FALSE;
dfName: ROPE _ NIL;
logfileStream _ FS.StreamOpen["MakeDo.log", create];
logFile _ FS.OpenFileFromStream[logfileStream];
msgout _ IOClasses.CreateDribbleOutputStream[logfileStream, cmd.err];
{ENABLE MakeDo.Warning => {AddMsg[message]; RESUME};
FOR i: INT _ in.SkipWhitespace[], in.SkipWhitespace[] WHILE NOT in.EndOf[] DO
thing: REF ANY _ GetObjectOrSwitch[in];
nArgs _ nArgs + 1;
IF thing # NIL THEN WITH thing SELECT FROM
a: ATOM => SELECT a FROM
$rg => AddDF[makeGoal, ignore];
$og => AddDF[makeGoal, makeGoal];
$rgom => {AddDF[makeGoal, makeModifiable]; rgomd _ TRUE};
$dr => {AddDF[makeGoal, makeModifiable]; rgomd _ TRUE};
$om => AddDF[makeModifiable, makeModifiable];
$nm => AddObject[FALSE, TRUE];
$p => MakeDo.SetProcessAllocation[in.GetInt[]];
ENDCASE => AddMsg[IO.PutFR["Bad switch [-%g]", IO.atom[a]]];
ENDCASE => {
n: MakeDo.Node _ MakeDo.NarrowToNode[thing];
NodeAdd[n, TRUE, TRUE];
};
Process.CheckForAbort[];
ENDLOOP;
IF NOT specModifiable THEN {modifiable.DestroyTable[]; modifiable _ NIL};
SELECT cmd.procData.clientData FROM
$MakeDo => {
okGoalCount, nonOKGoalCount, nSteps, nFailedSteps: NAT;
failedSteps: MakeDo.ActionList;
failedGoals: MakeDo.NodeList;
IF rgomd AND nArgs = 1 AND dfName # NIL THEN {
msgout.PutF["MakingDo package in %g.\n", [rope[dfName]]];
};
[okGoalCount:okGoalCount, nonOKGoalCount:nonOKGoalCount, nSteps:nSteps, failedSteps:failedSteps, nonOKGoalList:failedGoals] _ MakeDo.Ensure[goals, modifiable, cmd];
nFailedSteps _ 0;
FOR failedSteps _ failedSteps, failedSteps.rest WHILE failedSteps # NIL DO
msgout.PutF["%lFailed: %g%l\n", IO.rope["b"], IO.rope[failedSteps.first.PublicPartsOfAction[].cmd], IO.rope["B"]];
nFailedSteps _ nFailedSteps + 1;
ENDLOOP;
IF nFailedSteps > 0 THEN msgout.PutF["%g failed; %g ok.\n", IO.rope[Quantify[nFailedSteps, "step"]], IO.int[nSteps - nFailedSteps]];
msgout.PutF["%g OK; %g not.\n", IO.rope[Quantify[okGoalCount, "goal"]], IO.int[nonOKGoalCount]];
IF failedGoals # NIL THEN {
msgout.PutF["%lNot OK:", IO.rope["b"]];
FOR failedGoals _ failedGoals, failedGoals.rest WHILE failedGoals # NIL DO
msgout.PutF[" %g", IO.rope[failedGoals.first.DescribeNode[]]];
ENDLOOP;
msgout.PutF["%l\n", IO.rope["B"]];
};
result _ IF nonOKGoalCount # 0 THEN $Failure ELSE $Success;
};
$MakePrediction, $MakeCommandList => {
al: MakeDo.ActionList _ MakeDo.GetActions[
goals,
modifiable,
SELECT cmd.procData.clientData FROM
$MakePrediction => toBeDone,
$MakeCommandList => all,
ENDCASE => ERROR];
al _ MakeDo.DestructivelyReverseActionList[al];
msgout.PutRope["Commands:\n"];
FOR al _ al, al.rest WHILE al # NIL DO
a: MakeDo.Action = al.first;
cmd: ROPE = a.PublicPartsOfAction[].cmd;
msgout.PutF["%g\n", [rope[cmd]] ];
ENDLOOP;
al _ al;
};
ENDCASE => ERROR;
};
msgout.Flush[];
logFile.SetByteCountAndCreatedTime[created: BasicTime.Now[]];
logFile _ FS.nullOpenFile;
logfileStream.Close[];
END;

CmdExplain: PROC [cmd: Commander.Handle] RETURNS [result: REF ANY _ NIL, msg: ROPE _ NIL] --Commander.CommandProc-- =
BEGIN
args: MakeDo.RefTable _ MakeDo.MakeRefTable[];
in: IO.STREAM _ IO.RIS[cmd.commandLine];
FOR i: INT _ in.SkipWhitespace[], in.SkipWhitespace[] WHILE NOT in.EndOf[] DO
ENABLE MakeDo.Warning => {
cmd.out.PutRope[message];
cmd.out.PutRope["\n"];
RESUME};
n: MakeDo.Node _ GetObject[in];
IF n # NIL THEN MakeDo.EnsureRefInTable[n, args];
ENDLOOP;
MakeDo.Explain[cmd, args];
END;

CmdProduce: PROC [cmd: Commander.Handle] RETURNS [result: REF ANY _ NIL, msg: ROPE _ NIL] --Commander.CommandProc-- =
BEGIN
in: IO.STREAM _ IO.RIS[cmd.commandLine];
FOR i: INT _ in.SkipWhitespace[], in.SkipWhitespace[] WHILE NOT in.EndOf[] DO
ENABLE MakeDo.Warning => {
cmd.out.PutRope[message];
cmd.out.PutRope["\n"];
RESUME};
n: MakeDo.Node _ GetObject[in];
IF n # NIL THEN MakeDo.RetryToProduce[n];
ENDLOOP;
in.Close[];
END;

Bitch: ERROR [message: ROPE] = CODE;

CmdSuspect: PROC [cmd: Commander.Handle] RETURNS [result: REF ANY _ NIL, msg: ROPE _ NIL] --Commander.CommandProc-- =
BEGIN ENABLE Bitch => {msg _ message; result _ $Failure; CONTINUE};
in: IO.STREAM _ IO.RIS[cmd.commandLine];
FOR i: INT _ in.SkipWhitespace[], in.SkipWhitespace[] WHILE NOT in.EndOf[] DO
ENABLE MakeDo.Warning => {
cmd.out.PutRope[message];
cmd.out.PutRope["\n"];
RESUME};
thing: REF ANY _ GetObjectOrSwitch[in];
DoObject: PROC [change, current, producer: BOOL] = {
n: MakeDo.Node;
[] _ in.SkipWhitespace[];
IF in.EndOf[] THEN Bitch["MakeDo ran off end of command line --- missing object"];
n _ GetObject[in];
Work[n, change, current, producer];
};
Work: PROC [n: MakeDo.Node, change, current, producer: BOOL] = {
IF change THEN MakeDo.SuspectNodeChange[n];
IF current THEN MakeDo.UncurrentNode[n];
IF producer THEN MakeDo.UncurrentProducer[n];
};
IF thing # NIL THEN WITH thing SELECT FROM
a: ATOM => SELECT a FROM
$allCurrent => MakeDo.ForAll[FALSE, TRUE];
$allChange => MakeDo.ForAll[TRUE, FALSE];
$all => MakeDo.ForAll[TRUE, TRUE];
$change => DoObject[TRUE, FALSE, FALSE];
$current => DoObject[FALSE, TRUE, FALSE];
$producer => DoObject[FALSE, FALSE, TRUE];
ENDCASE => cmd.out.PutF["Unrecognized switch -%g\n", [atom[a]]];
ENDCASE => {
n: MakeDo.Node _ MakeDo.NarrowToNode[thing];
Work[n, TRUE, TRUE, TRUE];
};
ENDLOOP;
in.Close[];
END;

CmdDestroy: PROC [cmd: Commander.Handle] RETURNS [result: REF ANY _ NIL, msg: ROPE _ NIL] --Commander.CommandProc-- =
BEGIN
MakeDo.DestroyGraph[];
END;

Quantify: PROC [n: NAT, stuff: ROPE] RETURNS [quantity: ROPE] =
{quantity _ IO.PutFR["%g %g%g", IO.int[n], IO.rope[stuff], IO.rope[IF n = 1 THEN "" ELSE "s"]]};

Commander.Register[key: "MakeDo", proc: CmdMakeDo, clientData: $MakeDo, doc: "Ensure that derived files are up to date.  Syntax is
MakeDo <arg>*
	<arg>:
		<object> |
		-nm <object> |
		-rg <DF file name> |
		-og <DF file name> |
		-rgom <DF file name> |
		-dr <DF file name> |
		-om <DF file name> |
		-p <number>
	<object>:
		<file name> |
		(className:<ROPE> objectName:<ROPE>)"];

Commander.Register[key: "MakePrediction", proc: CmdMakeDo, clientData: $MakePrediction, doc: "Estimate what 'MakeDo' would execute.  Syntax is
MakeCommandList <arg>*"];

Commander.Register[key: "MakeCommandList", proc: CmdMakeDo, clientData: $MakeCommandList, doc: "List all commands needed to make goals.  Syntax is
MakeCommandList <arg>*"];

Commander.Register[key: "MakeExcuses", proc: CmdExplain, doc: "Explain why MakeDo is misbehaving.  Syntax is
MakeExcuses <object>*"];

Commander.Register[key: "MakeSuspicion", proc: CmdSuspect, doc: "Suspect cached information is out of synch with reality.  Syntax is
MakeSuspicion <arg>*
	<arg>:
		-change <object> --suspect the named file of change
		-current <object> --forget whether named file is current
		-producer <object> --suspect that the next execution of the file's producer will be different from the last
		<object> --all of the above
		-allChange --suspect every object of change
		-allCurrent --suspect every object of not being current and every action of behaving differently than last time
		-all --all of the above"];

Commander.Register[key: "MakeEmpty", proc: CmdDestroy, doc: "Delete the entire dependency graph.  No arguments"];

Commander.Register[key: "MakeProducer", proc: CmdProduce, doc: "For leaves, try again to find a producer.  Syntax is
MakeProducer <object>*"];

END.
PMakeDoCmds.Mesa
Last Edited by: Spreitzer, June 16, 1986 10:59:30 pm PDT
Κ
δ–

"cedar" style˜
code™J™8—K˜KšΟk	œ*œœ1˜jK˜šΠbx
œœ
˜Kšœ*œœ0˜gKšœ	˜—K˜Kš
˜K˜Kšœœœ
˜K˜šΟnœœœ
œœ	œ
œ˜Fšœ˜š
œ˜Kšœœ
œ
˜"Kšœ0˜6K˜—Kšœœ˜$—K˜—K˜š
Ÿœœœœœ˜7šœœ˜Kšœ˜Kšœ
˜—K˜—K˜š
Ÿ	œœœ
œœ˜Ašœ˜˜Kšœœ
˜K˜K˜Kšœœ
œ
˜"K˜"Kš
œ#˜#K˜šœœ˜Kšœ*˜0Kšœœ˜
K˜—Kš
œ*˜*šœ	œ
œ˜šœœ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšœœ˜
Kš
œ˜—Kš
œ*˜*Kšœ˜K˜—šœ˜Kšœ
œ"˜0Kš
œ@˜@Kšœ˜K˜——K˜—K˜šŸ
œœ
œ
œq˜™
šŸœœœ
œœœœ˜<Kš
˜K˜šœœ
˜Kšœœœ
˜*šœœ˜!Kšœœ˜Kšœœ
˜Kšœœ˜&K˜Cš	œœœœ
˜CKšœ
œ
˜Kšœœœ˜)Kšœ#œœ˜0Kšœœ
˜—K˜—Kšœœœ
˜(šœœ˜$Kšœœ
œœ˜*Kš
œ5˜5Kš
œ˜—Kšœœœ
˜(Kšœœœ
˜+Kšœœ
˜—Kšœ
˜—šŸœœœ
œ˜/Kš
œ9˜9K˜K˜—šŸœœœ˜3Kšœœ(˜3Kšœœ#˜/K˜—Kšœœ
œœ˜(Kš
œ5˜5Kš
œ
˜
K˜—K˜KšŸœœœœ
˜+K˜šŸ	œœœ
œ
œœœœΟcœ˜tKš
˜KšœMœ˜]šŸœœ1˜<Kš
˜Kšœœ
œœ
˜Kšœ œœœ
˜ZK˜Kšœœ-œ˜GKš
œ&˜&Kšœœ˜8Kš	œœœ
œœ˜UKš
œF˜FKšœ
˜—šŸœœœ˜3Kšœœ(˜3Kšœœ#˜/K˜—šŸ	œœ
œ˜%Kš
œ˜Kšœœœ
˜"K˜Kšœœ!œ˜;Kš
œ˜Kš
œ˜K˜—KšŸœœœ1˜IKš
œ/˜/Kš
œ4˜4Kšœœœ
˜Kš	œœ
œœ
œ˜(Kšœœ
œœ
˜'Kšœ	œ
˜Kšœœ˜Kšœœœ
˜Kšœœœ
˜Kšœœ"˜4Kšœ
œ#˜/Kš
œE˜EKšœ
œ%œ˜4š	œœ,œ
œ˜MKšœœ
œ˜'Kš
œ˜šœ	œ
œ
œœ
˜*šœœœ˜Kš
œ˜Kš
œ!˜!Kšœ3œ˜9Kšœ1œ˜7Kš
œ-˜-Kšœœœ˜Kš
œ/˜/Kšœœœ˜<—šœ˜K˜,Kšœœœ˜K˜——K˜Kšœ
˜—Kšœ
œœ*œ˜Išœ˜#š
œ˜Kšœ3œ
˜7Kš
œ˜K˜š
œœœ
œ
œ˜.K˜9K˜—Kš
œ€
˜€
Kš
œ˜šœ-œœ
˜JKšœ œœ4œ˜rKš
œ ˜ Kšœ
˜—Kšœœ$œ'œ˜„
Kšœ œ&œ˜`šœœ
œ˜Kšœœ˜'šœ-œœ
˜JKšœœ)˜>Kšœ
˜—Kšœœ˜"K˜—Kšœ	œœ
œ
˜;K˜—š
œ&˜&š
œ*˜*Kš
œ˜Kš
œ˜šœ˜#Kš
œ˜Kš
œ˜Kšœœ˜——Kš
œ/˜/K˜šœœœ
˜&K˜Kšœœ˜(K˜"Kšœ
˜—K˜Kš
œ˜—Kšœœ
˜—K˜Kš
œ˜Kš
œ=˜=Kšœ
œ˜Kš
œ˜Kšœ
˜—K˜šŸ
œœœ
œ
œœœœ œ˜uKš
˜Kš
œ.˜.Kš	œœ
œœ
œ˜(š	œœ,œ
œ˜Mšœ˜K˜K˜Kšœ˜—K˜Kšœœ
œ"˜1Kšœ
˜—Kš
œ˜Kšœ
˜—K˜šŸ
œœœ
œ
œœœœ œ˜uKš
˜Kš	œœ
œœ
œ˜(š	œœ,œ
œ˜Mšœ˜K˜K˜Kšœ˜—K˜Kšœœ
œ˜)Kšœ
˜—K˜Kšœ
˜—K˜KšŸœœœœ
˜$K˜šŸ
œœœ
œ
œœœœ œ˜uKšœ
œ-œ˜CKš	œœ
œœ
œ˜(š	œœ,œ
œ˜Mšœ˜K˜K˜Kšœ˜—Kšœœ
œ˜'šŸœœœ˜4K˜Kš
œ˜Kšœœ@˜RK˜Kš
œ#˜#K˜—šŸœœ-œ˜@Kšœœ˜+Kšœ	œ˜(Kšœ
œ˜-K˜—šœ	œ
œ
œœ
˜*šœœœ˜Kšœœœ˜*Kšœœœ˜)Kšœœœ˜"Kšœœœœ˜(Kšœœœœ˜)Kšœœœœ˜*Kšœ9˜@—šœ˜K˜,Kšœœœœ˜K˜——Kšœ
˜—K˜Kšœ
˜—K˜šŸ
œœœ
œ
œœœœ œ˜uKš
˜Kš
œ˜Kšœ
˜—K˜šŸœœœ	œœœ˜?Kšœœœ	œœœœœ˜`—K˜Kš&œwΟtœ‘œ‘
œ
‘
œ‘
œ‘œ‘œ	‘œ‘œ‘œ‘
œ‘œ
‘œΟbœ
‘
œ‘
œ‘
œ‘
’
œ˜ώK˜Kšœ
‘œ‘œ˜¨
K˜Kšœ“
‘œ‘œ˜¬
K˜Kšœm‘
œ‘œ˜…
K˜Kš%œ’
‘œ‘œ‘Πbt
‘œ‘Πct"’œ
‘
œ‘€&’œ
‘
œ‘€X‘œ‘€’
œ
  ’œ
 c’œ
 œ˜ΫK˜K˜qK˜Kšœ‚
‘
œ‘œ˜Ž
K˜Kšœ
˜—…—-0;d