subckt.c File Reference

#include "spice.h"
#include "sced.h"
#include "scedmacs.h"

Include dependency graph for subckt.c:

Go to the source code of this file.

Data Structures
struct	cc
struct	rd

Macros
#define	Mtest(zap)   if((zap) == 0) MallocFailed()

Functions
static void	set_subckt_list ()
static void	set_subckt_choices ()
static struct o *	make_array ()
static int	get_reference_terminal ()
static void	edit_cell ()
static int	pop_context ()
static struct o *	select_first_call ()
static struct o *	select_call ()
static void	flatten_cell ()
void	InitDeviceMenu ()
void	NewSubckt ()
void	Place (int *LookedAhead)
void	ShowNewInstance (long X, long Y, long RefX, long RefY)
static struct o *	make_array (long X, long Y)
static int	get_reference_terminal (struct s *CellDesc, long *X, long *Y)
void	NewSymbol ()
int	MutSelected (struct prpty *PDesc)
void	Push (int *LookedAhead)
static void	edit_cell (int Modified)
void	UpdateParent (char *NewName)
void	Pop ()
int	CheckModified ()
void	ClearContext ()
static struct o *	select_call (long X, long Y)
void	Flatten (int *LookedAhead)
static void	flatten_cell (struct s *CellDesc)
int	OpenCell (char *Master, struct s **MasterDesc)

Variables
static struct cc *	Context
static int	WroteCell
static char *	SubCktList [80]
static struct rd	CurInstance
char *	MenuUNDO
char *	MenuNEWSC
char *	MenuPLACE

Macro Definition Documentation

#define Mtest

(

zap

)

if((zap) == 0) MallocFailed()

Definition at line 30 of file subckt.c.

Function Documentation

int CheckModified

(

)

Definition at line 906 of file subckt.c.

{
    struct s *SDesc;
    struct cc *Cx = Context;
    char *TypeIn;

    while (Cx) {
        if (Cx->ccModified) {
            sprintf(TypeOut,"Circuit %s has been modified. Save it? (y) ",
                Cx->ccMaster);
            ShowPrompt(TypeOut);
            TypeIn = FBEdit(NULL);
            if (TypeIn == NULL) return (True);
            if (*TypeIn != 'n' && *TypeIn != 'N') {
                CDSymbol(Cx->ccMaster,&SDesc);
                if (SDesc && CDUpdate(SDesc,(char *)NULL)) {
                    Cx->ccModified = False;
                    if (Not CDReflect(SDesc))
                        MallocFailed();
                }
                else {
                    /* shouldn't happen */
                    sprintf(TypeOut,"Can't save %s.",Cx->ccMaster);
                    ShowPromptAndWait(TypeOut);
                    return (True);
                }
            }
        }
        Cx = Cx->ccNext;
    }
    ClearContext();
    return (False);
}

void ClearContext

(

)

Definition at line 944 of file subckt.c.

{
    while (Context) pop_context();
}

static void edit_cell ( )

static

static void edit_cell ( int  Modified )

static

Definition at line 733 of file subckt.c.

{
    char *TypeIn,*CellName,*NextCellName();

    SQClear();
    GPclearGraf(); /* clear graf references */
    ShowPrompt("Building database.  Please wait.");
    if (Not CDOpen(Parameters.kpCellName,&Parameters.kpCellDesc,'w')) {
        sprintf(TypeOut,"Can't edit cell %s. MORE",Parameters.kpCellName); 
        ShowPrompt(TypeOut);
        (void)FBGetchar(ERASE);
        sprintf(TypeOut,"%s",CDStatusString);
        ShowPrompt(TypeOut);
        Parameters.kpCellName[0] = '\0';
    }
    else {
        if (CDStatusInt == CDNEWSYMBOL) {
            ShowPrompt("Internal error: cell not found");
            return;
        }
        CenterFullView();
        EraseLargeCoarseViewport();
        CDUnmark(Parameters.kpCellDesc);
        Redisplay(View->kvCoarseWindow);
        if (Parameters.kpShowTerminals)
            DisplayTerminals(DISPLAY);
        sprintf(TypeOut,"Editing: %s",Parameters.kpCellName);
        ShowPrompt(TypeOut);
        Parameters.kpModified = Modified;
        TitleWindow();
    }
}

void Flatten

(

int *

LookedAhead

)

Definition at line 1049 of file subckt.c.

