[Indigo]<Rosemary>Release>Rosemary1>RoseTranslateRandoms.Mesa!1

RoseTranslateRandoms.Mesa

Last Edited by: Spreitzer, July 13, 1983 10:49 am

DIRECTORY

Atom, CIFS, ConvertUnsafe, Directory, FileIO, IO, Juniper, OrderedSymbolTableRef, PutGet, Rope, RoseTranslateTypes, RoseTranslateInsides, ShowTime, TextNode, TiogaFileOps, TiogaOps, TiogaStreams, UserExec, UserExecExtras, ViewerClasses, ViewerOps, ViewerTools, Volume;

RoseTranslateRandoms: CEDAR PROGRAM

IMPORTS Atom, CIFS, ConvertUnsafe, Directory, FileIO, IO, Juniper, OSTR: OrderedSymbolTableRef, PutGet, Rope, ShowTime, TFO: TiogaFileOps, TiogaOps, TS: TiogaStreams, RoseTranslateInsides, UserExec, ViewerOps, ViewerTools, Volume

EXPORTS RoseTranslateTypes, RoseTranslateInsides =

BEGIN OPEN RoseTranslateTypes, RoseTranslateInsides;

Circularity: PUBLIC ERROR = CODE;

signalTypes: PUBLIC SymbolTable ← OSTR.CreateTable[CompareSymbolTableEntries];

error: PUBLIC REF ANY ← NEW [INT ← 47];

ignoreMe: PUBLIC REF ANY ← NEW[INT ← 86];

RegisterSignalTypeConstructor: PUBLIC PROC [name: ROPE, stc: SignalTypeConstructor] =

BEGIN

signalTypes.Insert[NEW [SymbolTableEntryRep[signalTypeConstructor] ← [name: name, value: signalTypeConstructor[stc: stc]]]];

END;

ForceMesaType: PUBLIC PROC [mesaType: ROPE, on: SignalType] RETURNS [forced: SignalType] =

BEGIN

forced ← NEW [SignalTypeRep ← [forcedProcs, NEW [ForcedDataRep ← [on, mesaType]] ]];

END;

ForcedData: TYPE = REF ForcedDataRep;

ForcedDataRep: TYPE = RECORD [

unforced: SignalType,

mesaType: ROPE];

forcedProcs: SignalTypeProcs ← NEW [SignalTypeProcsRep ← [

Info: ForcedInfo,

Describe: DescribeForced,

Cannonize: CannonizeForced,

MesaTypeDecl: ForcedDecl]];

ForcedInfo: PROC [data: REF ANY] RETURNS [bitWidth: INT, roseType, mesaType: ROPE] =

BEGIN

fd: ForcedData ← NARROW[data];

[bitWidth, roseType, ] ← fd.unforced.procs.Info[fd.unforced.data];

mesaType ← fd.mesaType;

END;

DescribeForced: PROC [data: REF ANY] RETURNS [description: ROPE] =

BEGIN

fd: ForcedData ← NARROW[data];

description ← fd.unforced.procs.Describe[fd.unforced.data].Cat[" ~ \"", fd.mesaType, "\""];

END;

CannonizeForced: PROC [data: REF ANY] RETURNS [cannonized: REF ANY] =

BEGIN

fd: ForcedData ← NARROW[data];

cannonized ← fd.unforced.procs.Cannonize[fd.unforced.data];

END;

ForcedDecl: PROC [data: REF ANY] RETURNS [ROPE] = {RETURN [NIL]};

TranslateCmd: UserExec.CommandProc =

BEGIN

event.commandLineStream.SkipOver[IO.WhiteSpace];

WHILE NOT event.commandLineStream.EndOf[] DO

name: ROPE ← event.commandLineStream.GetToken[IO.IDProc];

errs: CARDINAL ← 1;

errs ← Translate[exec, name, NIL, TranslateJob !Circularity => CONTINUE];

IF errs > 0 THEN ok ← FALSE;

event.commandLineStream.SkipOver[IO.WhiteSpace];

ENDLOOP;

END;

Translate: PUBLIC PROC [exec: UserExec.ExecHandle, 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[CompareSymbolTableEntries],

used: OSTR.CreateTable[CompareRefAnies],

type: type,

start: ShowTime.GetMark[]]];

logFile: IO.STREAM;

sourceName, logName: ROPE;

inRoot ← PutGet.FromFile[sourceName ← rootName.Concat[".Rose"] !FileIO.OpenFailed, Juniper.Error, CIFS.Error, Volume.InsufficientSpace =>

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 ← FileIO.Open[fileName: logName ← rootName.Concat[".log"], accessOptions: overwrite];

job.log ← IO.CreateDribbleStream[stream: logFile, dribbleTo: 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

ls: LONG STRING ← [256];

lt: LONG STRING ← [256];

ConvertUnsafe.AppendRope[ls, sourceName];

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[Directory.GetProps[Directory.Lookup[ls], lt].createDate], IO.rope[UserExec.GetNameAndPassword[].name], IO.time[]]; 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];

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];

job.to.PutRope["BEGIN OPEN"];

job.openStream ← TS.CreateOutput[TS.CurOutNode[job.to], "code"];

TS.EndNode[job.to];

job.to.PutRope["--Signal Type decls"];

job.typeStream ← TS.CreateOutput[TS.CurOutNode[job.to], "code"];

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, "Rosemary"]; AddImport[job, "Rosemary"];

AddOpen[job, "IntTypes"]; AddImport[job, "IntTypes"];

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;

CompareSymbolTableEntries: OSTR.CompareProc =

BEGIN

s1, s2: ROPE;

s1 ← WITH r1 SELECT FROM

r: ROPE => r,

st: SymbolTableEntry => st.name,

ENDCASE => ERROR;

s2 ← WITH r2 SELECT FROM

r: ROPE => r,

st: SymbolTableEntry => st.name,

ENDCASE => ERROR;

RETURN [s1.Compare[s2, FALSE]];

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

UserExec.RegisterCommand["RoseTranslate", TranslateCmd, "Translates rosemary sources (.Rose) into Mesa files", "Syntax: \"RoseTranslate <rootName>*\". Each root name should not include the .Rose extension"];

END;

Setup[];

END.