Subversion Repositories Vertical

/*

 *  $Id: rename.c,v 1.2 2003/11/06 04:36:03 mjames Exp $

 *

 * $Log: rename.c,v $

 * Revision 1.2  2003/11/06 04:36:03  mjames

 * Checkin : builds but has problems with object renaming

 *

 * Revision 1.1.1.1  2003/11/04 23:34:57  mjames

 * Imported into local repositrory

 *

 * Revision 1.24  2003/01/02 21:37:17  mjames

 * Experiment on creating NOT_ROUTABLE_H and NOT_ROUTABLE_L

 * properties on the nets so that pin jumpers can be made without a problem.

 *

 * Still need to sort out pin assignments made to these not_routable nets

 * which will become legal in some cases so that pullups and pulldown

 * pins can be used on the FPGA.

 *

 * Revision 1.23  2002/10/02 18:41:24  MJAMES

 * Dont print '&a' if the pin_column is expression is less than or equal to zero

 *

 * Revision 1.22  2002/09/18 08:50:10  mjames

 * Removed further sidefects of redefining pin 'a' as 1 in place of '0'

 *

 * Revision 1.21  2002/09/16 14:41:43  mjames

 * Merge back pin indexing bug that meant

 * pin AZ12 was indistinguishable from pin Z12 in

 * rename ident/name commands

 *

 * Revision 1.19  2002/08/23 14:17:29  mjames

 * Regular expressions extended to

 * &a, &n &d , &i as special replacement patterns

 *

 * Revision 1.18  2002/01/21 09:33:30  mjames

 * Appended a null character when copying regular expression

 * matched pattern.

 *

 * Revision 1.17  2001/12/24 20:07:18  mjames

 * Added &D for device identifier in the replacement string in edit_pin as well

 * as &0 .. &9

 *

 * Revision 1.16  2001/12/11 20:30:26  mjames

 * Implemented  regular expression pin  name editing

 *

 * Revision 1.15  2001/11/19 10:21:04  mjames

 * Fixed errors

 *

 * Revision 1.14  2001/11/19 10:02:23  mjames

 * Merge back

 *

 * Revision 1.13.2.1  2001/11/15 22:03:52  mjames

 * Altered the 'alter' command to use two arguments rather than one

 * after TH suggestion.

 *

 * Revision 1.13  2001/10/31 22:28:27  mjames

 * Problems with regular expression argument lists.

 *

 * Revision 1.12  2001/10/31 22:20:14  mjames

 * Tidying up problematical comments caused by CVS

 * 'intelligent' comment guessing

 *

 * Revision 1.11  2001/10/31 16:18:05  mjames

 * Added a datastructure to hide regular expression information from programs.

 * Changed call to regexec to indicate 0 subexpressions to be matched

 * rather than a number dependent on strlen(string) which was wrong.

 *

 * Revision 1.10  2001/10/18 21:36:17  mjames

 * Added modify pins command : nets inherit identifier from selected socket and pin on that

 * socket to ease cross referencing.

 *

 * Revision 1.9  2001/10/11 16:10:16  mjames

 * Corrections to the SWAP command, and printout so that

 * WRITE net now outputs all chips in the design so that their generics

 * can be passed forward to the next phase.

 *

 * Revision 1.8  2001/10/10 20:18:21  mjames

 * Added a vert_regcomp function to compile regular expressions

 * with '^' (match start string) and  '$' (match end string) bracketing

 * this => wildcard must match entire string not just a part of it.

 *

 * Revision 1.7  2001/10/07 20:50:52  mjames

 * Added wildcard checking (warn user about

 * using wildcard '*' on the end of a string in stead of wildcard '.*')

 *

 * Revision 1.6  2001/09/25 23:15:23  mjames

 * Converted wildcards to use proper regexp pattern match library

 *

 * Revision 1.5  2001/08/31 09:37:42  mjames

 * modified rename rules so that un-named objects do not get

 * name suffixes appended.

 *

 * Revision 1.4  2001/07/20 14:49:42  mjames

 * Corrected reading names in on multiple boards : if present in a database file

 * when reading in a suffixed design

 * e.g. CHIP fred

 * Will also get its name suffixed.

 *

 * Revision 1.3  2001/06/06 12:10:18  mjames

 * Move from HPUX

 *

 * Revision 1.2  2001/01/26 21:50:10  mjames

 * Managed to get vertical non TCL to compile again

 *

 * Conversion to argv, argc[] mode of operation continues

 *

 * Revision 1.1.1.1  2000/10/19 21:58:39  mjames

 * Mike put it here

 *

 *

 * Revision 1.26  2000/08/25  09:57:15  09:57:15  mjames (Mike James)

 * Modified for Vertical2 : support COMPONENTS and SIGNALS

 *

 * Revision 1.26  2000/08/25  09:57:15  09:57:15  mjames (Mike James)

 * Part of Release Aug25_alpha

 *

 * Revision 1.25  2000/08/16  08:57:31  08:57:31  mjames (Mike James)

 * Part of Release CD01_Aug2000

 *

 * Revision 1.24  2000/08/14  14:45:12  14:45:12  mjames (Mike James)

 * Part of Release Aug_14_2000

 *

 * Revision 1.23  2000/08/11  08:30:33  08:30:33  mjames (Mike James)

 * Part of Release Aug_11_2000

 *

 * Revision 1.22  2000/08/09  10:31:48  10:31:48  mjames (Mike James)

 * Part of Release Aug__9_2000

 *

 * Revision 1.21  2000/05/31  11:42:58  11:42:58  mjames (Mike James)

 * Part of Release May_31_2000

 *

 * Revision 1.20  2000/05/08  17:01:38  17:01:38  mjames (Mike James)

 * Part of Release May__8_2000

 *

 * Revision 1.19  2000/05/08  16:59:31  16:59:31  mjames (Mike James)

 * Part of Release May__8_2000

 *

 * Revision 1.18  2000/05/08  16:57:08  16:57:08  mjames (Mike James)

 * Part of Release May__8_2000

 *

 * Revision 1.17  2000/03/08  16:19:26  16:19:26  mjames (Mike James)

 * New version including PC

 *

 * Revision 1.14  2000/01/20  15:58:48  15:58:48  mjames (Mike James)

 * Part of Release R22

 *

 * Revision 1.13  99/12/22  11:15:29  11:15:29  mjames (Mike James)

 * Part of Release Dec_22_1999

 *

 * Revision 1.12  99/06/25  14:35:49  14:35:49  mjames (Mike James)

 * Added in reference to expression.h, but no changes made

 * to the function of acfread yet.

 *

 * Revision 1.11  99/05/04  09:52:43  09:52:43  mjames (Mike James)

 * General checkin

 *

 * Revision 1.10  98/08/12  14:22:18  14:22:18  mjames (Mike James)

 * Corrected include file list

 *

 * Revision 1.9  98/04/24  14:07:51  14:07:51  mjames (Mike James)

 *  Added pin name swapping code

 *

 * Revision 1.8  98/03/16  11:38:24  11:38:24  mjames (Mike James)

 * Removed an old bug - suffixing of PCB names has been broken for about

 * a year. If a pcb were read in non-suffixed and then another with a suffix,

 * the suffix would be applied over all of the sockets and nets, not just the new ones.

 *

 * Revision 1.7  98/02/11  11:27:06  11:27:06  mjames (Mike James)

 * Checked in for version 6.2a

 *

 * Revision 1.6  97/04/23  08:43:22  08:43:22  mjames (Mike James)

 * CHecked in for release rel23041997

 *

 * Revision 1.5  96/07/19  14:38:51  14:38:51  mjames (Mike James)

 * Update to give to PRL

 *

 * Revision 1.4  1996/07/12  15:52:12  mjames

 * Sorted out things like Alias and Jumpers

 * Work Correctly

 * Print COrrectly

 *

 * Revision 1.4  1996/07/12  15:52:12  mjames

 * Sorted out things like Alias and Jumpers

 * Work Correctly

 * Print COrrectly

 *

 * Revision 1.3  96/06/04  11:53:28  11:53:28  mjames (Mike James)

 * Corrected the operation of the renaming function

 *

 * Revision 1.2  96/05/29  11:00:10  11:00:10  mjames (Mike James)

 * Added explanatory comments

 *

 * Revision 1.1  96/05/29  10:53:13  10:53:13  mjames (Mike James)

 * Initial revision

 *  */