{
    struct t *TGen;
    struct s *MasterDesc;
    struct ks *SQDesc;
    struct ks *OldSQDesc;
    struct prpty *PDesc;
    char *MasterName;
    char *TypeIn;
    int NumX,NumY;
    int Int1,Int2;
    int Undo = False;
    int Modified = 0;
    long X,Y;
    long DX,DY;
    long TF[9];
    struct ka OldSelectQBB;
    extern char *MenuFLATN;
    extern char *MenuUNDO;


    if (select_first_call() == NULL) {
        ShowPrompt("You haven't selected a subcircuit to flatten.");
        return;
    }
top:
    MenuSelect(MenuFLATN);
    SQDesc = SelectQHead;
    SQComputeBB(); 
    OldSelectQBB = SelectQBB;

    for (; SQDesc != NULL; SQDesc = SQDesc->ksSucc) {

        if (SQDesc->ksPointer->oType == CDSYMBOLCALL) {
            if (SQDesc->ksPointer->oInfo == SQ_GONE) continue;
            CDCall(SQDesc->ksPointer,&MasterName,&NumX,&DX,&NumY,&DY);
            if (IsCellInLib(MasterName)) continue;

            if (OpenCell(MasterName,&MasterDesc)) continue;

            SetTransform(SQDesc->ksPointer);
            TPremultiply();

            for (Int1 = NumY; Int1 >= 1; --Int1) {
                for (Int2 = 1; Int2 <= NumX; ++Int2) {
                    TPush();
                    TIdentity();
                    TTranslate((Int2-1)*DX,(Int1-1)*DY);
                    TPremultiply();
                    TCurrent(TF);
                    flatten_cell(MasterDesc); 
                    TPop();
                }
            }
            TPop();
            SQDesc->ksPointer->oInfo = SQ_GONE;
            Modified++;
        }
    }
    /* take care of instance markers */
    OldSelectQBB.kaRight += 600;
    OldSelectQBB.kaLeft -= 600;
    OldSelectQBB.kaTop += 600;
    OldSelectQBB.kaBottom -= 600;
    EraseBox(&OldSelectQBB);
    Redisplay(&OldSelectQBB);
    MenuDeselect(MenuFLATN);
    loop {
        switch (PointLoop(LookedAhead)) {
            case PL_ESC:
            case PL_CMD:
                goto quit;
            case PL_UND:
                MenuSelect(MenuUNDO);
                if (Undo == False) {
                    SQRestore(True);
                    EraseBox(&OldSelectQBB);
                    Redisplay(&OldSelectQBB);
                    MenuDeselect(MenuUNDO);
                    Modified--;
                    Undo = True;
                    continue;
                }
                else {
                    Undo = False;
                    MenuDeselect(MenuUNDO);
                    goto top;
                }
        }
    }

quit:
    SQRestore(False);
    if (Modified)
        Parameters.kpModified = True;
}

static void flatten_cell ( )

static

static void flatten_cell ( struct s *  CellDesc )

static

Definition at line 1150 of file subckt.c.

{
    struct g *GenDesc;
    struct o *Pointer,*NewPointer;
    struct p *Path;
    struct t *TGen;
    struct s *MasterDesc;
    struct prpty *PDesc, *PDesc1;
    char *Label;
    char *MasterName;
    char *TypeIn;
    char Xform;
    int Layer;
    int NumX,NumY;
    int Create;
    int Int1,Int2;
    long X,Y,Width;
    long DX,DY;
    long TF[9];

    /* mutual inductors */
    PDesc = CellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_MUT) continue;
        CDCopyProperty(Parameters.kpCellDesc,(struct o*)NULL,
            PDesc);
        PDesc1 = Parameters.kpCellDesc->sPrptyList; /* just added */
        TPoint((long*)&PDesc1->prpty_Data->p_mut.x1,
            (long*)&PDesc1->prpty_Data->p_mut.y1);
        TPoint((long*)&PDesc1->prpty_Data->p_mut.x2,
            (long*)&PDesc1->prpty_Data->p_mut.y2);
        PDesc1->prpty_Info = "new";  /* so we know to delete if undo */
    }

    /*
     * Traverse calls
     */
    if (Not CDInitGen(CellDesc,0,-CDINFINITY,-CDINFINITY,
        CDINFINITY,CDINFINITY,&GenDesc)) MallocFailed();
    loop {
        CDGen(CellDesc,GenDesc,&Pointer);
        if (Pointer == NULL) break;
        if (Pointer->oInfo == SQ_GONE) continue;

        CDCall(Pointer,&MasterName,&NumX,&DX,&NumY,&DY);

        if (TFull()) return;

        if (OpenCell(MasterName,&MasterDesc)) return;

        Create = False;
        if (IsCellInLib(MasterName)) {
            if (Not CDBeginMakeCall(Parameters.kpCellDesc,MasterName,
                NumX,DX,NumY,DY,&NewPointer)) MallocFailed();
            Create = True;
        }

        SetTransform(Pointer);
        TPremultiply();

        for (Int1 = NumY; Int1 >= 1; Int1--) {
            for (Int2 = 1; Int2 <= NumX; Int2++) {
                TPush();
                TIdentity();
                TTranslate((Int2-1)*DX,(Int1-1)*DY);
                TPremultiply();
                TCurrent(TF);

                if (!Create) {
                    flatten_cell(MasterDesc);
                }
                else {
                    AddResultingTransform(NewPointer,TF);
                    if (Not
                        CDEndMakeCall(Parameters.kpCellDesc,NewPointer))
                        MallocFailed();
                    SQInsert(NewPointer);
                    NewPointer->oInfo = SQ_NEW;

                    for (PDesc = Pointer->oPrptyList; PDesc;
                            PDesc = PDesc->prpty_Succ) {
                        if (PDesc->prpty_Value == P_VALUE ||
                                PDesc->prpty_Value == P_MODEL ||
                                PDesc->prpty_Value == P_INITC) {
                            CDRemoveProperty(Parameters.kpCellDesc,
                                NewPointer,PDesc->prpty_Value);
                            CDCopyProperty(Parameters.kpCellDesc,
                                NewPointer,PDesc);
                        }
                    }
                }
                TPop();
            }
        }
        TPop();
    }
    if (Not CDInitGen(CellDesc,1,-CDINFINITY,-CDINFINITY,
        CDINFINITY,CDINFINITY,&GenDesc)) MallocFailed();
    loop {
        CDGen(CellDesc,GenDesc,&Pointer);
        if (Pointer == NULL) break;
        if (Pointer->oInfo == SQ_GONE) continue;

        if (Pointer->oType == CDLABEL) {
            CDLabel(Pointer,&Layer,&Label,&X,&Y,&Xform);
            TPoint(&X,&Y);
            if (Not CDMakeLabel(Parameters.kpCellDesc,Layer,Label,
                X,Y,Xform,&Pointer)) MallocFailed();
            SQInsert(Pointer);
            Pointer->oInfo = SQ_NEW;
            continue;
        }
        if (Pointer->oType == CDWIRE) {
            CDWire(Pointer,&Layer,&Width,&Path);
            CopyPathWithXForm(&Path);
            if (Not CDMakeWire(Parameters.kpCellDesc,Layer,Width,Path,
                &Pointer)) MallocFailed();
            SQInsert(Pointer);
            Pointer->oInfo = SQ_NEW;
            AssignWireProperties(Pointer);
            continue;
        }
    }
}

