gattrib/src/s_table.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * gattrib -- gEDA component and net attribute manipulation using spreadsheet.
   3  * Copyright (C) 2003-2010 Stuart D. Brorson.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
  18  */
  19
  20 /*------------------------------------------------------------------*/
  21 /*! \file
  22  *  \brief Functions to manipulate the TABLE structure
  23  *
  24  * This file holds functions involved in manipulating the TABLE structure,
  25  * which is subsidiary to SHEET_DATA.  TABLE is a 2 dimensional array
  26  * of structs; each struct corresponds to the data about an element
  27  * in a single cell of the spreadsheet.
  28  * \todo TABLE should also store its dimensions in its own data
  29  *       structure to save carrying the dimensions around separately.
  30  */
  31
  32 #include <config.h>
  33
  34 #include <stdio.h>
  35 #ifdef HAVE_STRING_H
  36 #include <string.h>
  37 #endif
  38 #include <math.h>
  39
  40 /*------------------------------------------------------------------
  41  * Gattrib specific includes
  42  *------------------------------------------------------------------*/
  43 #include <libgeda/libgeda.h>       /* geda library functions  */
  44 #include "../include/struct.h"     /* typdef and struct declarations */
  45 #include "../include/prototype.h"  /* function prototypes */
  46 #include "../include/globals.h"
  47
  48 #ifdef HAVE_LIBDMALLOC
  49 #include <dmalloc.h>
  50 #endif
  51
  52 /* ===================  Public Functions  ====================== */
  53
  54 /*------------------------------------------------------------------*/
  55 /*! \brief Create a new table
  56  *
  57  * This is the table creator.  It returns a pointer to
  58  * an initialized TABLE struct.  As calling args, it needs
  59  * the number of rows and cols to allocate.  The table is a
  60  * dynamically allocated 2D array of structs.  To access data in
  61  * a cell in the table, you reference (for example):
  62  * ((sheet_data->comp_table)[i][j]).attrib_value
  63  * (Parens used only for clarity.  It works without parens.)
  64  * \param rows Number of rows required in the new table
  65  * \param cols Number of columns required in the new table
  66  * \returns a pointer to an initialized TABLE struct.
  67  */
  68 TABLE **s_table_new(int rows, int cols)
  69 {
  70   TABLE **new_table;
  71   int i, j;
  72
  73   /* Here I am trying to create a 2 dimensional array of structs */
  74   new_table = (TABLE **) g_malloc(rows*sizeof(TABLE *));
  75   for (i = 0; i < rows; i++) {
  76     new_table[i] = (TABLE *) g_malloc(cols * sizeof(TABLE));
  77     /* Note that I should put some checks in here to verify that
  78      * malloc worked correctly. */
  79   }
  80
  81   /* Now pre-load the table with NULLs */
  82   for (i = 0; i < rows; i++) {
  83     for (j = 0; j < cols; j++) {
  84       (new_table[i][j]).attrib_value = NULL;
  85       (new_table[i][j]).row_name = NULL;
  86       (new_table[i][j]).col_name = NULL;
  87       (new_table[i][j]).row = i;
  88       (new_table[i][j]).col = j;
  89       (new_table[i][j]).visibility = VISIBLE;
  90       (new_table[i][j]).show_name_value = SHOW_VALUE;
  91     }
  92   }
  93
  94   return (new_table);
  95
  96 }
  97
  98
  99 /*------------------------------------------------------------------*/
 100 /*! \brief Resize a TABLE
 101  *
 102  * This function recreates the table with
 103  * a new size.  It can only increase
 104  * the number of cols.  You can't increase the number of rows since
 105  * gattrib doesn't allow you to input new components.  Decreasing the
 106  * number of cols is also TBD.
 107  * \param table Table to resize
 108  * \param rows Number of rows in the table
 109  * \param old_cols Number of columns previously in the table
 110  * \param new_cols Number of columns required in the table
 111  * \returns a pointer to the resized table
 112  * \todo The row and column information could be stored in the
 113  *       TABLE struct.
 114  */
 115 TABLE **s_table_resize(TABLE **table,
 116                        int rows, int old_cols, int new_cols)
 117 {
 118   int i, j;
 119
 120   /* Here I am trying to resize the 2 dimensional array of structs */
 121   for (i = 0; i < rows; i++) {
 122     table[i] = (TABLE *) realloc(table[i], new_cols*sizeof(TABLE) );
 123     if (table[i] == NULL) exit(-1);  /* die if failed to realloc new memory */
 124   }
 125
 126   /* Now pre-load new cols with NULLs */
 127   for (i = 0; i < rows; i++) {
 128     for (j = old_cols; j < new_cols; j++) {
 129       (table[i][j]).attrib_value = NULL;
 130       (table[i][j]).row_name = NULL;
 131       (table[i][j]).col_name = NULL;
 132       (table[i][j]).row = i;
 133       (table[i][j]).col = j;
 134       (table[i][j]).visibility = VISIBLE;
 135       (table[i][j]).show_name_value = SHOW_VALUE;
 136     }
 137   }
 138
 139   return table;
 140 }
 141
 142
 143 /*------------------------------------------------------------------*/
 144 /*! \brief Destroy a table
 145  *
 146  * This function destroys the old table.
 147  * Use it after reading in a new
 148  * page to get rid of the old table before building a new one.
 149  * \param table Table to destroy
 150  * \param row_count Number of rows in table
 151  * \param col_count Number of columns in table
 152  */
 153 void s_table_destroy(TABLE **table, int row_count, int col_count)
 154 {
 155   int i, j;
 156
 157   if (table == NULL)
 158     return;
 159
 160   for (i = 0; i < row_count; i++) {
 161     for (j = 0; j < col_count; j++) {
 162       g_free( (table[i][j]).attrib_value );
 163       g_free( (table[i][j]).row_name );
 164       g_free( (table[i][j]).col_name );
 165     }
 166   }
 167
 168   for (i = 0; i < row_count; i++) {
 169     g_free( table[i] );
 170   }
 171
 172   g_free(table);
 173   table = NULL;
 174
 175   return;
 176 }
 177
 178
 179
 180 /*------------------------------------------------------------------*/
 181 /*! \brief Get a string index number
 182  *
 183  * This function returns the index number
 184  * when given a STRING_LIST and a
 185  * string to match.  It finds the index
 186  * number by iterating through the master  list.
 187  * \param local_list
 188  * \param local_string
 189  * \returns the index of the string
 190  */
 191 int s_table_get_index(STRING_LIST *local_list, char *local_string) {
 192   int count = 0;
 193   STRING_LIST *list_element;
 194
 195 #ifdef DEBUG
 196   printf("In s_table_get_index, examining %s to see if it is in the list.\n", local_string);
 197 #endif
 198
 199
 200   list_element = local_list;
 201   while (list_element != NULL) {
 202     if (strcmp(list_element->data, local_string) == 0) {
 203       return count;
 204     }
 205     count++;
 206     list_element = list_element->next;
 207   }
 208   return(-1);  /* return code when string is not in master_list  */
 209 }
 210
 211
 212
 213 /*------------------------------------------------------------------*/
 214 /*! \brief Create attribute pair
 215  *
 216  * This function takes a table, a row list, and a row name,
 217  * and returns a list holding
 218  * name=value pairs for all attribs pertainent to that particular
 219  * row.
 220  * If the row holds no attribs, it just returns NULL.
 221  *
 222  * \param row_name Name of the row to search for
 223  * \param table Table to be searched
 224  * \param row_list list of rows
 225  * \param num_attribs
 226  * \returns STRING_LIST of name=value pairs
 227  */
 228 STRING_LIST *s_table_create_attrib_pair(gchar *row_name,
 229                                         TABLE **table,
 230                                         STRING_LIST *row_list,
 231                                         int num_attribs)
 232 {
 233   STRING_LIST *attrib_pair_list;
 234   char *attrib_name, *attrib_value, *name_value_pair;
 235   int row, col;
 236   int count = 0;
 237
 238   attrib_pair_list = s_string_list_new();
 239
 240   row = s_table_get_index(row_list, row_name);
 241   /* Sanity check */
 242   if (row == -1) {
 243     /* we didn't find the item in the list */
 244     fprintf (stderr,
 245              "In s_table_create_attrib_pair, we didn't find the row name in the row list!\n");
 246     return attrib_pair_list;
 247   }
 248
 249   for (col = 0; col < num_attribs; col++) {
 250     /* pull attrib from table.  If non-null, add it to attrib_pair_list  */
 251     if ( (table[row][col]).attrib_value != NULL) {
 252       attrib_name = (table[row][col]).col_name;
 253       attrib_value = (table[row][col]).attrib_value;
 254       name_value_pair = g_strconcat(attrib_name, "=", attrib_value, NULL);
 255       s_string_list_add_item(attrib_pair_list, &count, name_value_pair);
 256       g_free(name_value_pair);
 257     }
 258   }
 259
 260   return attrib_pair_list;
 261 }
 262
 263
 264
 265
 266 /*------------------------------------------------------------------*/
 267 /*! \brief Add components to the component table
 268  *
 269  * This fcn iterates over adds all
 270  * objects found on this page looking
 271  * for components.  When it finds a component, it finds all component
 272  * attribs and sticks them in the TABLE.
 273  * \param obj_list pointer to GList containing objects on this page
 274  */
 275 void s_table_add_toplevel_comp_items_to_comp_table (const GList *obj_list) {
 276   gchar *temp_uref;
 277   int row, col;
 278   gchar *attrib_text;
 279   gchar *attrib_name;
 280   gchar *attrib_value;
 281   const GList *o_iter;
 282   GList *a_iter;
 283   OBJECT *a_current;
 284   gint old_visibility, old_show_name_value;
 285
 286
 287   if (verbose_mode) {
 288     printf("- Starting internal component TABLE creation\n");
 289   }
 290
 291 #ifdef DEBUG
 292   fflush(stderr);
 293   fflush(stdout);
 294   printf("=========== Just entered  s_table_add_toplevel_comp_items_to_comp_table!  ==============\n");
 295 #endif
 296
 297   /* -----  Iterate through all objects found on page  ----- */
 298   for (o_iter = obj_list; o_iter != NULL; o_iter = g_list_next (o_iter)) {
 299     OBJECT *o_current = o_iter->data;
 300
 301 #ifdef DEBUG
 302       printf("   ---> In s_table_add_toplevel_comp_items_to_comp_table, examining o_current->name = %s\n", o_current->name);
 303 #endif
 304
 305     /* -----  Now process objects found on page  ----- */
 306     if (o_current->type == OBJ_COMPLEX &&
 307         o_current->attribs != NULL) {
 308
 309       /* ---- Don't process part if it lacks a refdes ----- */
 310       temp_uref = g_strdup(s_attrib_get_refdes(o_current));
 311       if (temp_uref) {
 312
 313 #if DEBUG
 314         printf("      In s_table_add_toplevel_comp_items_to_comp_table, found component on page. Refdes = %s\n", temp_uref);
 315 #endif
 316         verbose_print(" C");
 317
 318         /* Having found a component, we loop over all attribs in this
 319          * component, and stick them
 320          * into cells in the table. */
 321         a_iter = o_current->attribs;
 322         while (a_iter != NULL) {
 323           a_current = a_iter->data;
 324           if (a_current->type == OBJ_TEXT
 325               && a_current->text != NULL) {  /* found an attribute */
 326             /* may need to check more thoroughly here. . . . */
 327             attrib_text = g_strdup(a_current->text->string);
 328             attrib_name = u_basic_breakup_string(attrib_text, '=', 0);
 329             attrib_value = s_misc_remaining_string(attrib_text, '=', 1);
 330             old_visibility = a_current->visibility;
 331             old_show_name_value = a_current->show_name_value;
 332
 333             /* Don't include "refdes" or "slot" because they form the row name. */
 334             /* Also don't include "net" per bug found by Steve W.  4.3.2007 -- SDB */
 335             if ( (strcmp(attrib_name, "refdes") != 0) &&
 336                  (strcmp(attrib_name, "net") != 0) &&
 337                  (strcmp(attrib_name, "slot") != 0) ) {
 338
 339               /* Get row and col where to put this attrib */
 340               row = s_table_get_index(sheet_head->master_comp_list_head, temp_uref);
 341               col = s_table_get_index(sheet_head->master_comp_attrib_list_head, attrib_name);
 342               /* Sanity check */
 343               if (row == -1 || col == -1) {
 344                 /* we didn't find the item in the table */
 345                 fprintf (stderr,
 346                          "In s_table_add_toplevel_comp_items_to_comp_table, we didn't find either row or col in the lists!\n");
 347               } else {
 348
 349 #if DEBUG
 350                 printf("       In s_table_add_toplevel_comp_items_to_comp_table, about to add row %d, col %d, attrib_value = %s\n",
 351                        row, col, attrib_value);
 352                 printf(" . . . current address of attrib_value cell is [%p]\n", &((sheet_head->component_table)[row][col]).attrib_value);
 353 #endif
 354                 /* Is there a compelling reason for me to put this into a separate fcn? */
 355                 ((sheet_head->component_table)[row][col]).row = row;
 356                 ((sheet_head->component_table)[row][col]).col = col;
 357                 ((sheet_head->component_table)[row][col]).row_name = g_strdup(temp_uref);
 358                 ((sheet_head->component_table)[row][col]).col_name = g_strdup(attrib_name);
 359                 ((sheet_head->component_table)[row][col]).attrib_value = g_strdup(attrib_value);
 360                 ((sheet_head->component_table)[row][col]).visibility = old_visibility;
 361                 ((sheet_head->component_table)[row][col]).show_name_value = old_show_name_value;
 362               }
 363             }
 364             g_free(attrib_name);
 365             g_free(attrib_text);
 366             g_free(attrib_value);
 367           }
 368           a_iter = g_list_next (a_iter);
 369
 370         }  /* while (a_current != NULL) */
 371         g_free(temp_uref);
 372       }  /* if (temp_uref) */
 373     }    /* if (o_current->type == OBJ_COMPLEX)  */
 374   }
 375
 376   verbose_done();
 377
 378 }
 379
 380 #if 0
 381 /*------------------------------------------------------------------*/
 382 /*! \brief Add nets to net table
 383  *
 384  * This function iterates over adds all
 385  * items found on this page looking
 386  * for nets and adds them individually to the net table.  Looping over
 387  * objects occurs here.
 388  *
 389  * \param start_obj Pointer to first object
 390  *
 391  * \todo Why do the calling semantics of this function disagree with
 392  *       s_table_add_toplevel_pin_items_to_pin_table()?  That function
 393  *       takes a GList, this one takes a pointer to OBJECT.
 394  */
 395 void s_table_add_toplevel_net_items_to_net_table(OBJECT *start_obj) {
 396   OBJECT *o_current;
 397   char *temp_netname;
 398   int row, col;
 399   char *attrib_text;
 400   char *attrib_name;
 401   char *attrib_value;
 402   ATTRIB *a_current;
 403
 404   /* -----  Iterate through all objects found on page  ----- */
 405   o_current = start_obj;
 406   while (o_current != NULL) {
 407
 408     /* -----  Now process objects found on page  ----- */
 409     if (o_current->type == OBJ_NET) {
 410 #if DEBUG
 411       fflush(stderr);
 412       fflush(stdout);
 413       printf("In s_table_add_toplevel_net_items_to_net_table, Found net on page\n");
 414 #endif
 415       verbose_print(" N");
 416
 417       /* Having found a net, we stick it into the table. */
 418       a_current = o_current->attribs;
 419       while (a_current != NULL) {
 420         if (a_current->object->type == OBJ_TEXT
 421             && a_current->object->text != NULL) {  /* found an attribute */
 422           /* may need to check more thoroughly here. . . . */
 423           attrib_text = g_strdup(a_current->object->text->string);
 424           attrib_name = u_basic_breakup_string(attrib_text, '=', 0);
 425           attrib_value = s_misc_remaining_string(attrib_text, '=', 1);
 426           if (strcmp(attrib_name, "netname") != 0) {
 427             /* Don't include "netname" */
 428
 429             /* Get row and col where to put this attrib */
 430             row = s_table_get_index(sheet_head->master_net_list_head, temp_netname);
 431             col = s_table_get_index(sheet_head->master_net_attrib_list_head, attrib_name);
 432 #if DEBUG
 433             fflush(stderr);
 434             fflush(stdout);
 435             printf("In s_table_add_toplevel_net_items_to_net_table, about to add row %d, col %d, attrib_value = %s\n",
 436                    row, col, attrib_value);
 437             printf(" . . . current address of attrib_value cell is [%p]\n", &((sheet_head->net_table)[row][col]).attrib_value);
 438 #endif
 439             /* Is there a compelling reason for me to put this into a separate fcn? */
 440             ((sheet_head->net_table)[row][col]).row = row;
 441             ((sheet_head->net_table)[row][col]).col = col;
 442             ((sheet_head->net_table)[row][col]).row_name = g_strdup(temp_netname);
 443             ((sheet_head->net_table)[row][col]).col_name = g_strdup(attrib_name);
 444             ((sheet_head->net_table)[row][col]).attrib_value = g_strdup(attrib_value);
 445           }
 446           g_free(attrib_name);
 447           g_free(attrib_text);
 448           g_free(attrib_value);
 449         }
 450         a_current = a_current->next;
 451
 452       }  /* while (a_current != NULL) */
 453       g_free(temp_netname);
 454
 455     }    /*--- if (o_current->type == OBJ_NET)   ---*/
 456
 457
 458     o_current = o_current->next;  /* iterate to next object on page */
 459   }  /* while o_current != NULL */
 460
 461   verbose_done();
 462
 463 #if DEBUG
 464   fflush(stderr);
 465   fflush(stdout);
 466   printf("In s_table_add_toplevel_net_items_to_net_table -- we are about to return\n");
 467 #endif
 468
 469 }
 470 #endif
 471
 472
 473 /*------------------------------------------------------------------*/
 474 /*! \brief Add pins to pin table.
 475  *
 476  * This function iterates over adds all items found on this page
 477  * looking for pins.  WHen it finds a pin, it gathers all
 478  * pin attribs and sticks them into the pin table.
 479  * \param obj_list List of objects on page
 480  */
 481 void s_table_add_toplevel_pin_items_to_pin_table (const GList *obj_list) {
 482   gchar *temp_uref;
 483   gchar *pinnumber;
 484   gchar *row_label;
 485   int row, col;
 486   gchar *attrib_text;
 487   gchar *attrib_name;
 488   gchar *attrib_value;
 489   const GList *o_iter;
 490   GList *a_iter;
 491   GList *o_lower_iter;
 492   OBJECT *pin_attrib;
 493
 494   if (verbose_mode) {
 495     printf("- Starting internal pin TABLE creation\n");
 496   }
 497
 498 #ifdef DEBUG
 499   printf("=========== Just entered  s_table_add_toplevel_pin_items_to_pin_table!  ==============\n");
 500 #endif
 501
 502   /* -----  Iterate through all objects found on page  ----- */
 503   for (o_iter = obj_list; o_iter != NULL; o_iter = g_list_next (o_iter)) {
 504     OBJECT *o_current = o_iter->data;
 505
 506 #ifdef DEBUG
 507       printf("   ---> In s_table_add_toplevel_pin_items_to_pin_table, examining o_current->name = %s\n", o_current->name);
 508 #endif
 509
 510     /* -----  Now process objects found on page  ----- */
 511     if (o_current->type == OBJ_COMPLEX &&
 512         o_current->attribs != NULL) {
 513
 514       /* ---- Don't process part if it lacks a refdes ----- */
 515       temp_uref = s_attrib_get_refdes(o_current);
 516       if (temp_uref) {
 517
 518         /* -----  Now iterate through lower level objects looking for pins.  ----- */
 519         for (o_lower_iter = o_current->complex->prim_objs;
 520              o_lower_iter != NULL;
 521              o_lower_iter = g_list_next (o_lower_iter)) {
 522           OBJECT *o_lower_current = o_lower_iter->data;
 523
 524           if (o_lower_current->type == OBJ_PIN) {
 525             /* -----  Found a pin.  First get its pinnumber.  then get attrib head and loop on attribs.  ----- */
 526             pinnumber = o_attrib_search_object_attribs_by_name (o_lower_current, "pinnumber", 0);
 527             row_label = g_strconcat(temp_uref, ":", pinnumber, NULL);
 528
 529 #if DEBUG
 530         printf("      In s_table_add_toplevel_pin_items_to_pin_table, examining pin %s\n", row_label);
 531 #endif
 532
 533             a_iter = o_lower_current->attribs;
 534             while (a_iter != NULL) {
 535               pin_attrib = a_iter->data;
 536               if (pin_attrib->type == OBJ_TEXT
 537                   && pin_attrib->text != NULL) {  /* found an attribute */
 538                 attrib_text = g_strdup(pin_attrib->text->string);
 539                 attrib_name = u_basic_breakup_string(attrib_text, '=', 0);
 540                 attrib_value = s_misc_remaining_string(attrib_text, '=', 1);
 541
 542                 if ( (strcmp(attrib_name, "pinnumber") != 0)
 543                      && (attrib_value != 0) ) {
 544                   /* Don't include "pinnumber" because it is already in other master list.
 545                    * Also must ensure that value is non-null; certain symbols are not well formed.
 546                    */
 547
 548                   /* Get row and col where to put this attrib */
 549                   row = s_table_get_index(sheet_head->master_pin_list_head, row_label);
 550                   col = s_table_get_index(sheet_head->master_pin_attrib_list_head, attrib_name);
 551                   /* Sanity check */
 552                   if (row == -1 || col == -1) {
 553                     /* we didn't find the item in the table */
 554                     fprintf (stderr,
 555                              "In s_table_add_toplevel_pin_items_to_pin_table, we didn't find either row or col in the lists!\n");
 556                   } else {
 557
 558 #if DEBUG
 559                     printf("       In s_table_add_toplevel_pin_items_to_pin_table, about to add row %d, col %d, attrib_value = %s\n",
 560                            row, col, attrib_value);
 561                     printf(" . . . current address of attrib_value cell is [%p]\n", &((sheet_head->component_table)[row][col]).attrib_value);
 562 #endif
 563                     /* Is there a compelling reason for me to put this into a separate fcn? */
 564                     ((sheet_head->pin_table)[row][col]).row = row;
 565                     ((sheet_head->pin_table)[row][col]).col = col;
 566                     ((sheet_head->pin_table)[row][col]).row_name = g_strdup(row_label);
 567                     ((sheet_head->pin_table)[row][col]).col_name = g_strdup(attrib_name);
 568                     ((sheet_head->pin_table)[row][col]).attrib_value = g_strdup(attrib_value);
 569                   }
 570                 }
 571                 g_free(attrib_name);
 572                 g_free(attrib_text);
 573                 g_free(attrib_value);
 574               }
 575               a_iter = g_list_next (a_iter);
 576
 577             }  /* while (pin_attrib != NULL) */
 578             g_free(pinnumber);
 579             g_free(row_label);
 580           }
 581
 582         }
 583       }
 584
 585       g_free(temp_uref);
 586     }
 587
 588   }
 589
 590   verbose_done();
 591 }
 592
 593
 594 /*------------------------------------------------------------------*/
 595 /*! \brief Push spreadsheet data to TABLEs.
 596  *
 597  * This function traverses the spreadsheet,
 598  * extracts the attribs from
 599  * the cells, and places them back into TABLE.  This is the
 600  * first step in saving out a project.
 601  */
 602 void s_table_gtksheet_to_all_tables() {
 603
 604   int num_rows;
 605   int num_cols;
 606   STRING_LIST *master_row_list;
 607   STRING_LIST *master_col_list;
 608   TABLE **local_table;
 609   GtkSheet *local_gtk_sheet;
 610
 611   /* First handle component sheet */
 612   num_rows = sheet_head->comp_count;
 613   num_cols = sheet_head->comp_attrib_count;
 614   local_gtk_sheet = sheets[0];
 615   master_row_list = sheet_head->master_comp_list_head;
 616   master_col_list = sheet_head->master_comp_attrib_list_head;
 617
 618   local_table = sheet_head->component_table;
 619
 620   /* now fill out new table */
 621 #ifdef DEBUG
 622   printf("In s_table_gtksheet_to_all_tables, now about to fill out new component table.\n");
 623 #endif
 624   s_table_gtksheet_to_table(local_gtk_sheet, master_row_list,
 625                        master_col_list, local_table,
 626                        num_rows, num_cols);
 627
 628 #if 0
 629   /* Next handle net sheet */
 630   num_rows = sheet_head->net_count;
 631   num_cols = sheet_head->net_attrib_count;
 632   local_gtk_sheet = sheets[1];
 633   master_row_list = sheet_head->master_net_list_head;
 634   master_col_list = sheet_head->master_net_attrib_list_head;
 635   local_table = sheet_head->net_table;
 636
 637   s_table_gtksheet_to_table(local_gtk_sheet, master_row_list,
 638                        master_col_list, local_table,
 639                        num_rows, num_cols);
 640 #endif
 641
 642 #ifdef UNIMPLEMENTED_FEATURES
 643   /* Finally, handle component pin sheet */
 644   num_rows = sheet_head->pin_count;
 645   num_cols = sheet_head->pin_attrib_count;
 646   local_gtk_sheet = sheets[2];
 647   master_row_list = sheet_head->master_pin_list_head;
 648   master_col_list = sheet_head->master_pin_attrib_list_head;
 649   /*  local_table = s_table_new(num_rows, num_cols);  */
 650   local_table = sheet_head->pin_table;
 651
 652   s_table_gtksheet_to_table(local_gtk_sheet, master_row_list,
 653                        master_col_list, local_table,
 654                        num_rows, num_cols);
 655 #endif
 656
 657   return;
 658 }
 659
 660
 661 /* ===================  Private Functions  ====================== */
 662 /*------------------------------------------------------------------*/
 663 /*! \brief Extract attributes from gtksheet into TABLE
 664  *
 665  * This function does the actual heavy lifting of looping
 666  * through the spreadsheet, extracting the attribs from
 667  * the cells, and placing them back into TABLE.  This is the
 668  * first step in saving out a project.
 669  *
 670  * \param local_gtk_sheet GtkSheet to save
 671  * \param master_row_list STRING_LIST of rows
 672  * \param master_col_list STRING_LIST of columns
 673  * \param local_table TABLE structure to fill
 674  * \param num_rows Number of rows in table
 675  * \param num_cols Number of columns in table
 676  */
 677 void s_table_gtksheet_to_table(GtkSheet *local_gtk_sheet, STRING_LIST *master_row_list,
 678                          STRING_LIST *master_col_list, TABLE **local_table,
 679                          int num_rows, int num_cols)
 680 {
 681   int row, col;
 682
 683   STRING_LIST *row_list_item;
 684   gchar *row_title;
 685
 686   STRING_LIST *col_list_item;
 687   gchar *col_title;
 688
 689   gchar *attrib_value;
 690
 691 #ifdef DEBUG
 692       printf("**********    Entering s_table_gtksheet_to_table     ******************\n");
 693 #endif
 694
 695
 696   row_list_item = master_row_list;
 697   for (row = 0; row < num_rows; row++) {
 698     row_title = (gchar *) g_strdup(row_list_item->data);
 699
 700     col_list_item = master_col_list;
 701     for (col = 0; col < num_cols; col++) {
 702       col_title = (gchar *) g_strdup(col_list_item->data);
 703
 704       /* get value of attrib in cell  */
 705       attrib_value = (gchar *) gtk_sheet_cell_get_text(GTK_SHEET(local_gtk_sheet), row, col);
 706
 707 #if 0
 708       if (strlen(attrib_value) == 0) {
 709         /* g_free(attrib_value);  */   /* sometimes we have spurious, zero length strings creep */
 710         attrib_value = NULL;    /* into the GtkSheet                                     */
 711       }
 712 #endif
 713
 714
 715 #ifdef DEBUG
 716       printf("In s_table_gtksheet_to_table, found attrib_value = %s in cell row=%d, col=%d\n",
 717              attrib_value, row, col);
 718 #endif
 719
 720       /* first handle attrib value in cell */
 721 #ifdef DEBUG
 722       printf("     Updating attrib_value %s\n", attrib_value);
 723 #endif
 724       g_free( local_table[row][col].attrib_value );
 725       if (attrib_value != NULL) {
 726         local_table[row][col].attrib_value = (gchar *) g_strdup(attrib_value);
 727       } else {
 728         local_table[row][col].attrib_value = NULL;
 729       }
 730
 731       /* next handle name of row (also held in TABLE cell) */
 732 #ifdef DEBUG
 733       printf("     Updating row_name %s\n", row_title);
 734 #endif
 735       g_free( local_table[row][col].row_name );
 736       if (row_title != NULL) {
 737         local_table[row][col].row_name = (gchar *) g_strdup(row_title);
 738       } else {
 739         local_table[row][col].row_name = NULL;
 740       }
 741
 742       /* finally handle name of col */
 743 #ifdef DEBUG
 744       printf("     Updating col_name %s\n", col_title);
 745 #endif
 746       g_free( local_table[row][col].col_name );
 747       if (col_title != NULL) {
 748         local_table[row][col].col_name = (gchar *) g_strdup(col_title);
 749       } else {
 750         local_table[row][col].col_name = NULL;
 751       }
 752
 753       /* get next col list item and then iterate. */
 754       col_list_item = col_list_item->next;
 755     }
 756
 757     row_list_item = row_list_item->next;
 758   }
 759
 760   return;
 761 }
 762