<> <> <> <> <> <> DIRECTORY Ascii, Atom, CD, CDAtomicObjects, CDBasics, CDCells, CDCommandOps, CDDirectory, CDInstances, CDMakeProcPrivate, CDProperties, CDOrient, CDSequencer, CDSymbolicObjects, Convert, IO, PriorityQueue, RefTab, Rope, SymTab, TerminalIO, TiogaFileOps, TiogaOps, ViewerTools; CDMakeProcCommands: CEDAR PROGRAM IMPORTS Ascii, Atom, Convert, CD, CDAtomicObjects, CDBasics, CDCells, CDCommandOps, CDDirectory, CDInstances, CDProperties, CDOrient, 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.PropList ]; <<>> ExpressionProc: TYPE = CDMakeProcPrivate.ExpressionProc; RegisterExpressionProc: PUBLIC PROC [for: REF, ep: ExpressionProc, tech: CD.Technology _ NIL] = BEGIN 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 END; SpecificCallExpression: PROC [env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE _ NIL] = BEGIN x: REF _ CDProperties.GetProp[ob.class.properties, $MakeCallExpression]; WITH x SELECT FROM rmce: REF ExpressionProc => r _ rmce^[env, ob] ENDCASE => NULL; END; MakeNodeComment: PROC [node: TiogaFileOps.Ref] = BEGIN TRUSTED { TiogaOps.PutProp[LOOPHOLE[node], $Comment, NEW[BOOLEAN _ TRUE]] }; END; Reserve: PROC [env: Environment, key: Rope.ROPE] = BEGIN [] _ SymTab.Store[env.nameToThing, key, $reserved]; END; IncludeDirectory: PUBLIC PROC [env: Environment, module: Rope.ROPE, import: BOOL_TRUE] = BEGIN [] _ SymTab.Store[env.nameToThing, module, $module]; [] _ SymTab.Insert[env.directory, module, module]; IF import THEN [] _ SymTab.Insert[env.imports, module, module]; END; MakeDirectory: PROC [env: Environment] = BEGIN r: Rope.ROPE _ NIL; Each: SymTab.EachPairAction = BEGIN IF num=0 THEN TiogaFileOps.SetContents[env.modHeaderNode, "DIRECTORY"] ELSE r _ r.Concat[", "]; r _ r.Concat[key]; num _ num+1; quit _ FALSE END; 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, ""]; END; MakeImportsExpr: PROC [env: Environment] RETURNS [r: Rope.ROPE _ NIL] = BEGIN Each: SymTab.EachPairAction = BEGIN IF num=0 THEN r _ "IMPORTS " ELSE r _ r.Concat[", "]; r _ r.Concat[key]; num _ num+1; quit _ FALSE END; num: INT _ 0; [] _ env.imports.Pairs[Each]; END; NewEnvironment: PROC [t: CD.Technology] RETURNS [env: Environment] = BEGIN env _ NEW[EnvironmentRep]; 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, "table: CDGenerate.Table _ CDGenerate.AssertTable[""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[]; END; <<>> FinishUp: PROC [env: Environment] = BEGIN 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["[] _ table.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.WriteRope[fileName]; TerminalIO.WriteRope[" created\n"]; [] _ ViewerTools.MakeNewTextViewer[info: [ file: fileName, label: fileName, name: fileName, iconic: FALSE ]]; END; MakeProcedureNode: PROC [env: Environment] RETURNS [TiogaFileOps.Ref] = BEGIN env.procNode _ TiogaFileOps.InsertNode[env.procNode]; env.procDecNode _ NIL; RETURN [env.procNode] END; MakeDeclarationNode: PROC [env: Environment] RETURNS [TiogaFileOps.Ref] = BEGIN env.declNode _ TiogaFileOps.InsertNode[env.declNode]; RETURN [env.declNode] END; GlobalDeclaration1: PUBLIC PROC [env: Environment, line: Rope.ROPE] = BEGIN node: TiogaFileOps.Ref _ MakeDeclarationNode[env]; TiogaFileOps.SetContents[node, line]; END; GlobalDeclaration2: PUBLIC PROC [env: Environment, line: Rope.ROPE] = BEGIN env.postDeclNode _ TiogaFileOps.InsertNode[env.postDeclNode]; TiogaFileOps.SetContents[env.postDeclNode, line]; END; GlobalStatement: PUBLIC PROC [env: Environment, line: Rope.ROPE] = BEGIN env.modStatementNode _ TiogaFileOps.InsertNode[env.modStatementNode]; TiogaFileOps.SetContents[env.modStatementNode, line]; END; <<>> MakeDirGenerator: PROC [env: Environment] = BEGIN IF ~env.hasDirGen THEN { env.hasDirGen _ TRUE; GlobalDeclaration2[env, "directory: CDGenerate.Table _ CDGenerate.AssertTable[""DIRECTORY""];"]; } END; RequestGlobalIdent: PUBLIC PROC[env: Environment, proposed: Rope.ROPE, whatFor: REF_NIL] RETURNS [Rope.ROPE] = BEGIN RETURN [RequestIdent[env, proposed, whatFor, TRUE]]; END; GlobalIdent: PUBLIC PROC [env: Environment, whatFor: REF] RETURNS [Rope.ROPE] = BEGIN RETURN [Ident[env, whatFor, TRUE]]; END; 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] = BEGIN 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 END; Ident: PROC [env: Environment, whatFor: REF, global: BOOL] RETURNS [Rope.ROPE_NIL] = BEGIN 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; END; IdentForLocalObject: PROC [env: Environment, ob: CD.Object] RETURNS [name: Rope.ROPE] = BEGIN 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]; END; PosToRope: PUBLIC PROC [pos: CD.Position] RETURNS [r: Rope.ROPE] = BEGIN RETURN [IO.PutFR["[x: %g, y: %g]", IO.int[pos.x], IO.int[pos.y] ]] END; RectToRope: PUBLIC PROC [rect: CD.Rect] RETURNS [r: Rope.ROPE] = BEGIN 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] ]] END; LayerIdent: PUBLIC PROC [env: Environment, l: CD.Layer] RETURNS [r: Rope.ROPE] = BEGIN 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]] END; MapIPos: PROC [inst: CD.Instance] RETURNS [iPos: CD.Position] = <<--given an instance find the origin in interest coordinates>> BEGIN iPos _ CDBasics.BaseOfRect[CDInstances.InstRectI[inst]]; END; MapClientPos: PROC [inst: CD.Instance] RETURNS [originPos: CD.Position] = BEGIN RETURN [CDOrient.MapPoint[ pointInCell: CD.ClientOrigin[inst.ob], cellSize: inst.ob.size, cellInstOrient: inst.orientation, cellInstPos: inst.location ]] END; LocalStatement: PUBLIC PROC [env: Environment, line: Rope.ROPE] = BEGIN node: TiogaFileOps.Ref; node _ TiogaFileOps.InsertAsLastChild[env.procNode]; TiogaFileOps.SetContents[node, line]; END; ProgramText: PROC [ob: CD.Object, design: CD.Design, env: Environment] = BEGIN 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 { pq: PriorityQueue.Ref _ PriorityQueue.Create[SortPred, IF ob.size.x> FOR list: CD.InstanceList _ cptr.contents, list.rest WHILE list#NIL DO x: REF _ RefTab.Fetch[childs, list.first.ob].val; PriorityQueue.Insert[pq, list.first]; IF x=NIL THEN { num _ num+1; [] _ RefTab.Store[childs, list.first.ob, $first] } ELSE IF x=$first THEN { r: Rope.ROPE _ IdentForLocalObject[env, list.first.ob]; num _ num-1; [] _ RefTab.Store[childs, list.first.ob, $hasName]; LocalStatement[env, Rope.Cat[r, ": CD.Object;"]]; } ELSE NULL; ENDLOOP; 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"; pos: CD.Position _ MapClientPos[inst]; iPos: CD.Position _ MapIPos[inst]; orientationCode: Rope.ROPE _ NIL; IF inst.orientation#0 THEN orientationCode _ IO.PutFR[", orientation: %g", IO.int[inst.orientation]]; 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, position: %g%0g, obCSystem: interrestCoords].newInst;", IO.rope[childName], IO.rope[PosToRope[iPos]], IO.rope[orientationCode] ]]; } ELSE { r _ Rope.Cat[ IO.PutFR["[] _ CDCells.IncludeOb[cell: ob, ob: %g, position: %g%0g, obCSystem: interrestCoords];", IO.rope[childName], IO.rope[PosToRope[iPos]], IO.rope[orientationCode] ]]; }; LocalStatement[env, r]; IF needInst THEN MakeInstanceStuff[env, inst]; }; EachInst[inst]; ENDLOOP; <<--interest rect>> ir _ CD.InterestRect[ob]; r _ Rope.Cat["CDCells.SetInterestRect[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.WriteRope["**could not convert to cell\n"]; ERROR ABORTED; } END; RopeToRope: PUBLIC PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = BEGIN RETURN [Convert.RopeFromRope[r]]; END; AtomToRope: PUBLIC PROC [env: Environment, a: ATOM] RETURNS [Rope.ROPE] = BEGIN 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], "]"] ]; END; MakeInstanceStuff: PROC[env: Environment, inst: CD.Instance] = BEGIN r: Rope.ROPE_NIL; HandleProp: PROC [key: ATOM] = BEGIN val: Rope.ROPE _ CDCommandOps.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]; }; END; 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]; } END; 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> <<>> <<--XX INIT XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX>> [] _ CDProperties.RegisterProperty[$MakeCallExpression, $chj]; CDSequencer.ImplementCommand[$MakeProgram, MakeProgramCommand,, doQueue]; TerminalIO.WriteRope["make program command loaded\n"]; END.