static int get_reference_terminal ( )

static

static int get_reference_terminal ( struct s *  CellDesc, long *  X, long*  Y  )

static

Definition at line 394 of file subckt.c.

{
    struct prpty *PDesc;

    /* Terminal 0 is the reference point */
    PDesc = CellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        if (PDesc->prpty_Data->p_node.inode == 0) {
            *X = PDesc->prpty_Data->p_node.x;
            *Y = PDesc->prpty_Data->p_node.y;
            return (False); /* success */
        }
    }
    return (True); /* not defined */
}

void InitDeviceMenu

(

)

Definition at line 70 of file subckt.c.

{
    if (DeviceMenu == NULL)
        DeviceMenu = (MENU *) malloc(DefMenuSize*sizeof(MENU));
    if (DeviceMenu == NULL) MallocFailed();
    memset(DeviceMenu,0,DefMenuSize*sizeof(MENU));

    set_subckt_list();
    SetLibraryChoices();
    if (DeviceMenu[0].mEntry == NULL)
        ShowPrompt("No device library found!");
    set_subckt_choices();
    if (DeviceMenu[0].mEntry == NULL)
        ShowPrompt("No device library found, and no subcircuits!");
}

static struct o* make_array ( )

static

static struct o* make_array ( long  X, long  Y  )

static

Definition at line 335 of file subckt.c.

{
    struct o *Pointer;
    struct ka BB;
    int NumX,NumY;
    long XX,YY;
    long L,R,T,B;
    double DX,DY;

    NumX = Parameters.kpNumX;
    NumY = Parameters.kpNumY;
    DX = Parameters.kpDX;
    DY = Parameters.kpDY;

    CDBB(CurInstance.Desc,(struct o *)NULL,&L,&B,&R,&T);

    if (Not CDBeginMakeCall(Parameters.kpCellDesc,CurInstance.Name,NumX,
        R-L+(long)DX*RESOLUTION,NumY,T-B+(long)DY*RESOLUTION,&Pointer)) {
        MallocFailed();
    }

    /* Find translation so cell is always placed with lower left corner
     * at reference point or use the subckt's nodal reference point if
     * defined. */
    XX = L;
    YY = B;
    (void)get_reference_terminal(CurInstance.Desc,&XX,&YY);
    if (XX != 0 || YY != 0)
        Mtest(CDT(Pointer,CDTRANSLATE,-XX,-YY));

    if (Parameters.kpMX)
        Mtest(CDT(Pointer,CDMIRRORX,0L,0L));
    if (Parameters.kpMY)
        Mtest(CDT(Pointer,CDMIRRORY,0L,0L));
    if (Parameters.kpRotationAngle == 90) {
        Mtest(CDT(Pointer,CDROTATE,0L,1L));
    }
    elif (Parameters.kpRotationAngle == 180) {
        Mtest(CDT(Pointer,CDROTATE,-1L,0L));
    }
    elif (Parameters.kpRotationAngle == 270) {
        Mtest(CDT(Pointer,CDROTATE,0L,-1L));
    }

    Mtest(CDT(Pointer,CDTRANSLATE,X,Y));
    Mtest(CDEndMakeCall(Parameters.kpCellDesc,Pointer));

    /* CDBB will always return True if Pointer != NULL */
    CDStatusInt = CDBB(Parameters.kpCellDesc,Pointer,
        &BB.kaLeft,&BB.kaBottom,&BB.kaRight,&BB.kaTop);
    EraseBox(&BB);
    Redisplay(&BB);
    return (Pointer);
}

int MutSelected

(

struct prpty *

PDesc

)

Definition at line 592 of file subckt.c.

