DIRECTORY
Atom, BasicTime, Commander, FS, IO, IOClasses, OrderedSymbolTableRef, PutGet, Rope, RoseTranslateTypes, RoseTranslateInsides, SignalTypeRegistration, TextNode, TiogaFileOps, TiogaOps, TiogaStreams, UserCredentials, ViewerClasses, ViewerOps, ViewerTools;

RoseTranslateRandoms: CEDAR PROGRAM
IMPORTS Atom, BasicTime, Commander, FS, IO, IOClasses, OSTR: OrderedSymbolTableRef, PutGet, Rope, SignalTypeRegistration, TFO: TiogaFileOps, TiogaOps, TS: TiogaStreams, RoseTranslateInsides, UserCredentials, ViewerOps, ViewerTools
EXPORTS RoseTranslateTypes, RoseTranslateInsides =

BEGIN OPEN RoseTranslateTypes, RoseTranslateInsides;

TypeConstructionError: PUBLIC ERROR [msg: ROPE] = CODE;

Circularity: PUBLIC ERROR = CODE;


error: PUBLIC REF ANY _ NEW [ROPE _ "error"];

noDefault: PUBLIC REF ANY _ NEW [ROPE _ "no default"];


GetParm: PUBLIC PROC [n: [1..LAST[INTEGER]], name: ROPE, parms: REF ANY, default: REF ANY _ noDefault] RETURNS [it: REF ANY] =
BEGIN
IF parms = NIL THEN
BEGIN
IF default # noDefault THEN it _ default
ELSE ERROR TypeConstructionError[IO.PutFR["parm %g not found", IO.rope[name]]];
END
ELSE WITH parms SELECT FROM
bl: BindingList => BEGIN
FOR bl _ bl, bl.rest WHILE bl # NIL DO
IF bl.first.name.Equal[name, FALSE] THEN RETURN [bl.first.value];
ENDLOOP;
IF default # noDefault THEN it _ default
ELSE ERROR TypeConstructionError[IO.PutFR["parm %g not found", IO.rope[name]]];
END;
a: Args => BEGIN
i: INT _ n;
FOR l: LIST OF Arg _ a.args, l.rest WHILE l # NIL DO
IF i = 1 THEN RETURN [l.first];
i _ i - 1;
ENDLOOP;
IF default # noDefault THEN it _ default
ELSE ERROR TypeConstructionError[IO.PutFR["no %g'th parm", IO.int[i]]];
END;
ENDCASE => ERROR;
END;

ForceMesaType: PUBLIC PROC [mesaType: ROPE, on: NodeType] RETURNS [forced: NodeType] =
BEGIN
ERROR;	--no longer supported
END;

TranslateCmd: Commander.CommandProc --PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: Rope.ROPE _ NIL]-- =
BEGIN
commandLineStream: IO.STREAM _ IO.RIS[cmd.commandLine];
[] _ commandLineStream.SkipWhitespace[flushComments: FALSE];
WHILE NOT commandLineStream.EndOf[] DO
name: ROPE _ commandLineStream.GetTokenRope[IO.IDProc].token;
errs: CARDINAL _ 1;
errs _ Translate[cmd, name, NIL, TranslateJob !Circularity => CONTINUE];
IF errs > 0 THEN RETURN [$Failure];
[] _ commandLineStream.SkipWhitespace[flushComments: FALSE];
ENDLOOP;
END;

Translate: PUBLIC PROC [exec: Commander.Handle, rootName: ROPE, pathIn: LIST OF ROPE, type: JobType] RETURNS [errCount: CARDINAL] = TRUSTED
BEGIN
inRoot: TextNode.Ref _ NIL;
job: Job _ NEW [JobRep _ [
exec: exec,
rootName: rootName,
path: CONS[rootName, pathIn],
outRoot: TFO.CreateRoot[],
symbolsRoot: TFO.CreateRoot[],
directory: OSTR.CreateTable[CompareRopes],
imports: OSTR.CreateTable[CompareRopes],
opened: OSTR.CreateTable[CompareRopes],
libbed: OSTR.CreateTable[CompareRopes],
things: OSTR.CreateTable[SignalTypeRegistration.CompareSymbolTableEntries],
used: OSTR.CreateTable[CompareRefAnies],
type: type,
start: BasicTime.GetClockPulses[]]];
logFile: IO.STREAM;
sourceName, logName: ROPE;