#include "rename.h"

#include "chck_names.h"

#include "cmdlog.h"

#include "cmdparse.h"

#include "database.h"

#include "expression.h"

#include "generic.h"

#include "lx_support.h"

#include "sorting.h"

#include "vertcl_main.h"

#include <ctype.h>

#include <regex.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#ident                                                                                        \

    "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/vertlib/rename.c,v 1.2 2003/11/06 04:36:03 mjames Exp $"

/* added on to suffix all signal names */

/* all new objects will appear after the 'mark'. Only

   these new objects need to be renamed by adding a suffix.

   Older objects have already been renamed. */

static net_t *mark_nets = NULL;

static socket_t *mark_skts = NULL;

/* record the last known net and socket before

   reading in new nets and sockets */

void mark_board_objects (void)

{

        net_t *net = routed_list;

        socket_t *skt = socket_head;

        while (net && net->next)

        {

                net = net->next;

        }

        mark_nets = net;

        while (skt && skt->next)

        {

                skt = skt->next;

        }

        mark_skts = skt;

        /*

          printf("Mark at net=%p and skt=%p\n",mark_nets,mark_skts);

        */

}

/* only name nets that are not null names */

static char *alter_id (char *id, char *suffix)

{

        if (!ISNULLSTR (id) && !ISNULLSTR (suffix))

        {

                id = realloc (id, strlen (id) + strlen (suffix) + 1);

                strcat (id, suffix);

                return (id);

        }

        return NULL;

}