{
    long x1,y1,x2,y2;
    struct ks *sq;
    struct o *p1, *p2;
    struct g *GenDesc;
    int found1, found2;
    char *name;

    x1 = PDesc->prpty_Data->p_mut.x1;
    y1 = PDesc->prpty_Data->p_mut.y1;
    x2 = PDesc->prpty_Data->p_mut.x2;
    y2 = PDesc->prpty_Data->p_mut.y2;

    if (Not CDInitGen(Parameters.kpCellDesc,0,
        x1,y1,x1,y1,&GenDesc)) MallocFailed();

    loop {
        CDGen(Parameters.kpCellDesc,GenDesc,&p1);
        if (p1 == NULL) break;
        if (p1->oInfo == SQ_GONE) continue;
        name = ((struct c *)p1->oRep)->cMaster->mName;
        if (!cieq(name,"ind")) continue;
        tfree(GenDesc);
        break;
    }
    if (p1 == NULL) return (False);

    if (Not CDInitGen(Parameters.kpCellDesc,0,
        x2,y2,x2,y2,&GenDesc)) MallocFailed();

    loop {
        CDGen(Parameters.kpCellDesc,GenDesc,&p2);
        if (p2 == NULL) break;
        if (p2->oInfo == SQ_GONE) continue;
        name = ((struct c *)p2->oRep)->cMaster->mName;
        if (!cieq(name,"ind")) continue;
        tfree(GenDesc);
        break;
    }
    if (p2 == NULL) return (False);

    found1 = found2 = False;
    for (sq = SelectQHead; sq; sq = sq->ksSucc) {
        if (sq->ksPointer->oType != CDSYMBOLCALL) continue;
        if (sq->ksPointer->oInfo == SQ_GONE) continue;
        if (p1 == sq->ksPointer)
            found1 = True;
        if (p2 == sq->ksPointer)
            found2 = True;
    }
    if (found1 && found2)
        return (True);
    return (False);
}

void NewSubckt

(

)

Definition at line 89 of file subckt.c.

{
    char *TypeIn;
    int i;
    struct s *MasterDesc;

    MenuSelect(MenuNEWSC);
    ShowPrompt("New subcircuit name? ");
    TypeIn = FBEdit(NULL);
    if (TypeIn == NULL || *TypeIn == '\0') {
        MenuDeselect(MenuNEWSC);
        return;
    }

    /* strip off any path prefix */
    if (FixCellName(TypeIn)) {
        ShowPromptAndWait("Warning: internal path overflow");
    }

    if (OpenCell(TypeIn,&MasterDesc)) {
        ShowPrompt("Bad subcell name, not found or error.");
        MenuDeselect(MenuNEWSC);
        return;
    }
    for (i = 0; i < 80 && SubCktList[i]; i++)
        if (!strcmp(SubCktList[i],TypeIn)) break;
    if (i < 80 && SubCktList[i] == NULL)
        SubCktList[i] = CopyString(TypeIn);

    SetLibraryChoices();
    set_subckt_choices();
    MenuDeselect(MenuNEWSC);
    ShowCommandMenu();
    ErasePrompt();
}

void NewSymbol

(

)

Definition at line 417 of file subckt.c.

