WebSVN – Vertical – Diff – /branches/metal/vertlib/sorting.c

  * Mike put it here
+ *
+ *
  * Revision 1.24  2000/10/04  10:37:10  10:37:10  mjames (Mike James)
  * Modified for Vertical2 : support COMPONENTS and SIGNALS
  *
  * Revision 1.24  2000/10/04  10:37:10  10:37:10  mjames (Mike James)
  * Part of Release PSAVAT01
  *
  * Revision 1.23  2000/10/02  11:04:21  11:04:21  mjames (Mike James)
  * new_vhdl
  *
  * Revision 1.22  2000/09/27  14:42:21  14:42:21  mjames (Mike James)
  * Part of Release Sep_27_ST_2000
  *
  * Revision 1.21  2000/09/21  10:15:51  10:15:51  mjames (Mike James)
  * Part of Release Sep21Alpha
  *
  * Revision 1.20  2000/08/25  09:57:16  09:57:16  mjames (Mike James)
  * Part of Release Aug25_alpha
  *
  * Revision 1.19  2000/08/16  08:57:33  08:57:33  mjames (Mike James)
  * Part of Release CD01_Aug2000
  *
  * Revision 1.18  2000/08/14  14:45:13  14:45:13  mjames (Mike James)
  * Part of Release Aug_14_2000
  *
  * Revision 1.17  2000/08/11  08:30:34  08:30:34  mjames (Mike James)
  * Part of Release Aug_11_2000
  *
  * Revision 1.16  2000/08/09  10:31:49  10:31:49  mjames (Mike James)
  * Part of Release Aug__9_2000
  *
  * Revision 1.15  2000/05/31  11:43:00  11:43:00  mjames (Mike James)
  * Part of Release May_31_2000
  *
  * Revision 1.14  2000/05/08  17:01:40  17:01:40  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.13  2000/05/08  16:59:33  16:59:33  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.12  2000/05/08  16:57:10  16:57:10  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.11  2000/03/08  16:19:31  16:19:31  mjames (Mike James)
  * New version including PC
  *
  * Revision 1.8  2000/01/20  15:58:50  15:58:50  mjames (Mike James)
  * Part of Release R22
  *
  * Revision 1.7  99/12/22  11:15:31  11:15:31  mjames (Mike James)
  * Part of Release Dec_22_1999
  *
  * Revision 1.6  99/06/25  14:35:51  14:35:51  mjames (Mike James)
  * Added in reference to expression.h, but no changes made
  * to the function of acfread yet.
  *
  * Revision 1.5  99/05/04  09:52:52  09:52:52  mjames (Mike James)
  * General checkin
  *
  * Revision 1.4  98/02/11  11:27:19  11:27:19  mjames (Mike James)
  * Checked in for version 6.2a
  *
  * Revision 1.3  97/04/23  08:43:25  08:43:25  mjames (Mike James)
  * CHecked in for release rel23041997
  *
  * Revision 1.2  96/12/23  15:17:00  15:17:00  mjames (Mike James)
  * Altered because find_socket takes a reference
  * to the head-of-list-pointer noth the pointer itself.
  *
  * Revision 1.1  96/12/23  10:26:21  10:26:21  mjames (Mike James)
  * Initial revision *  */
-#include <ctype.h>
-#include <regex.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
 #include <sys/types.h>
+#include <regex.h>
 /* TCL/Tk declarations */
-#include "cmdlog.h"
-#include "cmdparse.h"
-#include "database.h"
+#include "vertcl_main.h"
 #include "expression.h"
 #include "generic.h"
+#include "database.h"
 #include "routing.h"
+#include "cmdparse.h"
+#include "cmdlog.h"
 #include "sorting.h"
-#include "vertcl_main.h"
-#ident                                                                                        \
-    "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/vertlib/sorting.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $";
+#ident "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/vertlib/sorting.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $";
 /* the comparison function  : requires upgrade for checking :
    A1...A10 then B1..B10 or is it   1a..10a then 1b..10b */
 #if defined SORT_ORIGINAL