inRoot _ PutGet.FromFile[sourceName _ rootName.Concat[".Rose"] !FS.Error =>
BEGIN
viewerLog.PutF["\nOpen failed on %g\n", IO.rope[sourceName]];
inRoot _ NIL;
CONTINUE;
END];
IF inRoot = NIL THEN RETURN [1];
job.from _ TS.CreateInput[inRoot];
job.to _ TS.CreateOutput[job.outRoot, "code"];
job.symbolsStream _ TS.CreateOutput[job.symbolsRoot];
logFile _ FS.StreamOpen[fileName: logName _ rootName.Concat[".log"], accessOptions: create];
job.log _ IOClasses.CreateDribbleOutputStream[logFile, viewerLog];
Open[job, sourceName];
[job.parseTree, ] _ ParseExpression[job, FALSE];
Close[job];
logFile.Close[];
viewerLog.PutRope["Done.\n\n"];
errCount _ job.errCount;
END;

Open: PROC [job: Job, sourceName: ROPE] = TRUSTED
BEGIN
job.log.PutF["\nTranslating %g into %g.Mesa, log on %g.Log\n", IO.rope[sourceName], IO.rope[job.rootName], IO.rope[job.rootName]];
job.to.PutF["--%g.Mesa", IO.rope[job.rootName]]; TS.EndNode[job.to];
job.to.PutF["--created by RoseTranslate from %g of %g for %g at %g", IO.rope[sourceName], IO.time[FS.FileInfo[sourceName].created], IO.rope[UserCredentials.Get[].name], IO.time[]]; TS.EndNode[job.to];
TS.EndNode[job.to];
TS.EndNode[job.to];
job.to.PutRope["DIRECTORY"];
job.directoryStream _ TS.CreateOutput[TS.CurOutNode[job.to], "code"];
TS.EndNode[job.to];
TS.EndNode[job.to];
job.to.PutF["%g: CEDAR PROGRAM", IO.rope[job.rootName]];
job.importsStream _ TS.CreateOutput[TS.CurOutNode[job.to], "code"];
job.importsStream.PutRope["IMPORTS "];
TS.EndNode[job.to];
TS.EndNode[job.to];
job.to.PutRope["BEGIN OPEN"];
job.openStream _ TS.CreateOutput[TS.CurOutNode[job.to], "code"];
TS.EndNode[job.to];
TS.EndNode[job.to];
job.to.PutRope["--Signal Type decls"];
job.typeStream _ TS.CreateOutput[TS.CurOutNode[job.to], "code"];
TS.EndNode[job.to];
TS.EndNode[job.to];
job.to.PutRope["RegisterCells: PROC ="];
job.regStream _ TS.CreateOutput[TS.CurOutNode[job.to], "code"];
TS.EndNode[job.to];
job.regStream.PutRope["BEGIN"]; TS.EndNode[job.regStream];
AddOpen[job, "RoseTypes"];
AddImport[job, "RoseCreate"];
END;

TypeCheck: PUBLIC PROC [job: Job, args: REF ANY, interface: DigestedInterface, instanceName: ROPE] =
BEGIN
Check: PROC [keyword: ROPE, match: InterfaceElt, value: REF ANY] =
BEGIN
Descr: PROC RETURNS [r: ROPE] = {
r _ IF keyword = NIL
THEN IO.PutFR["%g#%g", IO.rope[instanceName], IO.card[index]]
ELSE IO.PutFR["%g.%g", IO.rope[instanceName], IO.rope[keyword]]};
ste: SymbolTableEntry;
valName: ROPE;
valNode: nodeEntry;
IF match = NIL AND keyword # NIL THEN
BEGIN
match _ NARROW[interface.asTable.Lookup[keyword]];
IF match = NIL THEN Whimper[job, "%g not a valid port on cell %g", IO.rope[keyword], IO.rope[instanceName]];
END;
WITH value SELECT FROM
r: ROPE => valName _ r;
ENDCASE => {Whimper[job, "%g should be bound to an ID, not %g", IO.rope[Descr[]], IO.refAny[value]]; RETURN};
ste _ NARROW[job.things.Lookup[valName]];
WITH ste SELECT FROM
ne: nodeEntry => valNode _ ne;
ENDCASE => {Whimper[job, "%g was bound to %g, which should have been a node, rather than %g", IO.rope[Descr[]], IO.rope[valName], IO.refAny[ste]]; RETURN};
IF match = NIL THEN RETURN;
IF match.spare THEN Whimper[job, "%g.%g specified twice", IO.rope[instanceName], IO.rope[match.name]]
ELSE match.spare _ TRUE;
IF match.sti.st # valNode.nodeType THEN
BEGIN
Whimper[job,
"Type mismatch for %g: got %g when expecting %g",
IO.rope[Descr[]],
IO.rope[valNode.nodeType.procs.UserDescription[valNode.nodeType]],
IO.rope[match.sti.st.procs.UserDescription[match.sti.st]]];
END;
END;
toMatch: InterfaceEltList _ interface.asList;
index: CARDINAL _ 0;
FOR iel: InterfaceEltList _ interface.asList, iel.rest WHILE iel # NIL DO
iel.first.spare _ FALSE;
ENDLOOP;
WITH args SELECT FROM
bl: BindingList => FOR bl _ bl, bl.rest WHILE bl # NIL DO
index _ index + 1;
Check[bl.first.name, NIL, bl.first.value];
ENDLOOP;
a: Args => BEGIN
l: LIST OF Arg;
FOR l _ a.args, l.rest WHILE l # NIL AND toMatch # NIL DO
index _ index + 1;
Check[NIL, toMatch.first, l.first];
toMatch _ toMatch.rest;
ENDLOOP;
IF l # NIL --OR toMatch # NIL-- THEN Whimper[job, "too many parameters to %g", IO.rope[instanceName]];
END;
ENDCASE => ERROR;
index _ 0;
FOR iel: InterfaceEltList _ interface.asList, iel.rest WHILE iel # NIL DO
index _ index + 1;
IF NOT iel.first.spare THEN
--old: Whimper[job, "%g.%g never specified", IO.rope[instanceName], IO.rope[iel.first.name]];--
--new:-- Check[iel.first.name, iel.first, iel.first.name];
ENDLOOP;
END;

