netlist.c File Reference

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

Include dependency graph for netlist.c:

Go to the source code of this file.

Data Structures
struct	ww

Macros
#define	umalloc(u)   (union u*)tmalloc(sizeof(union u))

Functions
void	UpdateProperties (struct o *Pointer)
static void	update_device (struct o *odesc, refcnts)
void	AssignWireProperties (struct o *Pointer)
static void	spice_deck_sort ()
static int	lcomp ()
void	DoSpiceList ()
void	DumpSpiceFile (FILE *fp)
struct line *	MakeSpiceDeck ()
struct line *	SpiceList (struct s *CellDesc)
static void	spice_deck_sort (struct line *line)
static int	lcomp (char **s, char **t)
static int	is_wire_grounded ()
static void	set_wire_node ()
static void	connect_wires ()
static void	change_wire_node ()
static void	renumber_wires ()
static void	connect_wire_to_device ()
static void	connect_ground_to_device ()
static void	connect_devices ()
static void	set_device_node ()
static int	find_node ()
static void	ww_free ()
static void	p_free ()
void	ConnectRecursive (struct s *CellDesc)
void	Connect (struct s *CellDesc)
static int	is_wire_grounded (struct o *Pointer, struct p *Path)
static void	set_wire_node (struct o *Pointer, int indx)
static void	connect_wires (struct ww *WList, struct o *Pointer1, struct o *Pointer2)
static void	change_wire_node (struct ww *WList, int oldnode, int newnode)
static void	renumber_wires (struct ww *Wlist, int *count)
static void	connect_wire_to_device (struct o *Pointer1, struct o *Pointer2)
static void	connect_ground_to_device (struct o *Pointer, struct p *Path)
static void	connect_devices (struct o *Pointer1, struct o *Pointer2, int *count)
static void	set_device_node (struct o *Pointer, int *count)
static int	find_node (struct ww *Wlist, struct ww *Dlist, long X, long Y)
static void	ww_free (struct ww *w)
static void	p_free (struct p *w)
static int	prptyKB ()
static void	global_modify ()
static int	pType ()
void	ShowProperties (int *LookedAhead)
static int	prptyKB (struct o *Pointer, struct prpty *PDesc)
static int	pType (char c)
static void	insert_terminal ()
void	Subcircuit (int *LookedAhead)
static void	insert_terminal (long X, long Y)
int	SelectNode (long *Xo, long *Yo)
void	ShowTerminals ()
void	DisplayTerminals (int DisplayOrErase)
static int	device_node ()
void	TransformReferences (struct o *Pointer)
void	TransformReferencePoint (struct o *Pointer, long RefX, long RefY)
void	UndoReferenceTransform ()
void	ClearReferenceUndoFlags ()
static int	device_node (long X, long Y)

Variables
char *	MenuSPICE = "spice"
char *	MenuPRPTY
char *	MenuSUBCT
char *	MenuUNDO
char *	MenuTERMS

Macro Definition Documentation

#define umalloc

(

u

)

(union u*)tmalloc(sizeof(union u))

Definition at line 17 of file netlist.c.

Function Documentation

void AssignWireProperties

(

struct o *

Pointer

)

Definition at line 98 of file netlist.c.

{
    struct prpty *PDesc;

    PDesc = alloc(prpty);
    PDesc->prpty_Data = umalloc(prp_data);
    PDesc->prpty_Value = P_NODE;
    PDesc->prpty_Succ = Pointer->oPrptyList;
    Pointer->oPrptyList = PDesc;
}

static void change_wire_node ( )

static

static void change_wire_node ( struct ww *  WList, int  oldnode, int  newnode  )

static

Definition at line 774 of file netlist.c.

{
    struct prpty *PDesc;

    for (; WList; WList = WList->ww_next) {
        PDesc = WList->ww_ptr->oPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if (PDesc->prpty_Value != P_NODE) continue;
            if (PDesc->prpty_Data->p_node.enode == oldnode)
                PDesc->prpty_Data->p_node.enode = newnode;
            break;
        }
    }
}

void ClearReferenceUndoFlags

(

)

Definition at line 1893 of file netlist.c.

{
    struct prpty *PDesc;

    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        if (PDesc->prpty_Info == NULL) continue;
        free(PDesc->prpty_Info);
        PDesc->prpty_Info = NULL;
    }
}

void Connect

(

struct s *

CellDesc

)

Definition at line 539 of file netlist.c.

{
    struct g *GenDesc;
    struct o *Pointer;
    struct prpty *PDesc;
    struct ww *w0 = NULL, *d0 = NULL;
    struct p *g0 = NULL, *g;
    struct ww *w, *wx;
    struct m *MDesc;
    char *name;
    int i, count;
    int refcnts[128];

    /* Make a list of wires, and set the node to 0. */

    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 Or Pointer->oInfo == SQ_INCMPLT)
            continue;
        if (Pointer->oType == CDWIRE) {
            if (w0 == NULL)
                w = w0 = alloc(ww);
            else {
                w->ww_next = alloc(ww);
                w = w->ww_next;
            }
            w->ww_ptr = Pointer;
            PDesc = Pointer->oPrptyList;
            for (; PDesc; PDesc = PDesc->prpty_Succ) {
                if (PDesc->prpty_Value != P_NODE) continue;
                PDesc->prpty_Data->p_node.enode = 0;
                break;
            }
        }
    }
    if (w0 != NULL)
        w->ww_next = NULL;

    /* Set the reference counts to zero.  Entries are used as counters
     * for naming devices.
     */
    for (i = 0; i < 128; i++)
        refcnts[i] = 0;

    /* Make a list of devices, and a list of ground coordinates.
     * Set the device terminal nodes to -1.
     */

    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;

        name = ((struct c *)Pointer->oRep)->cMaster->mName;
        if (cieq(name,"gnd")) {
            /* ground device */
            if (g0 == NULL)
                g = g0 = alloc(p);
            else {
                g->pSucc = alloc(p);
                g = g->pSucc;
            }
            PDesc = Pointer->oPrptyList;
            for (; PDesc; PDesc = PDesc->prpty_Succ) {
                if (PDesc->prpty_Value != P_NODE) continue;
                g->pX = PDesc->prpty_Data->p_node.x;
                g->pY = PDesc->prpty_Data->p_node.y;
                break;
            }
        }
        else {
            if (d0 == NULL)
                w = d0 = alloc(ww);
            else {
                w->ww_next = alloc(ww);
                w = w->ww_next;
            }
            w->ww_ptr = Pointer;
            PDesc = Pointer->oPrptyList;
            for (; PDesc; PDesc = PDesc->prpty_Succ) {
                if (PDesc->prpty_Value != P_NODE) continue;
                PDesc->prpty_Data->p_node.enode = -1;
            }
        }
        update_device(Pointer, refcnts);
    }
    if (d0 != NULL)
        w->ww_next = NULL;
    if (g0 != NULL)
        g->pSucc = NULL;

    for (count = 0,w = w0; w; w = w->ww_next)
        if (!is_wire_grounded(w->ww_ptr,g0)) {
            count++;
            set_wire_node(w->ww_ptr,count);
        }

    for (w = w0; w; w = w->ww_next)
        for (wx = w->ww_next; wx; wx = wx->ww_next)
            connect_wires(w0,w->ww_ptr,wx->ww_ptr);

    renumber_wires(w0,&count);

    for (w = w0; w; w = w->ww_next)
        for (wx = d0; wx; wx = wx->ww_next)
            connect_wire_to_device(w->ww_ptr,wx->ww_ptr);

    for (w = d0; w; w = w->ww_next)
        connect_ground_to_device(w->ww_ptr,g0);

    for (w = d0; w; w = w->ww_next)
        for (wx = w->ww_next; wx; wx = wx->ww_next)
            connect_devices(w->ww_ptr,wx->ww_ptr,&count);

    for (w = d0; w; w = w->ww_next)
        set_device_node(w->ww_ptr,&count);

    /* now set the subckt connections */
    PDesc = CellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        PDesc->prpty_Data->p_node.enode = find_node(w0,d0,
            PDesc->prpty_Data->p_node.x,PDesc->prpty_Data->p_node.y);
    }

    ww_free(w0);
    ww_free(d0);
    p_free(g0);
}

