gnetlist/src/s_rename.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * gnetlist - gEDA Netlist
   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., 59 Temple Place, Suite 330, Boston, MA 02111 USA
  19  */
  20
  21  /*
  22   * 2005/05/02  Almost totally reimplemented to support dynamic allocation.
  23   *
  24   * Changes are Copyright (C) 2005 Carlos A. R. Azevedo
  25   */
  26
  27 #include <config.h>
  28
  29 #include <stdio.h>
  30 #include <ctype.h>
  31 #ifdef HAVE_STRING_H
  32 #include <string.h>
  33 #endif
  34 #ifdef HAVE_STDLIB_H
  35 #include <stdlib.h>
  36 #endif
  37 #ifdef HAVE_ASSERT_H
  38 #include <assert.h>
  39 #endif
  40
  41 #include <libgeda/libgeda.h>
  42
  43 #include "../include/globals.h"
  44 #include "../include/prototype.h"
  45
  46 #ifdef HAVE_LIBDMALLOC
  47 #include <dmalloc.h>
  48 #endif
  49
  50 typedef struct {
  51     void * next;
  52     char * src;
  53     char * dest;
  54 } RENAME;
  55
  56 typedef struct {
  57     void * next_set;
  58     RENAME * first_rename;
  59     RENAME * last_rename;
  60 } SET;
  61
  62 static SET * first_set = NULL;
  63 static SET * last_set = NULL;
  64
  65 void s_rename_init(void)
  66 {
  67     if (first_set)
  68     {
  69         fprintf(stderr,"ERROR: Overwriting a valid rename list.\n");
  70         exit(-1);
  71     }
  72 }
  73
  74 void s_rename_destroy_all(void)
  75 {
  76     RENAME * temp;
  77     void * to_free;
  78
  79     for (; first_set;)
  80     {
  81         for (temp = first_set->first_rename; temp;)
  82         {
  83             g_free(temp->src);
  84             g_free(temp->dest);
  85             to_free = temp;
  86             temp = temp->next;
  87             g_free(to_free);
  88         }
  89         to_free = first_set;
  90         first_set = first_set->next_set;
  91         g_free(to_free);
  92     }
  93     last_set = NULL;
  94 }
  95
  96 void s_rename_next_set(void)
  97 {
  98     SET * new_set;
  99
 100     new_set = g_malloc(sizeof(SET));
 101     memset(new_set,0,sizeof(SET));
 102     if (first_set)
 103     {
 104         last_set->next_set = new_set;
 105         last_set = new_set;
 106     }
 107     else
 108     {
 109         first_set = last_set = new_set;
 110     }
 111 }
 112
 113 void s_rename_print(void)
 114 {
 115     SET * temp_set;
 116     RENAME * temp_rename;
 117     int i;
 118
 119     for (i = 0, temp_set = first_set; temp_set; temp_set = temp_set->next_set, i++)
 120     {
 121         for (temp_rename = temp_set->first_rename; temp_rename; temp_rename = temp_rename->next)
 122         {
 123             printf("%d) Source: _%s_", i, temp_rename->src);
 124             printf(" -> Dest: _%s_\n", temp_rename->dest);
 125         }
 126     }
 127 }
 128
 129 /* if the src is found, return true */
 130 /* if the dest is found, also return true, but warn user */
 131 /* If quiet_flag is true than don't print anything */
 132 int s_rename_search(char *src, char *dest, int quiet_flag)
 133 {
 134     RENAME * temp;
 135
 136     if (last_set)
 137     {
 138         for (temp = last_set->first_rename; temp; temp = temp->next)
 139         {
 140             if (strcmp(src, temp->src) == 0)
 141             {
 142                 return (TRUE);
 143             }
 144
 145             if (strcmp(dest, temp->src) == 0)
 146             {
 147                 if (!quiet_flag)
 148                 {
 149                     fprintf(stderr,"WARNING: Trying to rename something twice:\n\t%s and %s\nare both a src and dest name\n", dest, temp->src);
 150                     fprintf(stderr,"This warning is okay if you have multiple levels of hierarchy!\n");
 151                 }
 152                 return (TRUE);
 153             }
 154         }
 155     }
 156     return (FALSE);
 157 }
 158
 159 void s_rename_add(char *src, char *dest)
 160 {
 161     int flag;
 162     RENAME * last;
 163     RENAME * temp;
 164     RENAME * new_rename;
 165     SET * new_set;
 166
 167     if (src == NULL || dest == NULL)
 168     {
 169         return;
 170     }
 171
 172     flag = s_rename_search(src, dest, FALSE);
 173
 174     if (flag)
 175     {
 176         /* If found follow the original behaviour, limiting the operation to the current end-of-list */
 177         last = last_set->last_rename;
 178         for (temp = last_set->first_rename; ; temp = temp->next)
 179         {
 180             if (strcmp(dest, temp->src) == 0)
 181             {
 182 #if DEBUG
 183                 printf("Found dest [%s] in src [%s] and that had a dest as: [%s]\nSo you want rename [%s] to [%s]\n",
 184                        dest, temp->src, temp->dest, src, temp->dest);
 185 #endif
 186                 new_rename = g_malloc(sizeof(RENAME));
 187                      new_rename->next = NULL;
 188                      new_rename->src = g_strdup(src);
 189                      new_rename->dest = g_strdup(temp->dest);
 190                      /* If the rename pair was found then a set already exists, so there's no need the check it */
 191                      if (last_set->first_rename == NULL)
 192                      {
 193                          last_set->first_rename = last_set->last_rename = new_rename;
 194                      }
 195                      else
 196                      {
 197                          last_set->last_rename->next = new_rename;
 198                          last_set->last_rename = new_rename;
 199                      }
 200             }
 201             if (temp == last)
 202             {
 203                 break;
 204             }
 205         }
 206     }
 207     else
 208     {
 209         /* Check for a valid set */
 210         if (first_set == NULL)
 211         {
 212             new_set = g_malloc(sizeof(SET));
 213                 memset(new_set,0,sizeof(SET));
 214                 first_set = last_set = new_set;
 215         }
 216         new_rename = g_malloc(sizeof(RENAME));
 217              new_rename->next = NULL;
 218              new_rename->src = g_strdup(src);
 219              new_rename->dest = g_strdup(dest);
 220              if (last_set->first_rename == NULL)
 221              {
 222                  last_set->first_rename = last_set->last_rename = new_rename;
 223              }
 224              else
 225              {
 226                  last_set->last_rename->next = new_rename;
 227                  last_set->last_rename = new_rename;
 228              }
 229     }
 230 }
 231
 232 void s_rename_all_lowlevel(NETLIST * netlist_head, char *src, char *dest)
 233 {
 234     NETLIST *nl_current = NULL;
 235     CPINLIST *pl_current;
 236
 237     nl_current = netlist_head;
 238
 239     while (nl_current != NULL)
 240     {
 241         if (nl_current->cpins)
 242         {
 243             pl_current = nl_current->cpins;
 244             while (pl_current != NULL)
 245             {
 246                 if (pl_current->net_name != NULL)
 247                 {
 248                     if (strcmp(pl_current->net_name, src) == 0)
 249                     {
 250                         pl_current->net_name = g_strdup(dest);
 251                     }
 252                 }
 253                 pl_current = pl_current->next;
 254             }
 255         }
 256         nl_current = nl_current->next;
 257     }
 258 }
 259
 260 void s_rename_all(TOPLEVEL * pr_current, NETLIST * netlist_head)
 261 {
 262     RENAME * temp;
 263
 264 #if DEBUG
 265     s_rename_print();
 266 #endif
 267
 268     if (last_set)
 269     {
 270         for (temp = last_set->first_rename; temp; temp = temp->next)
 271         {
 272             verbose_print("R");
 273             s_rename_all_lowlevel(netlist_head, temp->src, temp->dest);
 274         }
 275     }
 276 }
 277
 278
 279 SCM g_get_renamed_nets(SCM scm_level)
 280 {
 281     SCM pairlist = SCM_EOL;
 282     SCM outerlist = SCM_EOL;
 283     SET * temp_set;
 284     RENAME * temp_rename;
 285     char *level;
 286
 287     level = SCM_STRING_CHARS (scm_level);
 288
 289     for (temp_set = first_set; temp_set; temp_set = temp_set->next_set)
 290     {
 291         for (temp_rename = temp_set->first_rename; temp_rename; temp_rename = temp_rename->next)
 292         {
 293             pairlist = scm_list_n (scm_makfrom0str (temp_rename->src), scm_makfrom0str (temp_rename->dest), SCM_UNDEFINED);
 294             outerlist = scm_cons (pairlist, outerlist);
 295         }
 296     }
 297     return (outerlist);
 298 }