DoMesaFormatting: PROC [fileName: ROPE] = TRUSTED
BEGIN
check: ATOM _ Atom.MakeAtom[fileName];
asAny: REF ANY _ Atom.GetProp[atom: check, prop: $mjsMesaFmtCheck];
ri: REF INT;
v: ViewerClasses.Viewer;
viewerName: ROPE;
IF asAny = NIL THEN Atom.PutProp[atom: check, prop: $mjsMesaFmtCheck, val: asAny _ ri _ NEW [INT _ 0]] ELSE ri _ NARROW[asAny];
ri^ _ ri^ + 1;
viewerName _ IF ri^ = 1 THEN fileName ELSE IO.PutFR["%g!%g", IO.rope[fileName], IO.int[ri^]];
v _ ViewerTools.MakeNewTextViewer[info: [name: viewerName, file: fileName, iconic: FALSE]];
TiogaOps.SelectDocument[v];
TiogaOps.MesaFormatting[];
END;

Complain: PUBLIC PROC [context: REF ANY, complaint: ROPE, v1, v2, v3, v4, v5: IO.Value _ [null[]]] RETURNS [reduced: REF ANY] =
BEGIN
job: Job _ NARROW[context];
job.log.PutF["Somewhere before %g: ", IO.int[job.from.GetIndex[]]];
job.log.PutF[complaint.Concat["\n"], v1, v2, v3, v4, v5];
job.errCount _ job.errCount + 1;
reduced _ error;
END;

Whimper: PUBLIC PROC [context: REF ANY, complaint: ROPE, v1, v2, v3, v4, v5: IO.Value _ [null[]]] =
BEGIN
job: Job _ NARROW[context];
job.log.PutF["Somewhere before %g: ", IO.int[job.from.GetIndex[]]];
job.log.PutF[complaint.Concat["\n"], v1, v2, v3, v4, v5];
job.warnCount _ job.warnCount + 1;
END;

CompareRopes: OSTR.CompareProc = {RETURN [Rope.Compare[NARROW[r1], NARROW[r2]]]};

CompareRefAnies: OSTR.CompareProc =
BEGIN
c1: LONG CARDINAL _ LOOPHOLE[r1];
c2: LONG CARDINAL _ LOOPHOLE[r2];
RETURN [IF c1 < c2 THEN less ELSE IF c1 > c2 THEN greater ELSE equal];
END;

Setup: PROC =
BEGIN

Commander.Register["RoseTranslate", TranslateCmd, "Translates rosemary sources (.Rose) into Mesa files"];

END;

Setup[];