/* suffixes all net and component identifiers

   since the last 'mark_board_objects' call with the string s */

void set_board_suffix (char *s)

{

        net_t *net = mark_nets;

        socket_t *skt = mark_skts;

        /*

          printf("Mark at net=%p and skt=%p\n",mark_nets,mark_skts);

        */

        /* flag the nets and sockets as having been renamed */

        mark_nets = NULL;

        mark_skts = NULL;

        if (net)

                net = net->next; /* move to next one (new one) */

        else

                net = routed_list;

        if (skt)

                skt = skt->next; /* ditto */

        else

                skt = socket_head;

        /* rename all of the net identifiers */

        while (net)

        {

                struct net *sub_n = net->subnets;

                /* jumpered nets have their subnets renamed */

                if (sub_n && net->how_joined == Jumpered)

                        while (sub_n)

                        {

                                sub_n->identifier = alter_id (sub_n->identifier, s);

                                sub_n = sub_n->subnets;

                        }

                else

                        net->identifier = alter_id (net->identifier, s);

                net = net->next;

        }

        /* rename all of the socket identifiers */

        while (skt)

        {

                skt->identifier = alter_id (skt->identifier, s);

                if (skt->name) /* mod MDJ July 2001 */

                        skt->name = alter_id (skt->name, s);

                skt = skt->next;

        }

}

/*********************************************************************/

/* Pin_swapping : reverse A23 to 23a                                 */

/* allow up to lead_chars before digits to permit pin swap           */

/* lead_chars = 2  -> aa23 maps to 23aa but pin23 remains unswapped  */

/*********************************************************************/

/* modified from the original, now allows swapping 1a to a1 if

 * AlphaSwap_t == Want_A1

 * or allows swapping a1 to 1a if

 * AlphaSwap_t == Want_1A

 * probably better using the renaming command below.

 */

void pin_id_swap (char *template, int lead_chars, AlphaSwap_t lead_alpha)

