/* * $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 #include #include #include #include #include #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) { len = strlen ( chip_node ->net ->name); strncpy ( name_buff + count, chip_node ->net ->name, len); count += len; } else { fail = 1; } break; /* &d or &D is * the device * identifier */ case 'd': case 'D': len = strlen ( socket ->identifier); strncpy ( name_buff + count, socket ->identifier, len); count += len; break; /* &p or &P is * the pin * identifier */ case 'p': case 'P': len = strlen ( chip_node ->identifier); strncpy ( name_buff + count, chip_node ->identifier, len); count += len; break; /* &a is the * alpha * component of * the * identifier */ case 'a': case 'A': /* always * synthesise * pin column * from the * info left by * sort_nodes */ if (col_expr && col_expr ->expr) { index = eval_expression ( col_expr ->expr, &socket ->generics); } else { index = chip_node ->pin_col; } /* printf("Alpha * %d : * ",index); */ digits = 0; /* always at * least a * single char */ if (index > 0) /* index = 0 means no chars at all ! */ { do { if (c == 'a') /* lower case idents if lower case 'a' is used */ { temp[digits++] = tolower ( pin_map_chars [index % (PIN_MAP_LEGAL_CHAR_COUNT + 1) - 1]); } else { temp[digits++] = pin_map_chars [index % (PIN_MAP_LEGAL_CHAR_COUNT + 1) - 1]; } index /= (PIN_MAP_LEGAL_CHAR_COUNT + 1); } while ( index); temp[digits] = 0; /* printf("conversion * '%s'\n",temp); */ /* reverse * copy * string, * at * least * one * char */ for ( ; digits > 0; name_buff [count++] = temp [--digits]) ; } else { /* error * in * the * expansion * as * the * index * < 0 */ /* Leave it blank as there is a danger elsewhere name_buff[count++] = '&'; name_buff[count++] = c; */ } break; /* &n is the * alpha * component of * the * identifier */ case 'n': case 'N': if (row_expr && row_expr ->expr) { index = eval_expression ( row_expr ->expr, &socket ->generics); } else { index = chip_node ->pin_row; } /* printf("Numeric * %d\n",index); */ if (index > 0) /* index = 0 means no chars at all ! */ { sprintf ( temp, "%" "d", index); len = strlen ( temp); strncpy ( name_buff + count, temp, len); /* printf("result: * '%s' * %d\n",name_buff,strlen(name_buff)); */ count += len; } else { /* error * in * the * expansion * as * the * index * < 0 */ name_buff [count++] = '&'; name_buff [count++] = c; } break; case 'i': case 'I': sprintf ( temp, "%d", chip_node ->pin_row - socket ->min_pin_row + (chip_node ->pin_col - socket ->min_pin_col) * rows + 1); len = strlen ( temp); strncpy ( name_buff + count, temp, len); count += len; break; /* &0 to &9 or whatever is the regular expression bracketed section */ default: index = c - '0'; if (index < 0 || index > subexpressions) { fail = 1; } else { /* copy * subexpression * over */ copyp = ppin_reg ->regpatt [index] .rm_so; if (copyp >= 0) { while ( copyp < ppin_reg ->regpatt [index] .rm_eo) { name_buff [count++] = str [copyp++]; } } else { name_buff [count++] = '@'; } } } } } else { name_buff[count++] = pin_repl[editp++]; } } if (!fail) { name_buff[count] = 0; /* printf("replacing '%s' with '%s'\n",chip_node->identifier,name_buff); */ chip_node->identifier = realloc ( chip_node->identifier, count + 1); strcpy ( chip_node->identifier, name_buff); } } chip_node = chip_node->sktnext; } } sort_nodes (socket, NO_EXTRACT_XY); socket = socket->next; } } Log (LOG_GENERAL, "-- processed %d sockets\n", count); vert_regfree (&preg); vert_regfree (&ppin_reg); } /***************************************************************************************/ /* allows for net renaming : currently in the routed list only */ void edit_net_names (char *pin_patt, char *pin_repl, property_t search_space) { net_t *curr_net; int found, rc = 0; int subexpressions; int net_count; vert_regex_t *ppin_reg; int loop; net_count = 0; if (ISNULLSTR (pin_patt)) { return; } curr_net = routed_list; /* 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 net 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 = 3; /* loop 2,1, 0 or 1,0 dependent on whether search is type or ident based */ while (loop) { char *str; printf ("In loop %d\n", loop); switch (loop) { case 1: curr_net = routed_list; break; case 2: curr_net = unrouted_list; break; case 3: curr_net = named_list; break; default: curr_net = NULL; break; } loop--; while (curr_net) { found = 1; str = "nothing"; if (search_space == Name && !ISNULLSTR (curr_net->name)) { found = regexec ( ppin_reg->preg, curr_net->name, 0, ppin_reg->regpatt, 0); str = curr_net->name; } if (search_space == Ident && !ISNULLSTR (curr_net->identifier)) { found = regexec ( ppin_reg->preg, curr_net->identifier, 0, ppin_reg->regpatt, 0); str = curr_net->identifier; } /* printf("Checking '%s'\n",str); */ /* found will not be set if neither Name or Ident is used */ if (!found) { char name_buff[MAXIDLEN]; int fail, count; int editp, copyp; name_buff[0] = 0; /* get length of replacement string */ editp = 0; fail = 0; count = 0; net_count++; printf ("Processing '%s'\n", str); 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; editp++; c = pin_repl[editp]; if (c) { editp++; switch (c) { /* replace with name part of * net */ case 'n': case 'N': if (!ISNULLSTR ( curr_net->name)) { len = strlen ( curr_net->name); strncpy ( name_buff + count, curr_net->name, len); count += len; } else { fail = 1; } break; case 'i': case 'I': if (!ISNULLSTR ( curr_net->identifier)) { len = strlen ( curr_net ->identifier); strncpy ( name_buff + count, curr_net ->identifier, len); count += len; } else { fail = 1; } break; /* &0 to &9 or whatever is the regular expression bracketed section */ default: index = c - '0'; if (index < 0 || index > subexpressions) { fail = 1; } else { /* copy subexpression * over */ copyp = ppin_reg ->regpatt [index] .rm_so; if (copyp >= 0) { while ( copyp < ppin_reg ->regpatt [index] .rm_eo) { name_buff [count++] = str [copyp++]; } } else { name_buff [count++] = '@'; } } } /* cae */ } } else { name_buff[count++] = pin_repl[editp++]; } } if (!fail) { name_buff[count] = 0; /* printf("replacing '%s' with '%s'\n",chip_node->identifier,name_buff); */ if (search_space == Ident) { curr_net->identifier = realloc (curr_net->identifier, count + 1); printf ( "replacing '%s' with '%s'\n", curr_net->identifier, name_buff); strcpy (curr_net->identifier, name_buff); } if (search_space == Name) { curr_net->name = realloc (curr_net->name, count + 1); printf ( "replacing '%s' with '%s'\n", curr_net->name, name_buff); strcpy (curr_net->name, name_buff); } } } curr_net = curr_net->next; } } Log (LOG_GENERAL, "-- processed %d nets\n", net_count); vert_regfree (&ppin_reg); }