<> <> <> <> DIRECTORY Ascii, Atom, CD, CDAtomicObjects, CDBasics, CDCells, CDDirectory, CDInstances, CDMakeProcPrivate, CDProperties, CDOps, CDSequencer, CDSymbolicObjects, Convert, IO, PriorityQueue, RefTab, Rope, SymTab, TerminalIO, TiogaFileOps, TiogaOps, ViewerTools; CDMakeProcCommands: CEDAR PROGRAM IMPORTS Ascii, Atom, Convert, CD, CDAtomicObjects, CDBasics, CDCells, CDDirectory, CDInstances, CDProperties, CDOps, CDSequencer, CDSymbolicObjects, IO, PriorityQueue, RefTab, Rope, SymTab, TerminalIO, TiogaFileOps, TiogaOps, ViewerTools EXPORTS CDMakeProcPrivate = BEGIN Environment: TYPE = REF EnvironmentRep; EnvironmentRep: PUBLIC TYPE = RECORD [ invocationKey: REF, rootNode: TiogaFileOps.Ref, commentNode: TiogaFileOps.Ref, --insert sibling for next comment modHeaderNode: TiogaFileOps.Ref, --DIRECTORY... to excluding BEGIN declNode: TiogaFileOps.Ref, --insert sibling for next declaration on module level procNode: TiogaFileOps.Ref, --insert sibling for next global procedures procDecNode: TiogaFileOps.Ref, --insert sibling for next local declaration postDeclNode: TiogaFileOps.Ref, --insert sibling for next declaration on module level firstModStatementNode: TiogaFileOps.Ref, --reserved for first statement modStatementNode: TiogaFileOps.Ref, --insert sibling for next mudule statement procName: Rope.ROPE, modifier: INT _ 0, directory: SymTab.Ref, imports: SymTab.Ref, declaredLayers: ARRAY CD.Layer OF Rope.ROPE _ ALL[NIL], nameToThing: SymTab.Ref, thingToName: RefTab.Ref, globalThingToName: RefTab.Ref, hasDirGen: BOOL _ FALSE, properties: CD.PropRef ]; <<>> ExpressionProc: TYPE = CDMakeProcPrivate.ExpressionProc; GetEnvironmentProp: PUBLIC PROC [env: Environment, key: REF] RETURNS [REF] = { RETURN [CDProperties.GetProp[env.properties, key]] }; PutEnvironmentProp: PUBLIC PROC [env: Environment, key: REF, val: REF] = { CDProperties.PutProp[env.properties, key, val] }; RegisterExpressionProc: PUBLIC PROC [for: REF, ep: ExpressionProc, tech: CD.Technology _ NIL] = { WITH for SELECT FROM c: CD.ObjectClass => CDProperties.PutProp[c.properties, $MakeCallExpression, NEW[ExpressionProc_ep]]; a: ATOM => RegisterExpressionProc[CD.FetchObjectClass[a, tech], ep, tech]; ENDCASE => ERROR }; SpecificCallExpression: PROC [env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE _ NIL] = { x: REF _ CDProperties.GetProp[ob.class.properties, $MakeCallExpression]; WITH x SELECT FROM rmce: REF ExpressionProc => r _ rmce^[env, ob] ENDCASE => NULL; }; MakeNodeComment: PROC [node: TiogaFileOps.Ref] = { TRUSTED { TiogaOps.PutProp[LOOPHOLE[node], $Comment, NEW[BOOLEAN _ TRUE]] }; }; Reserve: PROC [env: Environment, key: Rope.ROPE] = { [] _ SymTab.Store[env.nameToThing, key, $reserved]; }; IncludeDirectory: PUBLIC PROC [env: Environment, module: Rope.ROPE, import: BOOL_TRUE] = { [] _ SymTab.Store[env.nameToThing, module, $module]; [] _ SymTab.Insert[env.directory, module, module]; IF import THEN [] _ SymTab.Insert[env.imports, module, module]; }; MakeDirectory: PROC [env: Environment] = { r: Rope.ROPE _ NIL; Each: SymTab.EachPairAction = { IF num=0 THEN TiogaFileOps.SetContents[env.modHeaderNode, "DIRECTORY"] ELSE r _ r.Concat[", "]; r _ r.Concat[key]; num _ num+1; quit _ FALSE }; num: INT _ 0; [] _ env.directory.Pairs[Each]; IF num>0 THEN { node: TiogaFileOps.Ref _ TiogaFileOps.InsertNode[env.modHeaderNode, TRUE]; TiogaFileOps.SetContents[node, r.Concat[";"]]; } ELSE TiogaFileOps.SetContents[env.modHeaderNode, ""]; }; MakeImportsExpr: PROC [env: Environment] RETURNS [r: Rope.ROPE _ NIL] = { Each: SymTab.EachPairAction = { IF num=0 THEN r _ "IMPORTS " ELSE r _ r.Concat[", "]; r _ r.Concat[key]; num _ num+1; quit _ FALSE }; num: INT _ 0; [] _ env.imports.Pairs[Each]; }; NewEnvironment: PROC [t: CD.Technology] RETURNS [env: Environment] = { env _ NEW[EnvironmentRep_[properties: CD.InitPropRef[]]]; env.invocationKey _ NEW[INT]; env.rootNode _ TiogaFileOps.CreateRoot[]; env.commentNode _ TiogaFileOps.InsertNode[env.rootNode, TRUE]; TiogaFileOps.SetContents[env.commentNode, "--///temp/ChipNDale/temp.mesa"]; MakeNodeComment[env.commentNode]; env.commentNode _ TiogaFileOps.InsertNode[env.commentNode]; TiogaFileOps.SetContents[env.commentNode, "--created by ChipNDale"]; MakeNodeComment[env.commentNode]; env.modHeaderNode _ TiogaFileOps.InsertNode[env.commentNode]; env.declNode _ TiogaFileOps.InsertNode[env.modHeaderNode]; TiogaFileOps.SetContents[env.declNode, "BEGIN"]; GlobalDeclaration1[env, IO.PutFR["tech: CD.Technology _ CD.FetchTechnology[$%g];", IO.atom[t.key]]]; env.procNode _ TiogaFileOps.InsertNode[env.declNode]; TiogaFileOps.SetContents[env.procNode, ""]; env.postDeclNode _ TiogaFileOps.InsertNode[env.procNode]; TiogaFileOps.SetContents[env.postDeclNode, "context: CDGenerate.Context _ CDGenerate.AssertContext[""USER""];"]; env.firstModStatementNode _ env.modStatementNode _ TiogaFileOps.InsertNode[env.postDeclNode]; env.nameToThing _ SymTab.Create[]; env.directory _ SymTab.Create[]; env.imports _ SymTab.Create[]; env.thingToName _ RefTab.Create[]; env.globalThingToName _ RefTab.Create[]; }; <<>> FinishUp: PROC [env: Environment] = { node: TiogaFileOps.Ref; subNode: TiogaFileOps.Ref; fileName: Rope.ROPE _ "///temp/ChipNDale/temp.mesa"; r: Rope.ROPE _ NIL; MakeDirectory[env]; node _ TiogaFileOps.InsertNode[env.modHeaderNode]; TiogaFileOps.SetContents[node, "Temp: CEDAR PROGRAM"]; subNode _ TiogaFileOps.InsertNode[node, TRUE]; TiogaFileOps.SetContents[subNode, Rope.Cat[MakeImportsExpr[env], " ="]]; r _ IO.PutFR["[] _ context.Register[""%g"", %g];", IO.rope[env.procName], IO.rope[env.procName]]; TiogaFileOps.SetContents[env.firstModStatementNode, r]; GlobalStatement[env, "END."]; TiogaFileOps.Store[env.rootNode, fileName]; env.rootNode _ env.commentNode _ env.modHeaderNode _ NIL; env.declNode _ env.procNode _ env.postDeclNode _ NIL; env.firstModStatementNode _ env.modStatementNode _ NIL; env.directory _ env.imports _ env.nameToThing _ NIL; env.thingToName _ NIL; env.globalThingToName _ NIL; TerminalIO.PutRope[fileName]; TerminalIO.PutRope[" created\n"]; [] _ ViewerTools.MakeNewTextViewer[info: [ file: fileName, label: fileName, name: fileName, iconic: FALSE ]]; }; MakeProcedureNode: PROC [env: Environment] RETURNS [TiogaFileOps.Ref] = { env.procNode _ TiogaFileOps.InsertNode[env.procNode]; env.procDecNode _ NIL; RETURN [env.procNode] }; MakeDeclarationNode: PROC [env: Environment] RETURNS [TiogaFileOps.Ref] = { env.declNode _ TiogaFileOps.InsertNode[env.declNode]; RETURN [env.declNode] }; GlobalDeclaration1: PUBLIC PROC [env: Environment, line: Rope.ROPE] = { node: TiogaFileOps.Ref _ MakeDeclarationNode[env]; TiogaFileOps.SetContents[node, line]; }; GlobalDeclaration2: PUBLIC PROC [env: Environment, line: Rope.ROPE] = { env.postDeclNode _ TiogaFileOps.InsertNode[env.postDeclNode]; TiogaFileOps.SetContents[env.postDeclNode, line]; }; GlobalStatement: PUBLIC PROC [env: Environment, line: Rope.ROPE] = { env.modStatementNode _ TiogaFileOps.InsertNode[env.modStatementNode]; TiogaFileOps.SetContents[env.modStatementNode, line]; }; <<>> MakeDirGenerator: PROC [env: Environment] = { IF ~env.hasDirGen THEN { env.hasDirGen _ TRUE; GlobalDeclaration2[env, "directory: CDGenerate.Context _ CDGenerate.AssertContext[""DIRECTORY""];"]; } }; RequestGlobalIdent: PUBLIC PROC[env: Environment, proposed: Rope.ROPE, whatFor: REF_NIL] RETURNS [Rope.ROPE] = { RETURN [RequestIdent[env, proposed, whatFor, TRUE]]; }; GlobalIdent: PUBLIC PROC [env: Environment, whatFor: REF] RETURNS [Rope.ROPE] = { RETURN [Ident[env, whatFor, TRUE]]; }; RopeToId: PROC [r: Rope.ROPE] RETURNS [id: Rope.ROPE] = { first: BOOL _ TRUE; Trans: Rope.TranslatorType = { IF Ascii.Letter[old] THEN new _ old ELSE IF Ascii.Digit[old] AND ~first THEN new _ old ELSE new _ 'x; first _ FALSE }; id _ Rope.Translate[base: r, translator: Trans]; IF Rope.IsEmpty[id] THEN id _ "x"; }; RequestIdent: PROC [env: Environment, proposed: Rope.ROPE_NIL, whatFor: REF_NIL, global: BOOL_FALSE] RETURNS [r: Rope.ROPE] = { proposed _ RopeToId[proposed]; r _ proposed; DO IF SymTab.Insert[env.nameToThing, r, whatFor] THEN { IF global THEN [] _ RefTab.Store[env.globalThingToName, whatFor, r]; [] _ RefTab.Store[env.thingToName, whatFor, r]; RETURN; }; env.modifier _ env.modifier+1; r _ IO.PutFR["%gx%g", IO.rope[proposed], IO.int[env.modifier]] ENDLOOP }; Ident: PROC [env: Environment, whatFor: REF, global: BOOL] RETURNS [Rope.ROPE_NIL] = { tab: RefTab.Ref _ IF global THEN env.globalThingToName ELSE env.thingToName; WITH RefTab.Fetch[tab, whatFor].val SELECT FROM n: Rope.ROPE => RETURN [n]; ENDCASE =>NULL; }; IdentForLocalObject: PROC [env: Environment, ob: CD.Object] RETURNS [name: Rope.ROPE] = { first: CHAR; name _ Ident[env, ob, FALSE]; IF name#NIL THEN RETURN [name]; name _ CDDirectory.Name[ob]; IF Rope.IsEmpty[name] THEN { name _ Atom.GetPName[ob.class.objectType] }; first _ Rope.Fetch[name]; IF Ascii.Letter[first] THEN first _ Ascii.Lower[first]; name _ Rope.Replace[ base: name, start: 0, len: 1, with: Rope.FromChar[first] ]; name _ RequestIdent[env, name, ob, FALSE]; }; PosToRope: PUBLIC PROC [pos: CD.Position] RETURNS [r: Rope.ROPE] = { RETURN [IO.PutFR["[x: %g, y: %g]", IO.int[pos.x], IO.int[pos.y] ]] }; RectToRope: PUBLIC PROC [rect: CD.Rect] RETURNS [r: Rope.ROPE] = { RETURN [IO.PutFR["[x1: %g, y1: %g, x2: %g, y2: %g]", IO.int[rect.x1], IO.int[rect.y1], IO.int[rect.x2], IO.int[rect.y2] ]] }; LayerIdent: PUBLIC PROC [env: Environment, l: CD.Layer] RETURNS [r: Rope.ROPE] = { IF env.declaredLayers[l]=NIL THEN { r: Rope.ROPE; name: Rope.ROPE _ RequestIdent[env, Atom.GetPName[CD.LayerKey[l]]]; env.declaredLayers[l] _ name; r _ IO.PutFR["%g: CD.Layer _ CD.FetchLayer[t: tech, uniqueKey: $%g];", IO.rope[name], IO.atom[CD.LayerKey[l]] ]; GlobalDeclaration1[env, r]; }; RETURN [env.declaredLayers[l]] }; LocalStatement: PUBLIC PROC [env: Environment, line: Rope.ROPE] = { node: TiogaFileOps.Ref; node _ TiogaFileOps.InsertAsLastChild[env.procNode]; TiogaFileOps.SetContents[node, line]; }; OrientationRope: PROC [o: CD.Orientation] RETURNS [r: Rope.ROPE] = { RETURN [SELECT o FROM original => "original", mirrorX => "mirrorX", rotate90 => "rotate90", rotate90X => "rotate90X", rotate180 => "rotate180", rotate180X => "rotate180X", rotate270 => "rotate270", rotate270X => "rotate270X" ENDCASE => "bad"] }; TransformationRope: PROC [trans: CD.Transformation] RETURNS [r: Rope.ROPE] = { r _ IO.PutFR["[[x: %g, y: %g]", IO.int[trans.off.x], IO.int[trans.off.y] ]; IF trans.orient#original THEN r _ Rope.Cat[r, ", ", OrientationRope[trans.orient]]; r _ Rope.Concat[r, "]"]; }; ProgramText: PROC [ob: CD.Object, design: CD.Design, env: Environment] = { env.procName _ RequestGlobalIdent[env, CDDirectory.Name[ob], ob]; IF ~CDCells.IsCell[ob] THEN ob _ CDDirectory.Expand[ob, design, NIL].new; IF ob#NIL AND CDCells.IsCell[ob] THEN { is: CD.Position _ CD.InterestSize[ob]; pq: PriorityQueue.Ref _ PriorityQueue.Create[SortPred, IF is.x> [] _ CDCells.EnumerateInstances[ob, EnQueueInst]; IF num#0 THEN LocalStatement[env, "child: CD.Object;"]; LocalStatement[env, "IF design.technology#tech THEN ERROR;"]; LocalStatement[env, "ob _ CDCells.CreateEmptyCell[];"]; <<--make instances>> FOR num: INT IN [0..PriorityQueue.Size[pq]) DO inst: CD.Instance _ NARROW[PriorityQueue.Remove[pq]]; EachInst: PROC [inst: CD.Instance] = { needInst: BOOL _ FALSE; childName: Rope.ROPE _ "child"; trans: CD.Transformation _ inst.trans; SELECT RefTab.Fetch[childs, inst.ob].val FROM $hasName => { childName _ IdentForLocalObject[env, inst.ob]; [r, needInst] _ MakeACallExpression[env, inst.ob]; r _ Rope.Cat[childName, " _ ", r, ";"]; LocalStatement[env, r]; IF needInst THEN [] _ RefTab.Store[childs, inst.ob, $hasValueMI] ELSE [] _ RefTab.Store[childs, inst.ob, $hasValue] }; $hasValue => { childName _ IdentForLocalObject[env, inst.ob]; needInst _ FALSE; }; $hasValueMI => { childName _ IdentForLocalObject[env, inst.ob]; needInst _ TRUE; }; ENDCASE => { childName _ "child"; [r, needInst] _ MakeACallExpression[env, inst.ob]; r _ Rope.Cat[childName, " _ ", r, ";"]; LocalStatement[env, r]; }; IF CDProperties.GetInstanceProp[inst, $SignalName]#NIL OR CDProperties.GetInstanceProp[inst, $InstanceName]#NIL THEN needInst _ TRUE; IF needInst THEN { hasInst _ TRUE; r _ Rope.Cat[ IO.PutFR["inst _ CDCells.IncludeOb[cell: ob, ob: %g, trans: %g, mode: dontResize].newInst;", IO.rope[childName], IO.rope[TransformationRope[trans]] ]]; } ELSE { r _ Rope.Cat[ IO.PutFR["[] _ CDCells.IncludeOb[cell: ob, ob: %g, trans: %g, mode: dontResize];", IO.rope[childName], IO.rope[TransformationRope[trans]] ]]; }; LocalStatement[env, r]; IF needInst THEN MakeInstanceStuff[env, inst]; }; EachInst[inst]; ENDLOOP; <<--interest rect>> ir _ CD.InterestRect[ob]; r _ Rope.Cat["CDCells.SetInterestRect[NIL, ob, ", RectToRope[ir], "];"]; LocalStatement[env, r]; <<--include in directory>> r _ Rope.Cat["[] _ CDDirectory.Include[design: design, object: ob"]; IF cptr.name#NIL THEN r _ Rope.Cat[r, ", alternateName: ", RopeToRope[cptr.name]]; r _ Rope.Cat[r, "];"]; LocalStatement[env, r]; LocalStatement[env, "END;"]; LocalStatement[env, ""]; IF hasInst THEN { env.procDecNode _ TiogaFileOps.InsertNode[env.procDecNode]; TiogaFileOps.SetContents[env.procDecNode, "inst: CD.Instance;"]; }; childs _ NIL; } ELSE { TerminalIO.PutRope["**could not convert to cell\n"]; ERROR ABORTED; } }; RopeToRope: PUBLIC PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = { RETURN [Convert.RopeFromRope[r]]; }; AtomToRope: PUBLIC PROC [env: Environment, a: ATOM] RETURNS [Rope.ROPE] = { r: Rope.ROPE _ Atom.GetPName[a]; leng: INT _ Rope.Length[r]; normalCase: BOOL _ leng>0; FOR i: INT IN [0..leng) DO c: CHAR _ Rope.Fetch[r, i]; IF ~(Ascii.Letter[c] OR Ascii.Digit[c]) THEN {normalCase_FALSE; EXIT} ENDLOOP; IF normalCase THEN RETURN [Rope.Cat["$", r]]; IncludeDirectory[env, "Atom"]; RETURN [ Rope.Cat["Atom.MakeAtom[", Convert.RopeFromRope[r], "]"] ]; }; MakeInstanceStuff: PROC[env: Environment, inst: CD.Instance] = { r: Rope.ROPE_NIL; HandleProp: PROC [key: ATOM] = { val: Rope.ROPE _ CDOps.ToRope[CDProperties.GetInstanceProp[inst, key]]; IF ~Rope.IsEmpty[val] THEN { r: Rope.ROPE _ Rope.Cat[ "CDProperties.PutInstanceProp[inst, ", AtomToRope[env, key], ", ", RopeToRope[val], "];" ]; IncludeDirectory[env, "CDProperties"]; LocalStatement[env, r]; }; }; IF CDSymbolicObjects.IsSymbolicOb[inst.ob] THEN { l: CD.Layer; owner: ATOM; name: Rope.ROPE _ CDSymbolicObjects.GetName[inst]; IF ~Rope.IsEmpty[name] THEN { r _ Rope.Cat["CDSymbolicObjects.SetName[inst, ", RopeToRope[name], "];"]; LocalStatement[env, r]; }; l _ CDSymbolicObjects.GetLayer[inst]; IF l#CD.undefLayer THEN { r _ Rope.Cat["CDSymbolicObjects.SetLayer[inst, ", LayerIdent[env, l], "];"]; LocalStatement[env, r]; }; owner _ CDSymbolicObjects.GetOwner[inst]; IF owner#NIL THEN { r _ Rope.Cat["CDSymbolicObjects.SetOwner[inst, ", AtomToRope[env, owner], "];"]; LocalStatement[env, r]; }; } ELSE { HandleProp[$SignalName]; HandleProp[$InstanceName]; } }; SortPred: PriorityQueue.SortPred = { p1: CD.Position _ CDBasics.BaseOfRect[CDInstances.InstRectI[NARROW[x]]]; p2: CD.Position _ CDBasics.BaseOfRect[CDInstances.InstRectI[NARROW[y]]]; IF data=$y AND p1.y#p2.y THEN RETURN[p1.y> [] _ CDProperties.RegisterProperty[$MakeCallExpression, $chj]; CDSequencer.ImplementCommand[$MakeProgram, MakeProgramCommand,, doQueue]; TerminalIO.PutRope["make program command loaded\n"]; END.