Tcl大括号内的变量替换

Question

Correct me wherever I am wrong.

When we use the variables inside braces, the value won't be replaced during evaluation and simply passed on as an argument to the procedure/command. (Yes, some exception are there like expr {$x+$y} ).

Consider the following scenarios,

Scenario 1

% set a 10
10
%  if {$a==10} {puts "value is $a"}
value is 10
%  if "$a==10" "puts \"value is $a\""
value is 10

Scenario 2

%  proc x {} {
        set c 10
        uplevel {set val $c}
}
%
% proc y {} {
         set c 10
        uplevel "set val $c"
}
% x
can't read "c": no such variable
% y
10
% set val
10
%

In both of the scenarios, we can see that the variable substitution is performed on the body of the if loop (ie {puts "value is $a"} ), whereas in the uplevel , it is not (ie {set val $c} ), based on the current context.

I can see it as if like they might have access it via upvar kind of stuffs may be. But, why it has to be different among places ? Behind the scene, why it has to be designed in such this way ? Or is it just a conventional way how Tcl works?

Answer 1

Tcl always works exactly the same way with exactly one level of interpretation, though there are some cases where there is a second level because a command specifically requests it. The way it works is that stuff inside braces is never interpolated or checked for word boundaries (provided those braces start at the start of a “word”), stuff in double quotes is interpolated but not parsed for word boundaries (provided they start a word), and otherwise both interpolation and word boundary scanning are done (with the results of interpolation not scanned).

But some commands send the resulting word through again. For example:

eval {
    puts "this is an example with your path: $env(PATH)"
}

The rule applies to the outer eval , but that concatenates its arguments and then sends the results into Tcl again. if does something similar with its body script except there's no concatenation, and instead there's conditional execution. proc also does the same, except it delays running the code until you call the procedure. The expr command is like eval , except that sends the script into the expression evaluation engine, which is really a separate little language. The if command also uses the expression engine (as do while and for ). The expression language understands $var (and […] ) as well.

So what happens if you do this?

set x [expr $x + $y]

Well, first we parse the first word out, set , then x , then with the third word we start a command substitution, which recursively enters the parser until the matching ] is found. With the inner expr , we first parse expr , then $x (reading the x variable), then + , then $y . Now the expr command is invoked with three arguments; it concatenates the values with spaces between them and sends the result of the concatenation into the expression engine. If you had x previously containing $ab and y containing [kaboom] , the expression to evaluate will be actually:

$ab + [kaboom]

which will probably give you an error about a non-existing variable or command. On the other hand, if you did expr {$x + $y} with the braces , you'll get an addition applied to the contents of the two variables (still an error in this case, because neither looks like a number).

---

You're recommended to brace your expressions because then the expression that you write is the expression that will be evaluated. Otherwise, you can get all sorts of “unexpected” behaviours. Here's a mild example:

set x {12 + 34}
puts [expr $x]
set y {56 + 78}
puts [expr $y]
puts [expr $x * $y]

Remember, Tcl always works the same way. No special cases. Anything that looks like a special cases is just a command that implements a little language (often by calling recursively back into Tcl or the expression engine).

Answer 2

In addition to Donal Fellows's answer:

In scenario 2, in x the command uplevel {set val $c} is invoked, and fails because there is no such variable at the caller's level.

In y , the equivalent of uplevel {set val 10} is invoked (because the value of c is substituted when the command is interpreted). This script can be evaluated at the caller's level since it doesn't depend on any variables there. Instead, it creates the variable val at that level.

It has been designed this way because it gives the programmer more choices. If we want to avoid evaluation when a command is prepared for execution (knowing that the command we invoke may still evaluate our variables as it executes), we brace our arguments. If we want evaluation to happend during command preparation, we use double quotes (or no form of quoting).

Now try this:

% set c 30
30
% x
30
% y
10

If there is such a variable at the caller's level, x is a useful command for setting the variable val to the value of c , while y is a useful command for setting the variable val to the value encapsulated inside y .