I have written one TCL script but I have one problem when making a string variable as below:
set a 100
set b "this is variable[$a]"
I want b to be assign with b = "this is variable[100]" but I got the error:
invalid command name 100
Please help me to fix it :-(.
You just need to escape it:
set a 100
set b "this is variable\[$a\]"
Other possibilities (but escaping the brackets is better):
set b [format {this is variable[%d]} $a]
set b [subst -nocom -noback {this is variable[$a]}]
Documentation:
set,
format,
subst
Related
I have set 3 global variables as below in a file FILE1:
set VAR1 2
set VAR2 3
set VAR3 4
Now I want to use these 3 variables in another file FILE2 in iterative way:
Means, something like this:
for {set a 1} {$a < 4} {incr a} {
$::VAR$a
}
where VAR$a - should be incremented each time to VAR1,VAR2,VAR3 etc...
But if I try like this using the global variable I get error in tcl
Any better solution for this?
Either make your meaning clearer to the interpreter
set ::VAR$a
(you are aware that this is just getting the variable's value without doing anything with the value, that is, a pointless operation, right?)
Or use an array, which is basically a two-part variable name:
set ::VAR($a)
in which case you need to initialize as an array:
set VAR(1) 2
etc, or
array set VAR {1 2 2 3 3 4}
The reason why $::VAR$a doesn't always work is AFAICT that the variable substitution becomes ambiguous. Given these definitions:
set foobar 1
set a foo
set b bar
what should $a$b substitute into? To avoid ambiguity, the substitution rules are kept simple: the first substitution stops before the second dollar sign, and the whole expression evaluates to the string foobar. How about $$a$b to substitute the value of foobar, then? No, a dollar-sign followed directly by a character that can't be a part of a variable name means that the first dollar sign becomes just a dollar sign: you get $foobar. The best way to handle this is to reduce the levels of substitution using the set command to get a value: set $a$b. Bottom line: variable substitution using $ does not always work well, but the set always does the job.
Documentation:
set,
Summary of Tcl language syntax
Could you please help me with the following script?
It is a Tcl script which Synopsys IC Compiler II will source.
set_dont_use [get_lib_cells */*CKGT*0P*] -power
set_dont_use [get_lib_cells */*CKTT*0P*] -setup
May I know how to take only */*CKGT*0P* and */*CKTT*0P* and assign these to a variable.
Of course you can treat a Tcl script as something you search through; it's just a file with text in it after all.
Let's write a script to select the text out. It'll be a Tcl script, of course. For readability, I'm going to put the regular expression itself in a global variable; treat it like a constant. (In larger scripts, I find it helps a lot to give names to REs like this, as those names can be used to remind me of the purpose of the regular expression. I'll call it “RE” here.)
set f [open theScript.tcl]
# Even with 10 million lines, modern computers will chew through it rapidly
set lines [split [read $f] "\n"]
close $f
# This RE will match the sample lines you've told us about; it might need tuning
# for other inputs (and knowing what's best is part of the art of RE writing)
set RE {^set_dont_use \[get_lib_cells ([\w*/]+)\] -\w+$}
foreach line $lines {
if {[regexp $RE $line -> term]} {
# At this point, the part you want is assigned to $term
puts "FOUND: $term"
}
}
The key things in the RE above? It's in braces to reduce backslash-itis. Literal square brackets are backslashed. The bit in parentheses is the bit we're capturing into the term variable. [\w*/]+ matches a sequence of one or more characters from a set consisting of “standard word characters” plus * and /.
The use of regexp has -> as a funny name for a variable that is ignored. I could have called it dummy instead; it's going to have the whole matched string in it when the RE matches, but we already have that in $term as we're using a fully-anchored RE. But I like using -> as a mnemonic for “assign the submatches into these”. Also, the formal result of regexp is the number of times the RE matched; without the -all option, that's effectively a boolean that is true exactly when there was a match, which is useful. Very useful.
To assign the output of any command <command> to a variable with a name <name>, use set <name> [<command>]:
> set hello_length [string length hello]
5
> puts "The length of 'hello' is $hello_length."
The length of 'hello' is 5.
In your case, maybe this is what you want? (I still don't quite understand the question, though.)
set ckgt_cells [get_lib_cells */*CKGT*0P*]
set cktt_cells [get_lib_cells */*CKTT*0P*]
I have searched for lappend $var1 $var2, but don't find any exact answer, how it will be executed.
% set a {a b c}
a b c
% set b {d e}
d e
% puts [lappend $c $b]
can't read "c": no such variable >>> here it throws error like variable not exist
% puts [lappend $a $b]
{d e} >>> here it doesn't throw any error, can someone explain it and how to print the value of $a, if $a is a new variable
% puts $$A
can't read "A": no such variable
% puts $$a
$a b c
% puts ${$a}
can't read "$a": no such variable
Tcl's got a two level syntax that it applies rigorously to everything. The first level is the Tcl generic syntax, which takes:
lappend $var1 $var2
and parses it out to three words: lappend, a word obtained by reading the variable var1, and a word obtained by reading the variable var2.
Then Tcl dispatches to the command named by the first word (lappend, a Tcl built-in) which applies command syntax handling. In the case of lappend, it's pretty simple: the first argument names a variable and the second and subsequent arguments are words to append to the list in the named variable.
In your case, the first argument that names a variable is obtained by reading another variable (var1) and the value to append to the list is coming from a variable (var2); a name like a b c d e is a legal variable name in Tcl, but it's really awkward to use. And the chance is very high that you don't want to write that: putting variable names in a variable is usually an indicator of confusing code. You can do it, but you hardly ever want to do it (except when you're using the variable name with upvar). You probably really meant to write:
lappend var1 $var2
Tcl is very exact about the distinction between variable names and variable contents. The $ is not decorative! It's there to say “read this variable, right now”, and $var1 is virtually equivalent to [set var1] in semantic terms. (The $ shorthand was later, a Tcl 2.0 feature from way back in the day!)
Tcl also doesn't allow double-dereferencing with $$vrbl. In the rare cases you need it, you do [set $vrbl]. And if you do that, you probably should immediately see if you can use an array instead as that's typically a better choice…
lappend's first parameter is a variable name, not a value. Therefore, in general, it should be:
lappend var1 $var2
where both var1 and var2 are list variables. See the Tcl lappend man page for more details.
What differences are there between creating a list in TCL using:
[list a b c]
vs
{a b c}
I'm by all means not an experienced TCL programmer, but the only difference I have encountered so far is when creating a list of multiple lines the first style requires using line continuation characters like:
[list \
a \
b \
c \
]
where this parses fine:
{
a
b
c
}
Are there any other differences? Which is considered better style or idiomatic?
It would appear that when creating a complex list with nested lists, the 2nd style is the only clean way to go.
The main difference is that using the list command makes it possible to use variables when defining the list. Notice the difference between these two:
% set foo 1
1
% set bar 2
2
% set list1 [list $foo $bar]
1 2
% set list2 {$foo $bar}
$foo $bar
Note that you can also use double quotes if you want:
% set list3 "$foo $bar"
1 2
It's important to note that of the two ways to build a list with variables, only using list is guaranteed to give you a proper list. Using quotes may or may not give you a list, depending on the contents of the variables. This isn't because Tcl is mysterious or random or buggy -- it's simply how tcl quoting works. With list you are asking tcl to construct a list with specific elements, in the others you're creating a string that looks like a list, but whether it can be treated like a list or not depends on the data in the string.
Here's an example where using quotes won't give you a list:
% set foo "{"
{
% set list4 "$foo $bar"
{ 2
% lindex $list4 0
unmatched open brace in list
... whereas using list will give you a proper list:
% set list5 [list $foo $bar]
\{ 2
% lindex $list5 0
{
It's important to know that the backslash appears only when tcl converts the list to a string for the purposes of printing the list -- the backslash isn't in the data, as you can see when you use lindex to fetch the value.
Are there any other differences? Which is considered better style or idiomatic?
In the case where you're after a list with just literals in it, no variable or command expansion or anything like that, using [list a b c] and {a b c} is exactly the same. They compile to identical bytecode in Tcl 8.6 (the push of a literal onto the result stack). There really is no difference at all.
Which is more idiomatic? I don't really know, to be honest. They are both idiomatic, and subject to individual preferences. The difference between them becomes important once you start using variable and command expansion, and then the question quickly ceases to be relevant.
That said, I mostly prefer to use {a b c}. It's more convenient when the literals are longer since I can break things over multiple lines without fussing around with backslash continuations. Other people will disagree with me; for them, the typing of [list…] reminds them strongly of what they intend to do with the data, and that's clearly of some mnemonic value.
I am a newbie in TCL Programming. I was having confusion about curly braces, answer to this question tcl curly braces cleared most of my doubts.
I can understand $var, {var}, and {$var}, But recently I came across another use of curly braces, ${var}. How is this interpreted by TCL?
I have seen this is used when accessing variables in namespaces when namespaces name is in variable.
for example:
set x myNamespace ;#myNamespace is name of namespace
puts [set ${x}::var1] ;#var1 is variable in the namespace
It gives error when you don't use curly braces around 'x'.
And I also don't understand the difference between {a b c} and [list a b c], what is the difference in result of interpretation of these two commands by TCL interpretation.
elaborated explanation would be highly appreciated.
See rule 8 of the manual. It allows you to have variable names that might get mis-interpreted. For instance:
% set dotted.name 1
1
% puts $dotted.name
can't read "dotted": no such variable
% puts ${dotted.name}
1
Read section 8 carefully as it actually explains all this quite explicitly.
Update to answer edited question
In the example you provide using a namespace name in a variable you must consider section 8 part 1: a variable name includes letters, digits, underscores and namespace separators. This means that x::var1 is a valid variable name. So $x::var1 will attempt to dereference the var1 variable in the x namespace. As this is not what you meant, you must dereference your x variable separately. There are two ways to do this. You can either use the set command or the dollar operator.
set x myNamespace
puts [set ${x}::var1]
puts [set [set x]::var1]
The two puts statements are equivalent here with the second version showing an explicit separate pass to obtain the value of the x variable which is then substituted into the expression for the outer set command. The same occurs in the first version but just uses the grouping operator to restrict the effect of the dollar to the x variable name.