In Tcl there is no distinction between built-in commands and user-defined procedures/functions. In Tcl, there are no reserved words Languages like C, C++, Java has reserved words with special meaning, E.g.: if, while, etc. When the Tcl interpreter starts up, there is a initial list of known commands (defined as procedures) that the Tcl interpreter can execute The set of initial commands include while            for set puts and so on. Note: You can re-define any built-in command of Tcl if you wish... Tcl can be crippled by this; but it is allowed... (See below for a strange example: click here )

proc CMD-NAME ARGS BODY

When the proc command is evaluated (= executed), Tcl will create (remember) a new command with name CMD-NAME that takes arguments ARGS. When Tcl encounters the command CMD-NAME in the input, Tcl will runs the code (Tcl commands) contained in BODY of the definition.

proc my-cmd {x y} { # Note: { has to be on this line... puts x puts y }

proc my-cmd {x y} { # Note: { has to be on this line... puts x puts y }

Sample command invocation:

my-cmd 4 6

Create local variables with the names x and y Copy the values of the actual parameters 4 and 6 to the local variables x and y. Evaluate the commands in the BODY of the command definition

Every procedure (command) will always return a value

A procedure can return a value explicitly using the return command. The return command will return its parameter to the calling program. Example: proc sum {arg1 arg2} { set x [expr {$arg1 + $arg2}]; return $x } A procedure will return a value implicitly when it reaches the last command in the body The return value of the last command is the return value of the procedure.

proc sum {arg1 arg2} { set x [expr {$arg1 + $arg2}]; return $x }

set x [sum 3 5] set y [sum $x 2]

The effect can be crippling

proc for {a b c d} { puts "The for command has been replaced by a puts"; puts "The arguments were: $a\n$b\n$c\n$d\n" }

Result:

The for loops will no longer work !!!

Example:

for {set i 1} {$i < 10} {incr i} { puts $i } Prints: The for command has been replaced by a puts The arguments were: set i 1 $i < 10 incr i puts $i

This is done by using the special formal parameter name args, which must be the last parameter.

(We don't need this, so I will skip it)

Global scope Variables "defined" (= first used) in the main program has global scope Local scope Parameter variables of a procedure has local scope Variables "defined" inside a procedure has local scope

proc my-proc {} { set x 1111 ;# Create a local var x ! puts "Inside my-proc: x = $x" } # ------------------------------- # Main program # ------------------------------- set x 4 ; # Glabel x puts "(1) In main program (outside) before my-proc: x = $x" my-proc puts "(2) In main program (outside) after my-proc: x = $x"

Output: (1) In main program (outside) before my-proc: x = 4 Inside my-proc: x = 1111 (2) In main program (outside) before my-proc: x = 4

proc my-incr {x} { puts "Inside my-incr before incr: x = $x" set x [expr $x + 1] ;# Change local var x ! puts "Inside my-incr after incr: x = $x" } # ------------------------------- # Main program # ------------------------------- set x 4 # Glabel x puts "(1) In main program (outside) before my-incr: x = $x" my-incr $x puts "(2) In main program (outside) before my-incr: x = $x"

Output: (1) In main program (outside) before my-incr: x = 4 Inside my-incr before incr: x = 4 Inside my-incr after incr: x = 5 (2) In main program (outside) before my-incr: x = 4

• You can see that the execution has the same effect as in C++ when the parameter is passed-by-value

The "upvar x y" command associate the name y with the variable x in the outer scope In order to access the you must use the variable x in the outer scope, you must use the name y in the procedure body.

Example:

proc my-incr {x} { # You can use another name, e.g.: y upvar x new_x puts "Inside my-incr before incr: new_x = $new_x" set new_x [expr $new_x + 1] ;# Change x ! puts "Inside my-incr after incr: new_x = $new_x" } set x 4 puts "In program (outside) before my-incr: x = $x" my-incr $x puts "In program (outside) before my-incr: x = $x"

Output: In program (outside) before my-incr: x = 4 Inside my-incr before incr: new_x = 4 Inside my-incr after incr: new_x = 5 In program (outside) before my-incr: x = 5

• You can see that the execution has the same effect as in C++ when the parameter is passed-by-reference

To access global variables from inside a procedure body, you must not use the name of the global variable as a name of some parameter !!! (Once you use the name of a global variable as the name of a parameter, that name is used to refer to a local variable It is too late to use it to refer to a global variable Overshadowed....)

Example:

proc my-incr {} { global x puts "Inside my-incr before incr: x = $x" incr x puts "Inside my-incr after incr: x = $x" } set x 4 puts "In program (outside) before my-incr: x = $x" my-incr puts "In program (outside) before my-incr: x = $x"

Output: In program (outside) before my-incr: x = 4 Inside my-incr before incr: x = 4 Inside my-incr after incr: x = 5 In program (outside) before my-incr: x = 4

proc my-proc {} { puts "Inside my-proc before set: x = $x" # $x has not been created yet !!! set x 1111 puts "Inside my-proc after set: x = $x" } set x 4 my-proc // Error !! (x undefined in my-proc)

proc my-proc {} { set x 1111 ;# Creates a local var x puts "Inside my-proc after set: x = $x" } set x 4 my-proc puts $x ---> 4 !!!