s_conn.c

Go to the documentation of this file.

/* gEDA - GPL Electronic Design Automation
 * libgeda - gEDA's library
 * Copyright (C) 1998-2010 Ales Hvezda
 * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <config.h>

#include <stdio.h>
#include <ctype.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#include "libgeda_priv.h"

#ifdef HAVE_LIBDMALLOC
#include <dmalloc.h>
#endif

CONN *s_conn_return_new(OBJECT * other_object, int type, int x, int y,
            int whichone, int other_whichone)
{
  CONN *new_conn;

  new_conn = (CONN *) g_malloc(sizeof(CONN));

#if DEBUG
  printf("** creating: %s %d %d\n", other_object->name, x, y);
#endif

  new_conn->other_object = other_object;
  new_conn->type = type;
  new_conn->x = x;
  new_conn->y = y;
  new_conn->whichone = whichone;
  new_conn->other_whichone = other_whichone;

  return (new_conn);
}

int s_conn_uniq(GList * conn_list, CONN * input_conn)
{
  GList *c_current;
  CONN *conn;

  c_current = conn_list;
  while (c_current != NULL) {
    conn = (CONN *) c_current->data;

    if (conn->other_object == input_conn->other_object &&
        conn->x == input_conn->x && conn->y == input_conn->y &&
        conn->type == input_conn->type) {
      return (FALSE);
    }

    c_current = g_list_next(c_current);
  }

  return (TRUE);
}

int s_conn_remove_other (TOPLEVEL *toplevel, OBJECT *other_object,
                         OBJECT *to_remove)
{
    GList *c_current = NULL;
    CONN *conn = NULL;

    o_emit_pre_change_notify (toplevel, other_object);

    c_current = other_object->conn_list;
    while (c_current != NULL) {
    conn = (CONN *) c_current->data;

    if (conn->other_object == to_remove) {
        other_object->conn_list =
        g_list_remove(other_object->conn_list, conn);

#if DEBUG
        printf("Found other_object in remove_other\n");
        printf("Freeing other: %s %d %d\n", conn->other_object->name,
           conn->x, conn->y);
#endif

        /* Do not write modify c_current like this, since this will cause */
        /* very nasty data corruption and upset glib's memory slice */
        /* allocator. */
        /* c_current->data = NULL;   Do not comment in */

        g_free(conn);

#if 0 /* this does not work right */
            if (other_object->type == OBJ_BUS &&
                other_object->conn_list == NULL) {
              other_object->bus_ripper_direction = 0;
            }
#endif
        s_conn_emit_conns_changed (toplevel, other_object);
            
        return (TRUE);
    }

    c_current = g_list_next(c_current);
    }

    o_emit_change_notify (toplevel, other_object);

    return (FALSE);
}

static void s_conn_remove_glist (TOPLEVEL *toplevel, GList *obj_list)
{
  OBJECT *o_current;
  GList *iter;

  for (iter = obj_list; iter != NULL; iter = g_list_next (iter)) {
    o_current = iter->data;
    s_conn_remove_object (toplevel, o_current);
  }
}

void s_conn_remove_object (TOPLEVEL *toplevel, OBJECT *to_remove)
{
  GList *c_iter;
  CONN *conn;

  switch (to_remove->type) {
    case OBJ_PIN:
    case OBJ_NET:
    case OBJ_BUS:
      for (c_iter = to_remove->conn_list;
           c_iter != NULL;
           c_iter = g_list_next (c_iter)) {
        conn = c_iter->data;


        s_conn_freeze_hooks (toplevel, conn->other_object);
        /* keep calling this till it returns false (all refs removed) */
        /* there is NO body to this while loop */
        while (s_conn_remove_other (toplevel, conn->other_object, to_remove));

        c_iter->data = NULL;
        s_conn_thaw_hooks (toplevel, conn->other_object);
        g_free (conn);
      }

      g_list_free (to_remove->conn_list);
      to_remove->conn_list = NULL;
      break;

    case OBJ_COMPLEX:
    case OBJ_PLACEHOLDER:
      s_conn_remove_glist (toplevel, to_remove->complex->prim_objs);
      break;
  }

  s_conn_emit_conns_changed (toplevel, to_remove);
}

