electron
/
kicad
mirror of https://gitlab.com/kicad/code/kicad.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
kicad/eeschema/netlist.cpp

1045 lines
30 KiB
C++
Raw Blame History

/***********************************/
/* Module de calcul de la Netliste */
/***********************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"
#include "general.h"
#include "netlist.h" /* Definitions generales liees au calcul de netliste */
#include "protos.h"
/* Routines locales */
static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus );
static void SheetLabelConnection(ObjetNetListStruct *SheetLabel);
static int ListeObjetConnection(WinEDA_SchematicFrame * frame, SCH_SCREEN *screen, ObjetNetListStruct *ObjNet);
static int ConvertBusToMembers(ObjetNetListStruct *ObjNet);
static void PointToPointConnect(ObjetNetListStruct *RefObj, int IsBus,
int start);
static void SegmentToPointConnect(ObjetNetListStruct *Jonction, int IsBus,
int start);
static void LabelConnection(ObjetNetListStruct *Label);
static int TriNetCode(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2);
static void ConnectBusLabels( ObjetNetListStruct *Label, int NbItems );
static void SetUnconnectedFlag( ObjetNetListStruct *ObjNet, int NbItems );
static int TriBySheet(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2);
/* Variable locales */
static int FirstNumWireBus, LastNumWireBus, RootBusNameLength;
static int LastNetCode, LastBusNetCode;
static int s_PassNumber;
/***********************************************************************/
void FreeTabNetList(ObjetNetListStruct * TabNetItems, int NbrNetItems)
/***********************************************************************/
/*
Routine de liberation memoire des tableaux utilises pour le calcul
de la netliste
TabNetItems = pointeur sur le tableau principal (liste des items )
NbrNetItems = nombre d'elements
*/
{
int i;
/* Liberation memoire des strings du champ Label reserve par ConvertBusToMembers */
for (i = 0; i < NbrNetItems; i++)
{
switch( TabNetItems[i].m_Type )
{
case NET_PIN:
case NET_SHEETLABEL:
case NET_SEGMENT:
case NET_JONCTION:
case NET_BUS:
case NET_LABEL:
case NET_GLOBLABEL:
case NET_PINLABEL:
case NET_NOCONNECT:
break;
case NET_GLOBBUSLABELMEMBER:
case NET_SHEETBUSLABELMEMBER:
case NET_BUSLABELMEMBER:
delete TabNetItems[i].m_Label;
break;
}
}
MyFree(TabNetItems);
}
/*****************************************************/
void * WinEDA_SchematicFrame::BuildNetListBase(void)
/*****************************************************/
/* Routine qui construit le tableau des elements connectes du projet
met a jour:
g_TabObjNet
g_NbrObjNet
*/
{
int NetNumber, SheetNumber;
int i, istart, NetCode;
SCH_SCREEN * screen;
ObjetNetListStruct * BaseTabObjNet;
wxString msg;
wxBusyCursor Busy;
NetNumber = 1;
s_PassNumber = 0;
MsgPanel->EraseMsgBox();
Affiche_1_Parametre(this, 1,_("List"), wxEmptyString, LIGHTRED);
/* Build the screen list */
EDA_ScreenList ScreenList(NULL);
/* 1ere passe : Comptage du nombre d'objet de Net */
g_NbrObjNet = 0;
g_TabObjNet = NULL; /* Init pour le 1er passage dans ListeObjetConnection */
/* Update the sheet number, sheet count and date and count nelist items */
ScreenSch->SetModify();
int kk = 1;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{
screen->m_SheetNumber = kk++;
screen->m_NumberOfSheet = ScreenList.GetCount();
screen->m_Date = GenDate();
g_NbrObjNet += ListeObjetConnection(this, screen, NULL);
}
if( g_NbrObjNet == 0 )
{
DisplayError(this, _("No component"), 20);
return(NULL);
}
i = sizeof(ObjetNetListStruct) * g_NbrObjNet;
BaseTabObjNet = g_TabObjNet = (ObjetNetListStruct *) MyZMalloc(i);
if( BaseTabObjNet == NULL ) return(NULL);
/* 2eme passe : Remplissage des champs des structures des objets de Net */
s_PassNumber ++;
Affiche_1_Parametre(this, 1,_("List"), wxEmptyString,RED);
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{
g_TabObjNet += ListeObjetConnection(this, screen, g_TabObjNet );
}
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),RED);
msg.Printf( wxT("%d"), g_NbrObjNet);
Affiche_1_Parametre(this, 8, _("NbItems"),msg,GREEN);
/* Recherche des connections pour les Segments et les Pins */
/* Tri du Tableau des objets de Net par Sheet */
qsort(BaseTabObjNet, g_NbrObjNet, sizeof(ObjetNetListStruct),
(int (*)(const void *, const void *)) TriBySheet);
Affiche_1_Parametre(this, 18,_("Conn"), wxEmptyString,CYAN);
g_TabObjNet = BaseTabObjNet;
SheetNumber = g_TabObjNet[0].m_SheetNumber;
LastNetCode = LastBusNetCode = 1;
for (i = istart = 0; i < g_NbrObjNet; i++)
{
if(g_TabObjNet[i].m_SheetNumber != SheetNumber )
{
SheetNumber = g_TabObjNet[i].m_SheetNumber; istart = i;
}
switch( g_TabObjNet[i].m_Type )
{
case NET_PIN:
case NET_PINLABEL:
case NET_SHEETLABEL:
case NET_NOCONNECT:
if ( g_TabObjNet[i].m_NetCode != 0 ) break; /* Deja connecte */
case NET_SEGMENT:
/* Controle des connexions type point a point ( Sans BUS ) */
if( g_TabObjNet[i].m_NetCode == 0 )
{
g_TabObjNet[i].m_NetCode = LastNetCode;
LastNetCode++;
}
PointToPointConnect(g_TabObjNet+i, 0, istart);
break;
case NET_JONCTION:
/* Controle des jonction , hors BUS */
if( g_TabObjNet[i].m_NetCode == 0 )
{
g_TabObjNet[i].m_NetCode = LastNetCode;
LastNetCode++;
}
SegmentToPointConnect( g_TabObjNet+i, 0, istart);
/* Controle des jonction , sur BUS */
if( g_TabObjNet[i].m_BusNetCode == 0 )
{
g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
LastBusNetCode++;
}
SegmentToPointConnect( g_TabObjNet+i, ISBUS, istart );
break;
case NET_LABEL:
case NET_GLOBLABEL:
/* Controle des connexions type jonction ( Sans BUS ) */
if( g_TabObjNet[i].m_NetCode == 0 )
{
g_TabObjNet[i].m_NetCode = LastNetCode;
LastNetCode++;
}
SegmentToPointConnect( g_TabObjNet+i, 0, istart );
break;
case NET_SHEETBUSLABELMEMBER:
if ( g_TabObjNet[i].m_BusNetCode != 0 ) break; /* Deja connecte */
case NET_BUS:
/* Controle des connexions type point a point mode BUS */
if( g_TabObjNet[i].m_BusNetCode == 0 )
{
g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
LastBusNetCode++;
}
PointToPointConnect(g_TabObjNet+i, ISBUS, istart);
break;
case NET_BUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER:
/* Controle des connexions semblables a des sur BUS */
if( g_TabObjNet[i].m_NetCode == 0 )
{
g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
LastBusNetCode++;
}
SegmentToPointConnect( g_TabObjNet+i, ISBUS, istart);
break;
}
}
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),CYAN);
/* Mise a jour des NetCodes des Bus Labels connectes par les Bus */
ConnectBusLabels( g_TabObjNet, g_NbrObjNet);
Affiche_1_Parametre(this, 26,_("Labels"), wxEmptyString,CYAN);
/* Connections des groupes d'objets par labels identiques */
for (i = 0; i < g_NbrObjNet; i++)
{
switch( g_TabObjNet[i].m_Type )
{
case NET_PIN:
case NET_SHEETLABEL:
case NET_SEGMENT:
case NET_JONCTION:
case NET_BUS:
case NET_NOCONNECT:
break;
case NET_LABEL:
case NET_GLOBLABEL:
case NET_PINLABEL:
case NET_BUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER:
LabelConnection( g_TabObjNet+i );
break;
case NET_SHEETBUSLABELMEMBER:
break;
}
}
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),CYAN);
/* Connexion des hierarchies */
Affiche_1_Parametre(this, 36,_("Hierar."), wxEmptyString,LIGHTRED);
for (i = 0; i < g_NbrObjNet; i++)
{
if( (g_TabObjNet[i].m_Type == NET_SHEETLABEL ) ||
( g_TabObjNet[i].m_Type == NET_SHEETBUSLABELMEMBER ) )
SheetLabelConnection(g_TabObjNet + i);
}
/* Tri du Tableau des objets de Net par NetCode */
qsort(g_TabObjNet, g_NbrObjNet, sizeof(ObjetNetListStruct),
(int (*)(const void *, const void *)) TriNetCode);
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),RED);
/* Compression des numeros de NetCode a des valeurs consecutives */
Affiche_1_Parametre(this, 46,_("Sorting"), wxEmptyString,GREEN);
LastNetCode = NetCode = 0;
for (i = 0; i < g_NbrObjNet; i++)
{
if(g_TabObjNet[i].m_NetCode != LastNetCode)
{
NetCode++; LastNetCode = g_TabObjNet[i].m_NetCode;
}
g_TabObjNet[i].m_NetCode = NetCode;
}
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),GREEN);
/* Affectation du m_FlagOfConnection en fonction de connection ou non */
SetUnconnectedFlag( BaseTabObjNet, g_NbrObjNet);
return( (void*) BaseTabObjNet);
}
/*************************************************************
* Routine qui connecte les sous feuilles par les sheetLabels *
**************************************************************/
static void SheetLabelConnection(ObjetNetListStruct *SheetLabel)
{
int i;
ObjetNetListStruct *ObjetNet;
if( SheetLabel->m_NetCode == 0 ) return;
/* Calcul du numero de sous feuille correspondante au sheetlabel */
/* Comparaison du SheetLabel avec les GLABELS de la sous feuille
pour regroupement des NetCodes */
for (i = 0, ObjetNet = g_TabObjNet; i < g_NbrObjNet; i++)
{
if( ObjetNet[i].m_SheetNumber != SheetLabel->m_NumInclude ) continue;
if( (ObjetNet[i].m_Type != NET_GLOBLABEL ) &&
(ObjetNet[i].m_Type != NET_GLOBBUSLABELMEMBER ) )
continue;
if( ObjetNet[i].m_NetCode == SheetLabel->m_NetCode ) continue;
if( ObjetNet[i].m_Label->CmpNoCase(*SheetLabel->m_Label) != 0) continue;
/* Propagation du Netcode a tous les Objets de meme NetCode */
if( ObjetNet[i].m_NetCode )
PropageNetCode(ObjetNet[i].m_NetCode, SheetLabel->m_NetCode, 0);
else ObjetNet[i].m_NetCode = SheetLabel->m_NetCode;
}
}
/*****************************************************************************/
static int ListeObjetConnection(WinEDA_SchematicFrame * frame, SCH_SCREEN *screen,
ObjetNetListStruct *ObjNet)
/*****************************************************************************/
/* Routine generant la liste des objets relatifs aux connection
entree:
screen: pointeur sur l'ecran a traiter
ObjNet:
si NULL: la routine compte seulement le nombre des objets
sinon: pointe le tableau a remplir
*/
{
int ii, NbrItem = 0, NumSheet;
EDA_BaseStruct *DrawList;
EDA_SchComponentStruct *DrawLibItem;
int TransMat[2][2], PartX, PartY, x2, y2;
EDA_LibComponentStruct *Entry;
LibEDA_BaseStruct *DEntry;
DrawSheetLabelStruct *SheetLabel;
int NumInclude;
NumSheet = screen->m_SheetNumber;
DrawList = screen->EEDrawList;
while ( DrawList )
{
switch( DrawList->m_StructType )
{
case DRAW_SEGMENT_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((EDA_DrawLineStruct *) DrawList)
if( ObjNet)
{
if ( (STRUCT->m_Layer != LAYER_BUS) &&
(STRUCT->m_Layer != LAYER_WIRE) )
break;
ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Start;
ObjNet[NbrItem].m_End = STRUCT->m_End;
if (STRUCT->m_Layer == LAYER_BUS)
{
ObjNet[NbrItem].m_Type = NET_BUS;
}
else /* Cas des WIRE */
{
ObjNet[NbrItem].m_Type = NET_SEGMENT;
}
}
NbrItem++;
break;
case DRAW_JUNCTION_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((DrawJunctionStruct *) DrawList)
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_Type = NET_JONCTION;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
}
NbrItem++;
break;
case DRAW_NOCONNECT_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((DrawNoConnectStruct *) DrawList)
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_Type = NET_NOCONNECT;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
}
NbrItem++;
break;
case DRAW_LABEL_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((DrawLabelStruct *) DrawList)
ii = IsBusLabel( STRUCT->m_Text);
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_Type = NET_LABEL;
if (STRUCT->m_Layer == LAYER_GLOBLABEL)
ObjNet[NbrItem].m_Type = NET_GLOBLABEL;
ObjNet[NbrItem].m_Label = & STRUCT->m_Text;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
/* Si c'est un Bus, eclatement en Label */
if ( ii ) ConvertBusToMembers(ObjNet + NbrItem);
}
NbrItem += ii+1;
break;
case DRAW_GLOBAL_LABEL_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((DrawGlobalLabelStruct *) DrawList)
ii = IsBusLabel( STRUCT->m_Text);
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_Type = NET_LABEL;
if (STRUCT->m_Layer == LAYER_GLOBLABEL)
ObjNet[NbrItem].m_Type = NET_GLOBLABEL;
ObjNet[NbrItem].m_Label = & STRUCT->m_Text;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
/* Si c'est un Bus, eclatement en Label */
if ( ii ) ConvertBusToMembers(ObjNet + NbrItem);
}
NbrItem += ii+1;
break;
case DRAW_LIB_ITEM_STRUCT_TYPE :
DrawLibItem = (EDA_SchComponentStruct *) DrawList;
memcpy(TransMat, DrawLibItem->m_Transform, sizeof(TransMat));
PartX = DrawLibItem->m_Pos.x; PartY = DrawLibItem->m_Pos.y;
Entry = FindLibPart(DrawLibItem->m_ChipName, wxEmptyString, FIND_ROOT);
if( Entry == NULL) break;
if(Entry->m_Drawings == NULL) break ;
DEntry = Entry->m_Drawings;
for ( ;DEntry != NULL; DEntry = DEntry->Next())
{
LibDrawPin * Pin = (LibDrawPin *) DEntry;
if( DEntry->m_StructType != COMPONENT_PIN_DRAW_TYPE) continue;
if( DEntry->m_Unit &&
(DEntry->m_Unit != DrawLibItem->m_Multi) ) continue;
if( DEntry->m_Convert &&
(DEntry->m_Convert != DrawLibItem->m_Convert)) continue;
x2 = PartX + TransMat[0][0] * Pin->m_Pos.x
+ TransMat[0][1] * Pin->m_Pos.y;
y2 = PartY + TransMat[1][0] * Pin->m_Pos.x
+ TransMat[1][1] * Pin->m_Pos.y;
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = DEntry;
ObjNet[NbrItem].m_Type = NET_PIN;
ObjNet[NbrItem].m_Link = DrawLibItem;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_ElectricalType = Pin->m_PinType;
ObjNet[NbrItem].m_PinNum = Pin->m_PinNum;
ObjNet[NbrItem].m_Label = & Pin->m_PinName;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start.x = x2;
ObjNet[NbrItem].m_Start.y = y2;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
}
NbrItem++;
if( ( (int) Pin->m_PinType == (int) PIN_POWER_IN ) &&
( Pin->m_Attributs & PINNOTDRAW ) )
{ /* Il y a un PIN_LABEL Associe */
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = NULL;
ObjNet[NbrItem].m_Type = NET_PINLABEL;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Label = & Pin->m_PinName;
ObjNet[NbrItem].m_Start.x = x2;
ObjNet[NbrItem].m_Start.y = y2;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
}
NbrItem++;
}
}
break;
case DRAW_PICK_ITEM_STRUCT_TYPE :
case DRAW_POLYLINE_STRUCT_TYPE :
case DRAW_BUSENTRY_STRUCT_TYPE :
case DRAW_MARKER_STRUCT_TYPE :
case DRAW_TEXT_STRUCT_TYPE :
break;
case DRAW_SHEET_STRUCT_TYPE :
#undef STRUCT
#define STRUCT ((DrawSheetStruct *) DrawList)
NumInclude = STRUCT->m_SheetNumber;
SheetLabel = STRUCT->m_Label;
for ( ; SheetLabel != NULL;
SheetLabel = (DrawSheetLabelStruct*) SheetLabel->Pnext)
{
ii = IsBusLabel(SheetLabel->m_Text);
if( ObjNet)
{
ObjNet[NbrItem].m_Comp = SheetLabel;
ObjNet[NbrItem].m_Link = DrawList;
ObjNet[NbrItem].m_Type = NET_SHEETLABEL;
ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_ElectricalType = SheetLabel->m_Shape;
ObjNet[NbrItem].m_Label = & SheetLabel->m_Text;
ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_NumInclude = NumInclude;
ObjNet[NbrItem].m_Start = SheetLabel->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
/* Si c'est un Bus, eclatement en Label */
if ( ii ) ConvertBusToMembers(ObjNet + NbrItem);
}
NbrItem += ii+1;
}
break;
case DRAW_SHEETLABEL_STRUCT_TYPE :
DisplayError(frame, wxT("Netlist: Type DRAW_SHEETLABEL inattendu"));
break;
default:
{
wxString msg;
msg.Printf( wxT("Netlist: unexpected type struct %d"),
DrawList->m_StructType);
DisplayError(frame, msg);
break;
}
}
DrawList = DrawList->Pnext;
}
return(NbrItem);
}
/************************************************************************/
static void ConnectBusLabels( ObjetNetListStruct *Label, int NbItems )
/************************************************************************/
/* Routine qui analyse les labels type xxBUSLABELMEMBER
Propage les Netcodes entre labels correspondants ( c'est a dire lorsque
leur numero de membre est identique) lorsqu'ils sont connectes
globalement par leur BusNetCode
Utilise et met a jour la variable LastNetCode
*/
{
ObjetNetListStruct *LabelInTst, *Lim;
Lim = Label + NbItems;
for ( ; Label < Lim; Label++)
{
if( (Label->m_Type == NET_SHEETBUSLABELMEMBER) ||
(Label->m_Type == NET_BUSLABELMEMBER) ||
(Label->m_Type == NET_GLOBBUSLABELMEMBER) )
{
if( Label->m_NetCode == 0 )
{
Label->m_NetCode = LastNetCode; LastNetCode++;
}
for ( LabelInTst = Label+1; LabelInTst < Lim; LabelInTst++)
{
if( (LabelInTst->m_Type == NET_SHEETBUSLABELMEMBER) ||
(LabelInTst->m_Type == NET_BUSLABELMEMBER) ||
(LabelInTst->m_Type == NET_GLOBBUSLABELMEMBER) )
{
if( LabelInTst->m_BusNetCode != Label->m_BusNetCode ) continue;
if( LabelInTst->m_Member != Label->m_Member ) continue;
if( LabelInTst->m_NetCode == 0 )
LabelInTst->m_NetCode = Label->m_NetCode;
else
PropageNetCode( LabelInTst->m_NetCode, Label->m_NetCode,0);
}
}
}
}
}
/**************************************************/
int IsBusLabel( const wxString & LabelDrawList )
/**************************************************/
/* Routine qui verifie si le Label a une notation de type Bus
Retourne 0 si non
nombre de membres si oui
met a jour FirstNumWireBus, LastNumWireBus et RootBusNameLength
*/
{
unsigned Num;
int ii;
wxString BufLine;
long tmp;
bool error = FALSE;
/* Search for '[' because a bus label is like "busname[nn..mm]" */
ii = LabelDrawList.Find('[');
if ( ii < 0 ) return(0);
Num = (unsigned) ii;
FirstNumWireBus = LastNumWireBus = 9;
RootBusNameLength = Num;
Num++;
while ( LabelDrawList[Num] != '.' && Num < LabelDrawList.Len())
{
BufLine.Append(LabelDrawList[Num]);
Num++;
}
if ( ! BufLine.ToLong(&tmp) ) error = TRUE;;
FirstNumWireBus = tmp;
while ( LabelDrawList[Num] == '.' && Num < LabelDrawList.Len() )
Num++;
BufLine.Empty();
while ( LabelDrawList[Num] != ']' && Num < LabelDrawList.Len())
{
BufLine.Append(LabelDrawList[Num]);
Num++;
}
if ( ! BufLine.ToLong(&tmp) ) error = TRUE;;
LastNumWireBus = tmp;
if( FirstNumWireBus < 0 ) FirstNumWireBus = 0;
if( LastNumWireBus < 0 ) LastNumWireBus = 0;
if( FirstNumWireBus > LastNumWireBus )
{
EXCHG( FirstNumWireBus, LastNumWireBus);
}
if ( error && (s_PassNumber == 0) )
{
wxString msg = _("Bad Bus Label: ") + LabelDrawList;
DisplayError(NULL, msg);
}
return(LastNumWireBus - FirstNumWireBus + 1 );
}
/***************************************************************/
static int ConvertBusToMembers(ObjetNetListStruct * BusLabel)
/***************************************************************/
/* Routine qui eclate un label type Bus en autant de Label qu'il contient de membres,
et qui cree les structures avec le type NET_GLOBBUSLABELMEMBER, NET_BUSLABELMEMBER
ou NET_SHEETBUSLABELMEMBER
entree = pointeur sur l'ObjetNetListStruct initialise corresp au buslabel
suppose que FirstNumWireBus, LastNumWireBus et RootBusNameLength sont a jour
modifie l'ObjetNetListStruct de base et remplit les suivants
m_Label is a pointer to a new wxString
m_Label must be deallocated by the user (only for a NET_GLOBBUSLABELMEMBER,
NET_BUSLABELMEMBER or a NET_SHEETBUSLABELMEMBER object type)
*/
{
int NumItem, BusMember;
wxString BufLine;
if( BusLabel->m_Type == NET_GLOBLABEL )
BusLabel->m_Type = NET_GLOBBUSLABELMEMBER;
else if (BusLabel->m_Type == NET_SHEETLABEL)
BusLabel->m_Type = NET_SHEETBUSLABELMEMBER;
else BusLabel->m_Type = NET_BUSLABELMEMBER;
/* Convertion du BusLabel en la racine du Label + le numero du fil */
BufLine = BusLabel->m_Label->Left(RootBusNameLength);
BusMember = FirstNumWireBus;
BufLine << BusMember;
BusLabel->m_Label = new wxString(BufLine);
BusLabel->m_Member = BusMember;
NumItem = 1;
for ( BusMember++; BusMember <= LastNumWireBus; BusMember++)
{
*(BusLabel+1) = *BusLabel; BusLabel ++; NumItem++;
/* Convertion du BusLabel en la racine du Label + le numero du fil */
BufLine = BusLabel->m_Label->Left(RootBusNameLength);
BufLine << BusMember;
BusLabel->m_Label = new wxString(BufLine);
BusLabel->m_Member = BusMember;
}
return( NumItem);
}
/**********************************************************************/
static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus )
/**********************************************************************/
/* PropageNetCode propage le netcode NewNetCode sur tous les elements
appartenant a l'ancien netcode OldNetCode
Si IsBus == 0; c'est le membre NetCode qui est propage
Si IsBus != 0; c'est le membre BusNetCode qui est propage
*/
{
int jj;
ObjetNetListStruct * Objet = g_TabObjNet;
if( OldNetCode == NewNetCode ) return;
if( IsBus == 0 ) /* Propagation du NetCode */
{
for (jj = 0; jj < g_NbrObjNet; jj++, Objet++)
{
if ( Objet->m_NetCode == OldNetCode )
{
Objet->m_NetCode = NewNetCode;
}
}
}
else /* Propagation du BusNetCode */
{
for (jj = 0; jj < g_NbrObjNet; jj++, Objet++)
{
if ( Objet->m_BusNetCode == OldNetCode )
{
Objet->m_BusNetCode = NewNetCode;
}
}
}
}
/***************************************************************************/
static void PointToPointConnect(ObjetNetListStruct *Ref, int IsBus, int start)
/***************************************************************************/
/* Routine qui verifie si l'element *Ref est connecte a
d'autres elements de la liste des objets du schema, selon le mode Point
a point ( Extremites superposees )
si IsBus:
la connexion ne met en jeu que des elements type bus
( BUS ou BUSLABEL ou JONCTION )
sinon
la connexion ne met en jeu que des elements type non bus
( autres que BUS ou BUSLABEL )
L'objet Ref doit avoir un NetCode valide.
La liste des objets est supposee classe par NumSheet Croissants,
et la recherche se fait a partir de l'element start, 1er element
de la feuille de schema
( il ne peut y avoir connexion physique entre elements de differentes sheets)
*/
{
int i, NetCode;
ObjetNetListStruct *Point = g_TabObjNet;
if ( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */
{
NetCode = Ref->m_NetCode;
for (i = start; i < g_NbrObjNet; i++)
{
if( Point[i].m_SheetNumber > Ref->m_SheetNumber ) break;
switch( Point[i].m_Type )
{
case NET_SEGMENT:
case NET_PIN:
case NET_LABEL:
case NET_GLOBLABEL:
case NET_SHEETLABEL:
case NET_PINLABEL:
case NET_JONCTION:
case NET_NOCONNECT:
if( (((Ref->m_Start.x == Point[i].m_Start.x) && (Ref->m_Start.y == Point[i].m_Start.y))) ||
(((Ref->m_Start.x == Point[i].m_End.x) && (Ref->m_Start.y == Point[i].m_End.y))) ||
(((Ref->m_End.x == Point[i].m_Start.x) && (Ref->m_End.y == Point[i].m_Start.y))) ||
(((Ref->m_End.x == Point[i].m_End.x) && (Ref->m_End.y == Point[i].m_End.y))) )
{
if( Point[i].m_NetCode == 0 ) Point[i].m_NetCode = NetCode;
else PropageNetCode( Point[i].m_NetCode, NetCode , 0);
}
break;
case NET_BUS:
case NET_BUSLABELMEMBER:
case NET_SHEETBUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER:
break;
}
}
}
else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/
{
NetCode = Ref->m_BusNetCode;
for (i = start; i < g_NbrObjNet; i++)
{
if( Point[i].m_SheetNumber > Ref->m_SheetNumber ) break;
switch( Point[i].m_Type )
{
case NET_SEGMENT:
case NET_PIN:
case NET_LABEL:
case NET_GLOBLABEL:
case NET_SHEETLABEL:
case NET_PINLABEL:
case NET_NOCONNECT:
break;
case NET_BUS:
case NET_BUSLABELMEMBER:
case NET_SHEETBUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER:
case NET_JONCTION:
if( (((Ref->m_Start.x == Point[i].m_Start.x) && (Ref->m_Start.y == Point[i].m_Start.y))) ||
(((Ref->m_Start.x == Point[i].m_End.x) && (Ref->m_Start.y == Point[i].m_End.y))) ||
(((Ref->m_End.x == Point[i].m_Start.x) && (Ref->m_End.y == Point[i].m_Start.y))) ||
(((Ref->m_End.x == Point[i].m_End.x) && (Ref->m_End.y == Point[i].m_End.y))) )
{
if( Point[i].m_BusNetCode == 0 )
Point[i].m_BusNetCode = NetCode;
else PropageNetCode( Point[i].m_BusNetCode, NetCode,1 );
}
break;
}
}
}
}
/**************************************************************/
static void SegmentToPointConnect(ObjetNetListStruct *Jonction,
int IsBus, int start)
/***************************************************************/
/*
Routine qui recherche si un point (jonction) est connecte a des segments,
et regroupe les NetCodes des objets connectes a la jonction.
Le point de jonction doit avoir un netcode valide
La liste des objets est supposee classe par NumSheet Croissants,
et la recherche se fait a partir de l'element start, 1er element
de la feuille de schema
( il ne peut y avoir connexion physique entre elements de differentes sheets)
*/
{
int i;
ObjetNetListStruct *Segment = g_TabObjNet;
for (i = start; i < g_NbrObjNet; i++)
{
if( Segment[i].m_SheetNumber > Jonction->m_SheetNumber ) break;
if( IsBus == 0)
{
if ( Segment[i].m_Type != NET_SEGMENT ) continue;
}
else
{
if ( Segment[i].m_Type != NET_BUS ) continue;
}
if ( SegmentIntersect(Segment[i].m_Start.x, Segment[i].m_Start.y,
Segment[i].m_End.x, Segment[i].m_End.y,
Jonction->m_Start.x, Jonction->m_Start.y) )
{
/* Propagation du Netcode a tous les Objets de meme NetCode */
if( IsBus == 0 )
{
if( Segment[i].m_NetCode )
PropageNetCode(Segment[i].m_NetCode,
Jonction->m_NetCode, IsBus);
else Segment[i].m_NetCode = Jonction->m_NetCode;
}
else
{
if( Segment[i].m_BusNetCode )
PropageNetCode(Segment[i].m_BusNetCode,
Jonction->m_BusNetCode, IsBus);
else Segment[i].m_BusNetCode = Jonction->m_BusNetCode;
}
}
}
}
/*****************************************************************
* Routine qui connecte les groupes d'objets si labels identiques *
*******************************************************************/
static void LabelConnection(ObjetNetListStruct *LabelRef)
{
int i, NetCode;
ObjetNetListStruct *ObjetNet;
if( LabelRef->m_NetCode == 0 ) return;
ObjetNet = g_TabObjNet;
for (i = 0; i < g_NbrObjNet; i++)
{
NetCode = ObjetNet[i].m_NetCode;
if( NetCode == LabelRef->m_NetCode ) continue;
if( ObjetNet[i].m_SheetNumber != LabelRef->m_SheetNumber )
{
if (ObjetNet[i].m_Type != NET_PINLABEL ) continue;
}
if( (ObjetNet[i].m_Type == NET_LABEL ) ||
(ObjetNet[i].m_Type == NET_GLOBLABEL ) ||
(ObjetNet[i].m_Type == NET_BUSLABELMEMBER ) ||
(ObjetNet[i].m_Type == NET_GLOBBUSLABELMEMBER ) ||
(ObjetNet[i].m_Type == NET_PINLABEL ) )
{
if( ObjetNet[i].m_Label->CmpNoCase(*LabelRef->m_Label) != 0) continue;
/* Ici 2 labels identiques */
/* Propagation du Netcode a tous les Objets de meme NetCode */
if( ObjetNet[i].m_NetCode )
PropageNetCode(ObjetNet[i].m_NetCode, LabelRef->m_NetCode, 0);
else ObjetNet[i].m_NetCode = LabelRef->m_NetCode;
}
}
}
/****************************************************************************/
static int TriNetCode(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2)
/****************************************************************************/
/* Routine de comparaison pour le tri par NetCode croissant
du tableau des elements connectes ( TabPinSort ) par qsort()
*/
{
return (Objet1->m_NetCode - Objet2->m_NetCode);
}
/*****************************************************************************/
static int TriBySheet(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2)
/*****************************************************************************/
/* Routine de comparaison pour le tri par NumSheet
du tableau des elements connectes ( TabPinSort ) par qsort() */
{
return (Objet1->m_SheetNumber - Objet2->m_SheetNumber);
}
/**********************************************************************/
static void SetUnconnectedFlag( ObjetNetListStruct *ListObj, int NbItems )
/**********************************************************************/
/* Routine positionnant le membre .FlagNoConnect des elements de
la liste des objets netliste, tries par ordre de NetCode
*/
{
ObjetNetListStruct * NetItemRef, * NetItemTst, *ItemPtr;
ObjetNetListStruct * NetStart, * NetEnd, * Lim;
int Nb;
IsConnectType StateFlag;
NetStart = NetEnd = ListObj;
Lim = ListObj + NbItems;
NetItemRef = NetStart;
Nb = 0; StateFlag = UNCONNECT;
for ( ; NetItemRef < Lim; NetItemRef++ )
{
if( NetItemRef->m_Type == NET_NOCONNECT )
if( StateFlag != CONNECT ) StateFlag = NOCONNECT;
/* Analyse du net en cours */
NetItemTst = NetItemRef + 1;
if( (NetItemTst >= Lim) ||
(NetItemRef->m_NetCode != NetItemTst->m_NetCode) )
{ /* Net analyse: mise a jour de m_FlagOfConnection */
NetEnd = NetItemTst;
for( ItemPtr = NetStart; ItemPtr < NetEnd; ItemPtr++ )
{
ItemPtr->m_FlagOfConnection = StateFlag;
}
if(NetItemTst >= Lim) return;
/* Start Analyse Nouveau Net */
StateFlag = UNCONNECT;
NetStart = NetItemTst;
continue;
}
for ( ; ; NetItemTst ++)
{
if( (NetItemTst >= Lim) ||
(NetItemRef->m_NetCode != NetItemTst->m_NetCode) )
break;
switch( NetItemTst->m_Type )
{
case NET_SEGMENT:
case NET_LABEL:
case NET_GLOBLABEL:
case NET_SHEETLABEL:
case NET_PINLABEL:
case NET_BUS:
case NET_BUSLABELMEMBER:
case NET_SHEETBUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER:
case NET_JONCTION:
break;
case NET_PIN:
if( NetItemRef->m_Type == NET_PIN )
StateFlag = CONNECT;
break;
case NET_NOCONNECT:
if( StateFlag != CONNECT ) StateFlag = NOCONNECT;
break;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink