
DIRECTORY
BasicTime USING [earliestGMT, GMT, Period],
FS USING [ComponentPositions, Error, ExpandName, StreamOpen],
IO USING [Close, EndOf, GetLineRope, PutFR, rope, SkipWhitespace, STREAM],
MakeDo USING [Action, ActionClass, ActionClassRep, ActionDep, AddFinder, fileClass, From, GetNode, InnerEnumerateSources, InnerGetCreated, Node, NodeList, notExistTime, PublicPartsOfAction, PublicPartsOfNode, Time],
Rope USING [Cat, Concat, Equal, Length, ROPE, Substr];

LupineDeps: CEDAR PROGRAM
IMPORTS BasicTime, FS, IO, MakeDo, Rope =

BEGIN

ROPE: TYPE = Rope.ROPE;

LupineAction: TYPE = REF LupineActionRep;
LupineActionRep: TYPE = RECORD [
interfaceName, resultPrefix: ROPE,
sourceNode, switchesNode: MakeDo.Node
];

lupineClass: MakeDo.ActionClass _ NEW [MakeDo.ActionClassRep _ [
CheckConsistency: CheckLupineConsistency,
Rederive: RederiveLupine
]];

LupineFind: PROC [resultName: ROPE, finderData: REF ANY] RETURNS [found: BOOLEAN, sought: MakeDo.Node, makes, cmdFrom: MakeDo.NodeList, from: MakeDo.From, cmd: ROPE, class: MakeDo.ActionClass, foundData: REF ANY] -- MakeDo.FinderProc -- =
BEGIN
EndsIn: PROC [ending: ROPE] RETURNS [ans: BOOL] = {
elen: INT = ending.Length[];
IF elen > slen THEN RETURN [FALSE];
IF (ans _ resultShort.Substr[start: slen - elen, len: elen].Equal[s2: ending, case: FALSE]) THEN {plen _ slen - elen; sending _ ending}};
Tail: PROC [ending: ROPE] RETURNS [node: MakeDo.Node] = {
node _ MakeDo.GetNode[resultPrefix.Cat[ending], MakeDo.fileClass];
IF ending.Equal[sending] THEN sought _ node};
resultCP: FS.ComponentPositions;
resultFull, resultPrefix, resultShort, interfaceName, sourceName, sending: ROPE;
sourceNode, switchesNode: MakeDo.Node;
la: LupineAction;
slen, plen: INT _ 0;
sought _ NIL;
found _ TRUE;
[resultFull, resultCP, ] _ FS.ExpandName[resultName !FS.Error => {found _ FALSE; CONTINUE}];
IF NOT found THEN RETURN;
resultShort _ resultFull.Substr[start: resultCP.base.start, len: (resultCP.ext.start + resultCP.ext.length) - resultCP.base.start];
slen _ resultShort.Length[];
found _ EndsIn["RpcControl.Mesa"] OR EndsIn["RpcClientImpl.Mesa"] OR EndsIn["RpcBinderImpl.Mesa"] OR EndsIn["RpcServerImpl.Mesa"];
IF NOT found THEN RETURN;
interfaceName _ resultShort.Substr[start: 0, len: plen];
resultPrefix _ resultFull.Substr[start: 0, len: resultCP.base.start].Concat[interfaceName];
cmdFrom _ LIST[
sourceNode _ MakeDo.GetNode[sourceName _ resultPrefix.Cat[".BCD"], MakeDo.fileClass],
switchesNode _ MakeDo.GetNode[resultPrefix.Cat[".LupineSwitches"], MakeDo.fileClass]
];
foundData _ la _ NEW [LupineActionRep _ [
interfaceName: interfaceName,
resultPrefix: resultPrefix,
sourceNode:  sourceNode,
switchesNode: switchesNode
]];
cmd _ DeriveCmd[la];
makes _ LIST[
Tail["RpcControl.Mesa"],
Tail["RpcClientImpl.Mesa"],
Tail["RpcBinderImpl.Mesa"],
Tail["RpcServerImpl.Mesa"]];
IF sought = NIL THEN ERROR;
from _ DeriveFrom[la];
class _ lupineClass;
END;