{

        enum

        {

                First_Char,

                Leading_Chars,

                Trailing_Digits,

                Leading_Digits,

                Trailing_Chars,

                No_Swap

        } SwapState;

        int rc;

        socket_t *chip;

        node_t *nodes;

        /* compile regular expression */

        vert_regex_t *preg;

        if (ISNULLSTR (template))

        {

                template = ".*";

        }

        rc = vert_regcomp (&preg, template);

        if (rc != 0)

        {

                char errbuff[100];

                regerror (rc, preg->preg, errbuff, 100);

                Log (

                    LOG_ERROR,

                    "-- Problem (rc=%d) %s with '%s' as regular expression\n",

                    rc,

                    errbuff,

                    template);

                /*    return TCL_ERROR;

                 */

                return;

        }

        else

        {

                Log (LOG_GENERAL, "-- Using '%s' as match pattern\n", template);

        }

        if (lead_alpha == Want_A1)

        {

                Log (

                    LOG_GENERAL,

                    "-- Swapping pin identifiers with up to %d leading letters\n",

                    lead_chars);

        }

        else

        {

                Log (

                    LOG_GENERAL,

                    "-- Swapping pin identifiers with up to %d trailing letters\n",

                    lead_chars);

        }

        Log (

            LOG_GENERAL,

            "-- for sockets matching template '%s' --\n",

            template ? template : "[ALL Sockets]");

        chip = socket_head;

        while (chip)

        {

                int found;

                found = regexec (preg->preg, chip->identifier, 0, preg->regpatt, 0);

                if (!found)

                {

                        Log (LOG_GENERAL, "-- Processing socket '%s' --\n", chip->identifier);

                        nodes = chip->nodes;

                        while (nodes)

                        {

                                int lead_count = 0;

                                int done = 0;

                                char new_id[MAXIDLEN];

                                char *pos = nodes->identifier;

                                SwapState = First_Char;

                                while (pos && *pos && !done)

                                {

                                        /*

                                                  printf("%s (%c) State

                                           %d\n",nodes->identifier,*pos,SwapState);

                                        */

                                        switch (SwapState)

                                        {

                                        case First_Char:

                                                if (lead_alpha == Want_A1 && isdigit (*pos) &&

                                                    lead_chars > 0)

                                                {

                                                        SwapState = Leading_Digits;

                                                        lead_count = 1;

                                                        break;

                                                }

                                                if (lead_alpha == Want_1A && isalpha (*pos) &&

                                                    lead_chars > 0)

                                                {

                                                        SwapState = Leading_Chars;

                                                        lead_count = 1;

                                                        break;

                                                }

                                                /* no action needed, so continue */

                                                SwapState = No_Swap;

                                                done = 1;

                                                break;

                                        case Leading_Chars:

                                                if (isdigit (*pos))

                                                {

                                                        if (lead_count <= lead_chars)

                                                        { /* encountered a digit after a

                                                             character success so far */

                                                                SwapState = Trailing_Digits;

                                                                break;

                                                        }

                                                        else

                                                        {

                                                                SwapState = No_Swap;

                                                                done = 1;

                                                                break;

                                                        }

                                                }

                                                if (isalpha (*pos))

                                                {

                                                        lead_count++;

                                                        break;

                                                }

                                                SwapState = No_Swap;

                                                done = 1;

                                                break;

                                        case Leading_Digits:

                                                if (isalpha (*pos))

                                                {

                                                        if (lead_count <= lead_chars)

                                                        { /* encountered a character after a

                                                             number success so far */

                                                                SwapState = Trailing_Chars;

                                                                break;

                                                        }

                                                        else

                                                        {

                                                                SwapState = No_Swap;

                                                                done = 1;

                                                                break;

                                                        }

                                                }

                                                if (isdigit (*pos))

                                                { /* continue ok */

                                                        lead_count++;

                                                        break;

                                                }

                                                SwapState = No_Swap;

                                                done = 1;

                                                break;

                                        case Trailing_Digits:

                                                if (!isdigit (*pos))

                                                {

                                                        SwapState = No_Swap;

                                                        done = 1;

                                                }

                                                break;

                                        case Trailing_Chars:

                                                if (!isalpha (*pos))

                                                {

                                                        SwapState = No_Swap;

                                                        done = 1;

                                                }

                                                break;

                                        default:

                                                break;

                                        }

                                        pos++;

                                }

                                /* on arrival here in either state we can swap the two parts of

                                 * the ident */

                                if (SwapState == Trailing_Digits ||

                                    SwapState == Trailing_Chars)

                                {

                                        int i, l;

                                        strcpy (new_id, (nodes->identifier) + lead_count);

                                        strncat (new_id, nodes->identifier, lead_count);

                                        l = strlen (new_id);

                                        for (i = 0; i < l; i++)

                                                new_id[i] = tolower (new_id[i]);

                                        Log (

                                            LOG_GENERAL,

                                            "# Renaming %s(%s) to %s(%s)\n",

                                            chip->identifier,

                                            nodes->identifier,

                                            chip->identifier,

                                            new_id);

                                        strcpy (nodes->identifier, new_id);

                                }

                                nodes = nodes->sktnext;

                        }

                }

                chip = chip->next;

        }

        vert_regfree (&preg);

}

/***************************************************************************************/

/* Name nets after node name on device instead of pcb CAD name                         */

/* Initially lookup all matching sockets                                               */

void alter_net_to_socket_name (char *chip_id_template, char *prefix_opt)