OBJECT *s_conn_check_midpoint(OBJECT *o_current, int x, int y)
{
  int min_x, min_y, max_x, max_y;

  switch(o_current->type) {
    case(OBJ_NET):
    case(OBJ_PIN):
    case(OBJ_BUS):
      min_y = min(o_current->line->y[0], 
                  o_current->line->y[1]);
      max_y = max(o_current->line->y[0], 
                  o_current->line->y[1]);

                /* vertical */
      if ( (o_current->line->x[0] == x) &&
           (y > min_y) && (y < max_y) &&
           (o_current->line->x[0] ==
            o_current->line->x[1]) ) {
#if DEBUG
        printf("Found vertical point\n");
#endif
        return(o_current);
      }

      min_x = min(o_current->line->x[0], 
                  o_current->line->x[1]);
      max_x = max(o_current->line->x[0], 
                  o_current->line->x[1]);

                /* horizontal */
      if ( (o_current->line->y[0] == y) &&
           (x > min_x) && (x < max_x) &&
           (o_current->line->y[0] ==
            o_current->line->y[1]) ) {
#if DEBUG
        printf("Found horizontal point\n");
#endif
        return(o_current);
      }

      break;
  }
  return(NULL);
}

void s_conn_update_glist (TOPLEVEL *toplevel, GList *obj_list)
{
  OBJECT *o_current;
  GList *iter;

  for (iter = obj_list; iter != NULL; iter = g_list_next (iter)) {
    o_current = iter->data;
    s_conn_update_object (toplevel, o_current);
  }
}


static int is_bus_related (OBJECT *object)
{
  return (object->type == OBJ_BUS ||
           (object->type == OBJ_PIN && object->pin_type == PIN_TYPE_BUS));
}


static int check_direct_compat (OBJECT *object1, OBJECT *object2)
{
  return (is_bus_related (object1) == is_bus_related (object2));
}


static void add_connection (TOPLEVEL *toplevel,
                            OBJECT *object, OBJECT *other_object,
                            int type, int x, int y,
                            int whichone, int other_whichone)
{
  /* Describe the connection */
  CONN *new_conn = s_conn_return_new (other_object, type, x, y,
                                      whichone, other_whichone);
  /* Do uniqness check */
  if (s_conn_uniq (object->conn_list, new_conn)) {
    object->conn_list = g_list_append (object->conn_list, new_conn);
    s_conn_emit_conns_changed (toplevel, object);
    s_conn_emit_conns_changed (toplevel, other_object);
  } else {
    g_free (new_conn);
  }
}

