Subversion Repositories Vertical

/*

 * $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 <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include "vertcl_main.h" 

#include "expression.h"

#include "generic.h"

#include "database.h"

#include "routing.h"

#include "jumpering.h"

#include "cmdparse.h"

#include "cmdlog.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) {

             sprintf (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 */

          strcpy(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;

    }

  }