/*
* $Header: c:\\cygwin\\cvsroot/Vert03/vertlib/jumpering.c,v 1.1.1.1 2003/11/04 23:34:57 mjames
* Exp $
*
* $Log: jumpering.c,v $
* Revision 1.1.1.1 2003/11/04 23:34:57 mjames
* Imported into local repositrory
*
* Revision 1.10 2003/01/02 21:37:15 mjames
* Experiment on creating NOT_ROUTABLE_H and NOT_ROUTABLE_L
* properties on the nets so that pin jumpers can be made without a problem.
*
* Still need to sort out pin assignments made to these not_routable nets
* which will become legal in some cases so that pullups and pulldown
* pins can be used on the FPGA.
*
* Revision 1.9 2002/10/02 18:41:54 MJAMES
* Removed diagnostic printout
*
* Revision 1.8 2002/09/27 22:37:25 MJAMES
* Added definition of create_vhdl_connections
*
* Revision 1.7 2002/09/09 10:13:32 mjames
* Moved pin remapping function to pin ident editing function from
* sorting pin name routine.
*
* Revision 1.6 2002/01/15 12:35:58 mjames
* DLL declarations put in,
*
* #ident used
*
* Revision 1.5 2001/11/19 10:41:51 mjames
* Merged back DTC release
*
* Revision 1.4.2.2 2001/11/15 21:06:43 mjames
* Promoted a jumper deletion message to an error status.
*
* Revision 1.4.2.1 2001/11/15 21:01:21 mjames
* Tidying up unused variables
*
* Revision 1.4 2001/10/31 22:20:07 mjames
* Tidying up problematical comments caused by CVS
* 'intelligent' comment guessing
*
* Revision 1.3 2001/06/19 05:23:59 mjames
* Moved some code dealing with finding nets with external connections
* to ext_nets.c
*
* Revision 1.2 2001/06/06 12:10:21 mjames
* Move from HPUX
*
* Revision 1.1.1.1 2000/10/19 21:58:38 mjames
* Mike put it here
*
* Revision 1.32 2000/10/04 10:37:06 10:37:06 mjames (Mike James)
* Modified for Vertical2 : support COMPONENTS and SIGNALS
*
* Revision 1.32 2000/10/04 10:37:06 10:37:06 mjames (Mike James)
* Part of Release PSAVAT01
*
* Revision 1.31 2000/10/02 11:04:15 11:04:15 mjames (Mike James)
* new_vhdl
*
* Revision 1.30 2000/09/27 14:42:16 14:42:16 mjames (Mike James)
* Part of Release Sep_27_ST_2000
*
* Revision 1.29 2000/09/21 10:15:46 10:15:46 mjames (Mike James)
* Part of Release Sep21Alpha
*
* Revision 1.28 2000/09/21 09:46:54 09:46:54 mjames (Mike James)
* Added code to deal with pin equivalents
*
* Revision 1.27 2000/08/25 09:57:12 09:57:12 mjames (Mike James)
* Part of Release Aug25_alpha
*
* Revision 1.26 2000/08/16 08:57:28 08:57:28 mjames (Mike James)
* Part of Release CD01_Aug2000
*
* Revision 1.25 2000/08/14 14:45:10 14:45:10 mjames (Mike James)
* Part of Release Aug_14_2000
*
* Revision 1.24 2000/08/14 14:42:53 14:42:53 mjames (Mike James)
* Changed checks for hierarchical jumpers
*
* Revision 1.23 2000/08/11 08:30:30 08:30:30 mjames (Mike James)
* Part of Release Aug_11_2000
*
* Revision 1.22 2000/08/09 10:31:44 10:31:44 mjames (Mike James)
* Part of Release Aug__9_2000
*
* Revision 1.21 2000/05/31 11:42:53 11:42:53 mjames (Mike James)
* Part of Release May_31_2000
*
* Revision 1.20 2000/05/08 17:01:35 17:01:35 mjames (Mike James)
* Part of Release May__8_2000
*
* Revision 1.19 2000/05/08 16:59:29 16:59:29 mjames (Mike James)
* Part of Release May__8_2000
*
* Revision 1.18 2000/05/08 16:57:05 16:57:05 mjames (Mike James)
* Part of Release May__8_2000
*
* Revision 1.17 2000/03/08 16:19:09 16:19:09 mjames (Mike James)
* New version including PC
*
* Revision 1.14 2000/01/20 15:58:45 15:58:45 mjames (Mike James)
* Part of Release R22
*
* Revision 1.13 99/12/22 11:15:25 11:15:25 mjames (Mike James)
* Part of Release Dec_22_1999
*
* Revision 1.12 99/06/25 14:35:36 14:35:36 mjames (Mike James)
* Added in reference to expression.h, but no changes made
* to the function of acfread yet.
*
* Revision 1.11 99/05/04 09:51:47 09:51:47 mjames (Mike James)
* General checkin
* ls
*
* Revision 1.9 98/11/30 13:48:12 13:48:12 mjames (Mike James)
* Corrected a create-jumper-with-no-nodes = core dump
* problem
*
* Revision 1.8 98/11/27 15:15:08 15:15:08 mjames (Mike James)
* Amended algorithm to work with newer database
* format
*
* Revision 1.7 98/11/25 12:46:54 12:46:54 mjames (Mike James)
* Checked in with some errors to do with not creating a jumper name !!
*
* Revision 1.6 98/11/16 13:18:30 13:18:30 mjames (Mike James)
*
* Revision 1.5 98/03/16 11:32:31 11:32:31 mjames (Mike James)
* Attempting to correct the jumpering of already jumpered jumper lists.
*
* Revision 1.4 98/02/11 11:26:28 11:26:28 mjames (Mike James)
* Checked in for version 6.2a
*
* Revision 1.3 97/04/23 08:42:54 08:42:54 mjames (Mike James)
* CHecked in for release rel23041997
*
* Revision 1.2 96/12/13 08:43:23 08:43:23 mjames (Mike James)
* Update to v5.1, added Write ID , exact routing
*
* Revision 1.1 96/08/06 13:39:40 13:39:40 mjames (Mike James)
* Initial revision
*
* */
#include "jumpering.h"
#include "cmdlog.h"
#include "cmdparse.h"
#include "database.h"
#include "expression.h"
#include "generic.h"
#include "routing.h"
#include "vertcl_main.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ident \
"@(#)$Header: c:\\cygwin\\cvsroot/Vert03/vertlib/jumpering.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $"
/* resolve not routable H or L */
HowRouted_t routing_resolve (HowRouted_t curr, HowRouted_t next)
{
/* the H property can be destroyed if it meets L or plain not_routable */
if (curr == Not_Routable_H)
{
if (next == Not_Routable || next == Not_Routable_L)
return Not_Routable;
}
if (curr == Not_Routable_L)
{
if (next == Not_Routable || next == Not_Routable_H)
return Not_Routable;
}
return next;
}
/* takes a net and removes it from the list of nets directly searchable
by routing algorithms, copying all its node references to the new net,
This is used in creating jumpers */
__declspec(dllexport) int transfer_net_to_subnet (net_t **list, net_t *topnet, net_t *subnet)
{
net_t *prev_net;
net_t *next_net;
char *subnet_orig_ident;
HowRouted_t subnet_how_routed;
int hierarchy;
hierarchy = 0;
/* algorithms check to see if there is a hierarchy of jumpers.
if there is then check to see if the jumper is basically a connection
to itself. If it is give up. */
subnet_how_routed = subnet->how_routed;
subnet_orig_ident = subnet->identifier;
/* Log(LOG_GENERAL,"# JUMPER: Net '%s' jumpered to '%s'\n",
topnet->identifier,subnet->identifier);
*/
if (subnet->join_parent)
{
hierarchy = 1;
while (subnet->join_parent)
{
/* Log(LOG_GENERAL,"# Info : Net '%s' is already jumpered to '%s':
trying parent jumper\n",
subnet->identifier,subnet->join_parent->identifier);
*/
subnet = subnet->join_parent;
}
}
if (topnet == subnet)
{
Log (
LOG_ERROR,
"# Error : - Cant join a net to itself !!! %s to %s : Suppressing "
"Jumper\n",
subnet_orig_ident,
topnet->identifier);
return 0;
}
else if (hierarchy)
{
Log (
LOG_GENERAL,
"# -- Info : Net '%s' will be jumpered via '%s' to '%s' \n",
subnet_orig_ident,
subnet->identifier,
topnet->identifier);
}
prev_net = subnet->prev;
next_net = subnet->next;
/* Remove subnet from directly searchable list */
/* if at head of list, correct list and point back at NULL */
if (subnet == *list)
{
*list = next_net;
if (next_net)
next_net->prev = NULL;
}
else if (next_net)
next_net->prev = subnet->prev;
if (prev_net)
prev_net->next = subnet->next;
/* attach net to topnet's subnet list */
/* printf("before: topnet->subnets = %p\n",topnet->subnets); */
/* printf("before: subnet = %p\n",subnet); */
subnet->prev = NULL;
subnet->next = NULL;
subnet->joined_nets = topnet->subnets; /* The subnets are linked horizontally via
the 'joined_nets' rather than subnet pointer now */
subnet->join_parent = topnet; /* The subnet is joined to the parent */
topnet->join_parent = NULL; /* this net does not have a parent */
topnet->subnets = subnet;
/* propagate up properties */
if (subnet->has_fix_location)
topnet->has_fix_location = 1;
if (IS_NOT_ROUTABLE (subnet_how_routed))
{
Log (
LOG_ERROR,
"# Warning - Jumpering '%s' and '%s' will be NON ROUTABLE\n",
subnet->identifier,
topnet->identifier);
}
topnet->how_routed = routing_resolve (topnet->how_routed, subnet_how_routed);
/* subnet->name = topnet->name;*/
/* printf("after: topnet->subnets = %p\n",topnet->subnets); */
/* printf("after: subnet->next = %p\n",subnet->next); */
/* now copy the noderef list from subnet to topnet */
{
noderef_t *newref;
noderef_t *oldref = subnet->nodes;
while (oldref)
{
/* create a new node reference */
newref
= calloc (1, sizeof (noderef_t
));
newref->base_noderef = oldref->base_noderef; /* point down to the
original node reference */
/* copy information : probably is not needed */
/* SNIP from here ? ************************************** */
newref->pindir = oldref->pindir;
/* newref->datatype = oldref->datatype; */
/* get_vhdl_buswidth(newref);*/ /* sort out the VHDL bus
declaration */
newref->vhdltype = copy_vhdl (oldref->vhdltype, NULL);
newref->node = oldref->node;
/* added as forgotten 05/11/1998 */
newref->orig_name = allocstr (oldref->orig_name);
newref->orig_vhdltype = copy_vhdl (oldref->orig_vhdltype, NULL);
/* end edit */
/* SNIP to here ? ************************************** */
/* new node refers to information on the top net if joined,
otherwise it is the sub net if aliased */
if (topnet->how_joined == Jumpered)
{
newref->net = topnet;
newref->node->routed_net =
topnet; /* change routed net reference to
point at jumper net rather than originals */
}
else
newref->net = subnet;
/* attach it to the net */
newref->next = topnet->nodes;
topnet->nodes = newref;
/* count nodes */
topnet->nodecount++;
oldref = oldref->next;
}
}
return 1; /* success on a plate */
}
/****************************************************************************/
/* this procedure takes a jumper apart as a result of failure */
/* it takes the subnets and links them back into the main routed net list,
removes the top net that was the jumper */
__declspec(dllexport) int disconnect_jumper (net_t **list, net_t *jumper)
{
net_t *first_member = jumper->subnets;
net_t *current_member;
net_t *previous_member = jumper;
net_t *next_list = jumper->next;
/* at this point we have
previous net<-->jumper<-->next net
|
sub1-->sub2-->sub3...
*/
current_member = first_member;
if (first_member)
{
while (current_member)
{
current_member->next =
current_member->joined_nets; /* copy next pointer from join list*/
current_member->prev = previous_member;
current_member->joined_nets = NULL;
current_member->join_parent = NULL; /* no longer part of a jumper */
previous_member->next = current_member;
previous_member = current_member;
Log (
LOG_ERROR,
"-- disconnecting '%s'\n",
current_member->identifier);
current_member = current_member->next;
};
previous_member->next = next_list;
if (previous_member->next)
previous_member->next->prev = previous_member;
}
/* converted to
previous net<-->jumper<-->sub1<-->sub2<-->sub3<-->next net
*/
Log (LOG_GENERAL, "-- From jumper '%s'\n\n", jumper->identifier);
remove_net (list, jumper);
return 1;
}
/* ******************************************** */
static net_t *
check_net (int *accept_nodes, net_t **best_net, net_t *routed_net, net_t *unrouted_net)
{
if (routed_net->has_external && routed_net->nodecount >= *accept_nodes &&
IS_ROUTABLE (routed_net->how_routed))
{
/* possibly enough nodes, but does it go the right places ?? */
int visit_count = 0;
noderef_t *unrouted_nodes = unrouted_net->nodes;
noderef_t *routed_nodes = routed_net->nodes;
clear_routing_flags (routed_nodes);
/* search for as yet unused but needed nodes on the unrouted net */
while (unrouted_nodes)
{
if (unrouted_nodes->r_flag == 0 &&
search_net_for_socket (unrouted_nodes, routed_nodes, 0) != NULL)
visit_count++;
unrouted_nodes = unrouted_nodes->next;
}
if (visit_count > *accept_nodes)
{
*accept_nodes = visit_count;
*best_net = routed_net;
}
}
return *best_net;
}
/* ******************************************** */
/* This function tries to tidy up all nets that are currently
still in the unrouted list because they are blocked
The algorithm is to try and locate the routed net which visits
the highest number of sockets referred to by the unrouted net
and which has an external connection on it. Mark this, assign its
nodes to a jumpered net. Remove nodes used from the unrouted
net and search again.
Repeat until either no jumper candidates are found or all
nodes on the unrouted net are used up. */
__declspec(dllexport) void perform_routing_by_making_jumpers (char *Suffix)
{
int jumper_count = 1;
net_t *unrouted_net = unrouted_list;
net_t *next_net;
HowRouted_t route_type = Free;
if (!Suffix)
Suffix = "";
/* firstly, set up the has_external flags on all of the nets, by checking to see if any
nodes on any nets are connected to external sockets */
/* code moved to ext_nets.c
while (routed_net)
{
noderef_t *noderefs = routed_net->nodes;
routed_net->has_external = 0;
while (noderefs)
{
if (noderefs->node->socket->is_external)
routed_net->has_external = 1;
noderefs = noderefs->next;
}
routed_net = routed_net->next;
}
*/
/* tidy up */
while (unrouted_net)
{ /* loop through all unrouted nets */
int routed_ok = 1;
int accept_nodes = 0;
int nets_used = 0;
int nodes_left = unrouted_net->nodecount;
net_t *best_net;
net_t *routed_net;
noderef_t *unrouted_nodes;
char jumper_name[JUMP_NAMLEN + 1];
net_t *jumper_net = NULL;
Log (
LOG_GENERAL,
"\n--Looking to create net '%s' which has %d nodes\n",
unrouted_net->identifier,
nodes_left);
/* using the routing flags to indicate a net has sucessfully visited node .
Only clear the flags if there is actually a node list !! */
if (unrouted_net->nodes)
clear_routing_flags (unrouted_net->nodes);
/* iterate until a loop fails to do better, or we have jumpered all of the
nodes we need */
while (routed_ok && nodes_left)
{
net_t **list;
int pass;
best_net = NULL;
accept_nodes = 0;
for (pass = 0; pass < 1 && !best_net; pass++)
{
if (pass == 0)
list = &routed_list;
else
list = &named_list;
/* check for FIX_LOCATION pins as these are most important
In this case, the best_net is one that can be connected to
the FIX_LOCATION pin because it is not yet in use */
unrouted_nodes = unrouted_net->nodes;
/* scan through until we find an unrouted node that has no
* routing flag set */
while (unrouted_nodes && !best_net)
{
if (unrouted_nodes->r_flag == 0)
{
net_t *poss_routed_net =
unrouted_nodes->node->routed_net;
if (poss_routed_net &&
poss_routed_net->list_ref == list)
{
if (level & 2)
{
Log (
LOG_GENERAL,
"\n-- pass %d checking "
"net '%s'\n",
pass,
poss_routed_net
->identifier);
}
/* is routed net still available on the
* routed list ? */
/* &&
* poss_routed_net->has_fix_location)
*/ /* only fix_location nets on pass 1, then all nets */
check_net (
&accept_nodes,
&best_net,
poss_routed_net, /* ???? was
routed_net . no
sense here !!
*/
unrouted_net);
}
}
unrouted_nodes = unrouted_nodes->next;
}
if ((level & 2) && best_net)
{
Log (
LOG_GENERAL,
"-- Phase 1 search Found as best match net '%s' "
"with %d corresponding nodes\n",
best_net->identifier,
accept_nodes);
}
if (!best_net)
{
/* check for any position to jumper if there are no
FIX_LOCATION pins Now, search simply for any useful
net, and try the one with the most sockets visited */
routed_net = *list;
accept_nodes = 0;
while (routed_net)
{
if (level & 2)
Log (
LOG_GENERAL,
"\n-- pass %d generally checking "
"net '%s'\n",
pass,
routed_net->identifier);
check_net (
&accept_nodes,
&best_net,
routed_net,
unrouted_net);
routed_net = routed_net->next;
}
if ((level & 2) && best_net)
Log (
LOG_GENERAL,
"-- Phase 2 search Found as best match "
"net '%s' with %d corresponding nodes\n",
best_net->identifier,
accept_nodes);
}
}
if (best_net)
{
Log (
LOG_GENERAL,
"-- Found as best match net '%s' with %d corresponding "
"nodes\n",
best_net->identifier,
accept_nodes);
nodes_left -=
accept_nodes; /* Count down how many nodes left to go */
{
noderef_t *unrouted_nodes = unrouted_net->nodes;
clear_routing_flags (best_net->nodes);
while (unrouted_nodes)
{
if (search_net_for_socket (
unrouted_nodes, best_net->nodes, 0) !=
NULL)
{
unrouted_nodes->r_flag = 1;
}
/* when all flags on unrouted nets go to '1'
then we have finished the jumpering */
if (level & 2)
Log (
LOG_GENERAL,
"-- flag on %s(%s) is %d\n",
unrouted_nodes->node->socket
->identifier,
unrouted_nodes->node->identifier,
unrouted_nodes->r_flag);
unrouted_nodes = unrouted_nodes->next;
}
}
if (nets_used++ == 0 && nodes_left == 0)
{
/* we seem to have found a complete path already with
all the nodes on it. the user is obviously using
'jumper' before 'route' */
if (level & 2)
Log (
LOG_GENERAL,
"-- This net contains all nodes "
"requested, simply connecting\n\n");
jumper_net = best_net;
route_type = By_Net;
}
else
{
route_type = By_Jumpering;
/* try hard to create a unique jumper ID */
while (!jumper_net)
{
jumper_name,
JUMP_FMT,
Suffix,
jumper_count++);
jumper_net = find_net (
&routed_list, Ident, jumper_name, Search);
/* if it is not found then the name proposed is
* unique */
if (!jumper_net)
{
jumper_net = find_net (
&routed_list,
Ident,
jumper_name,
Create);
/*
Log
(LOG_GENERAL, "-- Creating jumper
%s\n", jumper_net->identifier);
*/
jumper_net->how_joined = Jumpered;
break;
}
else
jumper_net =
NULL; /* if found already, it
should not terminate the
loop */
}
Log (
LOG_GENERAL,
"-- Jumpering %s to net %s (nodes_left=%d)\n",
jumper_net->identifier,
best_net->identifier,
nodes_left);
/* mark the used nodes by setting the r_flag on the
* used unrouted nodes */
/* find the first node that is connected to an external
* pin on the best_net */
/* record this as the external node */
{
noderef_t *routed_nodes = best_net->nodes;
while (routed_nodes)
{
if (routed_nodes->node->socket
->is_external)
{
best_net->external_node =
routed_nodes->node;
break;
}
routed_nodes = routed_nodes->next;
}
}
/* make the jumper */
transfer_net_to_subnet (
&routed_list, jumper_net, best_net);
routed_ok = 1;
}
}
else
{
routed_ok = 0;
Log (
LOG_ERROR,
"-- Error : insufficient/no jumperable nets free\n"
"-- to create net '%s' which requires %d more nodes\n",
unrouted_net->identifier,
nodes_left);
}
}
next_net = unrouted_net->next;
if (routed_ok)
{
combine_routed_and_unrouted (jumper_net, unrouted_net);
transfer_net_to_named (&routed_list, jumper_net); /* jumpers are in
routed list */
jumper_net->how_routed = route_type;
next_net = remove_net (&unrouted_list, unrouted_net);
}
else
{
/* Failure to complete, so remove the partially completed jumper net
* from the list */
if (jumper_net)
{
Log (
LOG_ERROR,
"-- failure : disconnecting partially completed jumper\n");
disconnect_jumper (&routed_list, jumper_net);
}
}
unrouted_net = next_net;
}
count_nets ("After using new paths created by jumpers");
}
/* ******************************************** */
__declspec(dllexport) void perform_jumpering (char *Suffix)
{
count_nets ("Before jumper creation");
/* remove any connections we can already make */
/* perform_routing_by_exact_path (); */
/* make the jumpers */
perform_routing_by_making_jumpers (Suffix);
/* then use the jumpers */
/* perform_routing_by_exact_path ();*/
/* then use the jumpers */
/* perform_routing_by_path (); */
}
/* ******************************************** */
/* try to join all the pins seen on ID1 to ID2 */
__declspec(dllexport) void create_all_jumpers (char *ID1, char *ID2)
{
socket_t *ID1_skt, *ID2_skt;
node_t *ID1_node, *ID2_node;
net_t *jumper_net, *ID1_net, *ID2_net;
char rootname[MAXIDLEN];
char *append_point;
ID1_skt = find_socket (Ident, ID1, Search, &socket_head);
ID2_skt = find_socket (Ident, ID2, Search, &socket_head);
if (!ID1_skt)
{
Log (LOG_ERROR, "# ERROR : CONNECTION cannot find socket '%s'\n", ID1);
return;
}
if (!ID2_skt)
{
Log (LOG_ERROR, "# ERROR : CONNECTION cannot find socket '%s'\n", ID2);
return;
}
sprintf (rootname
, "cn_%s_%s_", ID1_skt
->identifier
, ID2_skt
->identifier
); Log (LOG_GENERAL, "-- Creating CONNECTION '%s'\n", rootname);
append_point
= rootname
+ strlen (rootname
); /* where to append the final pin ID */ /* for each node on the first chip, try and find the net that it is on in
the routed list, and jumper it to the net that is on the same pin ID on the second
chip. */
ID1_node = ID1_skt->nodes;
while (ID1_node)
{
if (ID1_node->net && ID1_node->net->list_ref == &routed_list)
{
/* find the highest level of jumper and join it */
ID1_net = ID1_node->net;
while (ID1_net->join_parent)
ID1_net = ID1_net->join_parent;
ID2_node = find_node (ID2_skt, Ident, ID1_node->identifier, Search);
if (ID2_node)
{
if (ID2_node->net && ID2_node->net->list_ref == &routed_list)
{
/* find the highest level of jumper and join it */
ID2_net = ID2_node->net;
while (ID2_net->join_parent)
ID2_net = ID2_net->join_parent;
/* we now have a matched pair of nodes for which we
have to find the nets.
If the nets are both on the list of routed net, create
a named jumper between them */
append_point,
ID1_node->identifier); /* create the totla new net
name */
/*
printf("Can make jumper '%s'\n",rootname);
*/
jumper_net =
find_net (&routed_list, Ident, rootname, Create);
jumper_net->how_joined = Jumpered;
if (transfer_net_to_subnet (
&routed_list, jumper_net, ID1_net))
ID1_node->net->external_node = ID1_node;
if (transfer_net_to_subnet (
&routed_list, jumper_net, ID2_net))
ID2_node->net->external_node = ID2_node;
}
else
Log (
LOG_ERROR,
"-- Warning : Node '%s(%s)' does not appear on a "
"routed net\n",
ID2_skt->identifier,
ID2_node->identifier);
}
else
Log (
LOG_ERROR,
"-- Warning : Cannot locate pin '%s' on socket '%s'\n",
ID1_node->identifier,
ID2_skt->identifier);
}
else
Log (
LOG_ERROR,
"-- Warning : Node '%s(%s)' does not appear on a routed net\n",
ID1_skt->identifier,
ID1_node->identifier);
ID1_node = ID1_node->sktnext; /* move along the socket pins */
}
}
/*******************************************************/
void create_vhdl_connections (void)
{
net_t *top_net;
net_t *subnet;
/* assume that create_unrouted_list has already happened */
top_net = unrouted_list;
while (top_net)
{
if (top_net->vhdl_connect_net)
{
printf ("root net found '%s'\n", top_net
->name
); if (top_net->how_joined != NotJoined)
{
Log (
LOG_ERROR,
"# Warning : %s net '%s' already exists, net is being "
"extended from %d nodes\n",
top_net->how_joined == Jumpered ? "Jumpered" : "Aliased",
top_net->identifier,
top_net->nodecount);
/* if the net is already in existence, it will have nodes */
}
top_net->how_joined = Jumpered;
transfer_net_to_subnet (
&unrouted_list, top_net, top_net->vhdl_connect_net);
}
top_net = top_net->next;
}
}