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 <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include <sys/types.h>

#include <regex.h>

#include "vertcl_main.h"

#include "expression.h"

#include "generic.h"

#include "database.h"

#include "rename.h"

#include "cmdparse.h"

#include "cmdlog.h"

#include "lx_support.h"

#include "chck_names.h"

#include "sorting.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)

                      {

                      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]);