static void s_conn_update_line_object (TOPLEVEL *toplevel, OBJECT *object)
{
  TILE *t_current;
  GList *tl_current;
  GList *object_list;
  OBJECT *other_object;
  OBJECT *found;
  int j, k;

  s_conn_freeze_hooks (toplevel, object);

  /* loop over all tiles which object appears in */
  for (tl_current = object->tiles;
       tl_current != NULL;
       tl_current = g_list_next (tl_current)) {
    t_current = tl_current->data;

    for (object_list = t_current->objects;
         object_list != NULL;
         object_list = g_list_next (object_list)) {
      other_object = object_list->data;

      if (object == other_object)
        continue;

      s_conn_freeze_hooks (toplevel, other_object);

      /* Here is where you check the end points */
      /* Check both end points of the other object */
      for (k = 0; k < 2; k++) {

        /* If the other object is a pin, only check the correct end */
        if (other_object->type == OBJ_PIN && other_object->whichend != k)
          continue;

        /* Check both end points of the object */
        for (j = 0; j < 2; j++) {

          /* If the object is a pin, only check the correct end */
          if (object->type == OBJ_PIN && object->whichend != j)
            continue;

          /* Check for coincidence and compatability between
             the objects being tested. */
          if (object->line->x[j] == other_object->line->x[k] &&
              object->line->y[j] == other_object->line->y[k] &&
              check_direct_compat (object, other_object)) {

            o_emit_pre_change_notify (toplevel, other_object);

            add_connection (toplevel, object, other_object, CONN_ENDPOINT,
                            other_object->line->x[k],
                            other_object->line->y[k], j, k);

            add_connection (toplevel, other_object, object, CONN_ENDPOINT,
                            object->line->x[j],
                            object->line->y[j], k, j);

            o_emit_change_notify (toplevel, other_object);
          }
        }
      }

      /* Check both end points of the object against midpoints of the other */
      for (k = 0; k < 2; k++) {

        /* If the object is a pin, only check the correct end */
        if (object->type == OBJ_PIN && object->whichend != k)
          continue;

        /* check for midpoint of other object, k endpoint of current obj*/
        found = s_conn_check_midpoint (other_object, object->line->x[k],
                                                     object->line->y[k]);

        /* Pins are not allowed midpoint connections onto them. */
        /* Allow nets to connect to the middle of buses. */
        /* Allow compatible objects to connect. */
        if (found && other_object->type != OBJ_PIN &&
            ((object->type == OBJ_NET && other_object->type == OBJ_BUS) ||
              check_direct_compat (object, other_object))) {

          add_connection (toplevel, object, other_object, CONN_MIDPOINT,
                          object->line->x[k],
                          object->line->y[k], k, -1);

          add_connection (toplevel, other_object, object, CONN_MIDPOINT,
                          object->line->x[k],
                          object->line->y[k], -1, k);

        }
      }

      /* Check both end points of the other object against midpoints of the first */
      for (k = 0; k < 2; k++) {

        /* If the other object is a pin, only check the correct end */
        if (other_object->type == OBJ_PIN && other_object->whichend != k)
          continue;

        /* do object's endpoints cross the middle of other_object? */
        /* check for midpoint of other object, k endpoint of current obj*/
        found = s_conn_check_midpoint (object, other_object->line->x[k],
                                               other_object->line->y[k]);

        /* Pins are not allowed midpoint connections onto them. */
        /* Allow nets to connect to the middle of buses. */
        /* Allow compatible objects to connect. */
        if (found && object->type != OBJ_PIN &&
             ((object->type == OBJ_BUS && other_object->type == OBJ_NET) ||
               check_direct_compat (object, other_object))) {

          add_connection (toplevel, object, other_object, CONN_MIDPOINT,
                          other_object->line->x[k],
                          other_object->line->y[k], -1, k);

          add_connection (toplevel, other_object, object, CONN_MIDPOINT,
                          other_object->line->x[k],
                          other_object->line->y[k], k, -1);
        }
      }

      s_conn_thaw_hooks (toplevel, other_object);
    }
  }

#if DEBUG
  s_conn_print(object->conn_list);
#endif

  s_conn_thaw_hooks (toplevel, object);
}

void s_conn_update_object (TOPLEVEL *toplevel, OBJECT *object)
{
  switch (object->type) {
    case OBJ_PIN:
    case OBJ_NET:
    case OBJ_BUS:
      s_conn_update_line_object (toplevel, object);
      break;

    case OBJ_COMPLEX:
    case OBJ_PLACEHOLDER:
      s_conn_update_glist (toplevel, object->complex->prim_objs);
      break;
  }
}

void s_conn_print(GList * conn_list)
{
  CONN *conn;
  GList *cl_current;

  printf("\nStarting s_conn_print\n");
  cl_current = conn_list;
  while (cl_current != NULL) {

    conn = (CONN *) cl_current->data;
    printf("-----------------------------------\n");
    printf("other object: %s\n", conn->other_object->name);
    printf("type: %d\n", conn->type);
    printf("x: %d y: %d\n", conn->x, conn->y);
    printf("whichone: %d\n", conn->whichone);
    printf("other_whichone: %d\n", conn->other_whichone);
    printf("-----------------------------------\n");

    cl_current = g_list_next(cl_current);
  }

}