{

        node_t *chip_node;

        int found, rc, count = 0;

        socket_t *socket;

        vert_regex_t *preg;

        socket = socket_head;

        /*  create_unrouted_list(); */

        /* compile regular expression */

        if (!chip_id_template)

        {

                chip_id_template = ".*";

        }

        rc = vert_regcomp (&preg, chip_id_template);

        if (rc != 0)

        {

                char errbuff[100];

                regerror (rc, preg->preg, errbuff, 100);

                Log (

                    LOG_ERROR,

                    "-- Problem (rc=%d) %s with '%s' as regular expression\n",

                    rc,

                    errbuff,

                    chip_id_template);

                /*    return TCL_ERROR;

                 */

                return;

        }

        else

        {

                Log (LOG_GENERAL, "-- Using '%s' as match pattern\n", chip_id_template);

        }

        while (socket)

        {

                found = regexec (preg->preg, socket->identifier, 0, preg->regpatt, 0);

                if (!found)

                {

                        /*

                              Log(LOG_GENERAL,"found %s\n",skt->identifier);

                        */

                        count++;

                        chip_node = socket->nodes;

                        while (chip_node)

                        {

                                char name_buff[MAXIDLEN];

                                int count;

                                net_t *net = chip_node->net;

                                if (net && IS_ROUTABLE (net->how_routed))

                                {

                                        if (prefix_opt) /* TH requests this change. Not a

                                                           problem */

                                        {

                                                count = sprintf (

                                                    name_buff,

                                                    "%s%s",

                                                    prefix_opt,

                                                    chip_node->identifier);

                                        }

                                        else

                                        {

                                                count = sprintf (

                                                    name_buff,

                                                    "%s_%s",

                                                    socket->identifier,

                                                    chip_node->identifier);

                                        }

                                        net->identifier = realloc (net->identifier, count + 1);

                                        strcpy (net->identifier, name_buff);

                                        /*          printf("-- id = %s\n",name_buff); */

                                }

                                chip_node = chip_node->sktnext;

                        }

                }

                socket = socket->next;

        }

        Log (LOG_GENERAL, "-- processed %d sockets\n", count);

        vert_regfree (&preg);

}

static char pin_map_chars[] = PIN_MAP_LEGAL_CHARS;

static int row_index, col_index; /* Made static so I can check them later .*/

/***************************************************************************************/

/* Name nets after node name on device instead of pcb CAD name                         */

/* Initially lookup all matching sockets                                               */

/* change device template pin identifiers */

void edit_socket_pin_name (

    char *chip_id_template, char *pin_patt, char *pin_repl, property_t search_space)