{
    struct ks *SQDesc;
    struct o *Pointer;
    struct t *TGen;
    struct p *Path;
    struct prpty *PDesc;
    FILE *FileDesc;
    char *TypeIn;
    char *Label;
    char Type;
    char Xform;
    char *SymbolName;
    int Layer;
    int NumX,NumY;
    long X,Y,DX,DY,Width,Length;
    long Xo, Yo;
    extern char *MenuCRSYM;

    MenuSelect(MenuCRSYM);
    if (SelectQHead == NULL) {
        ShowPrompt("Objects must be selected first.");
        MenuDeselect(MenuCRSYM);
        return;
    }
    ShowPrompt("Name of new symbol? ");
    if ((TypeIn = FBEdit(NULL)) == NULL Or *TypeIn == '\0') {
        ErasePrompt();
        MenuDeselect(MenuCRSYM);
        return;
    }
    if ((FileDesc = POpen(TypeIn,"w",(char **)NULL)) == NULL) {
        sprintf(TypeOut,"Can't create symbol %s.",TypeIn);
        ShowPrompt(TypeOut);
        MenuDeselect(MenuCRSYM);
        return;
    }
    SQComputeBB();
    /* The new cell origin will be the lower left corner */
    Xo = SelectQBB.kaLeft;
    Yo = SelectQBB.kaBottom;
    fprintf(FileDesc,"(Symbol %s);\n",TypeIn);
    fprintf(FileDesc,"9 %s;\n",TypeIn);

    /* catch mutual inductors if both selected */
    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_MUT) continue;
        if (MutSelected(PDesc)) {
            fprintf(FileDesc,"5 %d %d %d %d %d %g;\n",
                P_MUT,PDesc->prpty_Data->p_mut.x1,
                PDesc->prpty_Data->p_mut.y1,
                PDesc->prpty_Data->p_mut.x2,
                PDesc->prpty_Data->p_mut.y2,
                PDesc->prpty_Data->p_mut.coeff);
        }
    }

    GenBeginSymbol(FileDesc,0,1L,1L);

    for (SQDesc = SelectQHead; SQDesc; SQDesc = SQDesc->ksSucc) {
        Pointer = SQDesc->ksPointer;
        if (Pointer->oType == CDSYMBOLCALL) {

            CDCall(Pointer,&SymbolName,&NumX,&DX,&NumY,&DY);
            /* add symbol name extension */
            fprintf(FileDesc,"9 %s;\n",SymbolName);

            /* property list info */
            for (PDesc = Pointer->oPrptyList; PDesc;
                    PDesc = PDesc->prpty_Succ) {

                switch (PDesc->prpty_Value) {
                    case P_NODE:
                        fprintf(FileDesc,"5 %d %d %d %ld %ld;\n",
                            P_NODE,-1,PDesc->prpty_Data->p_node.inode,
                            PDesc->prpty_Data->p_node.x-Xo,
                            PDesc->prpty_Data->p_node.y-Yo);
                        continue;
                    case P_MUT:
                        fprintf(FileDesc,"5 %d %d %d %d %d %g;\n",
                            P_MUT,PDesc->prpty_Data->p_mut.x1,
                            PDesc->prpty_Data->p_mut.y1,
                            PDesc->prpty_Data->p_mut.x2,
                            PDesc->prpty_Data->p_mut.y2,
                            PDesc->prpty_Data->p_mut.coeff);
                        continue;
                    case P_BRANCH:
                        fprintf(FileDesc,"5 %d %ld %ld %d %d;\n",
                            P_BRANCH,PDesc->prpty_Data->p_branch.x-Xo,
                            PDesc->prpty_Data->p_branch.y-Yo,
                            PDesc->prpty_Data->p_branch.r1,
                            PDesc->prpty_Data->p_branch.r2);
                        continue;
                    case P_NAME:
                        if (PDesc->prpty_Data->p_name.subname)
                            fprintf(FileDesc,"5 %d %s %d %s;\n",
                                P_NAME,PDesc->prpty_Data->p_name.name,
                                PDesc->prpty_Data->p_name.num,
                                PDesc->prpty_Data->p_name.subname);
                        else
                            fprintf(FileDesc,"5 %d %s %d;\n",
                                P_NAME,PDesc->prpty_Data->p_name.name,
                                PDesc->prpty_Data->p_name.num);
                        continue;
                    case P_MODEL:
                    case P_VALUE:
                    case P_INITC:
                        fprintf(FileDesc,"5 %d %s;\n",PDesc->prpty_Value,
                            HYtoascii((struct hprlist*)PDesc->prpty_Data));
                        continue;
                }
            }

            /* add symbol array extension */
            if (NumX != 1 Or NumY != 1)
                fprintf(FileDesc,"1 Array %d %ld %d %ld;\n",NumX,DX,NumY,DY);
            fprintf(FileDesc,"C 0");
            CDInitTGen(Pointer,&TGen);
            loop {
                CDTGen(&TGen,&Type,&X,&Y);
                if (TGen == NULL) {
                    fprintf(FileDesc,";\n");
                    break;
                }
                elif (Type == CDROTATE)
                    fprintf(FileDesc," R %ld %ld",X,Y);
                elif (Type == CDTRANSLATE)
                    fprintf(FileDesc," T %ld %ld",X-Xo,Y-Yo);
                elif (Type == CDMIRRORX)
                    fprintf(FileDesc," MX");
                elif (Type == CDMIRRORY)
                    fprintf(FileDesc," MY");
            }
        }
    }

    GenLayer(FileDesc,'S',"CED");
    for (SQDesc = SelectQHead; SQDesc; SQDesc = SQDesc->ksSucc) {
        Pointer = SQDesc->ksPointer;
        if (Pointer->oInfo == SQ_GONE) continue;

        if (Pointer->oType == CDWIRE) {
            CDWire(Pointer,&Layer,&Width,&Path);
            fprintf(FileDesc,"5 %d -1 0 0 0;\n",P_NODE);
            GenWireOffset(FileDesc,Width,Path,Xo,Yo);
            continue;
        }
        elif (Pointer->oType == CDPOLYGON) {
            CDPolygon(Pointer,&Layer,&Path);
            GenPolygonOffset(FileDesc,Path,Xo,Yo);
            continue;
        }
        elif (Pointer->oType == CDLABEL) {
            CDLabel(Pointer,&Layer,&Label,&X,&Y,&Xform);
            fprintf(FileDesc,"94 %s %ld %ld %d",Label,X-Xo,Y-Yo,Xform);
            fprintf(FileDesc,";\n");
            continue;
        }
    }
    
    GenEndSymbol(FileDesc);
    GenEnd(FileDesc);
    fclose(FileDesc);
    sprintf(TypeOut,"New symbol %s created and saved.",TypeIn);
    MenuDeselect(MenuCRSYM);
    ShowPrompt(TypeOut);
}

int OpenCell	(	char *	Master,
		struct s **	MasterDesc
	)

Definition at line 1279 of file subckt.c.

{
    char *TypeIn;

    if (Not CDOpen(Master,MasterDesc,'r')) {
        if (CDStatusInt == CDPARSEFAILED) {
            sprintf(TypeOut,"Can't display circuit %s. MORE",Master); 
            ShowPrompt(TypeOut);
            (void)FBGetchar(ERASE);
            ShowPrompt(CDStatusString);
        }
        if (CDStatusInt == CDMALLOCFAILED)
            MallocFailed();
        return (True);
    }
    if (CDStatusInt == CDNEWSYMBOL) {
        sprintf(TypeOut,
        "Can't display circuit %s, because it doesn't seem to be around.",
        Master); 
        ShowPrompt(TypeOut);
        return (True);
    }
    return (False);
}

void Place

(

int *

LookedAhead

)

Definition at line 128 of file subckt.c.