int s_conn_net_search(OBJECT* new_net, int whichone, GList * conn_list)
{
  CONN *conn;
  GList *cl_current;

  cl_current = conn_list;
  while (cl_current != NULL) {

    conn = (CONN *) cl_current->data;
    if (conn != NULL && conn->whichone == whichone && 
        conn->x == new_net->line->x[whichone] &&
    conn->y == new_net->line->y[whichone])
    {
       return TRUE;
    }

    cl_current = g_list_next(cl_current);
  }
 
  return FALSE;
}

static GList *s_conn_return_glist_others (GList *input_list, GList *obj_list)
{
  GList *return_list;
  GList *iter;
  OBJECT *o_current;

  return_list = input_list;

  for (iter = obj_list; iter != NULL; iter = g_list_next (iter)) {
    o_current = iter->data;
    return_list = s_conn_return_others (return_list, o_current);
  }

  return return_list;
}

GList *s_conn_return_others(GList *input_list, OBJECT *object)
{
  GList *c_iter;
  GList *return_list;

  return_list = input_list;

  switch (object->type) {
    case OBJ_PIN:
    case OBJ_NET:
    case OBJ_BUS:
      for (c_iter = object->conn_list;
           c_iter != NULL; c_iter = g_list_next (c_iter)) {
        CONN *conn = c_iter->data;

        if (conn->other_object && conn->other_object != object) {
          return_list = g_list_append(return_list, conn->other_object);
        }
      }
      break;

    case OBJ_COMPLEX:
    case OBJ_PLACEHOLDER:
      return_list = s_conn_return_glist_others (return_list,
                                                object->complex->prim_objs);
      break;
  }

  return return_list;
}


typedef struct {
  ConnsChangedFunc func;
  void *data;
} ConnsChangedHook;


void s_conn_append_conns_changed_hook (TOPLEVEL *toplevel,
                                       ConnsChangedFunc func,
                                       void *data)
{
  ConnsChangedHook *new_hook;

  new_hook = g_new0 (ConnsChangedHook, 1);
  new_hook->func = func;
  new_hook->data = data;

  toplevel->conns_changed_hooks =
    g_list_append (toplevel->conns_changed_hooks, new_hook);
}


static void call_conns_changed_hook (gpointer data, gpointer user_data)
{
  ConnsChangedHook *hook = data;
  OBJECT *object = user_data;

  hook->func (hook->data, object);
}


void s_conn_emit_conns_changed (TOPLEVEL *toplevel, OBJECT *object)
{
  if (object->conn_notify_freeze_count > 0) {
    object->conn_notify_pending = 1;
    return;
  }

  object->conn_notify_pending = 0;

  g_list_foreach (toplevel->conns_changed_hooks,
                  call_conns_changed_hook, object);
}

void s_conn_freeze_hooks (TOPLEVEL *toplevel, OBJECT *object)
{
  object->conn_notify_freeze_count += 1;
}

void s_conn_thaw_hooks (TOPLEVEL *toplevel, OBJECT *object)
{
  g_return_if_fail (object->conn_notify_freeze_count > 0);

  object->conn_notify_freeze_count -= 1;

  if (object->conn_notify_freeze_count == 0 &&
      object->conn_notify_pending)
    s_conn_emit_conns_changed (toplevel, object);
}

static void refresh_connectivity_cache (TOPLEVEL *toplevel, OBJECT *object)
{
    if (object->type == OBJ_NET) {
        /* FIXME: suboptimal to refresh cache every time */
        /* better approach would invalidate cache without refresh */
        /* refresh would be done on redraw of pin cues */
        o_net_refresh_conn_cache (toplevel, object);
    }
}

static void s_conn_init_toplevel (TOPLEVEL *toplevel)
{
    /* Connect the hooks for tracking net connectivity here */
    s_conn_append_conns_changed_hook (toplevel,
                                      (ConnsChangedFunc)
                                          refresh_connectivity_cache,
                                      toplevel);

    o_attrib_append_attribs_changed_hook (toplevel,
                                          (AttribsChangedFunc)
                                              refresh_connectivity_cache,
                                          toplevel);
}

void s_conn_init (void)
{
    s_toplevel_append_new_hook ((NewToplevelFunc) s_conn_init_toplevel,
                                NULL);
}