END.
`RoseTranslateRandoms.Mesa
Last Edited by: Spreitzer, May 10, 1984 4:49:41 pm PDT PDT PDT
Κs˜J™J™>J˜š
Οk	˜	JšœœœΫ
˜ύ
—Icode˜šΠbxœœ
˜#Kšœœœ
œ?œœM˜ζ
Kšœ+˜2—K˜Kšœ
œ*˜4K˜Kš
Πblœœ
œœœ
˜7K˜KšŸœœ
œœ
˜!K˜K˜Kšœœ
œ
œœœ˜-K˜Kšœœ
œ
œœœ˜6K˜K˜šΟnœœ
œ	œ
œ
œ	œ
œœ
œœœ
œ˜~Kš
˜šœ	œ
˜Kš
˜Kšœœ
˜(Kšœ
œœœ˜OKš
˜—šœ
œœ
˜šœ˜šœœœ
˜&Kšœœœ
œ˜AKšœ
˜—Kšœœ
˜(Kšœ
œœœ˜OKšœ
˜—šœ˜Kšœœ˜šœœ
œœœ
˜4Kšœœ
œ˜K˜
Kšœ
˜—Kšœœ
˜(Kšœ
œœœ
˜GKšœ
˜—Kšœœ
˜—Kšœ
˜—K˜š
 
œœ
œœœ˜VKš
˜KšœΟc˜Kšœ
˜—K˜š œ‘Hœ˜nKš
˜Kš	œœ
œœ
œ˜7Kšœ5œ˜<šœ
œ˜&Kšœœ"œ˜=Kšœœ˜Kšœœœ˜HKšœ
œ
œ˜#Kšœ5œ˜<Kšœ
˜—Kšœ
˜—K˜š 	œœ
œ$œ
œ
œ
œœœ˜‹
Kš
˜Kšœœ
˜šœœ˜Kš
œ˜Kš
œ˜Kšœœ˜Kšœ	œ˜Kšœ
œ˜Kšœœ˜*Kšœ	œ˜(Kšœœ˜'Kšœœ˜'Kšœœ?˜KKšœœ˜(K˜Kš
œ$˜$—Kšœ	œ
œ
˜Kšœœ
˜K˜š
œK˜KKš
˜Kšœ(œ˜=Kšœ	œ
˜
Kšœ
˜	Kšœ˜—Kšœ
œ
œ
œ˜ Kšœœ˜"Kšœ	œ#˜.Kšœœ˜5Kš
œ\˜\Kš
œB˜BK˜Kšœ)œ˜0K˜Kš
œ˜K˜K˜Kšœ
˜—K˜š œœœ˜1Kš
˜Kšœ?œœœ˜‚
Kšœœœ˜DKšœEœœ(œ#œ
œ˜Θ
Kšœ˜Kšœ˜K˜Kšœœœ˜EKšœ˜Kšœ˜Kšœ!œ˜8Kšœœœ˜CK˜&Kšœ˜Kšœ˜K˜Kšœ!œ˜@Kšœ˜Kšœ˜K˜&K˜@Kšœ˜Kšœ˜K˜(Kšœœœ˜?Kšœ˜Kšœ œ˜:K˜K˜Kšœ
˜—K˜š 	œœ
œœ
œ.œ˜dKš
˜š
 œœœœ
œ˜BKš
˜š œœ
œœ˜!šœœ˜Kšœ
œœœ
˜=Kšœ
œœœ˜A——Kš
œ˜Kšœ	œ
˜K˜š	œ	œ
œœ
˜%Kš
˜Kšœœ$˜2Kš
œ	œ
œ0œœ˜lKšœ
˜—šœœ
˜Kšœœ˜Kšœ9œœœ˜m—Kšœœ˜)šœœ
˜K˜Kš
œWœœœœ˜›
—Kšœ	œ
œ
œ
˜Kšœ
œ'œœ˜eKšœœ
˜šœ!˜'Kš
˜š
œ˜Kš
œ1˜1Kšœ˜Kšœ@˜BKšœ9˜;—Kšœ
˜—Kšœ
˜—Kš
œ-˜-Kšœœ˜šœ4œœ
˜IKšœœ
˜Kšœ
˜—šœœ
˜šœœœœ
˜9K˜Kšœœ˜*Kšœ
˜—šœ˜Kšœœ
œ˜šœœœ
œœ
˜9K˜Kšœœ˜#K˜Kšœ
˜—Kš
œœ
‘œ
œ+œ˜fKšœ
˜—Kšœœ
˜—Kš
œ
˜
šœ4œœ
˜IK˜šœ
œ˜Kš
‘_˜_Kš‘œ2˜:—Kšœ
˜—Kšœ
˜—K˜š œœœ˜1Kš
˜Kšœœ˜&Kšœœ
œ5˜CKšœœ
œ
˜K˜Kšœœ
˜Kšœ	œ
œEœœœœ˜K˜Kš
œ
œ	œ
œ
œœœ˜]KšœSœ˜[K˜K˜Kšœ
˜—K˜š œœ
œœ
œ
œœœœ
œ˜Kš
˜Kšœœ
˜Kšœ&œ˜CK˜9K˜ K˜Kšœ
˜—K˜š œœ
œœ
œ
œœ˜cKš
˜Kšœœ
˜Kšœ&œ˜CK˜9K˜"Kšœ
˜—K˜Kš
 œœœœœ˜QK˜š œœ˜#Kš
˜Kšœœ
œœ˜!Kšœœ
œœ˜!Kšœœ	œœ
œ	œ	œ˜FKšœ
˜—K˜š œœ˜
Kš
˜K˜K˜iK˜Kšœ
˜—K˜K˜K˜Kšœ
˜—…—#ΐ/“