Using Renaming Rules with CadEnhance Tools

The CadEnhance Tools support Renaming Rules for many of the opearations performed on Text Strings

PartBuilder uses Rename Rules to rename Pins, strip PinNumbers from within PinNames,  and remove leading zeros from PinNumbers or PinNames extracted from PinReports

CE_HDL uses Rename rules to alter the Signal Names added to wires based on the PinName of the component

FPGA_PIN_PLANNER uses rename rules when migrate signal names or pin names between designs

NET_BOM can use rename rules to rename REF_DES or NET_NAMES from an old design to match the REF_DES or NET_NAME in the new design if the user knows that a bunch of names have been replaced in the next revision of a design.

SIG_RENAME_RULE SYNTAX

A SIG_RENAME_RULE using Match/Replace or Join can be entered as follows

1. MATCH_STRING:REPLACE_STRING
   1. checks all strings to see if they contain the MATCH_STRING... if it does, the occurrence of the MATCH_STRING will be replaced with the REPLACE_STRING
2. !JOIN_,MATCH_STRING,JOIN_STRING
   
   1. checks all strings to see if they contain the MATCH_STRING if they do the current pin name is appended with the JOIN_STRING preceeded by the character after the !JOIN which in this case and most cases will be the '_'

The SIG_RENAME_RULE can also be a REPLACEMENT_DIRECTIVE. The CadEnhance tools support several  REPLACEMENT_DIRECTIVES

1. !STRIP_LEADING_ZEROS 

   1. Remove leading zeros in any pin_name OR pin_number in the pin database.
      1. This is very useful for BSDL files which sometimes use leading zeros in their pinnames and pinnumbers
   2. dq00 will be changed to dq0, dq09 will be changed to dq9
   3. pin A01 will be change to A1 

2. !STRIP_LEADING_ZEROS_FROM_END

   1. This is for a case like intel signals 1p05_001
   2. we do not want to strip the p05 because it means something special... but we do want to strip the 001 down to 1

3. !FIX_ACTIVE_LOW (Added in release v22.1.1)

   1. This is very valuable in the CE_HDL tool where pinNames that start with '-' or end with '*' can be fixed
   2. -RESET or RESET* will be changed to RESET_N
   3. Bussed Names like: -DQ7 or DQ7* will be changed to DQ_N7  (to keeping the digit at the end so busses are properly maintained

The MATCH_STRING in the SIG_RENAME_RULES are sorted by length before they are applied. Only the longest match for a pin_name is applied. 

This enables the user to target more specific matches like the following (without worrying about the order the SIG_REPLACE_RULES are entered in)

VSS:GND

AVSS:ANALOG_GND

In this case a pin named AVSS_25 would be changed to ANALOG_GROUND_25

VSS_25 would be changed to GND_25

a pinNamed BVSS_25 would be changed to BGND_25 because it only matches the VSS PIN_MATCH

USEFUL RENAMING MATCH STRINGS

PartBuilder accepts regular expressions on the left side of the colon in the WAS:IS rename rule. This allows the user precise control over which pins get renamed as shown in the following table.

Using Renaming Rules with Math Operations

In v21.12.1 The CadEnhance tools added support to include Math operations using matching numbers in the Renaming Rule specs.

This is a very valuable addtion for the CE_HDL tool when you want to rename groups of pins in a large bus to a smaller bus

The Math operation is surrounded by exclamation points and includes a back reference from the match regexp

Supported Simple Math operators

The math is accomplished using perl builtin math, so proper order of operation is maintained. 

1. '+' addition

2. '-' subtraction

3. '*' multiply

4. '/' divide

   1. note that the user should be careful not to specify a divide operation with a 0 as the divisor

1. Simple Increment Math Replace:

   1. CB(\d+):DQ!$1+64!

   2. here the match has one set of parenthesis so the digits after CB string will be captured in $1

   3. The math operation says to add 64 to $1

   4. results:

      1. CB0 →CB64,

         1. $1=0

         2. math op = $1+64 =64

      2. CB1 →CB65...

         1. $1=1

         2. math op=$1+64 =65

2. Math using 2 or more back matches

   1. C(\d+)_D(\d+):DQ!($1+1)*64+$2!

   2. Here the match has 2 sets of parenthesis so the digits after the 'CB' string will be captured in $1, and the digits after the '_D' string will be captured in $2

   3. The math operation calculates $1+1*64 + $2

   4. sample results:

      1. C0_D1 -> DQ65

         1. $1 is 0, $2 is 1 {DQ'(0+1)*64+1'} ,

      2. C1_D1 -> DQ127 {DQ'(1+1)*64+1'}

         1. $1 is 1, $2 is 1 

3. Math using more than 1 operation

   1. #C(\d+)_D(\d+)_(\d+):C!$1*2!_D!$3*20+$2!

   2. Here the match as 3 sets of parenthisis, so the digits after the  'C' string will be captured in $1, the digits after '_D' will be captured in $2 and the digits after the last '_' will be captured in $3

   3. The replacement uses 2 math operations to build the replace string 

      1. the first is $1*$2

      2. the second is $3*20+$2

   4. sample results

      1. C1_D5_2 → C5_D45

         1. $1=1,$2=5,$3=2 

         2. math op 1  $1*$2=1*5=5

         3. math op 2 $3*20+$2 =2*20+5 =45

4. More Advanced Math operators

   1. Because the tools are using perl to run the math functions, any valid perl math statement can be used between the 2 !perl_math_expr!'

   2. you can try something more exotic expressions:

      1. C!int(4/$2)+$3**2! 

      2. use the integer of (4/$2) and then add $3 raised to the power of 2(squared)

   3. We will not attempt to document all the possiblities, rather we provide some links to websites where things have already been explained
      1. https://www.perltutorial.org/perl-operators/
      2. https://www.geeksforgeeks.org/perl-operators-set-1/
      3. https://docstore.mik.ua/orelly/perl3/prog/ch01_05.htm
   4. Obviously if you are willing to try, you can create some very powerful rules
      1. You can try these at your own risk and know that support staff will be happy to help you acheive your desired replacement rules 
      2. If there is an error in a math expression, you will be warned and the resulting value substituted for that operation will be 'MATH_ERR'

RR_REPLACE_CHAR_LIST

The RR_REPLACE_CHAR_LIST is a kind of REPLACEMENT_DIRECTIVE but it is provided separately from the SIG_RENAME_RULES entry or File.

It's purpose is to  provide a list of restricted characters for the symbol_tool, and have all those characters replaced with a valid character the RR_REPLACE_CHAR_SUB

the list defaults to ()\/ so any and the RR_REPLACE_CHAR_SUB defaults to the _

Any occurrence of the restricted characters in the pin_names will be substituted to the RR_REPLACE_CHAR_SUB 

This substitution occurs after all the SIG_RENAME_RULES have been applied.