{
    char *TypeIn;
    struct o *Pointer = NULL;
    struct s *MasterDesc;
    struct ka BB;
    long X,Y;
    int Undo = False;
    int modified = 0;
    int i;

    /* the cell name is hidden in the command string */
    TypeIn = Parameters.kpCommand;
    while (*TypeIn) TypeIn++;
    TypeIn++;
    strcpy(CurInstance.Name,TypeIn);
    MenuSelectDev(CurInstance.Name);

    if (OpenCell(CurInstance.Name,&MasterDesc)) {
        ShowPrompt("Bad subcell name, not found or error.");
        MenuDeselectDev(CurInstance.Name);
        return;
    }
    CurInstance.Desc = MasterDesc;
    CurInstance.DevLib = IsCellInLib(CurInstance.Name);
    ShowPrompt("Point to locations to place cell.");
    FBSetRubberBanding('p');

    loop {
        switch (PointLoop(LookedAhead)) {

            case PL_CMD:
            case PL_ESC:
                goto quit;

            case PL_UND:
                *LookedAhead = False;
                if (Pointer == NULL)
                    continue;
                MenuSelect(MenuUNDO);
                if (Undo == False) {
                    CDStatusInt = CDBB(Parameters.kpCellDesc,Pointer,
                        &BB.kaLeft,&BB.kaBottom,&BB.kaRight,&BB.kaTop);
                    EraseBox(&BB);
                    CDDelete(Parameters.kpCellDesc,Pointer);
                    Redisplay(&BB);
                    modified--;
                    Undo = True;
                }
                else {
                    FBSetRubberBanding(0);
                    Pointer = make_array(X,Y);
                    FBSetRubberBanding('p');
                    modified++;
                    Undo = False;
                }
                MenuDeselect(MenuUNDO);
                continue;

            case PL_PCW:
                X = SCursor.kcX;
                Y = SCursor.kcY;
                FBSetRubberBanding(0);
                Pointer = make_array(X,Y);
                FBSetRubberBanding('p');
                modified++;
                Undo = False;
                continue;
        }
    }

quit:
    FBSetRubberBanding(0);
    MenuDeselectDev(CurInstance.Name);
    ErasePrompt();
    if (modified)
        Parameters.kpModified = True;
}

void Pop

(

)

Definition at line 829 of file subckt.c.

{
    int i;
    struct s *CellDesc;
    char *TypeIn;
    extern char *MenuPOP;

    MenuSelect(MenuPOP);
    if (Context == NULL)
        ShowPrompt("There isn't a context to pop to.");

    else {
        SQClear();
        if (WroteCell) {
            /* 
             * Restore cell to its old state, because we don't want
             *  a global change, but we want a change to the instance
             *  pushed from.
             */
            Parameters.kpModified = False;
        }
        if (Parameters.kpModified) {
            ShowPrompt("You've modified this cell.  Do you want to save it (y)?");
            TypeIn = FBEdit(NULL);
            if (TypeIn == NULL)
                goto quit;
            if (TypeIn[0] != 'n' && TypeIn[0] != 'N')
                WriteCell();
        }
        WroteCell = False;
        if (Parameters.kpShowTerminals)
            DisplayTerminals(ERASE);
        if (Not CDClose(Parameters.kpCellDesc))
            MallocFailed();
        edit_cell(pop_context());
    }
quit:
    TitleWindow();
    MenuDeselect(MenuPOP);
}

static int pop_context ( )

static

Definition at line 873 of file subckt.c.

{
    struct kw *Tmp;
    struct cc *Old;
    int Modified;

    strcpy(Parameters.kpCellName,Context->ccMaster);
    InitCoarseWindow(Context->ccX,Context->ccY,Context->ccWidth);
    InitFineWindow(Context->ccX,Context->ccY);

    for (Tmp = Parameters.kpWindowStack; Tmp;
        Tmp = Parameters.kpWindowStack) {
        Parameters.kpWindowStack = Tmp->kwNext;
        tfree(Tmp);
    }
    Parameters.kpWindowStack = Context->ccSaveWindow;
    free(Context->ccMaster);
    TPush();
    TLoadCurrent(Context->ccXform);
    TStore();
    TPop();
    SetPositioning();
    Parameters.kpModified = False;
    Modified = Context->ccModified;
    Old = Context;
    Context = Context->ccNext;
    tfree(Old);
    return (Modified);
}

void Push

(

int *

LookedAhead

)

Definition at line 653 of file subckt.c.

