RoseDeps.Mesa
Last Edited by: Spreitzer, May 8, 1985 4:07:10 pm PDT
DIRECTORY BasicTime, FS, IO, IOClasses, MakeDo, Rope;
RoseDeps: CEDAR PROGRAM
IMPORTS BasicTime, FS, IO, IOClasses, MakeDo, Rope =
BEGIN
ROPE: TYPE = Rope.ROPE;
RoseCommand: TYPE = REF RoseCommandRep; RoseCommandRep: TYPE = RECORD [
resultBase, resultShort: ROPE,
roseNode, transNode: MakeDo.Node,
earliestResultNode, lateIngredientNode: MakeDo.Node ← NIL,
earliestResultTime, lateIngredientTime: BasicTime.GMT ← BasicTime.nullGMT,
cmd: ROPENIL];
rosemaryClass: MakeDo.CommandClass ← NEW [MakeDo.CommandClassRep ← [
NotCurrent: RoseNotCurrent,
Rederive: RederiveRose,
UpdateTime: MakeDo.FileTime,
Explain: ExplainRose
]];
RoseFind: PROC [resultName: ROPE, finderData: REF ANY] RETURNS [found: BOOLEAN, sought: MakeDo.Node, makes, from, why: MakeDo.NodeList, cmd: ROPE, class: MakeDo.CommandClass, foundData: REF ANY] --MakeDo.FinderProc-- =
BEGIN
resultCP: FS.ComponentPositions;
resultFull, resultBase, resultExt, roseName: ROPE;
roseFound: BOOLEAN;
roseNode: MakeDo.Node;
rc: RoseCommand;
[resultFull, resultCP, ] ← FS.ExpandName[resultName];
resultExt ← resultFull.Substr[start: resultCP.ext.start, len: resultCP.ext.length];
roseFound ← resultExt.Equal["RoseSymbols", FALSE]
OR resultExt.Equal["roseDeps", FALSE]
OR resultExt.Equal["partsAssertions", FALSE]
OR resultExt.Equal["RoseLoad", FALSE];
found ← roseFound OR resultExt.Equal["Mesa", FALSE];
IF NOT found THEN RETURN;
resultBase ← resultFull.Substr[start: 0, len: resultCP.ext.start-1];
why ← LIST[roseNode ← MakeDo.GetNode[roseName ← resultBase.Cat[".Rose"]]];
found ← MakeDo.Exists[roseNode, MakeDo.FileTime];
IF NOT found THEN RETURN;
foundData ← rc ← NEW [RoseCommandRep ← [
resultBase: resultBase,
resultShort: resultFull.Substr[start:resultCP.base.start, len:resultCP.base.length],
roseNode: roseNode,
transNode: MakeDo.GetNode["RoseTranslator.Version"]
]];
makes ← LIST[
MakeDo.GetNode[resultBase.Cat[".RoseDeps"]],
MakeDo.GetNode[resultBase.Cat[".RoseSymbols"]],
MakeDo.GetNode[resultBase.Cat[".partsAssertions"]],
MakeDo.GetNode[resultBase.Cat[".RoseLoad"]],
MakeDo.GetNode[resultBase.Cat[".Mesa"]]];
sought ←
IF resultExt.Equal["RoseSymbols", FALSE] THEN makes.first ELSE
IF resultExt.Equal["partsAssertions", FALSE] THEN makes.rest.first ELSE
IF resultExt.Equal["RoseLoad", FALSE] THEN makes.rest.rest.first ELSE
IF resultExt.Equal["Mesa", FALSE] THEN makes.rest.rest.rest.first ELSE
ERROR;
from ← DeriveFrom[rc];
rc.cmd ← cmd ← IO.PutFR["RoseTranslate %g", IO.rope[rc.resultShort]];
class ← rosemaryClass;
END;
DeriveFrom: PROC [rc: RoseCommand] RETURNS [from: MakeDo.NodeList] =
BEGIN
NoteModuleRef: PROC [moduleName: ROPE, type: ModuleReferenceType] = {
SELECT type FROM
Directory, Imports, Open => NULL;
Library => from ← CONS[
MakeDo.GetNode[FS.ExpandName[moduleName.Cat[".RoseSymbols"]].fullFName],
from];
ENDCASE => ERROR};
from ← LIST[rc.roseNode, rc.transNode];
[] ← EnumerateModuleReferences[fromName: rc.roseNode.PublicPartsOfNode[].name, to: NoteModuleRef];
END;
IDProc: IO.BreakProc = {RETURN [SELECT char FROM
IN [IO.NUL .. IO.SP] => sepr,
'; => break,
ENDCASE => other]};
RederiveRose: PROC [c: MakeDo.Command] RETURNS [from: MakeDo.NodeList, cmd: ROPE] --MakeDo.RederiveProc-- = {
rc: RoseCommand ← NARROW[c.PublicPartsOfCommand[].foundData];
from ← DeriveFrom[rc];
cmd ← rc.cmd};
RoseNotCurrent: PROC [c: MakeDo.Command] RETURNS [notCurrent: BOOLEAN] --MakeDo.NotCurrentProc-- =
BEGIN
fd: REF ANY;
makes, from: MakeDo.NodeList;
rc: RoseCommand;
[foundData: fd, makes: makes, from: from] ← c.PublicPartsOfCommand[];
rc ← NARROW[fd];
rc.earliestResultTime ← BasicTime.latestGMT;
rc.earliestResultNode ← rc.lateIngredientNode ← NIL;
FOR ml: MakeDo.NodeList ← makes, ml.rest WHILE ml # NIL DO
thisTime: BasicTime.GMT ← MakeDo.Latest[ml.first];
IF NOT MakeDo.Needed[ml.first] THEN LOOP;
IF thisTime # BasicTime.nullGMT AND thisTime.Period[rc.earliestResultTime] > 0
THEN {rc.earliestResultTime ← thisTime; rc.earliestResultNode ← ml.first};
ENDLOOP;
IF rc.earliestResultNode = NIL THEN RETURN [FALSE];
FOR fl: MakeDo.NodeList ← from, fl.rest WHILE fl # NIL DO
fromTime: BasicTime.GMT ← MakeDo.Latest[fl.first];
IF (fromTime # BasicTime.nullGMT) AND (fromTime.Period[rc.earliestResultTime] < 0) THEN {
rc.lateIngredientTime ← fromTime;
rc.lateIngredientNode ← fl.first;
RETURN [TRUE]};
ENDLOOP;
notCurrent ← FALSE;
END;
ExplainRose: PROC [c: MakeDo.Command, to: IO.STREAM] --MakeDo.ExplainProc-- =
BEGIN
rc: RoseCommand ← NARROW[c.PublicPartsOfCommand[].foundData];
IF rc.earliestResultNode = NIL THEN to.PutRope["\t\tno result files existed yet.\n"]
ELSE IF rc.lateIngredientNode = NIL THEN to.PutRope["\t\tall result files were dated later than any ingredient file.\n"]
ELSE to.PutF["\t\tresult %g of %g predated ingredient %g of %g.\n", IO.rope[rc.earliestResultNode.PublicPartsOfNode[].name], IO.time[rc.earliestResultTime], IO.rope[rc.lateIngredientNode.PublicPartsOfNode[].name], IO.time[rc.lateIngredientTime]];
END;
ModuleReferenceType: TYPE = {Directory, Open, Imports, Exports, Library};
MRKeywords: ARRAY ModuleReferenceType OF ROPE = ["Directory", "Open", "Imports", "Exports", "Library"];
GotoSyntaxError: ERROR = CODE;
Break: IO.BreakProc = {RETURN [SELECT char FROM
IN ['a .. 'z], IN ['A .. 'Z], IN ['0 .. '9] => other,
IO.SP, IO.CR, IO.TAB, IO.LF, IO.FF => sepr,
ENDCASE => break]};
EnumerateModuleReferences: PROC [fromName: ROPE, to: PROC [moduleName: ROPE, type: ModuleReferenceType]] RETURNS [exists: BOOLEAN] =
BEGIN
NextToken: PROC RETURNS [ROPE] = {
[] ← from.SkipWhitespace[];
IF from.PeekChar[] = '$ THEN {
IF from.GetChar[] # '$ THEN ERROR;
RETURN [IF from.PeekChar[] # '" THEN "$" ELSE from.GetRopeLiteral];
};
RETURN [from.GetTokenRope[Break].token]};
ModuleReferenceKey: PROC [r: ROPE] RETURNS [is: BOOL, mrt: ModuleReferenceType] = {
FOR mrt IN ModuleReferenceType DO
IF MRKeywords[mrt].Equal[s2: r, case: FALSE] THEN RETURN [TRUE, mrt];
ENDLOOP;
is ← FALSE};
ParseRefs: PROC = {
next: ROPE;
DO
still: BOOLEAN;
mrt: ModuleReferenceType;
[still, mrt] ← ModuleReferenceKey[next ← NextToken[]];
IF NOT still THEN EXIT;
next ← EatModuleReferenceBody[mrt];
IF next.Length[] = 0 AND from.EndOf[] THEN EXIT --end of file--;
IF NOT next.Equal[";"] THEN ERROR GotoSyntaxError;
ENDLOOP;
};
EatModuleReferenceBody: PROC [mrt: ModuleReferenceType] RETURNS [next: ROPE] = {
DO
next ← NextToken[];
to[next, mrt];
next ← NextToken[];
IF next.Equal[";"] THEN RETURN;
IF NOT next.Equal[","] THEN ERROR GotoSyntaxError;
ENDLOOP};
from: IO.STREAMNIL;
from ← FS.StreamOpen[fileName: fromName, accessOptions: $read !FS.Error => {from ← NIL; CONTINUE}];
IF NOT (exists ← from # NIL) THEN RETURN;
from ← IOClasses.CreateCommentFilterStream[from];
[] ← from.GetIndex[];
ParseRefs[!GotoSyntaxError =>
BEGIN
SIGNAL MakeDo.Warning[IO.PutFR["Syntax error in %g; parse aborted at %g", IO.rope[fromName], IO.int[from.GetIndex[]]]];
CONTINUE
END];
from.Close[];
END;
MakeDo.AddFinder[[RoseFind], back];
END.