gnetlist-legacy/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-2019 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
  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 #include "../include/gettext.h"
  46
  47 typedef struct {
  48     void * next;
  49     char * src;
  50     char * dest;
  51 } RENAME;
  52
  53 typedef struct {
  54     void * next_set;
  55     RENAME * first_rename;
  56     RENAME * last_rename;
  57 } SET;
  58
  59 static SET * first_set = NULL;
  60 static SET * last_set = NULL;
  61
  62 void s_rename_init(void)
  63 {
  64     if (first_set)
  65     {
  66         fprintf(stderr, _("ERROR: Overwriting a valid rename list.\n"));
  67         exit(-1);
  68     }
  69 }
  70
  71 void s_rename_destroy_all(void)
  72 {
  73     RENAME * temp;
  74     void * to_free;
  75
  76     for (; first_set;)
  77     {
  78         for (temp = first_set->first_rename; temp;)
  79         {
  80             g_free(temp->src);
  81             g_free(temp->dest);
  82             to_free = temp;
  83             temp = temp->next;
  84             g_free(to_free);
  85         }
  86         to_free = first_set;
  87         first_set = first_set->next_set;
  88         g_free(to_free);
  89     }
  90     last_set = NULL;
  91 }
  92
  93 void s_rename_next_set(void)
  94 {
  95     SET * new_set;
  96
  97     new_set = g_malloc(sizeof(SET));
  98     memset(new_set,0,sizeof(SET));
  99     if (first_set)
 100     {
 101         last_set->next_set = new_set;
 102         last_set = new_set;
 103     }
 104     else
 105     {
 106         first_set = last_set = new_set;
 107     }
 108 }
 109
 110 void s_rename_print(void)
 111 {
 112     SET * temp_set;
 113     RENAME * temp_rename;
 114     int i;
 115
 116     for (i = 0, temp_set = first_set; temp_set; temp_set = temp_set->next_set, i++)
 117     {
 118         for (temp_rename = temp_set->first_rename; temp_rename; temp_rename = temp_rename->next)
 119         {
 120             printf("%d) Source: _%s_", i, temp_rename->src);
 121             printf(" -> Dest: _%s_\n", temp_rename->dest);
 122         }
 123     }
 124 }
 125
 126 /* if the src is found, return true */
 127 /* if the dest is found, also return true, but warn user */
 128 /* If quiet_flag is true than don't print anything */
 129 int s_rename_search(char *src, char *dest, int quiet_flag)
 130 {
 131     RENAME * temp;
 132
 133     if (last_set)
 134     {
 135         for (temp = last_set->first_rename; temp; temp = temp->next)
 136         {
 137             if (strcmp(src, temp->src) == 0)
 138             {
 139                 return (TRUE);
 140             }
 141
 142             if (strcmp(dest, temp->src) == 0)
 143             {
 144                 if (!quiet_flag)
 145                 {
 146                     fprintf(stderr, _("WARNING: Trying to rename something twice:\n\t%s and %s\nare both a src and dest name\n"), dest, temp->src);
 147                     fprintf(stderr, _("This warning is okay if you have multiple levels of hierarchy!\n"));
 148                 }
 149                 return (TRUE);
 150             }
 151         }
 152     }
 153     return (FALSE);
 154 }
 155
 156 static void s_rename_add_lowlevel (const char *src, const char *dest)
 157 {
 158     RENAME *new_rename;
 159
 160     g_return_if_fail(last_set != NULL);
 161
 162     new_rename = g_malloc(sizeof (RENAME));
 163
 164     g_return_if_fail(new_rename != NULL);
 165
 166     new_rename->next = NULL;
 167     new_rename->src = g_strdup(src);
 168     new_rename->dest = g_strdup(dest);
 169
 170     if (last_set->first_rename == NULL)
 171     {
 172         last_set->first_rename = last_set->last_rename = new_rename;
 173     }
 174     else
 175     {
 176         last_set->last_rename->next = new_rename;
 177         last_set->last_rename = new_rename;
 178     }
 179 }
 180
 181 void s_rename_add(char *src, char *dest)
 182 {
 183     int flag;
 184     RENAME * last;
 185     RENAME * temp;
 186     RENAME * new_rename;
 187     SET * new_set;
 188
 189     if (src == NULL || dest == NULL)
 190     {
 191         return;
 192     }
 193
 194     flag = s_rename_search(src, dest, FALSE);
 195
 196     if (flag)
 197     {
 198         /* If found follow the original behaviour, limiting the operation to the current end-of-list */
 199         last = last_set->last_rename;
 200         for (temp = last_set->first_rename; ; temp = temp->next)
 201         {
 202         if ((strcmp(dest, temp->src) == 0)
 203             && (strcmp(src, temp->dest) != 0))
 204         {
 205             /* we found a -> b, while adding c -> a.
 206              * hence we would have c -> a -> b, so add c -> b.
 207              * avoid renaming if b is same as c!
 208              */
 209 #if DEBUG
 210             printf("Found dest [%s] in src [%s] and that had a dest as: [%s]\n"
 211                    "So you want rename [%s] to [%s]\n",
 212                    dest, temp->src, temp->dest, src, temp->dest);
 213 #endif
 214             s_rename_add_lowlevel(src, temp->dest);
 215
 216         }
 217         else if ((strcmp(src, temp->src) == 0)
 218                  && (strcmp(dest, temp->dest) != 0))
 219         {
 220             /* we found a -> b, while adding a -> c.
 221              * hence b <==> c, so add c -> b.
 222              * avoid renaming if b is same as c!
 223              */
 224 #if DEBUG
 225             printf("Found src [%s] that had a dest as: [%s]\n"
 226                    "Unify nets by renaming [%s] to [%s]\n",
 227                    src, temp->dest, dest, temp->dest);
 228 #endif
 229             s_rename_add_lowlevel(dest, temp->dest);
 230         }
 231             if (temp == last)
 232             {
 233                 break;
 234             }
 235         }
 236     }
 237     else
 238     {
 239         /* Check for a valid set */
 240         if (first_set == NULL)
 241         {
 242             new_set = g_malloc(sizeof(SET));
 243                 memset(new_set,0,sizeof(SET));
 244                 first_set = last_set = new_set;
 245         }
 246         new_rename = g_malloc(sizeof(RENAME));
 247              new_rename->next = NULL;
 248              new_rename->src = g_strdup(src);
 249              new_rename->dest = g_strdup(dest);
 250              if (last_set->first_rename == NULL)
 251              {
 252                  last_set->first_rename = last_set->last_rename = new_rename;
 253              }
 254              else
 255              {
 256                  last_set->last_rename->next = new_rename;
 257                  last_set->last_rename = new_rename;
 258              }
 259     }
 260 }
 261
 262 void s_rename_all_lowlevel(NETLIST * netlist_head, char *src, char *dest)
 263 {
 264     NETLIST *nl_current = NULL;
 265     CPINLIST *pl_current;
 266
 267     nl_current = netlist_head;
 268
 269     while (nl_current != NULL)
 270     {
 271         if (nl_current->cpins)
 272         {
 273             pl_current = nl_current->cpins;
 274             while (pl_current != NULL)
 275             {
 276                 if (pl_current->net_name != NULL)
 277                 {
 278                     if (strcmp(pl_current->net_name, src) == 0)
 279                     {
 280                         pl_current->net_name = g_strdup(dest);
 281                     }
 282                 }
 283                 pl_current = pl_current->next;
 284             }
 285         }
 286         nl_current = nl_current->next;
 287     }
 288 }
 289
 290 void s_rename_all(TOPLEVEL * pr_current, NETLIST * netlist_head)
 291 {
 292     RENAME * temp;
 293
 294 #if DEBUG
 295     s_rename_print();
 296 #endif
 297
 298     if (last_set)
 299     {
 300         for (temp = last_set->first_rename; temp; temp = temp->next)
 301         {
 302             verbose_print("R");
 303             s_rename_all_lowlevel(netlist_head, temp->src, temp->dest);
 304         }
 305     }
 306 }
 307
 308
 309 SCM g_get_renamed_nets(SCM scm_level)
 310 {
 311     SCM pairlist = SCM_EOL;
 312     SCM outerlist = SCM_EOL;
 313     SET * temp_set;
 314     RENAME * temp_rename;
 315     char *level;
 316
 317     level = scm_to_utf8_string (scm_level);
 318
 319     for (temp_set = first_set; temp_set; temp_set = temp_set->next_set)
 320     {
 321         for (temp_rename = temp_set->first_rename; temp_rename; temp_rename = temp_rename->next)
 322         {
 323             pairlist = scm_list_n (scm_from_utf8_string (temp_rename->src),
 324                                    scm_from_utf8_string (temp_rename->dest),
 325                                    SCM_UNDEFINED);
 326             outerlist = scm_cons (pairlist, outerlist);
 327         }
 328     }
 329
 330     free (level);
 331     return (outerlist);
 332 }