{
    struct o *Pointer;
    struct t *TGen;
    struct cc *New;
    char Type;
    char *MasterName;
    int  i,NumX,NumY;
    long DX,DY;
    long X,Y;
    extern char *MenuPUSH;

    MenuSelect(MenuPUSH);
    WroteCell = False;
    Pointer = select_first_call();
    loop {
        /*
         * Fetch first call desc in select Q if any.
         * Its master is the cell we will push to.
         * Otherwise, point to select an instance;
         */
        if (Pointer != NULL) break;

        ShowPrompt("Point to instance to push to ");
        switch (PointLoop(LookedAhead)) {
            case PL_ESC:
            case PL_CMD:
            case PL_UND:
                ErasePrompt();
                MenuDeselect(MenuPUSH);
                return;
            case PL_PCW:
                Pointer = select_call(SCursor.kcRawX,SCursor.kcRawY);
        }
    }
    ErasePrompt();
    CDCall(Pointer,&MasterName,&NumX,&DX,&NumY,&DY);
    New = alloc(cc);
    if (New == NULL) MallocFailed();
    New->ccMaster = CopyString(Parameters.kpCellName);
    New->ccInst = Pointer;
    New->ccX = View->kvCoarseWindow->kaX;
    New->ccY = View->kvCoarseWindow->kaY;
    New->ccModified = Parameters.kpModified;
    New->ccWidth = View->kvCoarseWindow->kaWidth;
    New->ccSaveWindow = Parameters.kpWindowStack;
    New->ccNext = Context;
    Context = New;
    strcpy(Parameters.kpCellName,MasterName);
    Parameters.kpModified = False;
    Parameters.kpWindowStack = NULL;

    /* find the inverse transform of the cell, used when displaying
     * context */
    TPush();
    TLoad();         /* load the current inverse transform */
    TCurrent(New->ccXform);
    TInverse();      /* compute the inverse (actual transform) */
    TLoadInverse();  /* load it */

    SetTransform(Pointer);
    TPremultiply();

    TInverse();      /* compute the inverse */
    TLoadInverse();  /* load it */
    TStore();        /* save it for use in redisplay() */
    TPop();
    TPop();

    if (Parameters.kpShowTerminals)
        DisplayTerminals(ERASE);
    edit_cell(False);
    TitleWindow();
    MenuDeselect(MenuPUSH);
}

static struct o* select_call ( )

static

static struct o* select_call ( long  X, long  Y  )

static

Definition at line 972 of file subckt.c.

{
    struct g *GenDesc;
    struct o *Pointer,*Found;
    int Count = 0;
    char *name;
    char OldMenu;

    if (Not CDInitGen(Parameters.kpCellDesc,0,
        X,Y,X,Y,&GenDesc)) MallocFailed();

    loop {
        CDGen(Parameters.kpCellDesc,GenDesc,&Pointer);
        if (Pointer == NULL) break;
        if (Pointer->oInfo == SQ_GONE) continue;

        name = ((struct c *)Pointer->oRep)->cMaster->mName;
        if (IsCellInLib(name)) continue;
        /* found a subcircuit */
        Count++;
        AmbiguityMenu[Count].mEntry = name;
        Found = Pointer;
    }
    if (Count == 0)
        return (NULL);
    if (Count == 1)
        return (Found);
    AmbiguityMenu[Count].mEntry = NULL;
    FixMenuPrefix(AmbiguityMenu);

    OldMenu = Parameters.kpMenu;
    Parameters.kpMenu = AMBIGUITYMENU;
    ShowMenu(AmbiguityMenu);

    /* Which instance is user interested in? */
    ShowPrompt("Point to the name of the subcircuit you want selected.");
    loop {
        int dummy;
        switch (PointLoopSafe(&dummy)) {
            case PL_ESC:
                break;
            case PL_CMD:
                break;
            case PL_PCW:
                ShowPrompt("You aren't pointing at the menu.");
                continue;
        }
        break;
    }
    Parameters.kpMenu = OldMenu;
    ErasePrompt();
    ShowCommandMenu();

    if (Parameters.kpCommand[1] == ESCAPE) return (NULL);
    if (Not CDInitGen(Parameters.kpCellDesc,0,
        X,Y,X,Y,&GenDesc)) MallocFailed();

    loop {
        CDGen(Parameters.kpCellDesc,GenDesc,&Pointer);
        if (Pointer == NULL) break;
        if (Pointer->oInfo == SQ_GONE) continue;

        name = ((struct c *)Pointer->oRep)->cMaster->mName;
        if (cieq(name,Parameters.kpCommand)) {
            tfree(GenDesc);
            return (Pointer);
        }
    }
    /* shouldn't get here */
    return (NULL);
}

static struct o * select_first_call ( )

static

Definition at line 953 of file subckt.c.

{
    struct ks *SQDesc;
    char *name;

    for (SQDesc = SelectQHead; SQDesc; SQDesc = SQDesc->ksSucc) {
        if (SQDesc->ksPointer->oType == CDSYMBOLCALL) {
            name =
                ((struct c *)SQDesc->ksPointer->oRep)->cMaster->mName;
            if (IsCellInLib(name)) continue;
            return (SQDesc->ksPointer);
        }
    }
    return (NULL);
}

static void set_subckt_choices ( )

static

Definition at line 305 of file subckt.c.

{
    int i, j;
    int NumEntries = MenuViewport.kaBottom;

    for (i = 0; ; i++)
        if (BasicMenu[i].mEntry == NULL) break;
    if (i < MenuViewport.kaY)
        i = MenuViewport.kaY;
    if (i >= DefMenuSize)
        i = DefMenuSize - 1;
    NumEntries = i;

    for (i = 0; i < NumEntries; i++)
        if (DeviceMenu[i].mEntry == NULL) break;

    for (j = 0; (i < NumEntries) && SubCktList[j]; i++, j++) {
        DeviceMenu[i].mEntry = SubCktList[j];
        DeviceMenu[i].mActive = False;
    }

    DeviceMenu[i].mEntry = NULL;
    /*
    FixMenuPrefix(DeviceMenu);
    */
}

static void set_subckt_list ( )

static

Definition at line 267 of file subckt.c.

