Do define/paramter(same as in verilog language) exist in TCL script? - tcl

Question

Is there any command in TCL that is same as #define or parameter in C?
I want to reduce my code in script with define as below:
lappend links [lindex $all_list $i] $j $k 0
-> this command are used many times in my script.
How do I define it define lap_lk lappend links [lindex $all_list $i] $j $k 0 as verilog and using it in TCL script with short command lap_lk?
Thanks you very much :) .

Answer 1

Tcl isn't exactly the same as in C (or other languages that use that preprocessor). However, you can create procedures that have the sort of effects that you want. The type of procedure you want to make depends on whether you are passing in any arguments.
Simple, Parameterless
In the simplest case, without arguments, you can just use uplevel inside the procedure to run some code in the caller's context:
proc lap_lk {} {
uplevel 1 {
lappend links [lindex $all_list $i] $j $k 0
}
}
The code inside the uplevel (the 1 is optional, but I recommend it for clarity) is simply run as if it was run instead of the call to lap_lk; it uses the variables that are visible to the caller.
With Parameters
However, if you are taking arguments then things get more complicated. Let's assume that you are taking in the index into $all_list, $i, and the parts $j and $k, and let's assume that they're not too horrible…
# Using A B C to make it clear that these are different things
proc lap_lk {A B C} {
uplevel 1 [subst {
lappend links \[lindex \$all_list $A] [list $B] [list $C] 0
}]
}
The key here is that I'm using subst to inject things into the script (I could have also used double-quotes around the script instead) and I'm using list to add exactly the quoting to $B and $C to make them substitution-safe; I really ought to do so around $A, except that indices usually are substitution-safe anyway. You'd then call the code like this:
lap_lk $i $j $k
Toward the Tao of Tcl
However, in more complicated case (such as where a non-trivial loop is required) then you will use uplevel and upvar to do something more subtle. That's where you're going almost completely beyond what a C preprocessor can do elegantly. (Using a level-target other than 1 is where you go completely beyond the capabilities of the preprocessor.) In this case, using upvar lets us completely avoid using uplevel.
proc lap_lk {targetList sourceList A B C} {
upvar 1 $targetList tgt $sourceList src
lappend tgt [lindex $src $A] $B $C 0
}
# Calling pattern
lap_lk links all_list $i $j $k
It's recommended if you work this way to pass in the names of all (relevant) local variables as arguments rather than hard-coding the context. It's usually considered good practice to make procedures as independent of their calling context as possible. It's not always possible, of course.
Changing the above code to work with passing no explicit arguments (by hard-coding the names of the variables) is left as an exercise.