GetSwitches: PROC [resultPrefix: ROPE] RETURNS [switches: ROPE] = {
ss: IO.STREAM _ NIL;
ss _ FS.StreamOpen[resultPrefix.Cat[".LupineSwitches"] !FS.Error => CONTINUE];
IF ss = NIL THEN RETURN [NIL];
[] _ ss.SkipWhitespace[];
IF ss.EndOf[] THEN RETURN [NIL];
switches _ ss.GetLineRope[];
ss.Close[];
};

DeriveFrom: PROC [la: LupineAction] RETURNS [from: MakeDo.From] =
BEGIN
from _ [mustHave: LIST[la.sourceNode], optional: NIL];
END;

DeriveCmd: PROC [la: LupineAction] RETURNS [cmd: ROPE] = {
cmd _ IO.PutFR[
"Lupine %g TranslateInterface[%g]",
IO.rope[GetSwitches[la.resultPrefix]],
IO.rope[la.interfaceName]
]
};

RederiveLupine: PROC [a: MakeDo.Action] RETURNS [from: MakeDo.From, cmd: ROPE] --MakeDo.RederiveProc-- = {
la: LupineAction _ NARROW[a.PublicPartsOfAction[].foundData];
from _ DeriveFrom[la];
cmd _ DeriveCmd[la];
};

FindLatestIngredient: PROC [a: MakeDo.Action] RETURNS [someIngredientsExist: BOOL _ FALSE, missingIngredient, latestIngredientNode: MakeDo.Node _ NIL, latestIngredientTime: MakeDo.Time _ BasicTime.earliestGMT] = {
PerSource: PROC [n: MakeDo.Node, which: MakeDo.ActionDep, optional: BOOL] = {
fromTime: BasicTime.GMT _ MakeDo.InnerGetCreated[n];
IF fromTime = MakeDo.notExistTime THEN {IF NOT optional THEN missingIngredient _ n}
ELSE {someIngredientsExist _ TRUE;
IF latestIngredientTime.Period[fromTime] > 0 THEN {
latestIngredientTime _ fromTime;
latestIngredientNode _ n;
};
};
};
MakeDo.InnerEnumerateSources[a, data, PerSource];
RETURN};

CheckLupineConsistency: PROC [a: MakeDo.Action, result: MakeDo.Node] RETURNS [consistent: BOOL, reason: ROPE] --MakeDo.ConsistencyChecker-- =
BEGIN
resultTime: MakeDo.Time = result.InnerGetCreated[];
resultName: ROPE = result.PublicPartsOfNode[].name;
resultExists: BOOL ~ resultTime # MakeDo.notExistTime;
someIngredientsExist: BOOL;
missingIngredient, latestIngredientNode: MakeDo.Node;
latestIngredientTime: MakeDo.Time;
[someIngredientsExist, missingIngredient, latestIngredientNode, latestIngredientTime] _ FindLatestIngredient[a];
IF NOT someIngredientsExist THEN RETURN [TRUE, "no ingredients exist to indicate inconsistency"];
IF NOT resultExists THEN RETURN [FALSE, "some inputs but no outputs exist"];
IF latestIngredientTime.Period[resultTime] < 0 THEN RETURN [
FALSE,
IO.PutFR[
"result %g (of %g) predates ingredient %g (of %g)",
[rope[resultName]],
[time[resultTime]],
[rope[latestIngredientNode.PublicPartsOfNode[].name]],
[time[latestIngredientTime]]
]];
RETURN [TRUE, "result dated later than any existing ingredient"];
END;

MakeDo.AddFinder[["Lupine", LupineFind], back];

END.

   ً  