-static int sort_nodes_compar (const void *p, const void *q)
+static int sort_nodes_compar(const void * p,const void * q)
-{
-        char *s1 = (*(node_t **) p)->identifier;
+{ char * s1 = (*(node_t **)p)->identifier;
-        char *s2 = (*(node_t **) q)->identifier;
+  char * s2 = (*(node_t **)q)->identifier;
-        int l1 = strlen (s1);
+  int l1 = strlen(s1);
-        int l2 = strlen (s2);
+  int l2 = strlen(s2);
-        if (l1 == l2) /* only call strcmp() for same length strings
+  if(l1==l2) /* only call strcmp() for same length strings
-                         This makes '2' smaller than '19' */
+                This makes '2' smaller than '19' */
-                return strcmp (s1, s2);
+    return strcmp(s1,s2);
-        else
+  else
-                return l1 - l2; /* if different lengths, use the shorter name */
+    return l1-l2; /* if different lengths, use the shorter name */
+}
 #else
 /* this sort works for alpha - numeric strings : A1 A2
    use SWAP command to swap identifiers  */
-static int sort_nodes_compar (const void *p, const void *q)
+static int sort_nodes_compar(const void * p,const void * q)
+{
-        char *s1 = (*(node_t **) p)->id_alpha_chars;
+  char * s1 = (*(node_t **)p)->id_alpha_chars;
-        char *s2 = (*(node_t **) q)->id_alpha_chars;
+  char * s2 = (*(node_t **)q)->id_alpha_chars;
-        int l1 = (*(node_t **) p)->id_alpha_cnt;
+  int l1    = (*(node_t **)p)->id_alpha_cnt;
-        int l2 = (*(node_t **) q)->id_alpha_cnt;
+  int l2    = (*(node_t **)q)->id_alpha_cnt;
-        int diff = 0;
+  int diff = 0;
-        /*
+/*
-          printf("cmp p: a %3s[%2d] n %3s[%2d]\n",
+  printf("cmp p: a %3s[%2d] n %3s[%2d]\n",
-           (*(node_t **)p)->id_alpha_chars,
+   (*(node_t **)p)->id_alpha_chars,
-            (*(node_t **)p)->id_alpha_cnt,
+    (*(node_t **)p)->id_alpha_cnt,
-            (*(node_t **)p)->id_numeric_chars,
+    (*(node_t **)p)->id_numeric_chars,
-            (*(node_t **)p)->id_numeric_cnt);
+    (*(node_t **)p)->id_numeric_cnt);
-          printf("cmp q: a %3s[%2d] n %3s[%2d]\n",
+  printf("cmp q: a %3s[%2d] n %3s[%2d]\n",
-           (*(node_t **)q)->id_alpha_chars,
+   (*(node_t **)q)->id_alpha_chars,
-            (*(node_t **)q)->id_alpha_cnt,
+    (*(node_t **)q)->id_alpha_cnt,
-            (*(node_t **)q)->id_numeric_chars,
+    (*(node_t **)q)->id_numeric_chars,
-            (*(node_t **)q)->id_numeric_cnt);
+    (*(node_t **)q)->id_numeric_cnt);
-        */
+*/
-        if (l1 == l2)
+  if(l1==l2)
-        {
+    {
-                /* only call strcmp() for same length strings */
+    /* only call strcmp() for same length strings */
-                diff = strncmp (s1, s2, l1);
+    diff = strncmp(s1,s2,l1);
-                /*
+/*
-                    printf("alpha cmp (%s,%s,%d) different %d\n",s1,s2,l1,diff);
+    printf("alpha cmp (%s,%s,%d) different %d\n",s1,s2,l1,diff);
-                */
+*/
-                if (diff == 0) /* alpha same */
+    if (diff==0) /* alpha same */
-                {
+      {
-                        /* otherwise check the numeric parts of the strings */
+      /* otherwise check the numeric parts of the strings */
-                        /* these have been decoded already */
+      /* these have been decoded already */
-                        l1 = (*(node_t **) p)->pin_row;
+      l1    = (*(node_t **)p)->pin_row;
-                        l2 = (*(node_t **) q)->pin_row;
+      l2    = (*(node_t **)q)->pin_row;
-                        diff = l1 - l2;
+      diff  = l1-l2;
-                        /*
+/*
-                              printf("num different %d\n",diff);
+      printf("num different %d\n",diff);
-                        */
+*/
-                }
+      }
-        }
+    }
-        else
+  else
-        {
+    {
-                diff = l1 - l2; /* if different alpha lengths, use the shorter name */
+    diff = l1-l2; /* if different alpha lengths, use the shorter name */
-                                /*
+/*
-                                    printf("alpha len different %d\n",diff);
+    printf("alpha len different %d\n",diff);
-                                */
+*/
-        }
+    }
-        /*
+/*
-          printf("diff: %d  string %7s row %2d and %7s row%2d\n",diff,
+  printf("diff: %d  string %7s row %2d and %7s row%2d\n",diff,
-            (*(node_t **)p)->identifier,
+    (*(node_t **)p)->identifier,
-            (*(node_t **)p)->pin_row,
+    (*(node_t **)p)->pin_row,
-            (*(node_t **)q)->identifier,
+    (*(node_t **)q)->identifier,
-            (*(node_t **)q)->pin_row);
+    (*(node_t **)q)->pin_row);
-        */
+*/
-        return diff;
+  return diff;
-}
+  }
 #endif
 /* this function sorts all of the pin references on a chip
    into alphanumeric order, and also generates a unique pin index for each pin
    in the case of alphanumeric pin identifiers : pin A1 or 1A will become index 1 */
 #define BIG 1000000
 /* mapping table has no letter 'I' or 'O' in it */
 static unsigned char illegal_chars[] = PIN_MAP_ILLEGAL_CHARS;