{
    struct m *MDesc;
    int i;
    int restart = False;

    if (Parameters.kpCellDesc == NULL)
        return;

top:
    for (MDesc = Parameters.kpCellDesc->sMasterList; MDesc;
            MDesc = MDesc->mSucc) {

        if (IsCellInLib(MDesc->mName))
            continue;

        for (i = 0; i < 80 && SubCktList[i]; i++)
            if (!strcmp(SubCktList[i],MDesc->mName))
                break;

        if (i == 80) {
            if (restart)
                return;
            for (i = 0; i < 80; i++) {
                free(SubCktList[i]);
                SubCktList[i] = NULL;
            }
            restart = True;
            goto top;
        }
        if (SubCktList[i] == NULL)
            SubCktList[i] = CopyString(MDesc->mName);
    }
}

void ShowNewInstance	(	long	X,
		long	Y,
		long	RefX,
		long	RefY
	)

Definition at line 212 of file subckt.c.

{
    struct ka BB, BB1;
    long TFold[9];
    long XX,YY;
    long DX,DY;
    int NumX,NumY,Int1,Int2;

    TCurrent(TFold);
    NumX = Parameters.kpNumX;
    NumY = Parameters.kpNumY;
    DX = Parameters.kpDX;
    DY = Parameters.kpDY;
    CDBB(CurInstance.Desc,(struct o *)NULL,&BB.kaLeft,
        &BB.kaBottom,&BB.kaRight,&BB.kaTop);
    /* Find translation so cell is always placed with lower left corner
     * at reference point or use the subckt's nodal reference point if
     * defined. */
    XX = BB.kaLeft;
    YY = BB.kaBottom;
    (void)get_reference_terminal(CurInstance.Desc,&XX,&YY);

    TPush();
    TIdentity();
    SetNewTransform(XX,YY,X,Y);
    TPremultiply();

    for (Int1 = NumY-1; Int1 >= 0; --Int1) {
        for (Int2 = 0; Int2 < NumX; ++Int2 ){
            TPush();
            TIdentity();
            TTranslate(Int2*DX,Int1*DY);
            TPremultiply();
            BB1.kaLeft = BB.kaLeft;
            BB1.kaRight = BB.kaRight;
            BB1.kaBottom = BB.kaBottom;
            BB1.kaTop = BB.kaTop;
            TPoint(&BB1.kaLeft,&BB1.kaBottom);
            TPoint(&BB1.kaRight,&BB1.kaTop);
            if (CurInstance.DevLib)
                ShowTransformed(CurInstance.Desc,&BB1,TFold);
            else {
                TLoadCurrent(TFold);
                ShowEmptyBox(HighlightingColor,&BB1);
            }
            TPop();
        }
    }
    TPop();
}

void UpdateParent

(

char *

NewName

)

Definition at line 770 of file subckt.c.

{
    char *TypeIn,*MasterName,Type;
    int NumX,NumY;
    long X,Y,DX,DY;
    struct s *CellDesc;
    struct o *Pointer;
    struct t *TGen;

    if (Context == NULL)
        return;

    ShowPrompt("Update parent cell to call new cell name? (n) ");
    TypeIn = FBEdit(NULL);
    if (TypeIn And (*TypeIn == 'y' Or *TypeIn == 'Y')) {
        /*Change the instance pushed from so its master is NewName.*/
        if (Not CDOpen(Context->ccMaster,&CellDesc,'w')) {
            sprintf(TypeOut,"Can't display %s. MORE",
                Context->ccMaster); 
            ShowPrompt(TypeOut);
            (void)FBGetchar(ERASE);
            ShowPrompt(CDStatusString);
            return;
        }
        CDCall(Context->ccInst,&MasterName,&NumX,&DX,&NumY,&DY);
        if (Not CDBeginMakeCall(
            CellDesc,NewName,NumX,DX,NumY,DY,&Pointer)) {
            if (CDStatusInt ==
                CDPARSEFAILED Or CDStatusInt == CDNEWSYMBOL) {
                sprintf(TypeOut,"Can't write cell %s. MORE",NewName);
                ShowPrompt(TypeOut);
                (void)FBGetchar(ERASE);
                ShowPrompt(CDStatusString); 
                return;
            }
            elif (CDStatusInt == CDMALLOCFAILED)
                MallocFailed();
        }
        CDInitTGen(Context->ccInst,&TGen);
        loop {
            CDTGen(&TGen,&Type,&X,&Y);
            if (TGen == NULL)
                break;
            if (Not CDT(Pointer,Type,X,Y))
                MallocFailed();
        }
        if (Not CDEndMakeCall(CellDesc,Pointer))
            MallocFailed();
        CDDelete(CellDesc,Context->ccInst);
        WroteCell = True;
        Context->ccModified = True; 
        Context->ccInst = Pointer;
    }
}

Variable Documentation

struct cc* Context

static

Definition at line 28 of file subckt.c.

struct rd CurInstance

static

Definition at line 40 of file subckt.c.

char* MenuNEWSC

Definition at line 92 of file scedintr.c.

char* MenuPLACE

Definition at line 94 of file scedintr.c.

char* MenuUNDO

Definition at line 108 of file scedintr.c.

char* SubCktList[80]

static

Definition at line 33 of file subckt.c.

int WroteCell

static

Definition at line 32 of file subckt.c.