LupineDeps.Mesa
Last Edited by: Spreitzer, September 13, 1985 6:33:19 pm PDT
Last Edited by: Pavel, May 28, 1984 3:06:54 pm PDT
Last tweaked by Mike Spreitzer on October 27, 1989 11:49:51 am PDT
JKF January 11, 1989 10:15:47 am PST
 ‌ت	  •NewlineDelimiter
™ code™K™<K™2K™BK™$—Kک ڑدk	ک	Kڑœ
‌œ‌œ
ک+Kڑ‌œ‌œ5ک=Kڑ‌œ‌œ:‌œکJKڑœ‌œثک×Kڑœ‌œ‌œ
ک6—Kک ڑذbx
œ‌œ‌کKڑ‌œ‌œ‌œک)—Kک Kڑ‌کKک Kڑ‌œ‌œ‌œکKک Kڑœ‌œ‌œک)ڑœ‌œ‌œک Kڑœ‌œک"Kڑœ%ک%Kڑœک—Kک ڑœ"‌œک@Kڑœ)ک)KکKک—Kک ڑدn
œ‌œ‌œ‌œ‌œ‌œ	‌œP‌œ(‌œ‌œدcœکîKڑ‌کڑ
ںœ‌œ
‌œ‌œ‌œک3Kڑœ‌œکKڑ‌œ‌œ‌œ‌œک#Kڑ‌œR‌œ‌œ)ک‰—ڑںœ‌œ
‌œ‌œک9KڑœBکBKڑ‌œ‌œک-—Kڑœ
‌œک KڑœK‌œکPKک&KکKڑœ‌œکKڑœ	‌œکKڑœ‌œکKڑ	œ‌œ‌œ‌œ‌œک\Kڑ‌œ‌œ‌œ‌œکKڑœƒکƒKکKڑœ"‌œ‌œ‌œک‚Kڑ‌œ‌œ‌œ‌œکKڑœ8ک8Kڑœ[ک[ڑœ
‌œکKڑœUکUKڑœTکTKک—ڑœ‌œک)KڑœکKڑœکKڑœکKکKک—Kکڑœ‌œکKڑœکKڑœکKڑœکKڑœک—Kڑ‌œ
‌œ‌œ‌œکKکKڑœکKڑ‌œک—Kک ڑ
ںœ‌œ‌œ‌œ‌œکCKڑœ‌œ‌œ‌œکKڑœ‌œ1‌œ
‌œکNKڑ
‌œ‌œ‌œ‌œ‌œکKکKڑ‌œ‌œ‌œ‌œک KڑœکKکKک—Kک ڑں
œ‌œ‌œکAKڑ‌کKڑœ‌œ‌œک6Kڑ‌œک—Kک ڑں	œ‌œ‌œ‌œک:ڑœ‌œکKڑœ#ک#Kڑ‌œ$ک&Kڑ‌œکKڑœک—Kک—Kک ڑ
ںœ‌œ‌œ‌œ œکjKڑœ‌œ$ک=KکKکKک—Kک ڑںœ‌œ‌œ‌œ‌œ9‌œ@کصڑں	œ‌œ5‌œکMKڑœ‌œک4Kڑ
‌œ ‌œ‌œ‌œ
‌œکSڑ‌œ‌œک"ڑ‌œ+‌œک3Kڑœ ک KڑœکKڑœک—Kک—Kک—Kڑœ1ک1Kڑ‌œک—Kک ڑںœ‌œ)‌œ‌œ
‌œ œکچKڑ‌کKڑœ3ک3Kڑœ‌œ#ک3Kڑœ‌œ$ک6Kڑœ‌œکKڑœ5ک5Kڑœ"ک"KڑœpکpKڑ
‌œ‌œ‌œ‌œ‌œ4کaKڑ
‌œ‌œ‌œ‌œ‌œ&کLڑ‌œ-‌œ‌œک<Kڑ‌œکڑ‌œک	Kڑœ3ک3KڑœکKڑœکKڑœ6ک6KڑœکKک——Kڑ‌œ‌œ5کAKڑ‌œک—Kک Kڑœ/ک/Kک Kڑ‌œکKک — …—    d  ]  