libgeda/src/o_net_basic.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * libgeda - gEDA's library
   3  * Copyright (C) 1998-2010 Ales Hvezda
   4  * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <math.h>
  24
  25 #include "libgeda_priv.h"
  26
  27 #ifdef HAVE_LIBDMALLOC
  28 #include <dmalloc.h>
  29 #endif
  30
  31 /*! \file o_net_basic.c
  32  *  \brief functions for the net object
  33  */
  34
  35 /*! \brief get the position of the first net point
  36  *  \par Function Description
  37  *  This function gets the position of the first point of a net object.
  38  *
  39  *  \param [in] toplevel The toplevel environment.
  40  *  \param [out] x       pointer to the x-position
  41  *  \param [out] y       pointer to the y-position
  42  *  \param [in] object   The object to get the position.
  43  *  \return TRUE if successfully determined the position, FALSE otherwise
  44  */
  45 gboolean o_net_get_position (TOPLEVEL *toplevel, gint *x, gint *y,
  46                               OBJECT *object)
  47 {
  48   return o_line_get_position(toplevel, x, y, object);
  49 }
  50
  51 /*! \brief calculate and return the boundaries of a net object
  52  *  \par Function Description
  53  *  This function calculates the object boudaries of a net \a object.
  54  *
  55  *  \param [in]  toplevel  The TOPLEVEL object.
  56  *  \param [in]  object    a net object
  57  *  \param [out] left      the left world coord
  58  *  \param [out] top       the top world coord
  59  *  \param [out] right     the right world coord
  60  *  \param [out] bottom    the bottom world coord
  61  */
  62 void world_get_net_bounds(TOPLEVEL *toplevel, OBJECT *object, int *left,
  63                           int *top, int *right, int *bottom)
  64 {
  65   world_get_line_bounds( toplevel, object, left, top, right, bottom );
  66 }
  67
  68 /*! \brief create a new net object
  69  *  \par Function Description
  70  *  This function creates and returns a new net object.
  71  *
  72  *  \param [in]     toplevel    The TOPLEVEL object.
  73  *  \param [in]     type        The OBJECT type (usually OBJ_NET)
  74  *  \param [in]     color       The color of the net
  75  *  \param [in]     x1          x-coord of the first point
  76  *  \param [in]     y1          y-coord of the first point
  77  *  \param [in]     x2          x-coord of the second point
  78  *  \param [in]     y2          y-coord of the second point
  79  *  \return A new net OBJECT
  80  */
  81 OBJECT *o_net_new(TOPLEVEL *toplevel, char type,
  82                   int color, int x1, int y1, int x2, int y2)
  83 {
  84   OBJECT *new_node;
  85
  86   new_node = s_basic_new_object(type, "net");
  87   new_node->color = color;
  88
  89   new_node->line = (LINE *) g_malloc(sizeof(LINE));
  90   /* check for null */
  91
  92   new_node->line->x[0] = x1;
  93   new_node->line->y[0] = y1;
  94   new_node->line->x[1] = x2;
  95   new_node->line->y[1] = y2;
  96   new_node->line_width = NET_WIDTH;
  97
  98   o_net_recalc (toplevel, new_node);
  99
 100   return new_node;
 101 }
 102
 103 /*! \brief recalc the visual properties of a net object
 104  *  \par Function Description
 105  *  This function updates the visual coords of the \a o_current object.
 106  *
 107  *  \param [in]     toplevel    The TOPLEVEL object.
 108  *  \param [in]     o_current   a net object.
 109  *
 110  */
 111 void o_net_recalc(TOPLEVEL *toplevel, OBJECT *o_current)
 112 {
 113   int left, right, top, bottom;
 114
 115   if (o_current == NULL) {
 116     return;
 117   }
 118
 119   if (o_current->line == NULL) {
 120     return;
 121   }
 122
 123   world_get_net_bounds(toplevel, o_current, &left, &top, &right,
 124                  &bottom);
 125
 126   o_current->w_left = left;
 127   o_current->w_top = top;
 128   o_current->w_right = right;
 129   o_current->w_bottom = bottom;
 130   o_current->w_bounds_valid = TRUE;
 131 }
 132
 133 /*! \brief read a net object from a char buffer
 134  *  \par Function Description
 135  *  This function reads a net object from the buffer \a buf.
 136  *  If the netobject was read successfully, a new net object is
 137  *  allocated and appended to the \a object_list.
 138  *
 139  *  \param [in] toplevel     The TOPLEVEL object
 140  *  \param [in] buf          a text buffer (usually a line of a schematic file)
 141  *  \param [in] release_ver  The release number gEDA
 142  *  \param [in] fileformat_ver a integer value of the file format
 143  *  \return The object list
 144  *
 145  */
 146 OBJECT *o_net_read (TOPLEVEL *toplevel, char buf[],
 147                     unsigned int release_ver, unsigned int fileformat_ver)
 148 {
 149   OBJECT *new_obj;
 150   char type;
 151   int x1, y1;
 152   int x2, y2;
 153   int color;
 154
 155   sscanf (buf, "%c %d %d %d %d %d\n", &type, &x1, &y1, &x2, &y2, &color);
 156
 157   if (x1 == x2 && y1 == y2) {
 158     s_log_message (_("Found a zero length net [ %c %d %d %d %d %d ]\n"),
 159                    type, x1, y1, x2, y2, color);
 160   }
 161
 162
 163   if (toplevel->override_net_color != -1) {
 164     color = toplevel->override_net_color;
 165   }
 166
 167   if (color < 0 || color > MAX_COLORS) {
 168     s_log_message (_("Found an invalid color [ %s ]\n"), buf);
 169     s_log_message (_("Setting color to default color\n"));
 170     color = DEFAULT_COLOR;
 171   }
 172
 173   new_obj = o_net_new (toplevel, type, color, x1, y1, x2, y2);
 174
 175   return new_obj;
 176 }
 177
 178 /*! \brief Create a string representation of the net object
 179  *  \par Function Description
 180  *  This function takes a net \a object and return a string
 181  *  according to the file format definition.
 182  *
 183  *  \param [in] toplevel  a TOPLEVEL structure
 184  *  \param [in] object  a net OBJECT
 185  *  \return the string representation of the net OBJECT
 186  */
 187 char *o_net_save(TOPLEVEL *toplevel, OBJECT *object)
 188 {
 189   int x1, x2, y1, y2;
 190   char *buf;
 191
 192   x1 = object->line->x[0];
 193   y1 = object->line->y[0];
 194   x2 = object->line->x[1];
 195   y2 = object->line->y[1];
 196
 197   buf = g_strdup_printf("%c %d %d %d %d %d", object->type, x1, y1, x2, y2, object->color);
 198   return (buf);
 199 }
 200
 201 /*! \brief move a net object
 202  *  \par Function Description
 203  *  This function changes the position of a net \a object.
 204  *
 205  *  \param [in] toplevel     The TOPLEVEL object
 206  *  \param [in] dx           The x-distance to move the object
 207  *  \param [in] dy           The y-distance to move the object
 208  *  \param [in] object       The net OBJECT to be moved
 209  *
 210  */
 211 void o_net_translate_world(TOPLEVEL *toplevel, int dx, int dy,
 212                            OBJECT *object)
 213 {
 214   if (object == NULL)
 215     printf("ntw NO!\n");
 216
 217   /* Update world coords */
 218   object->line->x[0] = object->line->x[0] + dx;
 219   object->line->y[0] = object->line->y[0] + dy;
 220   object->line->x[1] = object->line->x[1] + dx;
 221   object->line->y[1] = object->line->y[1] + dy;
 222
 223   /* Update bounding box */
 224   o_net_recalc (toplevel, object);
 225
 226   s_tile_update_object(toplevel, object);
 227 }
 228
 229 /*! \brief create a copy of a net object
 230  *  \par Function Description
 231  *  This function creates a copy of the net object \a o_current.
 232  *
 233  *  \param [in] toplevel     The TOPLEVEL object
 234  *  \param [in] o_current    The object that is copied
 235  *  \return a new net object
 236  */
 237 OBJECT *o_net_copy(TOPLEVEL *toplevel,  OBJECT *o_current)
 238 {
 239   OBJECT *new_obj;
 240
 241   /* make sure you fix this in pin and bus as well */
 242   /* still doesn't work... you need to pass in the new values */
 243   /* or don't update and update later */
 244   /* I think for now I'll disable the update and manually update */
 245   new_obj = o_net_new (toplevel, OBJ_NET, o_current->color,
 246                        o_current->line->x[0], o_current->line->y[0],
 247                        o_current->line->x[1], o_current->line->y[1]);
 248
 249   return new_obj;
 250 }
 251
 252 /*! \brief postscript print command for a net object
 253  *  \par Function Description
 254  *  This function writes the postscript command of the net object \a o_current
 255  *  into the FILE \a fp points to.
 256  *
 257  *  \param [in] toplevel     The TOPLEVEL object
 258  *  \param [in] fp           pointer to a FILE structure
 259  *  \param [in] o_current    The OBJECT to print
 260  *  \param [in] origin_x     x-coord of the postscript origin
 261  *  \param [in] origin_y     y-coord of the postscript origin
 262  */
 263 void o_net_print(TOPLEVEL *toplevel, FILE *fp, OBJECT *o_current,
 264                  int origin_x, int origin_y)
 265 {
 266   int net_width;
 267   int x1, y1;
 268   int x2, y2;
 269
 270   if (o_current == NULL) {
 271     printf("got null in o_net_print\n");
 272     return;
 273   }
 274
 275   f_print_set_color(toplevel, fp, o_current->color);
 276
 277   net_width = 2;
 278   if (toplevel->net_style == THICK) {
 279     net_width = NET_WIDTH;
 280   }
 281
 282   x1 = o_current->line->x[0] - origin_x,
 283   y1 = o_current->line->y[0] - origin_y;
 284   x2 = o_current->line->x[1] - origin_x,
 285   y2 = o_current->line->y[1] - origin_y;
 286
 287   fprintf(fp, "%d %d %d %d %d line\n", x1,y1,x2,y2,net_width);
 288 }
 289
 290
 291 /*! \brief rotate a net object around a centerpoint
 292  *  \par Function Description
 293  *  This function rotates a net \a object around the point
 294  *  (\a world_centerx, \a world_centery).
 295  *
 296  *  \param [in] toplevel      The TOPLEVEL object
 297  *  \param [in] world_centerx x-coord of the rotation center
 298  *  \param [in] world_centery y-coord of the rotation center
 299  *  \param [in] angle         The angle to rotat the net object
 300  *  \param [in] object        The net object
 301  *  \note only steps of 90 degrees are allowed for the \a angle
 302  */
 303 void o_net_rotate_world(TOPLEVEL *toplevel,
 304                         int world_centerx, int world_centery, int angle,
 305                         OBJECT *object)
 306 {
 307   int newx, newy;
 308
 309   if (angle == 0)
 310     return;
 311
 312   /* translate object to origin */
 313   o_net_translate_world(toplevel, -world_centerx, -world_centery,
 314                         object);
 315
 316   rotate_point_90(object->line->x[0], object->line->y[0], angle,
 317                   &newx, &newy);
 318
 319   object->line->x[0] = newx;
 320   object->line->y[0] = newy;
 321
 322   rotate_point_90(object->line->x[1], object->line->y[1], angle,
 323                   &newx, &newy);
 324
 325   object->line->x[1] = newx;
 326   object->line->y[1] = newy;
 327
 328   o_net_translate_world(toplevel, world_centerx, world_centery, object);
 329 }
 330
 331 /*! \brief mirror a net object horizontaly at a centerpoint
 332  *  \par Function Description
 333  *  This function mirrors a net \a object horizontaly at the point
 334  *  (\a world_centerx, \a world_centery).
 335  *
 336  *  \param [in] toplevel      The TOPLEVEL object
 337  *  \param [in] world_centerx x-coord of the mirror position
 338  *  \param [in] world_centery y-coord of the mirror position
 339  *  \param [in] object        The net object
 340  */
 341 void o_net_mirror_world(TOPLEVEL *toplevel, int world_centerx,
 342                         int world_centery, OBJECT *object)
 343 {
 344   /* translate object to origin */
 345   o_net_translate_world(toplevel, -world_centerx, -world_centery,
 346                         object);
 347
 348   object->line->x[0] = -object->line->x[0];
 349
 350   object->line->x[1] = -object->line->x[1];
 351
 352   o_net_translate_world(toplevel, world_centerx, world_centery, object);
 353 }
 354
 355 /*! \brief calculate the orientation of a net object
 356  *  \par Function Description
 357  *  This function calculates the orientation of a net object.
 358  *
 359  *  \param [in] object   The net object
 360  *  \return The orientation: HORIZONTAL, VERTICAL or NEITHER
 361  */
 362 int o_net_orientation(OBJECT *object)
 363 {
 364     if (object->line->y[0] == object->line->y[1]) {
 365         return (HORIZONTAL);
 366     }
 367
 368     if (object->line->x[0] == object->line->x[1]) {
 369         return (VERTICAL);
 370     }
 371
 372     return (NEITHER);
 373 }
 374
 375
 376 /*! \brief merge two net object
 377  *  \par Function Description
 378  *  This function does the actual work of making one net segment out of two
 379  *  connected segments. The first net segment is extended to the lenght of
 380  *  both objects.
 381  *  The second object (\a del_object) is the object that should be deleted.
 382  *
 383  *  \param [in] object     A net object to extend
 384  *  \param [in] del_object A net object to be merged into \a object
 385  *  \param [in] orient     The orientation of both net objects
 386  *
 387  *  \note The first net \a object gets the attributes of the second net
 388  *  \a del_object if the two nets are merged together.
 389  */
 390 static void o_net_consolidate_lowlevel (OBJECT *object,
 391                                         OBJECT *del_object, int orient)
 392 {
 393   int temp1, temp2;
 394   int final1, final2;
 395   int changed = 0;
 396   GList *a_iter;
 397   OBJECT *a_current;
 398
 399 #if DEBUG
 400   printf("o %d %d %d %d\n", object->line->x[0], object->line->y[0],
 401          object->line->x[1], object->line->y[1]);
 402   printf("d %d %d %d %d\n", del_object->line->x[0],
 403          del_object->line->y[0], del_object->line->x[1],
 404          del_object->line->y[1]);
 405 #endif
 406
 407
 408   if (orient == HORIZONTAL) {
 409
 410     temp1 = min(object->line->x[0], del_object->line->x[0]);
 411     temp2 = min(object->line->x[1], del_object->line->x[1]);
 412
 413     final1 = min(temp1, temp2);
 414
 415     temp1 = max(object->line->x[0], del_object->line->x[0]);
 416     temp2 = max(object->line->x[1], del_object->line->x[1]);
 417
 418     final2 = max(temp1, temp2);
 419
 420     object->line->x[0] = final1;
 421     object->line->x[1] = final2;
 422     changed = 1;
 423   }
 424
 425   if (orient == VERTICAL) {
 426     temp1 = min(object->line->y[0], del_object->line->y[0]);
 427     temp2 = min(object->line->y[1], del_object->line->y[1]);
 428
 429     final1 = min(temp1, temp2);
 430
 431     temp1 = max(object->line->y[0], del_object->line->y[0]);
 432     temp2 = max(object->line->y[1], del_object->line->y[1]);
 433
 434     final2 = max(temp1, temp2);
 435
 436     object->line->y[0] = final1;
 437     object->line->y[1] = final2;
 438     changed = 1;
 439   }
 440 #if DEBUG
 441   printf("fo %d %d %d %d\n", object->line->x[0], object->line->y[0],
 442          object->line->x[1], object->line->y[1]);
 443 #endif
 444
 445   /* Move any attributes from the deleted object*/
 446   if (changed && del_object->attribs != NULL) {
 447
 448     /* Reassign the attached_to pointer on attributes from the del object */
 449     a_iter = del_object->attribs;
 450     while (a_iter != NULL) {
 451       a_current = a_iter->data;
 452       a_current->attached_to = object;
 453       a_iter = g_list_next (a_iter);
 454     }
 455
 456     object->attribs = g_list_concat (object->attribs, del_object->attribs);
 457
 458     /* Don't free del_object->attribs as it's relinked into object's list */
 459     del_object->attribs = NULL;
 460   }
 461 }
 462
 463 /*! \brief Check if there's a midpoint connection at (x,y)
 464  *  \par Function Description
 465  *  This function checks if the \a object is connected to another net
 466  *  between it's endpoints. Net segment's only can be merged if there
 467  *  is no midpoint connection.
 468  *
 469  *  \param object  a net OBJECT to check
 470  *  \param x       x-coord of the connection location
 471  *  \param y       y-coord of the connection location
 472  *  \return TRUE if there's no midpoint connection, else return FALSE
 473  */
 474 static int o_net_consolidate_nomidpoint (OBJECT *object, int x, int y)
 475 {
 476   GList *c_current;
 477   CONN *conn;
 478
 479   c_current = object->conn_list;
 480   while(c_current != NULL) {
 481     conn = (CONN *) c_current->data;
 482     if (conn->other_object) {
 483       if (conn->other_object->sid != object->sid &&
 484           conn->x == x && conn->y == y &&
 485           conn->type == CONN_MIDPOINT) {
 486 #if DEBUG
 487         printf("Found one! %s\n", conn->other_object->name);
 488 #endif
 489         return(FALSE);
 490       }
 491     }
 492
 493     c_current = g_list_next(c_current);
 494   }
 495
 496   return(TRUE);
 497 }
 498
 499 /*! \brief try to consolidate a net object
 500  *  \par Function Description
 501  *  This function tries to consolidate a net with any other object
 502  *  that is connected to the current \a object.
 503  *
 504  *  \param toplevel   The TOPLEVEL object
 505  *  \param object     The object to consolidate
 506  *  \return 0 if no consolidation was possible, -1 otherwise
 507  *
 508  */
 509 static int o_net_consolidate_segments (TOPLEVEL *toplevel, OBJECT *object)
 510 {
 511   int object_orient;
 512   int other_orient;
 513   GList *c_current;
 514   CONN *conn;
 515   OBJECT *other_object;
 516   PAGE *page;
 517   int changed = 0;
 518
 519   g_return_val_if_fail ((toplevel != NULL), 0);
 520   g_return_val_if_fail ((object != NULL), 0);
 521   g_return_val_if_fail ((object->type == OBJ_NET), 0);
 522
 523   /* It's meaningless to do anything here if the object isn't in a page. */
 524   page = o_get_page (toplevel, object);
 525   g_return_val_if_fail ((page != NULL), 0);
 526
 527   object_orient = o_net_orientation(object);
 528
 529   c_current = object->conn_list;
 530   while(c_current != NULL) {
 531     conn = (CONN *) c_current->data;
 532     other_object = conn->other_object;
 533
 534     /* only look at end points which have a valid end on the other side */
 535     if (other_object != NULL && conn->type == CONN_ENDPOINT &&
 536         conn->other_whichone != -1 && conn->whichone != -1 &&
 537         o_net_consolidate_nomidpoint(object, conn->x, conn->y) ) {
 538
 539       if (other_object->type == OBJ_NET) {
 540         other_orient = o_net_orientation(other_object);
 541
 542         /* - both objects have the same orientation (either vert or horiz) */
 543         /* - it's not the same object */
 544         if (object_orient == other_orient &&
 545             object->sid != other_object->sid &&
 546             other_orient != NEITHER) {
 547
 548 #if DEBUG
 549           printf("consolidating %s to %s\n", object->name, other_object->name);
 550 #endif
 551
 552           o_net_consolidate_lowlevel(object, other_object, other_orient);
 553
 554           changed++;
 555           if (other_object->selected == TRUE ) {
 556             o_selection_remove (toplevel, page->selection_list, other_object);
 557
 558             /* If we're consolidating with a selected object,
 559              * ensure we select the resulting object.
 560              */
 561             if (object->selected == FALSE) {
 562               o_selection_add (toplevel, page->selection_list, object);
 563             }
 564           }
 565
 566           s_delete_object (toplevel, other_object);
 567           o_net_recalc(toplevel, object);
 568           s_tile_update_object(toplevel, object);
 569           s_conn_update_object (toplevel, object);
 570           return(-1);
 571         }
 572       }
 573
 574     }
 575
 576     c_current = g_list_next (c_current);
 577   }
 578
 579   return(0);
 580 }
 581
 582 /*! \brief consolidate all net objects
 583  *  \par Function Description
 584  *  This function consolidates all net objects in a page until no more
 585  *  consolidations are possible.
 586  *
 587  *  \param toplevel  The TOPLEVEL object.
 588  *  \param page      The PAGE to consolidate nets in.
 589  */
 590 void o_net_consolidate(TOPLEVEL *toplevel, PAGE *page)
 591 {
 592   OBJECT *o_current;
 593   const GList *iter;
 594   int status = 0;
 595
 596   g_return_if_fail (toplevel != NULL);
 597   g_return_if_fail (page != NULL);
 598
 599   iter = s_page_objects (page);
 600
 601   while (iter != NULL) {
 602     o_current = (OBJECT *)iter->data;
 603
 604     if (o_current->type == OBJ_NET) {
 605       status = o_net_consolidate_segments(toplevel, o_current);
 606     }
 607
 608     if (status == -1) {
 609       iter = s_page_objects (page);
 610       status = 0;
 611     } else {
 612       iter = g_list_next (iter);
 613     }
 614   }
 615 }
 616
 617 /*! \brief modify one point of a net object
 618  *  \par Function Description
 619  *  This function modifies one point of a net \a object. The point
 620  *  is specified by the \a whichone variable and the new coordinate
 621  *  is (\a x, \a y).
 622  *
 623  *  \param toplevel   The TOPLEVEL object
 624  *  \param object     The net OBJECT to modify
 625  *  \param x          new x-coord of the net point
 626  *  \param y          new y-coord of the net point
 627  *  \param whichone   net point to modify
 628  *
 629  */
 630 void o_net_modify(TOPLEVEL *toplevel, OBJECT *object,
 631                   int x, int y, int whichone)
 632 {
 633   object->line->x[whichone] = x;
 634   object->line->y[whichone] = y;
 635
 636   o_net_recalc (toplevel, object);
 637
 638   s_tile_update_object(toplevel, object);
 639 }
 640
 641 /*! \brief Refresh & cache number of connected entities.
 642  *
 643  *  \par Function Description
 644  *  Traverse all network segments reachable from this net and count
 645  *  total number of unique entities connected to all net segments.
 646  *
 647  *  For the purpose of this function, an entity is:
 648  *    - pin
 649  *    - bus
 650  *    - attached netname attribute
 651  *
 652  *  Computed number of entities is afterwards stored in all traversed
 653  *  net segments.
 654  *
 655  *  The algorithm does not handle corner cases, ie two bus segments
 656  *  belonging to the same bus will be counted twice.
 657  *
 658  *  \param [in] toplevel    The TOPLEVEL object
 659  *  \param [in] o_current   The NET OBJECT to check connectivity of
 660  */
 661 void o_net_refresh_conn_cache(TOPLEVEL *toplevel, OBJECT *o_current)
 662 {
 663   gint            num_conns = 0;
 664   GHashTable     *visited;
 665   GHashTableIter  iter;
 666   GList          *stack = NULL;
 667   OBJECT         *obj;
 668   gpointer       *key;
 669
 670   g_return_if_fail (toplevel);
 671   g_return_if_fail (o_current);
 672   g_return_if_fail (o_current->type == OBJ_NET);
 673
 674   /* Keep track of visited nets, pins and buses in the hash table.
 675    * This way we short-circuit the search and avoid loops.
 676    */
 677   visited = g_hash_table_new (NULL, NULL);
 678
 679   /*
 680    * Add the starting net to the hash so:
 681    *   1. it is not traversed twice
 682    *   2. it is updated at the end if no connections are found
 683    */
 684   g_hash_table_insert (visited, o_current, o_current);
 685
 686   /* Check if a netname= is attached to the starting net segment */
 687   if (NULL != o_attrib_search_object_attribs_by_name (o_current,
 688                                                       "netname",
 689                                                       0)) {
 690     num_conns += 1;
 691   }
 692
 693   /* Keep track of connections to search at each net segment in a stack.
 694    * Each stack entry points to an entry in obj->conn_list.
 695    * Pop the stack when we have no more connections to check.
 696    * Push next entry on the stack if we encounter a net segment.
 697    */
 698
 699   /* Initialise the stack for the starting net segment. */
 700   stack = g_list_prepend (stack, o_current->conn_list);
 701
 702   while (stack != NULL) {
 703     /* At start of the loop, take a new connection from the stack. */
 704     GList *conn_list = (GList*) stack->data;
 705     CONN *conn;
 706
 707     if (conn_list == NULL) {
 708       /* No more connections to check at this level. Pop the stack. */
 709       stack = g_list_delete_link (stack, stack);
 710       continue;
 711     }
 712
 713     /* Extract the next connected object and advance the connection list. */
 714     conn = (CONN*) conn_list->data;
 715     obj = conn->other_object;
 716     stack->data = (gpointer) g_list_next (conn_list);
 717
 718     /* Act upon the object that is connected to the segment. */
 719     switch (obj->type) {
 720       case OBJ_PIN:
 721       case OBJ_BUS:
 722         if (NULL == g_hash_table_lookup (visited, obj)) {
 723           g_hash_table_insert (visited, obj, obj);
 724           num_conns += 1;
 725         }
 726         break;
 727       case OBJ_NET:
 728         if (NULL == g_hash_table_lookup (visited, obj)) {
 729           g_hash_table_insert (visited, obj, obj);
 730           /* Check if a netname= is attached to this net segment */
 731           if (NULL != o_attrib_search_object_attribs_by_name (obj,
 732                                                               "netname",
 733                                                               0)) {
 734             num_conns += 1;
 735           }
 736           /* Push new list of connections to check onto the stack */
 737           stack = g_list_prepend (stack, obj->conn_list);
 738         }
 739         break;
 740       default:
 741         break;
 742     }
 743   }
 744
 745   /* Cache value of num_conns in all visited objects */
 746   g_hash_table_iter_init (&iter, visited);
 747
 748   while (g_hash_table_iter_next (&iter, &key, NULL)) {
 749     obj = (OBJECT*) key;
 750     if (obj->type == OBJ_NET) {
 751       obj->net_num_connected = num_conns;
 752       obj->valid_num_connected = TRUE;
 753     }
 754   }
 755
 756   g_hash_table_destroy (visited);
 757   g_list_free (stack);
 758 }
 759
 760 /*! \brief Check if net is fully connected.
 761  *
 762  *  \par Function Description
 763  *  Net is fully connected when it connects at least
 764  *  two separate entities.
 765  *
 766  *  \sa o_net_refresh_conn_cache
 767  *
 768  *  \param [in] toplevel    The TOPLEVEL object
 769  *  \param [in] o_current   The OBJECT to check connectivity of
 770  *  \return TRUE if net is fully connected, FALSE otherwise
 771  */
 772 gboolean o_net_is_fully_connected (TOPLEVEL *toplevel,
 773                                    OBJECT   *o_current)
 774 {
 775   g_return_val_if_fail (toplevel, FALSE);
 776   g_return_val_if_fail (o_current, FALSE);
 777   g_return_val_if_fail (o_current->type == OBJ_NET, FALSE);
 778
 779   if (!o_current->valid_num_connected)
 780     o_net_refresh_conn_cache (toplevel, o_current);
 781
 782   g_return_val_if_fail (o_current->valid_num_connected, FALSE);
 783
 784   return o_current->net_num_connected > 1 ? TRUE : FALSE;
 785 }