static void connect_devices ( )

static

static void connect_devices ( struct o *  Pointer1, struct o*  Pointer2, int *  count  )

static

Definition at line 901 of file netlist.c.

{

    struct prpty *PDesc1,*PDesc2,*pd;
    int int11,int21;
    int X,Y;

    PDesc1 = Pointer1->oPrptyList;
    PDesc2 = Pointer2->oPrptyList;

    for (; PDesc1; PDesc1 = PDesc1->prpty_Succ) {
        if (PDesc1->prpty_Value != P_NODE) continue;

        X = PDesc1->prpty_Data->p_node.x;
        Y = PDesc1->prpty_Data->p_node.y;
        int11 = PDesc1->prpty_Data->p_node.enode;

        for (pd = PDesc2; pd; pd = pd->prpty_Succ) {
            if (pd->prpty_Value != P_NODE) continue;

            if (X == pd->prpty_Data->p_node.x &&
                Y == pd->prpty_Data->p_node.y) {

                int21 = pd->prpty_Data->p_node.enode;

                if (int11 < 0 && int21 >= 0) {
                    PDesc1->prpty_Data->p_node.enode = int21;
                    int11 = int21;
                }
                else if (int21 < 0 && int11 >= 0) {
                    pd->prpty_Data->p_node.enode = int11;
                }
                else if (int11 < 0 && int21 < 0) {
                    (*count)++;
                    PDesc1->prpty_Data->p_node.enode = *count;
                    pd->prpty_Data->p_node.enode = *count;
                    int11 = *count;
                }
                else if (int11 != int21) {
                    /* trouble */

                }
            }
        }
    }
}

static void connect_ground_to_device ( )

static

static void connect_ground_to_device ( struct o *  Pointer, struct p *  Path  )

static

Definition at line 877 of file netlist.c.

{
    struct prpty *PDesc;
    struct p *pp;

    for (PDesc = Pointer->oPrptyList; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        for (pp = Path; pp; pp = pp->pSucc) {
            if (pp->pX == PDesc->prpty_Data->p_node.x &&
                pp->pY == PDesc->prpty_Data->p_node.y) {
                PDesc->prpty_Data->p_node.enode = 0;
            }
        }
    }
}

static void connect_wire_to_device ( )

static

static void connect_wire_to_device ( struct o *  Pointer1, struct o*  Pointer2  )

static

Definition at line 840 of file netlist.c.

{
    struct p *p1, *pp;
    struct prpty *PDesc1,*PDesc2;
    int node1;

    p1 = ((struct w *)Pointer1->oRep)->wPath;
    PDesc1 = Pointer1->oPrptyList;
    node1 = -1;
    for (; PDesc1; PDesc1 = PDesc1->prpty_Succ) {
        if (PDesc1->prpty_Value != P_NODE) continue;
        node1 = PDesc1->prpty_Data->p_node.enode;
        break;
    }
    if (node1 < 0)
        /* trouble */
        return;

    PDesc2 = Pointer2->oPrptyList;
    for (; PDesc2; PDesc2 = PDesc2->prpty_Succ) {
        if (PDesc2->prpty_Value != P_NODE) continue;
        for (pp = p1; pp; pp = pp->pSucc) {
            if (pp->pX == PDesc2->prpty_Data->p_node.x &&
                pp->pY == PDesc2->prpty_Data->p_node.y) {
                PDesc2->prpty_Data->p_node.enode = node1;
            }
        }
    }
}

static void connect_wires ( )

static

static void connect_wires ( struct ww *  WList, struct o *  Pointer1, struct o*  Pointer2  )

static

Definition at line 720 of file netlist.c.

{
    struct p *p1,*p2,*pp;
    struct prpty *PDesc1,*PDesc2;
    int node1,node2;

    p1 = ((struct w *)Pointer1->oRep)->wPath;
    p2 = ((struct w *)Pointer2->oRep)->wPath;

    for (; p1; p1 = p1->pSucc) {
        for (pp = p2; pp; pp = pp->pSucc) {

            if (p1->pX == pp->pX && p1->pY == pp->pY) {

                PDesc1 = Pointer1->oPrptyList;
                PDesc2 = Pointer2->oPrptyList;

                node1 = node2 = -1;

                for (; PDesc1; PDesc1 = PDesc1->prpty_Succ) {
                    if (PDesc1->prpty_Value != P_NODE) continue;
                    node1 = PDesc1->prpty_Data->p_node.enode;
                    break;
                }
                for (; PDesc2; PDesc2 = PDesc2->prpty_Succ) {
                    if (PDesc2->prpty_Value != P_NODE) continue;
                    node2 = PDesc2->prpty_Data->p_node.enode;
                    break;
                }
                if (node1 < 0 || node2 < 0)
                    /* Things are foobar */
                    return;

                if (node1 == node2) return;

                if (node1 < node2)
                    change_wire_node(WList,node2,node1);
                else
                    change_wire_node(WList,node1,node2);
                return;
            }
        }
    }
}

void ConnectRecursive

(

struct s *

CellDesc

)

Definition at line 512 of file netlist.c.

{
    struct s *Desc, *TmpD;
    struct m *MDesc;

    Connect(CellDesc);

    /* need this for hypertext */
    TmpD = Parameters.kpCellDesc;
    Parameters.kpCellDesc = CellDesc;
    HYinit();

    /* now expand the subcircuits */
    MDesc = CellDesc->sMasterList;
    for (; MDesc; MDesc = MDesc->mSucc) {
        if (Not CDOpen(MDesc->mName,&Desc,'r')) continue;
        if (CDStatusInt == CDNEWSYMBOL Or CDStatusInt == CDPARSEFAILED)
            continue;
        ConnectRecursive(Desc);
    }
    Parameters.kpCellDesc = TmpD;
}

