
    <<CDMakeProcCommands.mesa   (module for ChipNDale)>>
        <<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
        <<by Christian Jacobi, May 9, 1985 1:58:40 pm PDT >>
        <<last edited Christian Jacobi, March 25, 1986 6:27:17 pm PST>>

    DIRECTORY
        Ascii,
        Atom,
        CD,
        CDAtomicObjects,
        CDCells,
        CDCommandOps,
        CDDirectory,
        CDMakeProcPrivate,
        CDMenus, 
        CDProperties,
        CDOrient,
        CDSequencer,
        CDSymbolicObjects,
        Convert,
        IO,
        RefTab,
        Rope,
        SymTab,
        TerminalIO,
        TiogaFileOps,
        TiogaOps,
        ViewerTools;

    CDMakeProcCommands: CEDAR PROGRAM
        IMPORTS Ascii, Atom, Convert, CD, CDAtomicObjects, CDCells, CDCommandOps, CDDirectory, CDMenus, CDProperties, CDOrient, 
        CDSequencer, CDSymbolicObjects, IO, 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

        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 _ "[] _ table.Register[""Temp"", CreateCell];";
        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;

    RequestIdent: PROC [env: Environment, proposed: Rope.ROPE_NIL, whatFor: REF_NIL, global: BOOL_FALSE] RETURNS [r: Rope.ROPE] =
        BEGIN

        Trans: Rope.TranslatorType =
            BEGIN
            IF Ascii.Letter[old] THEN new _ old
            ELSE IF Ascii.Digit[old] AND ~first THEN new _ old
            ELSE new _ 'x;
            first _ FALSE
            END;

        first: BOOL _ TRUE;
        proposed _ Rope.Translate[base: proposed, translator: Trans];
        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;

    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
        IF ~CDCells.IsCell[ob] THEN ob _ CDDirectory.Expand[ob, design, NIL].new;
        IF ob#NIL AND CDCells.IsCell[ob] THEN {
            ir: CD.Rect;
            hasInst: BOOL _ FALSE;
            num: INT _ 0;
            r: Rope.ROPE _ NIL;
            cptr: CD.CellPtr = NARROW[ob.specificRef];
            childs: RefTab.Ref _ RefTab.Create[];
            node: TiogaFileOps.Ref _ MakeProcedureNode[env];
            TiogaFileOps.SetContents[node, "CreateCell: CDGenerate.GeneratorProc ="];
            env.procDecNode _ TiogaFileOps.InsertAsLastChild[env.procNode];
            TiogaFileOps.SetContents[env.procDecNode, "BEGIN"];
            <<--make declarations>>
            FOR list: CD.InstanceList _ cptr.contents, list.rest WHILE list#NIL DO
                x: REF _ RefTab.Fetch[childs, list.first.ob].val;
                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 list: CD.InstanceList _ cptr.contents, list.rest WHILE list#NIL DO
                needInst: BOOL _ FALSE;
                childName: Rope.ROPE _ "child";
                pos: CD.Position _ MapClientPos[inst: list.first];
                orientationCode: Rope.ROPE _ NIL;
                IF list.first.orientation#0 THEN 
                    orientationCode _ IO.PutFR[", orientation: %g", IO.int[list.first.orientation]];
                SELECT RefTab.Fetch[childs, list.first.ob].val FROM
                    $hasName => {
                        childName _ IdentForLocalObject[env, list.first.ob];
                        [r, needInst] _ MakeACallExpression[env, list.first.ob];
                        r _ Rope.Cat[childName, " _ ", r, ";"];
                        LocalStatement[env, r];
                        IF needInst THEN [] _ RefTab.Store[childs, list.first.ob, $hasValueMI]
                        ELSE [] _ RefTab.Store[childs, list.first.ob, $hasValue]
                        };
                    $hasValue => {
                        childName _ IdentForLocalObject[env, list.first.ob];
                        needInst _ FALSE;
                        };
                    $hasValueMI => {
                        childName _ IdentForLocalObject[env, list.first.ob];
                        needInst _ TRUE;
                        };
                    ENDCASE => {
                        childName _ "child";
                        [r, needInst] _ MakeACallExpression[env, list.first.ob];
                        r _ Rope.Cat[childName, " _ ", r, ";"];
                        LocalStatement[env, r];
                        };
                IF CDProperties.GetInstanceProp[list.first, $SignalName]#NIL OR CDProperties.GetInstanceProp[list.first, $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].newInst;",
                        IO.rope[childName], 
                        IO.rope[PosToRope[pos]], 
                        IO.rope[orientationCode] 
                        ]];
                    }
                ELSE {
                    r _ Rope.Cat[
                        IO.PutFR["[] _ CDCells.IncludeOb[cell: ob, ob: %g, position: %g%0g];",
                        IO.rope[childName], 
                        IO.rope[PosToRope[pos]], 
                        IO.rope[orientationCode] 
                        ]];
                    };
                LocalStatement[env, r];
                IF needInst THEN MakeInstanceStuff[env, list.first];
                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;

    MakeACallExpression: PROC[env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE _ NIL, mustHandleInstance: BOOL _ FALSE] =
        BEGIN
        r _ SpecificCallExpression[env, ob];
        IF Rope.IsEmpty[r] THEN {
            IF ob.class.inDirectory THEN {
                MakeDirGenerator[env];
                r _ Rope.Cat["CDGenerate.FetchNCall[directory, design, ", RopeToRope[CDDirectory.Name[ob]], "]"];
                }
            ELSE IF CDAtomicObjects.IsAtomicOb[ob] THEN {
                IncludeDirectory[env, "CDAtomicObjects"];
                r _ "CDAtomicObjects.CreateAtomicOb[classKey: ";
                r _ Rope.Cat[r, "$", CDCommandOps.ToRope[ob.class.objectType], ", size: "];
                r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]], ", "];
                r _ Rope.Cat[r, "tech: tech, lev: ", LayerIdent[env, ob.layer], "]"];
                }
            ELSE IF CDSymbolicObjects.IsPin[ob] THEN {
                IncludeDirectory[env, "CDSymbolicObjects"];
                r _ IO.PutFR["CDSymbolicObjects.CreatePin[%g]", IO.rope[PosToRope[ob.size]]];
                mustHandleInstance _ TRUE;
                }
            ELSE IF CDSymbolicObjects.IsSegment[ob] THEN {
                IncludeDirectory[env, "CDSymbolicObjects"];
                r _ IO.PutFR["CDSymbolicObjects.CreateSegment[length: %g, dummyWidth: %g]", IO.int[ob.size.y], IO.int[ob.size.x]];
                mustHandleInstance _ TRUE;
                }
            ELSE IF CDSymbolicObjects.IsMark[ob] THEN {
                IncludeDirectory[env, "CDSymbolicObjects"];
                r _ IO.PutFR["CDSymbolicObjects.CreateMark[dummySize: %g]", IO.int[ob.size.y]];
                mustHandleInstance _ TRUE;
                }
            ELSE IF ob.class.wireTyped THEN {
                IncludeDirectory[env, "CDRects"];
                r _ "CDRects.CreateRect[size: ";
                r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]]];
                r _ Rope.Cat[r, ", l: ", LayerIdent[env, ob.layer], "]"];
                }
            ELSE {
                r _ "--Unknown[]--";
                IncludeDirectory[env, "CDRects"];
                r _ Rope.Cat[r, "CDRects.CreateRect[size: "];
                r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]]];
                r _ Rope.Cat[r, ", l: CD.highLightError]"];
                };
            };
        END;

    MakeProgramCommand: PROC [comm: CDSequencer.Command] =
        BEGIN
        inst: CD.Instance = CDCommandOps.TheInstance[comm, "make program text"];
        IF inst#NIL THEN {
            env: Environment _ NewEnvironment[comm.design.technology]; 
            Reserve[env, "design"];
            Reserve[env, "key"];
            Reserve[env, "table"];
            Reserve[env, "directory"];
            Reserve[env, "data"];
            Reserve[env, "tech"];
            Reserve[env, "child"];
            Reserve[env, "CreateCell"];
            Reserve[env, "ob"];
            Reserve[env, "inst"];
            IncludeDirectory[env, "CDCells"];
            IncludeDirectory[env, "CDGenerate"];
            IncludeDirectory[env, "CD"];
            IncludeDirectory[env, "CDDirectory"];
            ProgramText[inst.ob, comm.design, env];
            FinishUp[env];
            }
        END;

    <<--XX SPECIAL OBJECTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX>>
    <<>>
    <<--XX INIT XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX>>

    [] _ CDProperties.RegisterProperty[$MakeCallExpression, $chj];
    CDSequencer.ImplementCommand[$MakeProgram, MakeProgramCommand,, doQueue];
    CDMenus.CreateEntry[menu: $ProgramMenu, entry: "make text", key: $MakeProgram];
    TerminalIO.WriteRope["make program command loaded\n"];
    END.