-void sort_nodes (socket_t *chip, extract_xy_t mode)
+void sort_nodes(socket_t * chip,extract_xy_t mode) {
-{
+  node_t * nodes = chip-> nodes;
-        node_t *nodes = chip->nodes;
+  node_t ** sort_list;
-        node_t **sort_list;
+  int alpha_seen = 0;
-        int alpha_seen = 0;
+  int numeric_seen = 0;
-        int numeric_seen = 0;
+/* Use generics to find out if the user has defined pin row/column
-        /* Use generics to find out if the user has defined pin row/column
+   limits (in the case where top or bottom connector rows are not
-           limits (in the case where top or bottom connector rows are not
+   connected at all */
-           connected at all */
+  generic_info_t gen[1];
-        generic_info_t gen[1];
-        /*
+/*
-          printf("chip %s\n",chip->identifier);
+  printf("chip %s\n",chip->identifier);
-        */
+*/
-        int nodecnt = 0;
+  int nodecnt = 0;
-        int max_row = -BIG;
+  int max_row = -BIG;
-        int min_row = BIG;
+  int min_row =  BIG;
-        int max_col = -BIG;
+  int max_col = -BIG;
-        int min_col = BIG;
+  int min_col =  BIG;
-        while (nodes)
+  while(nodes) {
-        {
+/* to do  need to identify the pattern of node identifiers */
-                /* to do  need to identify the pattern of node identifiers */
+/* numeric only ? */
-                /* numeric only ? */
+/* alpha only   ? */
-                /* alpha only   ? */
+/* alpha number */
-                /* alpha number */
+/* number alpha */
-                /* number alpha */
+/* highest pin number ? */
-                /* highest pin number ? */
+/* number of different alphas */
-                /* number of different alphas */
+/* assign an ordinal automatically to each node element */
-                /* assign an ordinal automatically to each node element */
+/* sorting data structure */
-                /* sorting data structure */
+/* the form is 23A */
-                /* the form is 23A */
+    if (nodes->identifier)
-                if (nodes->identifier)
+      {
-                {
+      if (isdigit(nodes->identifier[0]))
-                        if (isdigit (nodes->identifier[0]))
+        {
-                        {
+        nodes->id_numeric_chars  = nodes->identifier;
-                                nodes->id_numeric_chars = nodes->identifier;
+        nodes->id_numeric_cnt    = 0;              /* the numeric part of the identifier */
-                                nodes->id_numeric_cnt =
+        while(isdigit(nodes->identifier[nodes->id_numeric_cnt]))
-; /* the numeric part of the identifier */
+          nodes->id_numeric_cnt++;  /* the number of numeric chars in this part of the identifier */
-                                while (isdigit (nodes->identifier[nodes->id_numeric_cnt]))
+        nodes->id_alpha_chars    = nodes->identifier+nodes->id_numeric_cnt;
-                                        nodes->id_numeric_cnt++; /* the number of numeric chars
+        nodes->id_alpha_cnt      = strlen(nodes->identifier)-nodes->id_numeric_cnt;
-                                                                    in this part of the
+        }
-                                                                    identifier */
+      else
-                                nodes->id_alpha_chars =
+        {
-                                    nodes->identifier + nodes->id_numeric_cnt;
+        nodes->id_alpha_chars  = nodes->identifier;
-                                nodes->id_alpha_cnt =
+        nodes->id_alpha_cnt    = 0;              /* the numeric part of the identifier */
-                                    strlen (nodes->identifier) - nodes->id_numeric_cnt;
+        while(isalpha (nodes->identifier[nodes->id_alpha_cnt]))
-                        }
+          nodes->id_alpha_cnt++;  /* the number of numeric chars in this part of the identifier */
-                        else
+        nodes->id_numeric_chars    = nodes->identifier+nodes->id_alpha_cnt;
-                        {
+        nodes->id_numeric_cnt      = strlen(nodes->identifier)-nodes->id_alpha_cnt;
-                                nodes->id_alpha_chars = nodes->identifier;
+        }
-                                nodes->id_alpha_cnt =
-; /* the numeric part of the identifier */
+/*
-                                while (isalpha (nodes->identifier[nodes->id_alpha_cnt]))
+      printf("node : %s : alpha=%d num=%d\n",nodes->identifier,nodes->id_alpha_cnt,nodes->id_numeric_cnt);
-                                        nodes->id_alpha_cnt++; /* the number of numeric chars
+*/
-                                                                  in this part of the
+      }
-                                                                  identifier */
+    else
-                                nodes->id_numeric_chars =
+      {
-                                    nodes->identifier + nodes->id_alpha_cnt;
+      nodes->id_alpha_chars  = NULL;              /* the numeric part of the identifier */
-                                nodes->id_numeric_cnt =
+      nodes->id_alpha_cnt    = 0;  /* the number of numeric chars in this part of the identifier */
-                                    strlen (nodes->identifier) - nodes->id_alpha_cnt;
+      nodes->id_numeric_chars= NULL;
-                        }
+      nodes->id_numeric_cnt  = 0;
+      }
-                        /*
-                              printf("node : %s : alpha=%d
+/* dont touch the row/col indices unless asked to */
-                           num=%d\n",nodes->identifier,nodes->id_alpha_cnt,nodes->id_numeric_cnt);
+   if(mode == EXTRACT_XY)
-                        */
+     {
-                }
+/* if digits seen these are assigned as row 1..n */
-                else
+    if(nodes->id_numeric_cnt)
-                {
+      {
-                        nodes->id_alpha_chars = NULL; /* the numeric part of the identifier */
+      int index = atoi(nodes->id_numeric_chars);
-                        nodes->id_alpha_cnt =
+      numeric_seen = 1;
-; /* the number of numeric chars in this part of the identifier */
+      nodes->pin_row = index;
-                        nodes->id_numeric_chars = NULL;
+      if(index > max_row)
-                        nodes->id_numeric_cnt = 0;
+        {
-                }
+        max_row=index;
+        }
-                /* dont touch the row/col indices unless asked to */
+      else if(index < min_row)
-                if (mode == EXTRACT_XY)
+        {
-                {
+        min_row=index;
-                        /* if digits seen these are assigned as row 1..n */
+        }
-                        if (nodes->id_numeric_cnt)
+      }
-                        {
+    else
-                                int index = atoi (nodes->id_numeric_chars);
+      {
-                                numeric_seen = 1;
+/* default is on row 1 */
-                                nodes->pin_row = index;
+      nodes->pin_row = 1;
-                                if (index > max_row)
+      }
-                                {
+    if(nodes->id_alpha_cnt > 0)
-                                        max_row = index;
+      {
-                                }
+      alpha_seen = 1;
-                                else if (index < min_row)
+      }
-                                {
-                                        min_row = index;
+    /* between 1 and a few letters can be processed */
-                                }
+    if(nodes->id_alpha_cnt > 0 && nodes->id_alpha_cnt <= MAX_ID_ALPHA_SORT )
-                        }
+      {
-                        else
+      int index;
-                        {
+      int charcnt;
-                                /* default is on row 1 */
+      index = 0;
-                                nodes->pin_row = 1;
+      for (charcnt=0;charcnt<nodes->id_alpha_cnt;charcnt++)
-                        }
+        {
-                        if (nodes->id_alpha_cnt > 0)
+        int  i;
-                        {
+        char c,d;
-                                alpha_seen = 1;
+        d = 0;
-                        }
+        c = toupper(nodes->id_alpha_chars[charcnt]);
+        /* work out how many illegal chars are before this one */
-                        /* between 1 and a few letters can be processed */
+        /* this mapping actually collapses I onto J and O onto P */
-                        if (nodes->id_alpha_cnt > 0 &&
+        /* I am assuming those two chars dont exist in the pin ID .... */
-                            nodes->id_alpha_cnt <= MAX_ID_ALPHA_SORT)
+        /* flag an error and continue for the present */
-                        {
+        /* characters are actually coded as 1..n so that IDs like 'AA' look */
-                                int index;
+        /* different to 'A', which they wont be if the leading 'A' is coded as 0 */
-                                int charcnt;
+        for (i=0;i< PIN_MAP_ILLEGAL_CHAR_COUNT; i++)
-                                index = 0;
+          {
-                                for (charcnt = 0; charcnt < nodes->id_alpha_cnt; charcnt++)
+          if(c==illegal_chars[i])
-                                {
+            {
-                                        int i;
+            Log(LOG_GENERAL,"-- Warning : illegal pin ident character in %s(%d)\n",
-                                        char c, d;
+               chip->identifier,nodes->identifier);
-                                        d = 0;
+            }
-                                        c = toupper (nodes->id_alpha_chars[charcnt]);
+          if(c>=illegal_chars[i])
-                                        /* work out how many illegal chars are before this one
+            {
-                                         */
+            d++;
-                                        /* this mapping actually collapses I onto J and O onto
+            }
-                                         * P */
+          }
-                                        /* I am assuming those two chars dont exist in the pin
+        index *= (PIN_MAP_LEGAL_CHAR_COUNT+1);
-                                         * ID .... */
+        index +=  (c-d-'A'+1);
-                                        /* flag an error and continue for the present */
-                                        /* characters are actually coded as 1..n so that IDs
+        }
-                                         * like 'AA' look */
+/*
-                                        /* different to 'A', which they wont be if the leading
+      printf("'\n");
-                                         * 'A' is coded as 0 */
+*/      nodes->pin_col = index;
-                                        for (i = 0; i < PIN_MAP_ILLEGAL_CHAR_COUNT; i++)
+      if(index > max_col)
-                                        {
+        {
-                                                if (c == illegal_chars[i])
+        max_col=index;
-                                                {
+        }
-                                                        Log (
+      else if(index < min_col)
-                                                            LOG_GENERAL,
+        {
-                                                            "-- Warning : illegal pin ident "
+        min_col=index;
-                                                            "character in %s(%d)\n",
+        }
-                                                            chip->identifier,
+      }
-                                                            nodes->identifier);
+    else
-                                                }
+      {
-                                                if (c >= illegal_chars[i])
+/* default is column zero */
-                                                {
+      nodes->pin_col = 0;
-                                                        d++;
+      }
-                                                }
+     }
-                                        }
+    nodecnt++;
-                                        index *= (PIN_MAP_LEGAL_CHAR_COUNT + 1);
+    nodes=nodes->sktnext;
-                                        index += (c - d - 'A' + 1);
+    }
-                                }
-                                /*
-                                      printf("'\n");
+  chip-> max_pin_col = max_col== -BIG ? 0 : max_col;
-                                */
+  chip-> min_pin_col = min_col==  BIG ? 0 : min_col;
-                                nodes->pin_col = index;
+  chip-> max_pin_row = max_row== -BIG ? 0 : max_row;
-                                if (index > max_col)
+  chip-> min_pin_row = min_row==  BIG ? 0 : min_row;
-                                {
+/*
-                                        max_col = index;
+  printf("chip %10s col %3d to %3d , row %3d to %3d\n",chip->identifier,max_col,min_col,max_row,min_row);
-                                }
+*/
-                                else if (index < min_col)
+  /* know the number of nodes now allocate storage for the pointers
-                                {
+     to be used by qsort() */
-                                        min_col = index;
-                                }
+  sort_list = calloc(nodecnt,sizeof(node_t *));
-                        }
-                        else
-                        {
+  /* grab hold of all of the pointers */
-                                /* default is column zero */
+  nodes = chip-> nodes;
-                                nodes->pin_col = 0;
+  nodecnt = 0;
-                        }
+  while(nodes) {
-                }
+    sort_list[nodecnt++]=nodes;
-                nodecnt++;
+    nodes=nodes->sktnext;
-                nodes = nodes->sktnext;
+    }
-        }
+  /* sort them */
-        chip->max_pin_col = max_col == -BIG ? 0 : max_col;
-        chip->min_pin_col = min_col == BIG ? 0 : min_col;
+  if(nodecnt) {
-        chip->max_pin_row = max_row == -BIG ? 0 : max_row;
+    int i;
-        chip->min_pin_row = min_row == BIG ? 0 : min_row;
-        /*
+    qsort((void *)sort_list,
-          printf("chip %10s col %3d to %3d , row %3d to
+          nodecnt,sizeof(node_t *),&sort_nodes_compar);
-          %3d\n",chip->identifier,max_col,min_col,max_row,min_row);
-        */
+    /* and now rebuild the list based on the sorted list */
-        /* know the number of nodes now allocate storage for the pointers
+    chip->nodes    = sort_list[0];
-           to be used by qsort() */
+    chip->lastnode = sort_list[nodecnt-1];
-        sort_list = calloc (nodecnt, sizeof (node_t *));
+    /* relink the list */
+    for(i=0;i<(nodecnt-1);i++) {
-        /* grab hold of all of the pointers */
+      sort_list[i]->sktnext = sort_list[i+1];
-        nodes = chip->nodes;
+      }
-        nodecnt = 0;
+    sort_list[nodecnt-1]->sktnext = NULL;
-        while (nodes)
-        {
+    }
-                sort_list[nodecnt++] = nodes;
-                nodes = nodes->sktnext;
+  free(sort_list);
-        }
+  /* check for overrides in case there are missing rows/cols */
-        /* sort them */
+  if (get_generic_value(&chip->generics, "min_pin_row",gen) == IS_ATTRIBUTE)
-        if (nodecnt)
+    {
-        {
+    chip->min_pin_row = eval_expression(gen->expr, &chip->generics);
-                int i;
+    }
+  if (get_generic_value(&chip->generics, "max_pin_row",gen) == IS_ATTRIBUTE)
-                qsort ((void *) sort_list, nodecnt, sizeof (node_t *), &sort_nodes_compar);
+    {
+    chip->max_pin_row = eval_expression(gen->expr, &chip->generics );
-                /* and now rebuild the list based on the sorted list */
+    }
-                chip->nodes = sort_list[0];
+  if (get_generic_value(&chip->generics, "min_pin_col",gen) == IS_ATTRIBUTE)
-                chip->lastnode = sort_list[nodecnt - 1];
+    {
+    chip->min_pin_col = eval_expression(gen->expr, &chip->generics );
-                /* relink the list */
+    }
-                for (i = 0; i < (nodecnt - 1); i++)
+  if (get_generic_value(&chip->generics, "max_pin_col",gen) == IS_ATTRIBUTE)
-                {
+    {
-                        sort_list[i]->sktnext = sort_list[i + 1];
+    chip->max_pin_col = eval_expression(gen->expr, &chip->generics );
-                }
+    }
-                sort_list[nodecnt - 1]->sktnext = NULL;
-        }
-        free (sort_list);
-        /* check for overrides in case there are missing rows/cols */
-        if (get_generic_value (&chip->generics, "min_pin_row", gen) == IS_ATTRIBUTE)
-        {
-                chip->min_pin_row = eval_expression (gen->expr, &chip->generics);
-        }
-        if (get_generic_value (&chip->generics, "max_pin_row", gen) == IS_ATTRIBUTE)
-        {
-                chip->max_pin_row = eval_expression (gen->expr, &chip->generics);
-        }
-        if (get_generic_value (&chip->generics, "min_pin_col", gen) == IS_ATTRIBUTE)
-        {
-                chip->min_pin_col = eval_expression (gen->expr, &chip->generics);
-        }
-        if (get_generic_value (&chip->generics, "max_pin_col", gen) == IS_ATTRIBUTE)
-        {
-                chip->max_pin_col = eval_expression (gen->expr, &chip->generics);
-        }
+}
 /* we have a pair of pointers to array elements */
-static int sort_socket_compar (const void *p, const void *q)
+static int sort_socket_compar(const void * p,const void * q)
+{
-        return strcmp ((*(socket_t **) p)->identifier, (*(socket_t **) q)->identifier);
+  return strcmp((*(socket_t **)p)->identifier,(*(socket_t **)q)->identifier);
+}
-/* this function sorts all of  sockets into alphanumeric order */
-socket_t *sort_sockets (socket_t **head)
-{
-        socket_t **sort_list, *chip = *head;
-        int sktcnt = 0;
-        while (chip)
-        {
-                sktcnt++;
-                chip = chip->next;
-        }
-        /* know the number of nodes now allocate storage for the pointers
-           to be used by qsort() */
-        sort_list = calloc (sktcnt, sizeof (socket_t *));
+/* this function sorts all of  sockets into alphanumeric order */
-        /* grab hold of all of the pointers */
-        chip = *head;
-        sktcnt = 0;
-        while (chip)
-        {
-                sort_list[sktcnt++] = chip;
-                chip = chip->next;
-        }
-        /* sort them */
+socket_t * sort_sockets(socket_t ** head) {
+  socket_t ** sort_list,* chip= *head;
+  int sktcnt = 0;
+  while(chip) {
+    sktcnt++;
+    chip=chip->next;
+    }
+  /* know the number of nodes now allocate storage for the pointers
+     to be used by qsort() */
+  sort_list = calloc(sktcnt,sizeof(socket_t *));
+  /* grab hold of all of the pointers */
+  chip = *head;
+  sktcnt = 0;
+  while(chip) {
+    sort_list[sktcnt++]=chip;
+    chip=chip->next;
+    }
+  /* sort them */
-        if (sktcnt)
+  if(sktcnt) {
-        {
+    int i;
+    qsort((char *)sort_list,
-                int i;
+          sktcnt,
+          sizeof(socket_t *),
+          &sort_socket_compar);
-                qsort ((char *) sort_list, sktcnt, sizeof (socket_t *), &sort_socket_compar);
+    /* and now rebuild the list based on the sorted list */
+    *head    = sort_list[0];
+    /* relink the list */
+    for(i=0;i<(sktcnt-1);i++)  {
+      sort_list[i]->next = sort_list[i+1];
+      }
+    sort_list[sktcnt-1]->next = NULL;
+    }
+  free(sort_list);
+  return * head;
+}
-                /* and now rebuild the list based on the sorted list */
-                *head = sort_list[0];
-                /* relink the list */
-                for (i = 0; i < (sktcnt - 1); i++)
-                {
-                        sort_list[i]->next = sort_list[i + 1];
-                }
-                sort_list[sktcnt - 1]->next = NULL;
-        }
-        free (sort_list);
-        return *head;
-}
 /* compile regular expression according
    to Vertical expectations */
 /* What is required is a whole string match. In order to
    achieve this, the regular expression is bracketed with
    ^ and $ which mean in this context 'match start of string'
    and 'match end of string' */
-int vert_regcomp (vert_regex_t **vert_preg, char *expr)
-{
-        int rc;
-        vert_regex_t *preg;
-        /* allocate structure members */
-        preg = calloc (1, sizeof (vert_regex_t));
-        *vert_preg = preg;
-        rc = check_wildcard (expr);
-        if (rc != TCL_OK)
-        {
-                preg->buff = malloc (3);
-                strcpy (preg->buff, "^$");
-        }
-        else
-        {
-                preg->buff = malloc (strlen (expr) + 3);
-                sprintf (preg->buff, "^%s$", expr);
-        }
-        /*  printf("-- compare '%s'\n",preg->buff); */
-        rc = regcomp (preg->preg, preg->buff, REG_EXTENDED | REG_ICASE);
-        return rc;
-}
+int vert_regcomp(vert_regex_t ** vert_preg,char * expr)
+  {
+  int rc;
+  vert_regex_t * preg;
+/* allocate structure members */
+  preg          = calloc(1,sizeof(vert_regex_t));
+  *vert_preg    = preg;
+  rc = check_wildcard(expr);
+  if (rc!=TCL_OK)
+    {
+    preg->buff = malloc(3);
+    strcpy(preg->buff,"^$");
+    }
+  else
+    {
+    preg->buff = malloc(strlen(expr)+3);
+    sprintf(preg->buff,"^%s$",expr);
+    }
+/*  printf("-- compare '%s'\n",preg->buff); */
+  rc = regcomp(preg->preg,preg->buff,REG_EXTENDED | REG_ICASE);
+  return rc;
+  }
 /* tidy up */
-int vert_regfree (vert_regex_t **vert_preg)
+int vert_regfree(vert_regex_t ** vert_preg)
-{
+   {
-        regfree ((*vert_preg)->preg);
+   regfree((*vert_preg)->preg);
-        free ((*vert_preg)->buff);
+   free((*vert_preg)->buff);
-        free (*vert_preg);
+   free(*vert_preg);
-        *vert_preg = NULL;
+   *vert_preg = NULL;
-        return 0;
+   return 0;
-}
+   }

Subversion Repositories Vertical

(root)/branches/metal/vertlib/sorting.c – Rev 2 → 11