static int device_node ( )

static

static int device_node ( long  X, long  Y  )

static

Definition at line 1909 of file netlist.c.

{
    struct g *GenDesc;
    struct prpty *PDesc;
    struct o *Pointer;
    int Info;

    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;

        PDesc = Pointer->oPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if (PDesc->prpty_Value != P_NODE) continue;
            if (X == PDesc->prpty_Data->p_node.x &&
                Y == PDesc->prpty_Data->p_node.y) {
                tfree(GenDesc);
                return (True);
            }
        }
    }
    return (False);
}

void DisplayTerminals

(

int

DisplayOrErase

)

Definition at line 1729 of file netlist.c.

{
    struct prpty *PDesc;

    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        ShowMarker(DisplayOrErase,HighlightingColor,
            PDesc->prpty_Data->p_node.x,PDesc->prpty_Data->p_node.y,
            100,MARK_CROSS,0);
    }
}

void DoSpiceList

(

)

Definition at line 132 of file netlist.c.

{
    FILE *fp;
    char *c;
    struct line *d,*d0;

    sprintf(TypeOut,"%s",Parameters.kpCellName);
    if ((c = strchr(TypeOut,'.')) != NULL)
        *c = '\0';
    strcat(TypeOut,".ckt");
    fp = fopen(TypeOut,"w");
    if (fp == NULL) {
        ShowPrompt("Can't open netlist file.");
        return;
    }
    MenuSelect(MenuSPICE);
    sprintf(TypeOut + 80,"Netlist is in file %s.",TypeOut);
    ShowPrompt(TypeOut + 80);
    d0 = MakeSpiceDeck();
    for (d = d0; d; d = d->li_next)
        fprintf(fp,"%s\n",d->li_line);
    inp_deckfree(d0);
    fclose(fp);
    MenuDeselect(MenuSPICE);
}

void DumpSpiceFile

(

FILE *

fp

)

Definition at line 162 of file netlist.c.

{
    struct line *d0,*d,*d1;

    d0 = MakeSpiceDeck();
    for (d = d0; d; d = d->li_next) {
        if (d->li_actual != NULL) {
            for (d1 = d->li_actual; d1; d1 = d1->li_next)
                fprintf(fp,"%s\n",d1->li_line);
        }
        else
            fprintf(fp,"%s\n",d->li_line);
    }
    inp_deckfree(d0);
}

static int find_node ( )

static

static int find_node ( struct ww *  Wlist, struct ww*  Dlist, long  X, long  Y  )

static

Definition at line 976 of file netlist.c.

{
    struct ww *w;
    struct prpty *PDesc;
    struct p *Path;

    /* first look at device terminals */
    for (w = Dlist; w; w = w->ww_next) {
        PDesc = w->ww_ptr->oPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if (PDesc->prpty_Value != P_NODE) continue;
            if (X == PDesc->prpty_Data->p_node.x &&
                Y == PDesc->prpty_Data->p_node.y)
                return (PDesc->prpty_Data->p_node.enode);
        }
    }

    /* now check wire vertices */
    for (w = Wlist; w; w = w->ww_next) {
        Path = ((struct w *)w->ww_ptr->oRep)->wPath;
        for (; Path; Path = Path->pSucc) {
            if (X == Path->pX && Y == Path->pY) {
                PDesc = w->ww_ptr->oPrptyList;
                for (; PDesc; PDesc = PDesc->prpty_Succ) {
                    if (PDesc->prpty_Value != P_NODE) continue;
                    return (PDesc->prpty_Data->p_node.enode);
                }
            }
        }
    }
    return (-1);
}

static void global_modify ( )

static

Definition at line 1411 of file netlist.c.

{
    struct ks *SQDesc;
    struct prpty *pd;
    int val, InChar;
    char *name;
    struct hprlist *ht;

    ShowPrompt(
"Enter property type to globally add/repl (Model m  Value v  Init Cnd i): ");
top:
    if ((InChar = FBGetchar(DISPLAY)) == ESCAPE)
        return;
    val = pType(InChar);
    switch (val) {
        case P_MODEL:
            ShowPrompt("Model name? ");
            break;
        case P_VALUE:
            ShowPrompt("Value? ");
            break;
        case P_INITC:
            ShowPrompt("Initial Conditions? ");
            break;
        default:
            ShowPrompt("Bad entry, enter m,v,i or Esc to exit: ");
            goto top;
    }
    ht = FBHyEdit(NULL);
    if (ht == NULL)
        return;

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

        for (pd = SQDesc->ksPointer->oPrptyList; pd; pd = pd->prpty_Succ)
            if (pd->prpty_Value == val) break;
        if (pd) {
            HYfree((struct hprlist*)pd->prpty_Data);
            pd->prpty_Data = (union prp_data*)HYcopy(ht);
        }
        else {
            pd = alloc(prpty);
            pd->prpty_Value = val;
            pd->prpty_Data = (union prp_data*)HYcopy(ht);
            pd->prpty_Succ = SQDesc->ksPointer->oPrptyList;
            SQDesc->ksPointer->oPrptyList = pd;
        }
    }
    HYfree(ht);
    Parameters.kpModified = True;
}

static void insert_terminal ( )

static

static void insert_terminal ( long  X, long  Y  )

static

Definition at line 1590 of file netlist.c.

{
    struct prpty *PDesc;
    struct prpty *PPrev = NULL;

    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PPrev = PDesc,PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        if (X == PDesc->prpty_Data->p_node.x &&
            Y == PDesc->prpty_Data->p_node.y) {
            if (PPrev)
                PPrev->prpty_Succ = PDesc->prpty_Succ;
            else
                Parameters.kpCellDesc->sPrptyList = PDesc->prpty_Succ;
            ShowMarker(ERASE,0,X,Y,100,MARK_CROSS,0);
            free(PDesc->prpty_Data);
            free(PDesc);
            return;
        }
    }
    sprintf(TypeOut,"-1 0 %ld %ld",X,Y);
    if (Not CDAddProperty(Parameters.kpCellDesc,(struct o *)NULL,
        P_NODE,TypeOut))
        MallocFailed();
    ShowMarker(DISPLAY,HighlightingColor,X,Y,100,MARK_CROSS,0);
}

static int is_wire_grounded ( )

static

static int is_wire_grounded ( struct o *  Pointer, struct p *  Path  )

static

Definition at line 681 of file netlist.c.

{
    struct p *Wpath, *w;

    Wpath = ((struct w *)Pointer->oRep)->wPath;

    for (; Wpath; Wpath = Wpath->pSucc)
        for  (w = Path; w; w = w->pSucc)
            if (w->pX == Wpath->pX && w->pY == Wpath->pY)
                return (True);

    return (False);
}