{

        node_t *chip_node;

        int found, rc, count = 0;

        int subexpressions;

        socket_t *socket;

        vert_regex_t *preg;

        vert_regex_t *ppin_reg;

        int loop;

        if (ISNULLSTR (pin_patt))

        {

                return;

        }

        socket = template_head;

        /*  create_unrouted_list(); */

        /* compile regular expression for chip type */

        if (!chip_id_template)

        {

                chip_id_template = ".*";

        }

        rc = vert_regcomp (&preg, chip_id_template);

        if (rc != 0)

        {

                char errbuff[100];

                regerror (rc, preg->preg, errbuff, 100);

                Log (

                    LOG_ERROR,

                    "-- Problem (rc=%d) %s with '%s' as regular expression\n",

                    rc,

                    errbuff,

                    chip_id_template);

                /*    return TCL_ERROR;

                 */

                return;

        }

        else

        {

                Log (

                    LOG_GENERAL,

                    "-- Using '%s' as match pattern for chip %s\n",

                    chip_id_template,

                    search_space == Type ? "type" : "ident");

        }

        /* now compile pin regexp match pattern */

        rc = vert_regcomp (&ppin_reg, pin_patt);

        if (rc != 0)

        {

                char errbuff[100];

                regerror (rc, ppin_reg->preg, errbuff, 100);

                Log (

                    LOG_ERROR,

                    "-- Problem (rc=%d) %s with '%s' as regular expression\n",

                    rc,

                    errbuff,

                    pin_patt);

                /*    return TCL_ERROR;

                 */

                return;

        }

        else

        {

                subexpressions = ppin_reg->preg->re_nsub + 1; /* count up subexpressions */

                Log (

                    LOG_GENERAL,

                    "-- Using '%s' as chip pin ID matching pattern (%d subexpressions)\n",

                    pin_patt,

                    subexpressions);

        }

        if (subexpressions > MAX_REGEXP_SUBEXPR)

        {

                Log (LOG_ERROR, "-- Too many (>%d) subexpressions\n", MAX_REGEXP_SUBEXPR);

                return;

        }

        /* decode the command type */

        switch (search_space)

        {

        case Ident:

                loop = 1;

                break;

        case Type:

                loop = 2;

                break;

        default:

                loop = 0;

                break;

        }

        /* loop 2,1, 0 or 1,0 dependent on whether search is type or ident based */

        while (loop)

        {

                switch (loop)

                {

                case 1:

                        socket = socket_head;

                        break;

                case 2:

                        socket = template_head;

                        break;

                default:

                        break;

                }

                loop--;

                while (socket)

                {

                        if (search_space == Type)

                        {

                                found =

                                    regexec (preg->preg, socket->type, 0, preg->regpatt, 0);

                        }

                        else

                        {

                                found = regexec (

                                    preg->preg, socket->identifier, 0, preg->regpatt, 0);

                        }

                        if (!found)

                        {

                                /*

                                      Log(LOG_GENERAL,"found %s\n",skt->identifier);

                                */

                                int rows, columns;

                                /*      int row_index,col_index;  Made static so I can check

                                 * them later .*/

                                generic_info_t info, *row_expr, *col_expr;

                                /* Setup the row and column variables for this device */

                                /* these are input names that can be used in an expression */

                                info.g_type = IS_ATTRIBUTE;

                                info.g_class = DEFINED;

                                /* info is copied, simply change the variable parts and call

                                   the compile and set functions */

                                info.name = "pin_row";

                                info.expr = compile_variable_reference (&row_index, "pin_row");

                                set_generic_value (&socket->generics, &info);

                                info.name = "pin_col";

                                info.expr = compile_variable_reference (&row_index, "pin_col");

                                set_generic_value (&socket->generics, &info);

                                /* this expression will be evaluated when &n is seen in the

                                    input file */

                                row_expr = get_generic_ref (&socket->generics, "row_expr");

                                /*

                                      if(row_expr && row_expr->expr)

                                        {

                                        printf("row = ");

                                        print_expression(stdout,row_expr->expr,NO_RECURSE);

                                        printf("\n");

                                        }

                                */

                                /* this expression will be evaluated when &a is seen in the

                                    input file */

                                col_expr = get_generic_ref (&socket->generics, "col_expr");

                                /*

                                      if(col_expr && col_expr->expr)

                                        {

                                        printf("col = ");

                                        print_expression(stdout,col_expr->expr,NO_RECURSE);

                                        printf("\n");

                                        }

                                */

                                count++;

                                sort_nodes (socket, EXTRACT_XY); /* sort pins , determine pin

                                                                    row and column*/

                                rows = socket->max_pin_row - socket->min_pin_row + 1;

                                columns = socket->max_pin_col - socket->min_pin_col + 1;

                                chip_node = socket->nodes;

                                while (chip_node)

                                {

                                        char *str;

                                        str = chip_node->identifier;

                                        /* allow one bracketed subexpression in pin names */

                                        found = regexec (

                                            ppin_reg->preg,

                                            str,

                                            subexpressions,

                                            ppin_reg->regpatt,

                                            0);

                                        if (!found)

                                        {

                                                char name_buff[MAXIDLEN];

                                                int count, fail;

                                                int editp, copyp;

                                                name_buff[0] = 0;

                                                /* get length of replacement string */

                                                editp = 0;

                                                count = 0;

                                                fail = 0;

                                                /*          printf("Processing

                                                 * '%s'\n",pin_repl); */

                                                while (pin_repl[editp] && !fail)

                                                {

                                                        /* escape anything */

                                                        if (pin_repl[editp] == '\\')

                                                        {

                                                                editp++;

                                                                name_buff[count++] =

                                                                    pin_repl[editp];

                                                                if (pin_repl[editp])

                                                                {

                                                                        editp++;

                                                                }

                                                        }

                                                        /* replace matched patterns */

                                                        else if (pin_repl[editp] == '&')

                                                        {

                                                                int index, len;

                                                                char c;

                                                                char temp[30];

                                                                int digits;

                                                                /* change values to those seen

                                                                 * on this pin */

                                                                col_index = chip_node->pin_col;

                                                                row_index = chip_node->pin_row;

                                                                editp++;

                                                                c = pin_repl[editp];

                                                                if (c)

                                                                {

                                                                        /*                 printf("c='%c'

                                                                         * row = %d col

                                                                         * =%d\n",c,chip_node->pin_row

                                                                         * ,chip_node->pin_col);

                                                                         */

                                                                        editp++;

                                                                        switch (c)

                                                                        {

                                                                        case 'c':

                                                                        case 'C':

                                                                                if (chip_node

                                                                                        ->net &&

                                                                                    chip_node

                                                                                        ->net

                                                                                        ->name)

                                                                                {