static int lcomp ( )

static

static int lcomp ( char **  s, char **  t  )

static

Definition at line 462 of file netlist.c.

{
    return (strcmp(*s,*t));
}

struct line* MakeSpiceDeck

(

)

Definition at line 183 of file netlist.c.

{
    struct line *line,*d;
    int count;

    Connect(Parameters.kpCellDesc);
    sprintf(TypeOut,"Generated by SCED from file %s",Parameters.kpCellName);
    line = AllocateLine(TypeOut);
    line->li_next = SpiceList(Parameters.kpCellDesc);
    for (d = line; d->li_next; d = d->li_next) ;
    d->li_next = AllocateLine(".end");
    d->li_next->li_next = NULL;
    count = 0;
    for (d = line; d; d = d->li_next)
        d->li_linenum = count++;
    return (line);
}

static void p_free ( )

static

static void p_free ( struct p *  w )

static

Definition at line 1031 of file netlist.c.

{
    struct p *wn;

    for (; w; w = wn) {
        wn = w->pSucc;
        tfree(w);
    }
}

static int prptyKB ( )

static

static int prptyKB ( struct o *  Pointer, struct prpty *  PDesc  )

static

Definition at line 1235 of file netlist.c.

{
    struct prpty *pd;
    struct hprlist *ht;
    char InChar;
    int Value,pv;

    if ((InChar = FBGetchar(DISPLAY)) == ESCAPE)
        return (0);

    if (InChar == 'n' || InChar == 'N')
        return (-1);

    if (InChar == '\0' || InChar == '\n' || InChar == '\r')
        goto quit;

    if  (Pointer->oType == CDWIRE) {
        ShowPromptAndWait("Can't modify wire properties.");
        goto quit;
    }

    if (InChar == 'a' || InChar == 'A') {
        loop {
            Value = 0;
            ShowPrompt(
    "Enter property type to add (Model m  Value v  Init Cnd i  Other o): ");
            if ((InChar = FBGetchar(DISPLAY)) == ESCAPE)
                return (0);
            if (InChar == '\n' || InChar == '\r') {
                if (PDesc != NULL)
                    Value = PDesc->prpty_Value;
                else
                    continue;
            }
            else
                Value = pType(InChar);
            pv = Value;
            switch (Value) {
                case P_MODEL:
                    ShowPrompt("Model name? ");
                    break;
                case P_VALUE:
                    ShowPrompt("Value? ");
                    break;
                case P_INITC:
                    ShowPrompt("Initial Conditions? ");
                    break;
                case P_OTHER:
                    strcpy(TypeOut,"Load from? (");
                    pv = 0;
                    for (pd = Pointer->oPrptyList; pd; pd = pd->prpty_Succ)
                        if (pd->prpty_Value == P_MODEL) {
                            strcat(TypeOut,"Model m");
                            pv = 1;
                            break;
                        }
                    for (pd = Pointer->oPrptyList; pd; pd = pd->prpty_Succ)
                        if (pd->prpty_Value == P_VALUE) {
                            if (pv) strcat(TypeOut,"  ");
                            strcat(TypeOut,"Value v");
                            pv = 1;
                            break;
                        }
                    for (pd = Pointer->oPrptyList; pd; pd = pd->prpty_Succ)
                        if (pd->prpty_Value == P_INITC) {
                            if (pv) strcat(TypeOut,"  ");
                            strcat(TypeOut,"Init Cnd i");
                            pv = 1;
                            break;
                        }
                    if (pv) {
                        strcat(TypeOut,"): ");
                        ShowPrompt(TypeOut);
                        if ((InChar = FBGetchar(DISPLAY)) == ESCAPE)
                            goto quit;
                        pv = pType(InChar);
                    }
                    else
                        pv = P_OTHER;
                    ShowPrompt("Property String? ");
                    Value = P_OTHER;
                    break;
            }
            break;
        }
        if (PDesc && PDesc->prpty_Value == pv)
            pd = PDesc;
        else {
            if (pv == P_OTHER)
                pd = NULL;
            else
                for (pd = Pointer->oPrptyList; pd; pd = pd->prpty_Succ)
                    if (pd->prpty_Value == pv) break;
        }
        if (pd)
            ht = FBHyEdit((struct hprlist*)pd->prpty_Data);
        else
            ht = FBHyEdit(NULL);
        if (ht == NULL)
            return (0);

        if (Value == P_OTHER) {
            ShowPrompt("Also store in? (Model m  Value v  Inid Cnd i): ");
            if ((InChar = FBGetchar(DISPLAY)) == ESCAPE)
                goto quit;
            pv = pType(InChar);
            if (pv != P_OTHER) {
                for (pd = Pointer->oPrptyList; pd; pd = pd->prpty_Succ)
                    if (pd->prpty_Value == pv) break;
                if (pd) {
                    HYfree((struct hprlist*)pd->prpty_Data);
                    pd->prpty_Data = (union prp_data*)ht;
                }
                else {
                    pd = alloc(prpty);
                    pd->prpty_Value = pv;
                    pd->prpty_Data = (union prp_data*)ht;
                    pd->prpty_Succ = Pointer->oPrptyList;
                    Pointer->oPrptyList = pd;
                }
                ht = HYcopy(ht);
            }
        }
        if (PDesc && PDesc->prpty_Value == Value) {
            HYfree((struct hprlist*)PDesc->prpty_Data);
            PDesc->prpty_Data = (union prp_data*)ht;
        }
        else {
            for (pd = Pointer->oPrptyList; pd; pd = pd->prpty_Succ)
                if (pd->prpty_Value == Value) break;
            if (pd && Value != P_OTHER) {
                HYfree((struct hprlist*)pd->prpty_Data);
                pd->prpty_Data = (union prp_data*)ht;
            }
            else {
                pd = alloc(prpty);
                pd->prpty_Value = Value;
                pd->prpty_Data = (union prp_data*)ht;
                pd->prpty_Succ = Pointer->oPrptyList;
                Pointer->oPrptyList = pd;
            }
        }
        Parameters.kpModified = True;
    }
    else if (InChar == 'd' || InChar == 'D') {
        if (PDesc == NULL) {
            ShowPromptAndWait("No property to delete.");
            goto quit;
        }
        if (PDesc->prpty_Value >= 10) {
            ShowPromptAndWait("Can't delete internal properties.");
            goto quit;
        }
        pd = Pointer->oPrptyList;
        if (pd == PDesc)
            Pointer->oPrptyList = PDesc->prpty_Succ;
        else {
            /* must be in the list */
            for (; pd && pd->prpty_Succ != PDesc; pd = pd->prpty_Succ) ;
              pd->prpty_Succ = PDesc->prpty_Succ;
        }
        HYfree((struct hprlist*)PDesc->prpty_Data);
        tfree(PDesc);
        Parameters.kpModified = True;
        ShowPromptAndWait("Property deleted.");
    }
quit:
    return (1);
}

static int pType ( )

static

static int pType ( char  c )

static

Definition at line 1469 of file netlist.c.

{
    switch (c) {
        case '1':
        case 'm':
        case 'M':
            return (P_MODEL);
        case '2':
        case 'v':
        case 'V':
            return (P_VALUE);
        case '3':
        case 'i':
        case 'I':
            return (P_INITC);
        default:
            return (P_OTHER);
    }
}

static void renumber_wires ( )

static

static void renumber_wires ( struct ww *  Wlist, int *  count  )

static

Definition at line 795 of file netlist.c.

{
    struct ww *w;
    struct prpty *PDesc;
    int *itmp,i,sum;

    itmp = (int *) malloc((*count+1)*sizeof(int));
    if (itmp == NULL) MallocFailed();

    for (i = 0; i <= *count; i++)
        *(itmp+i) = 0;

    for (w = Wlist; w; w = w->ww_next) {
        PDesc =  w->ww_ptr->oPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if  (PDesc->prpty_Value != P_NODE) continue;
            if (PDesc->prpty_Data->p_node.enode == 0) continue;
            itmp[PDesc->prpty_Data->p_node.enode] = 1;
        }
    }

    for (sum = 0,i = 1; i <= *count; i++) {
        sum += itmp[i];
        itmp[i]  = sum;
    }
    *count = sum;

    for (w = Wlist; w; w = w->ww_next) {
        PDesc =  w->ww_ptr->oPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if  (PDesc->prpty_Value != P_NODE) continue;
            if (PDesc->prpty_Data->p_node.enode == 0) continue;
            PDesc->prpty_Data->p_node.enode =
                itmp[PDesc->prpty_Data->p_node.enode];
        }
    }
    free(itmp);
}

int SelectNode	(	long *	Xo,
		long*	Yo
	)

Definition at line 1624 of file netlist.c.

{
    struct ka AOI;
    struct g *GenDesc;
    struct o *Pointer;
    struct p *Path;
    struct prpty *PDesc;
    int Layer,Delta;
    long X,Y,Width,*xy;


    if (SCursor.kcInFine == True)
        Delta = 5.0/View->kvFineRatio;
    else
        Delta = 5.0/View->kvCoarseRatio;

    AOI.kaLeft = *Xo - Delta;
    AOI.kaRight = *Xo + Delta;
    AOI.kaBottom = *Yo - Delta;
    AOI.kaTop = *Yo + Delta;

    /* first check subcircuit terminals */
    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        X = PDesc->prpty_Data->p_node.x;
        Y = PDesc->prpty_Data->p_node.y;

        if (InBox(X,Y,&AOI)) {
            *Xo = X;
            *Yo = Y;
            return (True);
        }
    }

    /* next check the devices */
    if (Not CDInitGen(Parameters.kpCellDesc,0,AOI.kaLeft,AOI.kaBottom,
        AOI.kaRight,AOI.kaTop,&GenDesc)) MallocFailed();
    loop {
        CDGen(Parameters.kpCellDesc,GenDesc,&Pointer);
        if (Pointer == NULL) break;
        if (Pointer->oInfo == SQ_GONE) continue;

        PDesc = Pointer->oPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if (PDesc->prpty_Value != P_NODE) continue;
            X = PDesc->prpty_Data->p_node.x;
            Y = PDesc->prpty_Data->p_node.y;

            if (InBox(X,Y,&AOI)) {
                tfree(GenDesc);
                *Xo = X;
                *Yo = Y;
                return (True);
            }
        }
    }

    /* now check wires */
    if (Not CDInitGen(Parameters.kpCellDesc,1,AOI.kaLeft,AOI.kaBottom,
        AOI.kaRight,AOI.kaTop,&GenDesc)) MallocFailed();
    loop {
        CDGen(Parameters.kpCellDesc,GenDesc,&Pointer);
        if (Pointer == NULL) break;
        if (Pointer->oInfo == SQ_GONE) continue;
        if (Pointer->oType != CDWIRE) continue;
        CDWire(Pointer,&Layer,&Width,&Path);

        for (; Path; Path = Path->pSucc)
            if (InBox(Path->pX,Path->pY,&AOI)) {
                tfree(GenDesc);
                *Xo = Path->pX;
                *Yo = Path->pY;
                return (True);
            }
    }
    return (False);
}

static void set_device_node ( )

static

static void set_device_node ( struct o *  Pointer, int *  count  )

static

Definition at line 957 of file netlist.c.

{
    struct prpty *PDesc;

    PDesc = Pointer->oPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        if (PDesc->prpty_Data->p_node.enode >= 0) continue;
        (*count)++;
        PDesc->prpty_Data->p_node.enode = *count;
    }
}

static void set_wire_node ( )

static

static void set_wire_node ( struct o *  Pointer, int  indx  )

static

Definition at line 703 of file netlist.c.

{
    struct prpty *PDesc;

    PDesc = Pointer->oPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ)
        if (PDesc->prpty_Value == P_NODE) break;
    if (PDesc == NULL) return;
    PDesc->prpty_Data->p_node.enode = indx;
}

void ShowProperties

(

int *

LookedAhead

)

Definition at line 1065 of file netlist.c.

{
    struct prpty *PDesc;
    struct ks *SQDesc;
    char Types[4], *TypeIn;
    int Pret;
    int GotOne = False;
    char *s;

    Types[0]= CDSYMBOLCALL;
    Types[1]= CDWIRE;
    Types[2] = '\0';

    MenuSelect(MenuPRPTY);
    ConnectRecursive(Parameters.kpCellDesc);

    if (AreTypesInQ(Types))
        GotOne = True;
top:
    if (!GotOne) {
        ShowPrompt(
"Select object, at \">\" hit ENTER or a (add/repl), d (delete), n (break).");
        switch (PointLoop(LookedAhead)) {
            case PL_ESC:
            case PL_CMD:
            case PL_UND:
                goto quit;
            case PL_PCW:
                SelectTypes(Types);
                if (Not AreTypesInQ(Types))
                    goto top;
        }
    }
    else {
        ShowPrompt(
"Hit * for global, at \">\" hit a (add/repl), d (delete), n (next), ENTER.");

        switch (FBGetchar(ERASE)) {
            case ESCAPE:
                goto quit;
            case '*':
                global_modify();
                goto quit;
            default:
                SQComputeBB();
                Parameters.kpEnableSelectQRedisplay = False;
                EraseBox(&SelectQBB);
                Redisplay(&SelectQBB);
                break;
        }
    }

    for (SQDesc = SelectQHead; SQDesc; SQDesc = SQDesc->ksSucc) {
        if (SQDesc->ksPointer->oType != CDSYMBOLCALL &&
            SQDesc->ksPointer->oType != CDWIRE) continue;
        ShowCurrentObject(SQDesc->ksPointer,DISPLAY);
        PDesc = SQDesc->ksPointer->oPrptyList;
        if (PDesc == NULL) {
            ShowPrompt("Object has no properties.  > ");
            if (prptyKB(SQDesc->ksPointer,NULL) == 0) goto quit;
            continue;
        }
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if (SQDesc->ksPointer->oType == CDWIRE) {
                if (PDesc->prpty_Value == P_NODE) {
                    sprintf(TypeOut,"Wire Node Number (internal): %d   > ",
                        PDesc->prpty_Data->p_node.enode);
                    ShowPrompt(TypeOut);
                }
                if ((Pret = prptyKB(SQDesc->ksPointer,NULL)) == 0)
                    goto quit;
                if (Pret == -1) goto next;
                continue;
            }

            switch (PDesc->prpty_Value) {
                case P_MODEL:
                    sprintf(TypeOut,"Model: %s   > ",
                        s = HYtostr((struct hprlist*)PDesc->prpty_Data));
                    ShowPrompt(TypeOut);
                    txfree(s);
                    if ((Pret = prptyKB(SQDesc->ksPointer,PDesc)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
                case P_VALUE:
                    sprintf(TypeOut,"Value: %s   > ",
                        s = HYtostr((struct hprlist*)PDesc->prpty_Data));
                    ShowPrompt(TypeOut);
                    txfree(s);
                    if ((Pret = prptyKB(SQDesc->ksPointer,PDesc)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
                case P_INITC:
                    sprintf(TypeOut,"Initial Conditions: %s   > ",
                        s = HYtostr((struct hprlist*)PDesc->prpty_Data));
                    ShowPrompt(TypeOut);
                    txfree(s);
                    if ((Pret = prptyKB(SQDesc->ksPointer,PDesc)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
                case P_OTHER:
                    sprintf(TypeOut,"External Property: %s   > ",
                        s = HYtostr((struct hprlist*)PDesc->prpty_Data));
                    ShowPrompt(TypeOut);
                    txfree(s);
                    if ((Pret = prptyKB(SQDesc->ksPointer,PDesc)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
                case P_NAME:
                    sprintf(TypeOut,"Device Name (internal): %s%d   > ",
                        PDesc->prpty_Data->p_name.name,
                        PDesc->prpty_Data->p_name.num);
                    ShowPrompt(TypeOut);
                    if ((Pret = prptyKB(SQDesc->ksPointer,NULL)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
                case P_NODE:
                    sprintf(TypeOut,"Node Number (internal): %d   > ",
                        PDesc->prpty_Data->p_node.enode);
                    ShowPrompt(TypeOut);
                    if ((Pret = prptyKB(SQDesc->ksPointer,NULL)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
                case P_BRANCH:
                    sprintf(TypeOut,"Branch (internal)  > ");
                    ShowPrompt(TypeOut);
                    if ((Pret = prptyKB(SQDesc->ksPointer,NULL)) == 0)
                        goto quit;
                    if (Pret == -1) goto next;
                    break;
            }
        }
next:
        ShowCurrentObject(SQDesc->ksPointer,ERASE);
    }
    if (!GotOne) {
        SQComputeBB();
        SQDesel(Types);
        EraseBox(&SelectQBB);
        Redisplay(&SelectQBB);
        goto top;
    }
quit:
    ShowCurrentObject(NULL,ERASE);
    if (!GotOne) {
        if (AreTypesInQ(Types)) {
            SQComputeBB();
            SQDesel(Types);
            EraseBox(&SelectQBB);
            Redisplay(&SelectQBB);
        }
    }
    else {
        Parameters.kpEnableSelectQRedisplay = True;
        SQShow();
    }
    ErasePrompt();
    MenuDeselect(MenuPRPTY);
}

void ShowTerminals

(

)

Definition at line 1710 of file netlist.c.

{

    if (Parameters.kpShowTerminals) {
        MenuDeselect(MenuTERMS);
        Parameters.kpShowTerminals = False;
        DisplayTerminals(ERASE);
    }
    else {
        MenuSelect(MenuTERMS);
        Parameters.kpShowTerminals = True;
        DisplayTerminals(DISPLAY);
    }    
}

static void spice_deck_sort ( )

static

static void spice_deck_sort ( struct line *  line )

static

Definition at line 434 of file netlist.c.

{
    struct line *l;
    char **stuff;
    int i;

    for (i = 0,l = line; l; i++,l = l->li_next) ;
    if (i < 2) return;
    stuff = (char **)malloc(i*sizeof(char *));
    if (stuff == NULL) MallocFailed();
    for (i = 0, l = line; l; i++,l = l->li_next)
        stuff[i] = l->li_line;
    qsort((char *) stuff, i, sizeof (char *),
#if __STDC__
        (int(*)(const void*,const void*))lcomp);
#else
        lcomp);
#endif
    for (i = 0, l = line; l; i++,l = l->li_next)
        l->li_line = stuff[i];
    free(stuff);
    return;
}

struct line* SpiceList

(

struct s *

CellDesc

)

Definition at line 205 of file netlist.c.

{
    struct g *GenDesc;
    struct o *Pointer;
    struct s *Desc, *TmpD;
    struct m *MDesc;
    struct prpty *PDesc;
    struct line *d,*d1,*d0 = NULL;
    union prp_data *p_data;
    int nodes[20];
    int foundsc;
    int i,maxn;
    char *device, *subname;
    char *value,*model, *extra;
    char *name, *s;

    QueueModel(NULL);

    /* need this for hypertext */
    TmpD = Parameters.kpCellDesc;
    Parameters.kpCellDesc = CellDesc;
    HYinit();

    /* first add device and subcircuit 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;
        /* skip gnd */
        name = ((struct c *)Pointer->oRep)->cMaster->mName;
        if (cieq(name,"gnd")) continue;

        PDesc = Pointer->oPrptyList;

        for (i = 0; i < 20; i++)
            nodes[i] = 0;
        maxn = 0;
        device = NULL;
        subname = NULL;
        model = NULL;
        value = NULL;
        extra = NULL;

        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            p_data = PDesc->prpty_Data;
            switch (PDesc->prpty_Value) {
                case P_NODE:
                    nodes[p_data->p_node.inode] = p_data->p_node.enode;
                    if (maxn < p_data->p_node.inode)
                        maxn = p_data->p_node.inode;
                    continue;
                case P_NAME:
                    device = tmalloc(strlen(p_data->p_name.name)+10);
                    sprintf(device,"%s%d",
                        p_data->p_name.name,p_data->p_name.num);
                    if (p_data->p_name.subname) {
                        subname = CopyString(p_data->p_name.subname);
                    }
                    continue;
                case P_MODEL:
                    if (p_data) {
                        model = HYtostr((struct hprlist*)p_data);
                        QueueModel(model);
                    }
                    continue;
                case P_VALUE:
                    if (p_data) {
                        value = HYtostr((struct hprlist*)p_data);
                    }
                    continue;
                case P_INITC:
                    if (p_data) {
                        extra = HYtostr((struct hprlist*)p_data);
                    }
                    continue;
            }
        }
        if (!device)
            /* should never happen */
            continue;

        for (s = TypeOut,i = 0; i <= maxn; i++) {
            sprintf(s," %d",nodes[i]);
            while (*s) s++;
        }
        i = strlen(device) + strlen(TypeOut) + 1;
        if (subname)
            i += strlen(subname) + 1;
        if (model)
            i += strlen(model) + 1;
        if (value)
            i += strlen(value) + 1;
        if (extra)
            i += strlen(extra) + 1;

        device = trealloc(device,i+1);
        s = device;
        while (*s) s++;
        *s++ = ' ';
        strcpy(s,TypeOut);
        while (*s) s++;
        if (subname) {
            *s++ = ' ';
            strcpy(s,subname);
            free(subname);
            while (*s) s++;
        }
        if (model) {
            *s++ = ' ';
            strcpy(s,model);
            free(model);
            while (*s) s++;
        }
        if (value) {
            *s++ = ' ';
            strcpy(s,value);
            free(value);
            while (*s) s++;
        }
        if (extra) {
            *s++ = ' ';
            strcpy(s,extra);
            free(extra);
            while (*s) s++;
        }

        if (d0 == NULL)
            d = d0 = AllocateLine(device);
        else {
            d->li_next = AllocateLine(device);
            d = d->li_next;
        }
        txfree(device);
    }

    d1 = PrintMutual(CellDesc);
    if (d0 == NULL)
        d = d0 = d1;
    else {
        d->li_next = d1;
    }
    for (; d->li_next; d = d->li_next) ;
    
    /* sort the element cards */
    spice_deck_sort(d0);

    /* now expand the subcircuits */
    MDesc = CellDesc->sMasterList;
    for (; MDesc; MDesc = MDesc->mSucc) {
        if (Not CDOpen(MDesc->mName,&Desc,'r')) continue;
        if (CDStatusInt == CDNEWSYMBOL Or CDStatusInt == CDPARSEFAILED)
            continue;
        for (i = 0; i < 20; i++)
            nodes[i] = 0;
        maxn = 0;
        subname = NULL;
        PDesc = Desc->sPrptyList;
        Connect(Desc);
        foundsc = False;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            p_data = PDesc->prpty_Data;
            switch (PDesc->prpty_Value) {
                case P_NODE:
                    nodes[p_data->p_node.inode] = p_data->p_node.enode;
                    if (maxn < p_data->p_node.inode)
                        maxn = p_data->p_node.inode;
                    continue;
                case P_NAME:
                    /* The third entry in the name field signifies
                     * a subcircuit.  Devices from the library
                     * have only two entries.
                     */
                    if (p_data->p_name.subname == NULL)
                        goto next;
                    subname = CopyString(p_data->p_name.subname);
                    foundsc = True;
                    continue;
                case P_MODEL:
                case P_VALUE:
                case P_INITC:
                    continue;
            }
        }
        if (foundsc) {
            sprintf(TypeOut,".subckt %s",subname);
            s = TypeOut;
            while (*s) s++;
            for (i = 0; i <= maxn; i++) {
                sprintf(s," %d",nodes[i]);
                while (*s) s++;
            }
            if (d0 == NULL)
                d = d0 = AllocateLine(TypeOut);
            else {
                d->li_next = AllocateLine(TypeOut);
                d = d->li_next;
            }
            d->li_next = SpiceList(Desc);
            sprintf(TypeOut,".ends %s",subname);
            free(subname);
            for (; d->li_next; d = d->li_next) ;
            d->li_next = AllocateLine(TypeOut);
            d = d->li_next;
        }
next:
        ;
    }
    d1 = PrintModels();

    if (d0 == NULL)
        d0 = d1;
    else
        d->li_next = d1;

    Parameters.kpCellDesc = TmpD;
    return (d0);
}

void Subcircuit

(

int *

LookedAhead

)

Definition at line 1510 of file netlist.c.

{
    struct prpty *PDesc;
    int setone,count,int1,int2;
    long X,Y,OldX,OldY;

    MenuSelect(MenuSUBCT);
    ShowPrompt("Point to subcircuit connection points (ESC to exit).");

    DisplayTerminals(DISPLAY);
    loop {
        switch (PointLoop(LookedAhead)) {
            case PL_CMD:
                if (!strcmp(Parameters.kpCommand,MenuSUBCT))
                    *LookedAhead = False;
            case PL_ESC:
                goto quit;
            case PL_UND:
                MenuSelect(MenuUNDO);
                if (setone > 0) {
                    insert_terminal(OldX,OldY);
                    MenuDeselect(MenuUNDO);
                }
                else
                    goto quit;
                break;
            case PL_PCW:
                X = SCursor.kcX;
                Y = SCursor.kcY;
                if (!SelectNode(&X,&Y)) continue;
                insert_terminal(X,Y);
                Parameters.kpModified = True;
                setone = True;
                OldX = X;
                OldY = Y;
        }
    }
quit:

    /* The first (or earliest) terminal assigned is the
     * reference terminal.  This is last on the list.
     */
    count = 0;
    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        count++;
    }
    if (count) {
        PDesc = Parameters.kpCellDesc->sPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ) {
            if (PDesc->prpty_Value != P_NODE) continue;
            count--;
            PDesc->prpty_Data->p_node.enode = -1;
            PDesc->prpty_Data->p_node.inode = count;
            ShowMarker(ERASE,0,PDesc->prpty_Data->p_node.x,
                PDesc->prpty_Data->p_node.y,100,MARK_CROSS,0);
        }
        /* subckts have 3 entries in name field */
        PDesc = Parameters.kpCellDesc->sPrptyList;
        for (; PDesc; PDesc = PDesc->prpty_Succ)
            if (PDesc->prpty_Value == P_NAME) break;
        if (!PDesc) {
            sprintf(TypeOut,"X 0 %s",Parameters.kpCellName);
            if (Not CDAddProperty(Parameters.kpCellDesc,(struct o *)NULL,
                P_NAME,TypeOut))
                MallocFailed();
        }
    }
    
    MenuDeselect(MenuUNDO);
    MenuDeselect(MenuSUBCT);
    ErasePrompt();
}

void TransformReferencePoint	(	struct o *	Pointer,
		long	RefX,
		long	RefY
	)

Definition at line 1842 of file netlist.c.

{
    struct prpty *PDesc;
    long X,Y;

    if (Pointer->oType != CDWIRE) return;

    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        X = PDesc->prpty_Data->p_node.x;
        Y = PDesc->prpty_Data->p_node.y;
        if (RefX == X && RefY == Y) {
            TPoint(&X,&Y);
            PDesc->prpty_Info = (char*)PDesc->prpty_Data;
            PDesc->prpty_Data = umalloc(prp_data);
            PDesc->prpty_Data->p_node.x = X;
            PDesc->prpty_Data->p_node.y = Y;
            PDesc->prpty_Data->p_node.enode =
              ((union prp_data*)PDesc->prpty_Info)->p_node.enode;
            PDesc->prpty_Data->p_node.inode = 
              ((union prp_data*)PDesc->prpty_Info)->p_node.inode;
        }
    }
}

void TransformReferences

(

struct o *

Pointer

)

Definition at line 1760 of file netlist.c.

{
    struct ka BB;
    struct prpty *PDesc;
    struct p *Path;
    int Layer;
    long X,Y,Width,X1,Y1,X2,Y2;
    long *InPath();

    CDBB(Parameters.kpCellDesc,Pointer,
        &BB.kaLeft,&BB.kaBottom,&BB.kaRight,&BB.kaTop);

    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        switch (PDesc->prpty_Value) {
            case P_NODE:
                X = PDesc->prpty_Data->p_node.x;
                Y = PDesc->prpty_Data->p_node.y;
                if (!InBox(X,Y,&BB)) continue;
                switch (Pointer->oType) {
                    case CDWIRE:
                        CDWire(Pointer,&Layer,&Width,&Path);
                        if (InPath(20,Path,X,Y) == NULL) continue;
                        if (device_node(X,Y)) continue;
                    case CDSYMBOLCALL:
                        TPoint(&X,&Y);
                        PDesc->prpty_Info = (char*)PDesc->prpty_Data;
                        PDesc->prpty_Data = umalloc(prp_data);
                        PDesc->prpty_Data->p_node.x = X;
                        PDesc->prpty_Data->p_node.y = Y;
                        PDesc->prpty_Data->p_node.enode =
                          ((union prp_data*)PDesc->prpty_Info)->p_node.enode;
                        PDesc->prpty_Data->p_node.inode = 
                          ((union prp_data*)PDesc->prpty_Info)->p_node.inode;
                }
                continue;
            case P_MUT:
                /* get the transformed lower left corner */
                if (Pointer->oType != CDSYMBOLCALL) continue;
                X = PDesc->prpty_Data->p_mut.x1;
                Y = PDesc->prpty_Data->p_mut.y1;
                X1 = PDesc->prpty_Data->p_mut.x2;
                Y1 = PDesc->prpty_Data->p_mut.y2;
                if (X == BB.kaLeft && Y == BB.kaBottom) {
                    X2 = BB.kaRight;
                    Y2 = BB.kaTop;
                    TPoint(&X,&Y);
                    TPoint(&X2,&Y2);
                    if (X > X2) X = X2;
                    if (Y > Y2) Y = Y2;
                }
                else if (X1 == BB.kaLeft && Y1 == BB.kaBottom) {
                    X2 = BB.kaRight;
                    Y2 = BB.kaTop;
                    TPoint(&X1,&Y1);
                    TPoint(&X2,&Y2);
                    if (X1 > X2) X1 = X2;
                    if (Y1 > Y2) Y1 = Y2;
                }
                else
                    continue;
                PDesc->prpty_Info = (char*)PDesc->prpty_Data;
                PDesc->prpty_Data = umalloc(prp_data);
                PDesc->prpty_Data->p_mut.x1 = X;
                PDesc->prpty_Data->p_mut.y1 = Y;
                PDesc->prpty_Data->p_mut.x2 = X1;
                PDesc->prpty_Data->p_mut.y2 = Y1;
                PDesc->prpty_Data->p_mut.coeff =
                    ((union prp_data*)PDesc->prpty_Info)->p_mut.coeff;
                continue;
        }
    }
}

void UndoReferenceTransform

(

)

Definition at line 1876 of file netlist.c.

{
    struct prpty *PDesc;

    PDesc = Parameters.kpCellDesc->sPrptyList;
    for (; PDesc; PDesc = PDesc->prpty_Succ) {
        if (PDesc->prpty_Value != P_NODE) continue;
        if (PDesc->prpty_Info == NULL) continue;
        free(PDesc->prpty_Data);
        PDesc->prpty_Data = (union prp_data*)PDesc->prpty_Info;
        PDesc->prpty_Info = NULL;
    }
}

static void update_device ( struct o *  odesc, refcnts    )

static

Definition at line 66 of file netlist.c.

{
    struct prpty *pdesc;

    for (pdesc = odesc->oPrptyList; pdesc; pdesc = pdesc->prpty_Succ) {
        if (pdesc->prpty_Value == P_NAME) {
            if (pdesc->prpty_Data->p_name.subname == NULL) {
                /* a device */
                pdesc->prpty_Data->p_name.num =
                    ++(refcnts[(*pdesc->prpty_Data->p_name.name & 0x7f)]);
            }
            else {
                /* a subcircuit */
                pdesc->prpty_Data->p_name.num = ++(refcnts['X']);
                return;
            }
            break;
        }
    }
}

void UpdateProperties

(

struct o *

Pointer

)

Definition at line 27 of file netlist.c.

{
    struct prpty *PDesc;
    long X,Y;

    for (PDesc = Pointer->oPrptyList; PDesc; PDesc = PDesc->prpty_Succ) {
        switch (PDesc->prpty_Value) {
            case P_NODE:
                TPoint((long*)&PDesc->prpty_Data->p_node.x,
                    (long*)&PDesc->prpty_Data->p_node.y);
                continue;
            case P_MUT:
                TPoint((long*)&PDesc->prpty_Data->p_mut.x1,
                    (long*)&PDesc->prpty_Data->p_mut.y1);
                TPoint((long*)&PDesc->prpty_Data->p_mut.x2,
                    (long*)&PDesc->prpty_Data->p_mut.y2);
                continue;
            case P_BRANCH:
                TPoint((long*)&PDesc->prpty_Data->p_branch.x,
                    (long*)&PDesc->prpty_Data->p_branch.y);
                TPoint((long*)&PDesc->prpty_Data->p_branch.r1,
                    (long*)&PDesc->prpty_Data->p_branch.r2);
                X = 0;
                Y = 0;
                TPoint(&X,&Y);
                PDesc->prpty_Data->p_branch.r1 -= X;
                PDesc->prpty_Data->p_branch.r2 -= Y;
                continue;
        }
    }
}

static void ww_free ( )

static

static void ww_free ( struct ww *  w )

static

Definition at line 1017 of file netlist.c.

{
    struct ww *wn;

    for (; w; w = wn) {
        wn = w->ww_next;
        tfree(w);
    }
}

Variable Documentation

char* MenuPRPTY

Definition at line 97 of file scedintr.c.

char* MenuSPICE = "spice"

Definition at line 128 of file netlist.c.

char* MenuSUBCT

Definition at line 106 of file scedintr.c.

char* MenuTERMS

Definition at line 107 of file scedintr.c.

char* MenuUNDO

Definition at line 108 of file scedintr.c.