Tcl error command

Error in tcl script

Purpose: for users and developers to list error messages they encounter in Tcl and for others to explain some of the possible causes (and solutions) for these msgs. See also Common Tk Error Messages and Possible Explanations.

In many cases, the Tcl error messages are so clear that by reading the words carefully, one can pretty much figure out what is needed. However, there are occasionally times when this is not the case. Also, sometimes the error msg in question is from the operating system, but it appears as though the error is coming from Tcl. This page is intended to provide some assistance in those cases.

joem/tcl/faq.html#SectionD I start with these questions and answers:

1. «not found» or «Command not found»

This error message comes from your shell, not Tcl. The script probably starts with a #! that is followed by a path to the Tcl interpreter that is too long for your system. Many Unix systems are limited to 32 characters (including the #!) in this regard. So, something like this will fail:

You can either shorten the path by moving the tclsh executable to a different directory or by using symbolic links. Another option is to not specify the path at all. See the question «How do I make my script executable regardless of the location of tclsh?» for an example of how to do this.

You have probably commented out a line that ends with an open curly brace. See http://www.psg.com/

Another common cause can be the difference between interactive and command modes for Tcl. When you start up a Tcl interpreter, get a prompt, and type in commands to Tcl, this is called interactive mode. In this mode, Tcl does a few extra things for you. For instance, if you type ls, and you have no proc called ls defined, Tcl will try to exec a command called ls. This sometimes misleads a new Tcl user into thinking that Tcl has ls defined. They then copy into a script file the same commands they typed in during interactive mode. This results in the user getting the error:

Your braces aren’t balanced. Again, one likely, though perhaps non-obvious, reason is improperly commented lines. See Question 12.

1. expected integer but got .

This error occurs when the interpreter was trying to perform some mathematical operation that requires an integer value, but encountered a non-integer value. While this is pretty obvious when the value supplied is a floating point value or an alphabetic string, this error can be confusing when the value is something that may look like a valid integer — specifically numbers that have leading zeros. See the question How can I use numbers with leading zeros? for an explanation.

1. «Undefined symbol: main» or similar

The message, which comes not from Tcl but from some tool in the build process, occurs when linking an application. It is probably because the application was written for a version of Tcl different from the one you are linking against.

Older versions of Tcl included a main function in the library (libtcl.a). This caused various problems, in particular with C++ programs, and it was removed starting with version 7.4b1. The application being linked with the Tcl library must now provide the main routine itself.

1. «extra characters after close brace while executing» [confirm message text]

This error occurs when the user incorrectly codes a proc like this:

That is to say — neglects to put a space before the opening brace of the proc’s body.

1. «extra characters after close-quote»

This error can occur when there is no space between «if» and open brace «<» for example.

Источник

Debugging and Errors — errorInfo errorCode catch error return

In previous lessons we discussed how the return command could be used to return a value from a proc. In Tcl, a proc may return a value, but it always returns a status.

When a Tcl command or procedure encounters an error during its execution, the global variable errorInfo is set, and an error condition is generated. If you have proc a that called proc b that called c that called d , if d generates an error, the «call stack» will unwind. Since d generates an error, c will not complete execution cleanly, and will have to pass the error up to b , and in turn on to a . Each procedure adds some information about the problem to the report. For instance:

Produces the following output:

This actually occurs when any exception condition occurs, including break and continue . The break and continue commands normally occur within a loop of some sort, and the loop command catches the exception and processes it properly, meaning that it either stops executing the loop, or continues on to the next instance of the loop without executing the rest of the loop body.

It is possible to «catch» errors and exceptions with the catch command, which runs some code, and catches any errors that code happens to generate. The programmer can then decide what to do about those errors and act accordingly, instead of having the whole application come to a halt.

For example, if an open call returns an error, the user could be prompted to provide another file name.

A Tcl proc can also generate an error status condition. This can be done by specifying an error return with an option to the return command, or by using the error command. In either case, a message will be placed in errorInfo , and the proc will generate an error.

error message ?info? ?code?

Generates an error condition and forces the Tcl call stack to unwind, with error information being added at each step.

If info or code are provided, the errorInfo and errorCode variables are initialized with these values.

catch script ?varName?

Evaluates and executes script . The return value of catch is the status return of the Tcl interpreter after it executes script If there are no errors in script , this value is 0. Otherwise it is 1.

If varName is supplied, the value returned by script is placed in varName if the script successfully executes. If not, the error is placed in varName .

return ?-code code? ?-errorinfo info? ?-errorcode errorcode? ?value? Generates a return exception condition. The possible arguments are: -code code The next value specifies the return status. code must be one of:

• ok — Normal status return
• error — Proc returns error status
• return — Normal return
• break — Proc returns break status
• continue — Proc returns continue status

These allow you to write procedures that behave like the built in commands break , error , and continue . -errorinfo info info will be the first string in the errorInfo variable. -errorcode errorcode The proc will set errorCode to errorcode . value The string value will be the value returned by this proc. errorInfo errorInfo is a global variable that contains the error information from commands that have failed. errorCode errorCode is a global variable that contains the error code from command that failed. This is meant to be in a format that is easy to parse with a script, so that Tcl scripts can examine the contents of this variable, and decide what to do accordingly.

Источник

Error in tcl script

In previous lessons we discussed how the return command could be used to return a value from a proc. In Tcl, a proc may return a value, but it always returns a status.

When a Tcl command or procedure encounters an error during its execution, the global variable errorInfo is set, and an error condition is generated. If you have proc a that called proc b that called c that called d , if d generates an error, the «call stack» will unwind. Since d generates an error, c will not complete execution cleanly, and will have to pass the error up to b , and in turn on to a . Each procedure adds some information about the problem to the report. For instance:

This produces the following output:

This actually occurs when any exception condition occurs, including break and continue . The break and continue commands normally occur within a loop of some sort, and the loop command catches the exception and processes it properly, meaning that it either stops executing the loop, or continues on to the next instance of the loop without executing the rest of the loop body.

It is possible to «catch» errors and exceptions with the catch command, which runs some code, and catches any errors that code happens to generate. The programmer can then decide what to do about those errors and act accordingly, instead of having the whole application come to a halt. A more flexible facility is the try command — see below.

For example, if an open call returns an error, the user could be prompted to provide another file name.

A Tcl proc can also generate an error status condition. This can be done by specifying an error return with an option to the return command, or by using the error command. In either case, a message will be placed in errorInfo , and the proc will generate an error.

Источник

Error in tcl script

Fabricio Rocha — 08-Feb-2010 — Error treatment in programming always seems to be an underestimated topic, often untold by and to newbies, while it’s a useful thing that might be naturally taught along with the basics in a programming language. Only after some two years of studying Tcl/Tk I was able to find some information about this subject and develop myself a very basic and limited idea of how applications can avoid being crashed by bugs or misuse, so I would like to discuss some error management techniques with the experienced folks, while building up a tutorial from this discussion (something highly useful by aspiring Tclers like me). And, please, treat the errors you find.

What is error management?

Error management is about handling (and sometimes deliberately causing) error termination in scripts. Error termination is one of the modes of termination (see Script termination: results and control) provided by Tcl. As with all modes of termination, the interpreter gathers three pieces of information about the termination: the return code (always 1 in the case of error termination), the result value (by convention, the result value consists of an error message in the case of error termination), and the return options dictionary (a dict ionary structure, described under its own heading below).

Exceptions happen in an unplanned manner in programs: numeric operations overflow, a divisor value happens to be 0, a resource turns out to be unavailable, etc. Such events need to be dealt with to avoid the program crashing. Exceptions can, on the other hand, also be used as a form of flow control to e.g. abandon a deeply nested subroutine that can’t complete its task for some reason, and withdraw directly to a save point location higher up in the call stack.

Which error-management features are provided by Tcl?

Exception raising commands

The following commands cause an error ( raise an exception) that must be handled by code on an earlier level on the call stack: if the error isn’t handled (see below), the program stops. Exception-raising commands can add to the error information gathered by the interpreter, as described in the following.

return

The return command has been around for a long time, but has only been able to raise exceptions since Tcl 8.5.

When used to raise an exception, the minimal invocation is return -code error . Instead of -code error you may write -code 1 : it has the same meaning.

The value of the -code option is stored in the return options dictionary. Other options, such as -level , -errorinfo , -errorcode , -errorline , and -errorstack , may be added to the invocation of return and have their values stored in the return options dictionary too. The option -options , with a dictionary for value, may be used to set the return options dictionary all at once.

The return command always passes a return code equal to the value of the -code option (which, again, should be 1 or error when raising an exception) and a result value equal to the optional result parameter, which comes after any options given. It basically sets up the return options dictionary according to the invocation, with default values used if some options aren’t provided.

See return and the man page for a more thorough description of the command.

error

The error command has been the primary exception-raising command since Tcl 8.4.

It can be invoked in three ways:

The error command always passes a return code of 1 and a result value equal to the message parameter. It sets up the return options dictionary a bit differently depending on the invocation.

See error and the man page for a more thorough description of the command.

throw

The throw command was added in Tcl 8.6.

It is invoked like this:

throw type message

which is functionally equivalent to:

return -code error -level 0 -errorcode type message

The throw command always passes a return code of 1 and a result value equal to the message parameter.

See throw and the man page for a more thorough description of the command.

Dealing with an unknown command

This is a conditionally exception-raising command. When Tcl is asked to execute a command procedure it doesn’t know, it first attempts to save the situation by invoking another command named unknown , which then goes through a multi-step procedure to find the command that was asked for. If it still fails to find the command that was invoked, it raises an exception. You can override this behavior by providing your own unknown procedure.

Since Tcl 8.5, there is also the namespace unknown command, which allows the programmer to name a procedure which will be called when a command/procedure lookup fails in the scope of a specific namespace .

The unknown command doesn’t always raise an exception, but when it does, it passes a return code of 1 and a result value equal to invalid command name «yyz» (should the (non-existent) command yyz be invoked).

See unknown and the man page for a more thorough description of the command. The namespace unknown command is described here .

Exception handling commands

An exception that isn’t handled by the program is eventually handled by a default handler which basically only does two things: 1) output an error message, and 2) stop the program. If you want to do something else, like for instance deal with the error somehow and go on, or give up and at least save important data, you need to define an exception handler. The handler will deal with exceptions from commands invoked in the body script or from commands called by those commands, and so on.

An exception handler has two parts: the catcher and the dispatcher. The catcher executes a script or body and intercepts any exceptions raised during the execution. The interpreter passes the return code, the result value, and the return options dictionary to the handler. This information can then be used to dispatch to the exact piece of code (the handler clause) that the programmer has assigned to deal with the kind of termination in question.

catch

The catch command has been the basic exception-handling command since Tcl 8.4.

The catch command performs the catching part of exception handling, but does not dispatch. If fail is a command that raises an exception, this invocation:

simply prevents the exception from stopping the program but does nothing to deal with the problem. The traditional invocation looks like this:

set returnCode [catch < script> result]

In this case, after running catch the variable result contains the result value at termination of script . The result value of catch (which is stored in returnCode in this snippet) is the return code of the termination. If this return code is 0, no exception was raised and the variable result contains valid data, the return value of script . If it is greater than 0, the script was interrupted by an error or control flow operation (see Script termination: results and control for details).

This means that we can build a simplistic dispatcher using the return code from catch (in this example, only dealing with the non-zero and zero cases):

This construct will either set the variable f to whatever open returns, or if something happens, dispatch to the code puts «Ouch: $result» .

A more general dispatching construct:

For more fine-grained dispatching while handling exceptions, information from the return options dictionary (especially the -errorcode value) can be used. (The format of the value of -errorcode is discussed below.)

See catch and the man page for a more thorough description of the command.

The try command was added in Tcl 8.6.

The try command performs both the catching and dispatching parts of exception handling. The dispatching is defined by adding handler clauses to the command invocation:

There is no way to define a default handler clause to round up any remaining modes of termination, but if error codes like, say, 42 and 1138 are expected to be returned from a script, you can add the following specific clauses:

It isn’t necessary to define all kinds of handler clauses, indeed no handler clause at all needs to be defined. If none of the defined handler clauses get the dispatch, the exception is propagated outside the try construct.

Dispatching can also be based on the -errorcode value in the return options dictionary by using trap -style handler clauses:

The handler clauses should be ordered from most specific to most generic. Note that the on error handler clause must be placed after any trap handler clauses, because it picks up any kind of error exception.

If a handler clause needs to examine the return options dictionary, it can be passed as a second variable to the handler clause:

You can add a finally script clause to the try construct. The code in script will be run whether an error occurs or not and regardless of which handler clause, if any, was dispatched to.

The result value of the try construct is the result value of the handler clause that was dispatched to, or of the script if none of the handler clauses were engaged. The result value of the finally clause is never used.

See try and the man page for a more thorough description of the command.

Background error handling

Tcl/Tk automatically catches exceptions that are raised in background processing (e.g. when events are processed in an update or vwait call) and dispatches them to a programmer-defined handler procedure, if available. If such an exception handler is registered with interp bgerror (available as of Tcl 8.5) the result value of the termination (an error message) and the return options dictionary will be passed to the handler. If no such handler is registered for the active interpreter, it instead attempts to call a global command procedure named bgerror which the programmer needs to define (it doesn’t exist otherwise). The bgerror command only gets one argument passed to it, an error message. If bgerror isn’t available, the error message is simply displayed.

If fail is a command that raises an exception, and we run this code in a Tk-enabled console:

and then press K, we get a dialog box pointing out that an error has occurred.

If we define the bgerror command:

and then press K, we get the message «I’m bgerror».

If we define this command:

and then run this command:

interp bgerror <> myHandler

and then press K, we get the message «I’m myHandler».

See bgerror and the man page for a more thorough description of the command. The interp bgerror invocation is described here and background exception handling here .

The return options dictionary and other exception information sources

The return options dictionary

Whenever an exception is raised, since version 8.5 Tcl creates a dict ionary of keys and values that describe the exception:

(I’ve heard rumours (e.g. on the man page for try ) of a seventh key, -during , that’s supposed to store information on an original exception if another exception occurs during the handling of the first, but I’m unable to find any real documentation for it.)

As described above, this dictionary is passed by the interpreter to an exception handler, which may pass them on to a handler clause. It is passed with all modes of termination, but the -error* keys are only available on error termination.

Errorinfo

The value of the -errorinfo member is described here . The value of the -errorinfo member is a multi-line string that consists of at least an error message and, on following lines, a stack trace that lists the command invocations between the handler and the point where the exception was raised, interspersed with lines like invoked from within or while executing . The try handler also adds a line reporting on which line in the try body the error occurred. The command invocations are shown unsubstituted, like error $msg . The first line is taken from either

• the -errorinfo option to return , or
• the info argument to error , or
• the message / result argument to error , throw , or return , or
• whatever error message a failing command produces

Errorcode

The value of the -errorcode member is described here . The value is a list of code words and data that is intended for processing by the program. When raising your own exceptions (and not, say, replicating an error generated by some other command), the single-value list NONE is generally applicable (it means «no further information available», not «no error»). You may also define your own format, in which case you should avoid beginning the list with any of the standard code words (which indicate the class of error and at the same time the format of the rest of the code value) ARITH , CHILDKILLED , CHILDSTATUS , CHILDSUSP , POSIX , or TCL . The value is taken from either

• the -errorcode option to return , or
• the code / type argument to error or throw , or
• whatever error code is generated when a command fails

The CHILDKILLED and CHILDSUSP error classes include in their list the name of the signal that killed or suspended the child process; the name is one of those given in the signal.h C header file (most likely extended by signal names taken from Unix systems, for signals supported by the platform). The POSIX error class reports the symbolic name of the error as defined by the POSIX extension of the errno.h header file. Note that the level of compliance to the POSIX standard varies between platforms, with Windows being only partly compliant.

Errorstack

The value of the -errorstack member is described here . The value is an even-sized list where each pair of members represent one level on the call stack between the handler and the error. Every pair is a code word (or token) followed by a parameter list with one or more members: the members in the parameter list are the name of an invoked command or a descriptor like syntax , returnStk , returnImm , etc, followed by the parameter values as received by the command (i.e. substituted, unlike how they appear in the value of the -errorinfo member).

errorCode and errorInfo

Before Tcl 8.5, basic information on exceptions could be found in two global variables , errorCode and errorInfo . For backwards compatibility, the variables are still available. The errorCode variable contains, as might be expected, the same value as the -errorcode member of the return options dictionary for the latest error. Correspondingly, the errorInfo variable contains the same value as the -errorinfo member. The variables are in no way deprecated, but they are no longer needed: the return options dictionary should be used instead.

The info command

The invocation info errorstack returns the value contained in the -errorstack member of the return options dictionary for the latest error.

How to use all this stuff?

The infrastructure provided by Tcl allows applications to use exception handling, in the traditional sense of «try to do this, and if something goes wrong tell me and I’ll see what can I do». This contrasts to the approach of «errors prediction», which, for example, performs a series of tests on the data which will be passed to a command for checking its validity, before the operation is performed. Both techniques are not excludent, however. Tcl allows various approaches to errors management, with their pros and cons:

Approach 1: return, catch and process the error

1) Always use the advanced return options when writing procedures which can cause or face errors, or which may give back an invalid result;

2) Always use catch for calling commands or your own procedures which can cause or face errors like described in 1;

3) Create a procedure to be called in the case that catch captures an error, for interpreting the error codes and, based on that, show error messages in friendly and standardized dialogs and perform operations which could minimize or solve the error.

Approach 2: tracing ::errorCode

Create a trace on ::errorCode , and a procedure to be called everytime it is modified, for interpreting the codes, display them, provide minimization measures, etc.

Any other? Please add what you do!

LV One useful thing that I sometimes use is creation of log files containing information intended to be useful in determining the state of the program during particular points. Sometimes, displaying information about the values of a number of variables is not as helpful as having that information written to a file — for instance, there are times when a GUI application might not have easy access to stderr for error traces. Writing information to a log file, which is available — and perhaps even emailable — to the programmer responsible is helpful.

Which errors shall be told to the user?

Failure in files, channels and sockets operations?

Errors caused by invalid inputs. It is often useful to use a distinct error code (e.g., INVALID) for data validation errors, as it makes it possible for the application to distinguish between errors in the user’s input and errors in the validation or execution code.

Which errors shall NOT be told to the user?

Syntax errors and programming bugs — They’d better be fixed. Sure, but.

LV Certainly they need to be fixed. However, if you hide the info from the user, how will the programmer know what the bug/error is? Unless you have a guaranteed method of getting said info to the programmer (and email doesn’t count — the user MIGHT be working off line), then providing the user with sufficent information to a) know what the error is and b) know who to contact or what to do about the problem seems the best approach to me.

Fabricio Rocha — 12-Feb-2010 — One more reason for having a way to intercept and explain this kind of errors to common users is that it seems that any test suite or any test routine will not be able to find some errors that users are able to find. Of course it is not nice to show weaknesses to a final user, but this is something practically unavoidable in software. And in addition to the situations listed by LV, we can consider that, for an open source/free software, providing good information about an error is a way to c) allow a user with sufficient programming knowledge to fix the problem and possibly contribute to the software development.

Источник

Tcl itself is quite a good teacher. Don’t be afraid to do something wrong — it will most often deliver a helpful error message. When tclsh is called with no arguments, it starts in an interactive mode and displays a «%» prompt. The user types something in and sees what comes out: either the result or an error message.

Trying isolated test cases interactively, and pasting the command into the editor when satisfied, can greatly reduce debugging time (there is no need to restart the application after every little change — just make sure it’s the right one, before restarting.)

A quick tour[edit | edit source]

Here’s a commented session transcript:

% hello
invalid command name "hello"

OK, so we’re supposed to type in a command. Although it doesn’t look so, here’s one:

% hi
     1  hello
    2  hi

Interactive tclsh tries to guess what we mean, and «hi» is the unambiguous prefix of the «history» command, whose results we see here. Another command worth remembering is «info»:

% info
wrong # args: should be "info option ?arg arg ...?"

The error message tells us there should be at least one option, and optionally more arguments.

% info option
bad option "option": must be args, body, cmdcount, commands, complete, default,
exists, functions, globals, hostname, level, library, loaded, locals, nameofexecutable,
patchlevel, procs, script, sharedlibextension, tclversion, or vars

Another helpful error: «option» is not an option, but the valid ones are listed. To get information about commands, it makes sense to type the following:

% info commands
tell socket subst lremove open eof tkcon_tcl_gets pwd glob list exec pid echo 
dir auto_load_index time unknown eval lrange tcl_unknown fblocked lsearch gets 
auto_import case lappend proc break dump variable llength tkcon auto_execok return
pkg_mkIndex linsert error bgerror catch clock info split thread_load loadvfs array
if idebug fconfigure concat join lreplace source fcopy global switch which auto_qualify
update tclPkgUnknown close clear cd for auto_load file append format tkcon_puts alias 
what read package set unalias pkg_compareExtension binary namespace scan edit trace seek 
while flush after more vwait uplevel continue foreach lset rename tkcon_gets fileevent 
regexp tkcon_tcl_puts observe_var tclPkgSetup upvar unset encoding expr load regsub history
exit interp puts incr lindex lsort tclLog observe ls less string

Oh my, quite many… How many?

% llength [info commands]
115

Now for a more practical task — let’s let Tcl compute the value of Pi.

% expr acos(-1)
3.14159265359

Hm.. can we have that with more precision?

% set tcl_precision 17
17
% expr acos(-1)
3.1415926535897931

Back to the first try, where «hello» was an invalid command. Let’s just create a valid one:

% proc hello {} {puts Hi!}

Silently acknowledged. Now testing:

% hello
Hi!

Errors are exceptions[edit | edit source]

What in Tcl is called error is in fact more like an exception in other languages — you can deliberately raise an error, and also catch errors. Examples:

if {$username eq ""} {error "please specify a user name"}

if [catch {open $filename w} fp] {
   error "$filename is not writable"
}

One reason for errors can be an undefined command name. One can use this playfully, together with catch, as in the following example of a multi-loop break, that terminates the two nested loops when a matrix element is empty:

if [catch {
   foreach row $matrix {
      foreach col $row {
          if {$col eq ""} throw
      }
   }
}] {puts "empty matrix element found"}

The throw command does not exist in normal Tcl, so it throws an error, which is caught by the catch around the outer loop.

The errorInfo variable[edit | edit source]

This global variable provided by Tcl contains the last error message and the traceback of the last error. Silly example:

% proc foo {} {bar x}
% proc bar {input} {grill$input}
% foo
invalid command name "grillx"

% set errorInfo
invalid command name "grillx"
   while executing
"grill$input"
   (procedure "bar" line 1)
   invoked from within
"bar x"
   (procedure "foo" line 1)
   invoked from within
"foo"

If no error has occurred yet, errorInfo will contain the empty string.

The errorCode variable[edit | edit source]

In addition, there is the errorCode variable that returns a list of up to three elements:

• category (POSIX, ARITH, …)
• abbreviated code for the last error
• human-readable error text

Examples:

% open not_existing
couldn't open "not_existing": no such file or directory
% set errorCode
POSIX ENOENT {no such file or directory}

% expr 1/0
divide by zero
% set errorCode
ARITH DIVZERO {divide by zero}

% foo
invalid command name "foo"
% set errorCode
NONE

Tracing procedure calls[edit | edit source]

For a quick overview how some procedures are called, and when, and what do they return, and when, the trace execution is a valuable tool. Let’s take the following factorial function as example:

proc fac x {expr {$x<2? 1 : $x * [fac [incr x -1]]}} 

We need to supply a handler that will be called with different numbers of arguments (two on enter, four on leave). Here’s a very simple one:

proc tracer args {puts $args}

Now we instruct the interpreter to trace enter and leave of fac:

trace add execution fac {enter leave} tracer

Let’s test it with the factorial of 7:

fac 7

which gives, on stdout:

{fac 7} enter
{fac 6} enter
{fac 5} enter
{fac 4} enter
{fac 3} enter
{fac 2} enter
{fac 1} enter
{fac 1} 0 1 leave
{fac 2} 0 2 leave
{fac 3} 0 6 leave
{fac 4} 0 24 leave
{fac 5} 0 120 leave
{fac 6} 0 720 leave
{fac 7} 0 5040 leave

So we can see how recursion goes down to 1, then returns in backward order, stepwise building up the final result. The 0 that comes as second word in «leave» lines is the return status, 0 being TCL_OK.

Stepping through a procedure[edit | edit source]

To find out how exactly a proc works (and what goes wrong where), you can also register commands to be called before and after a command inside a procedure is called (going down transitively to all called procs). You can use the following step and interact procedures for this:

proc step {name {yesno 1}} {
   set mode [expr {$yesno? "add" : "remove"}]
   trace $mode execution $name {enterstep leavestep} interact
}

proc interact args {
   if {[lindex $args end] eq "leavestep"} {
       puts ==>[lindex $args 2]
       return
   }
   puts -nonewline "$args --"
   while 1 {
       puts -nonewline "> "
       flush stdout
       gets stdin cmd
       if {$cmd eq "c" || $cmd eq ""} break
       catch {uplevel 1 $cmd} res
       if {[string length $res]} {puts $res}
   }
}

#----------------------------Test case, a simple string reverter:
proc sreverse str {
   set res ""
   for {set i [string length $str]} {$i > 0} {} {
       append res [string index $str [incr i -1]]
   }
   set res
}

#-- Turn on stepping for sreverse:
step sreverse
sreverse hello

#-- Turn off stepping (you can also type this command from inside interact):
step sreverse 0
puts [sreverse Goodbye]

The above code gives the following transcript when sourced into a tclsh:

{set res {}} enterstep -->
==>
{for {set i [string length $str]} {$i > 0} {} {
       append res [string index $str [incr i -1]]
   }} enterstep -->
{string length hello} enterstep -->
==>5
{set i 5} enterstep -->
==>5
{incr i -1} enterstep -->
==>4
{string index hello 4} enterstep -->
==>o
{append res o} enterstep -->
==>o
{incr i -1} enterstep -->
==>3
{string index hello 3} enterstep -->
==>l
{append res l} enterstep -->
==>ol
{incr i -1} enterstep -->
==>2
{string index hello 2} enterstep -->
==>l
{append res l} enterstep -->
==>oll
{incr i -1} enterstep -->
==>1
{string index hello 1} enterstep -->
==>e
{append res e} enterstep -->
==>olle
{incr i -1} enterstep -->
==>0
{string index hello 0} enterstep -->
==>h
{append res h} enterstep -->
==>olleh
==>
{set res} enterstep -->
==>olleh
eybdooG

Debugging[edit | edit source]

The simplest way to inspect why something goes wrong is inserting a puts command before the place where it happens. Say if you want to see the values of variables x and y, just insert

puts x:$x,y:$y

(if the string argument contains no spaces, it needs not be quoted). The output will go to stdout — the console from where you started the script. On Windows or Mac, you might need to add the command

console show

to get the substitute console Tcl creates for you, when no real one is present.

If at some time you want to see details of what your program does, and at others not, you can define and redefine a dputs command that either calls puts or does nothing:

proc d+ {} {proc dputs args {puts $args}}
proc d- {} {proc dputs args {}}
d+ ;# initially, tracing on... turn off with d-

For more debugging comfort, add the proc interact from above to your code, and put a call to interact before the place where the error happens. Some useful things to do at such a debugging prompt:

info level 0    ;# shows how the current proc was called
info level      ;# shows how deep you are in the call stack
uplevel 1 ...   ;# execute the ... command one level up, i.e. in the caller of the current proc
set ::errorInfo ;# display the last error message in detail

Assertions[edit | edit source]

Checking data for certain conditions is a frequent operation in coding. Absolutely intolerable conditions can just throw an error:

  if {$temperature > 100} {error "ouch... too hot!"}

Where the error occurred is evident from ::errorInfo, which will look a bit clearer (no mention of the error command) if you code

  if {$temperature > 100} {return -code error "ouch... too hot!"}

If you don’t need hand-crafted error messages, you can factor such checks out to an assert command:

proc assert condition {
   set s "{$condition}"
   if {![uplevel 1 expr $s]} {
       return -code error "assertion failed: $condition"
   }
}

Use cases look like this:

  assert {$temperature <= 100}

Note that the condition is reverted — as «assert» means roughly «take for granted», the positive case is specified, and the error is raised if it is not satisfied.

Tests for internal conditions (that do not depend on external data) can be used during development, and when the coder is sure they are bullet-proof to always succeed, (s)he can turn them off centrally in one place by defining

proc assert args {}

This way, assertions are compiled to no bytecode at all, and can remain in the source code as a kind of documentation.

If assertions are tested, it only happens at the position where they stand in the code. Using a trace, it is also possible to specify a condition once, and have it tested whenever a variable’s value changes:

proc assertt {varName condition} {
   uplevel 1 [list trace var $varName w "assert $condition ;#"]
}

The «;#» at the end of the trace causes the additional arguments name element op, that are appended to the command prefix when a trace fires, to be ignored as a comment.

Testing:

% assertt list {[llength $list]<10}
% set list {1 2 3 4 5 6 7 8}
1 2 3 4 5 6 7 8
% lappend list 9 10
can't set "list": assertion failed: 10<10

The error message isn’t as clear as could be, because the [llength $list] is already substituted in it. But I couldn’t find an easy solution to that quirk in this breakfast fun project — backslashing the $condition in the assertt code sure didn’t help. Better ideas welcome.

To make the assertion condition more readable, we could quote the condition one more time,i.e

 % assertt list {{[llength $list]<10}}
 % set list {1 2 3 4 5 6 7 8}
 1 2 3 4 5 6 7 8
 % lappend list 9 10
 can't set "list": assertion failed: [llength $list]<10
 %

In this case,when trace trigger fires, the argument for assert is {[llength $list]<10}.

In any case, these few lines of code give us a kind of bounds checking — the size of Tcl’s data structures is in principle only bounded by the available virtual memory, but runaway loops may be harder to debug, compared to a few assertt calls for suspicious variables:

assertt aString {[string length $aString]<1024}

or

assertt anArray {[array size anArray] < 1024*1024}

Tcllib has a control::assert with more bells and whistles.

A tiny testing framework[edit | edit source]

Bugs happen. The earlier found, the easier for the coder, so the golden rule «Test early. Test often» should really be applied.

One easy way is adding self-tests to a file of Tcl code. When the file is loaded as part of a library, just the proc definitions are executed. If however you feed this file directly to a tclsh, that fact is detected, and the «e.g.» calls are executed. If the result is not the one expected, this is reported on stdout; and in the end, you even get a little statistics.

Here’s a file that implements and demonstrates «e.g.»:

# PROLOG -- self-test: if this file is sourced at top level:
if {[info exists argv0]&&[file tail [info script]] eq [file tail $argv0]} {
   set Ntest 0; set Nfail 0
   proc e.g. {cmd -> expected} {
       incr ::Ntest
       catch {uplevel 1 $cmd} res
       if {$res ne $expected} {
           puts "$cmd -> $res, expected $expected"
           incr ::Nfail
       }
   }
} else {proc e.g. args {}} ;# does nothing, compiles to nothing

##------------- Your code goes here, with e.g. tests following
proc sum {a b} {expr {$a+$b}}
e.g. {sum 3 4} -> 7

proc mul {a b} {expr {$a*$b}}
e.g. {mul 7 6} -> 42

# testing a deliberate error (this way, it passes):
e.g. {expr 1/0} -> "divide by zero"

## EPILOG -- show statistics:
e.g. {puts "[info script] : tested $::Ntest, failed $::Nfail"} -> ""

Guarded proc[edit | edit source]

In more complex Tcl software, it may happen that a procedure is defined twice with different body and/or args, causing hard-to-track errors. The Tcl command proc itself doesn’t complain if it is called with an existing name. Here is one way to add this functionality. Early in your code, you overload the proc command like this:

 rename proc _proc
 _proc proc {name args body} {
 	set ns [uplevel namespace current]
 	if {[info commands $name]!="" || [info commands ${ns}::$name]!=""} {
 		puts stderr "warning: [info script] redefines $name in $ns"
 	}
 	uplevel [list _proc $name $args $body]
 }

From the time that is sourced, any attempt to override a proc name will be reported to stderr (on Win-wish, it would show on the console in red). You may make it really strict by adding an «exit» after the «puts stderr …», or throw an error.

Known feature: proc names with wildcards will run into this trap, e.g.

  proc * args {expr [join $args *]*1}

will always lead to a complaint because «*» fits any proc name. Fix (some regsub magic on ‘name’) left as an exercise.

Windows wish console[edit | edit source]

While on Unixes, the standard channels stdin, stdout, and stderr are the same as the terminal you started wish from, a Windows wish doesn’t typically have these standard channels (and is mostly started with double-click anyway). To help this, a console was added that takes over the standard channels (stderr even coming in red, stdin in blue). The console is normally hidden, but can be brought up with the command

 console show

You can also use the partially documented «console» command. «console eval <script>» evals the given script in the Tcl interpreter that manages the console. The console’s text area is actually a text widget created in this interpreter. For example:

       console eval {.console config -font Times}

will change the font of the console to «Times». Since the console is a Tk text widget, you can use all text widget commands and options on it (for example, changing colors, bindings…).

console eval {winfo children .}

tells you more about the console widget: it is a toplevel with children .menu, .console (text), and .sb (scrollbar). You can resize the whole thing with

console eval {wm geometry . $Wx$H+$X+$Y}

where $W and $H are dimensions in character cells (default 80×24), but $X and $Y are in pixels.

And more again: you can even add widgets to the console — try

console eval {pack [button .b -text hello -command {puts hello}]}

The button appears between the text widget and the scroll bar, and looks and does as expected.
There is also a way back: the main interpreter is visible in the console interpreter under the name, consoleinterp.

Remote debugging[edit | edit source]

Here’s a simple experiment on how to connect two Tcl processes so that one (call it «debugger») can inspect and control the other («debuggee»). Both must have an event loop running (which is true when Tk runs, or when started with e.g. vwait forever).

As this goes over a socket connection, the two processes could be on different hosts and operating systems (though I’ve so far tested only the localhost variety). Use at your own risk, of course… :^)

The «debuggee» contains in my experiments the following code, in addition to its own:

proc remo_server {{port 3456}} {
   set sock [socket -server remo_accept $port]
}
proc remo_accept {socket adr port} {
   fileevent $socket readable [list remo_go $socket]
}
proc remo_go {sock} {
   gets $sock line
   catch {uplevel #0 $line} res
   puts $sock $res
   if [catch {flush $sock}] {close $sock}
}
remo_server

The «debugger» in this version (remo.tcl) runs only on Windows in a wish, as it needs a console, but you could modify it to avoid these restrictions:

#!/usr/bin/env wish
console show
wm withdraw .
set remo [socket localhost 3456]
fileevent $remo readable "puts [gets $remo]"
proc r args {puts $::remo [join $args]; flush $::remo}
puts "remote connection ready - use r to talk"

Now from remo you can call any Tcl command in the «debuggee», where it is executed in global scope, so in particular you can inspect (and modify) global variables. But you could also redefine procs on the fly, or whatever tickles your fancy… Examples from a remo session, showing that the two have different pids, how errors are reported, and that quoting is different from normal (needs more work):

10 % pid
600
11 % r pid
2556
12 % r wm title . "Under remote control"
wrong # args: should be "wm title window ?newTitle?"
13 % r wm title . {"Under remote control"}

Tcl – Обзор

Tcl – это сокращенная форма Tool Command Language . Джон Оустерхаут из Калифорнийского университета в Беркли разработал его. Это комбинация языка сценариев и его собственного интерпретатора, который внедряется в приложение, которое мы разрабатываем вместе с ним.

Tcl был разработан изначально для Unix. Затем он был портирован на Windows, DOS, OS / 2 и Mac OSX. Tcl очень похож на другие языки оболочки Unix, такие как Bourne Shell (Sh), C Shell (csh), Korn Shell (sh) и Perl.

Он направлен на предоставление возможности программам взаимодействовать с другими программами, а также выступать в качестве встраиваемого переводчика. Несмотря на то, что первоначальной целью было дать возможность программам взаимодействовать, вы можете найти полноценные приложения, написанные на Tcl / Tk.

Особенности Tcl

Особенности Tcl заключаются в следующем –

• Сокращение времени разработки.

• Мощный и простой пользовательский интерфейс с интеграцией TK.

• Пиши один раз, беги куда угодно. Он работает на Windows, Mac OS X и почти на любой платформе Unix.

• Довольно просто начать работу для опытных программистов; язык настолько прост, что они могут выучить Tcl за несколько часов или дней.

• Вы можете легко расширить существующие приложения с Tcl. Кроме того, можно включить Tcl в C, C ++ или Java в Tcl или наоборот.

• Имейте мощный набор сетевых функций.

• Наконец, это открытый исходный код, бесплатный и может быть использован для коммерческих приложений без каких-либо ограничений.

Сокращение времени разработки.

Мощный и простой пользовательский интерфейс с интеграцией TK.

Пиши один раз, беги куда угодно. Он работает на Windows, Mac OS X и почти на любой платформе Unix.

Довольно просто начать работу для опытных программистов; язык настолько прост, что они могут выучить Tcl за несколько часов или дней.

Вы можете легко расширить существующие приложения с Tcl. Кроме того, можно включить Tcl в C, C ++ или Java в Tcl или наоборот.

Имейте мощный набор сетевых функций.

Наконец, это открытый исходный код, бесплатный и может быть использован для коммерческих приложений без каких-либо ограничений.

Приложения

Tcl – это язык общего назначения, и вы можете найти Tcl везде. Это включает,

• Масштабируемые сайты, которые часто поддерживаются базами данных.
• Высокопроизводительные веб-серверы создаются с помощью TclHttpd.
• Tcl с CGI-сайтами.
• Настольные приложения с графическим интерфейсом.
• Встроенные приложения.

Tcl – настройка среды

Настройка локальной среды

Если вы хотите настроить свою среду для Tcl, вам потребуются следующие два программных приложения, доступные на вашем компьютере:

• Текстовый редактор
• Tcl переводчик.

Текстовый редактор

Это будет использоваться для ввода вашей программы. Примерами нескольких текстовых редакторов являются Блокнот Windows, команда «Редактирование ОС», Brief, Epsilon, EMACS и vim или vi.

Имя и версия текстового редактора могут различаться в разных операционных системах. Например, Блокнот будет использоваться в Windows, а vim или vi могут использоваться в Windows, а также в Linux или UNIX.

Файлы, которые вы создаете в текстовом редакторе, называются исходными файлами и содержат исходный код программы. Исходные файлы для программ Tcl названы с расширением “.tcl” .

Прежде чем приступить к программированию, убедитесь, что у вас есть один текстовый редактор, и у вас достаточно опыта, чтобы написать компьютерную программу, сохранить ее в файле, собрать ее и, наконец, выполнить.

Переводчик Tcl

Это небольшая программа, которая позволяет вам вводить команды Tcl и выполнять их построчно. Он останавливает выполнение файла tcl, в случае, если он сталкивается с ошибкой в ​​отличие от компилятора, который выполняется полностью.

Давайте создадим файл helloWorld.tcl следующим образом. Мы будем использовать это как первую программу, работающую на платформе, которую вы выберете.

#!/usr/bin/tclsh

puts "Hello World!" 

Установка на Windows

Загрузите последнюю версию для установщика Windows из списка доступных двоичных файлов Active Tcl. Активная версия сообщества Tcl бесплатна для личного использования.

Запустите загруженный исполняемый файл для установки Tcl, что можно сделать, следуя инструкциям на экране.

Теперь мы можем создать и запустить файл Tcl, скажем helloWorld.tcl, переключившись на папку, содержащую файл, с помощью команды ‘cd’, а затем выполнить программу, выполнив следующие шаги

C:Tcl> tclsh helloWorld.tcl

Мы можем увидеть следующий вывод.

C:Tcl> helloWorld

C: Tcl – папка, которую я использую для сохранения своих образцов. Вы можете изменить его на папку, в которой вы сохранили программы Tcl.

Установка в Linux

Большинство операционных систем Linux поставляются со встроенным Tcl, и вы можете сразу же начать работу с этими системами. В случае, если он недоступен, вы можете использовать следующую команду для загрузки и установки Tcl-Tk.

$ yum install tcl tk

Теперь мы можем создать и запустить файл Tcl, скажем helloWorld.tcl, переключившись на папку, содержащую этот файл, с помощью команды «cd», а затем выполнить программу, выполнив следующие шаги:

$ tclsh helloWorld.tcl

Мы можем увидеть следующий вывод –

$ hello world

Установка в системах на основе Debian

В случае, если это не доступно в вашей ОС, вы можете использовать следующую команду для загрузки и установки Tcl-Tk –

$ sudo apt-get install tcl tk

Теперь мы можем создать и запустить файл Tcl, скажем helloWorld.tcl, переключившись на папку, содержащую этот файл, с помощью команды «cd», а затем выполнить программу, выполнив следующие шаги:

$ tclsh helloWorld.tcl

Мы можем увидеть следующий вывод –

$ hello world

Установка в Mac OS X

Загрузите последнюю версию пакета Mac OS X из списка доступных двоичных файлов Active Tcl. Активная версия сообщества Tcl бесплатна для личного использования.

Запустите загруженный исполняемый файл, чтобы установить Active Tcl, что можно сделать, следуя инструкциям на экране.

Теперь мы можем создать и запустить файл Tcl, скажем helloWorld.tcl, переключившись на папку, содержащую файл, используя «cd», а затем выполнить программу, выполнив следующие шаги:

$ tclsh helloWorld.tcl

Мы можем увидеть следующий вывод –

$ hello world

Установка из исходных файлов

Вы можете использовать опцию установки из исходных файлов, когда двоичный пакет недоступен. Обычно предпочтительно использовать двоичные файлы Tcl для Windows и Mac OS X, поэтому ниже показана только компиляция исходных текстов в системе на основе Unix.

• Загрузите исходные файлы.

• Теперь используйте следующие команды для извлечения, компиляции и сборки после переключения в загруженную папку.

Загрузите исходные файлы.

Теперь используйте следующие команды для извлечения, компиляции и сборки после переключения в загруженную папку.

$ tar zxf tcl8.6.1-src.tar.gz
$ cd tcl8.6.1
$ cd unix
$ ./configure —prefix=/opt —enable-gcc
$ make
$ sudo make install

Примечание. Убедитесь, что вы изменили имя файла на версию, загруженную по командам 1 и 2, указанным выше.

Tcl – специальные переменные

В Tcl мы классифицируем некоторые переменные как специальные переменные, и они имеют предопределенное использование / функциональность. Список специальных переменных приведен ниже.

ARGC

Относится к ряду аргументов командной строки.

ARGV

Относится к списку, содержащему аргументы командной строки.

argv0

Относится к имени файла интерпретируемого файла или имени, под которым мы вызываем скрипт.

окр

Используется для представления массива элементов, которые являются переменными среды.

код ошибки

Предоставляет код ошибки для последней ошибки Tcl.

errorInfo

Предоставляет трассировку стека для последней ошибки Tcl.

tcl_interactive

Используется для переключения между интерактивным и неинтерактивным режимами, устанавливая это в 1 и 0 соответственно.

tcl_library

Используется для настройки расположения стандартных библиотек Tcl.

tcl_pkgPath

Предоставляет список каталогов, в которых обычно установлены пакеты.

tcl_patchLevel

Относится к текущему уровню исправления интерпретатора Tcl.

tcl_platform

Используется для представления массива элементов с объектами, включая byteOrder, machine, osVersion, platform и os.

tcl_precision

Относится к точности, т. Е. К числу цифр, сохраняемых при преобразовании чисел с плавающей запятой в строки. Значение по умолчанию 12.

tcl_prompt1

Относится к первичной подсказке.

tcl_prompt2

Относится к дополнительному приглашению с недопустимыми командами.

tcl_rcFileName

Предоставляет пользовательский файл запуска.

tcl_traceCompile

Используется для контроля трассировки компиляции байт-кода. Используйте 0 для отсутствия вывода, 1 для сводки и 2 для подробности.

tcl_traceExec

Используется для контроля отслеживания выполнения байт-кода. Используйте 0 для отсутствия вывода, 1 для сводки и 2 для подробности.

tcl_version

Возвращает текущую версию интерпретатора Tcl.

Указанные выше специальные переменные имеют свои особые значения для интерпретатора Tcl.

Примеры использования специальных переменных Tcl

Давайте посмотрим несколько примеров для специальных переменных.

Версия Tcl

Live Demo

#!/usr/bin/tclsh

puts $tcl_version

8.6

#!/usr/bin/tclsh

puts $env(PATH)

/home/cg/root/GNUstep/Tools:/usr/GNUstep/Local/Tools:/usr/GNUstep/
System/Tools:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/webmaster/.local/bin:/
home/webmaster/bin:/usr/local/scriba/bin:/usr/local/smlnj/
bin:/usr/local/bin/std:/usr/local/bin/extra:/usr/local/fantom/bin:/usr/
local/dart/bin:/usr/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/opt/mono/
bin:/opt/mono/lib/mono/4.5:/usr/local/bin:.:/usr/libexec/sdcc:/usr/local/
icon-v950/bin:/usr/local/mozart/bin:/opt/Pawn/bin:/opt/jdk1.7.0_75/bin:/
opt/jdk1.7.0_75/jre/bin:/opt/pash/Source/PashConsole/bin/Debug/

#!/usr/bin/tclsh

puts $tcl_pkgPath

/usr/lib64/tcl8.6 /usr/share/tcl8.6 /usr/lib64/tk8.6 /usr/share/tk8.6

#!/usr/bin/tclsh

puts $tcl_library

/usr/share/tcl8.6

#!/usr/bin/tclsh

puts $tcl_patchLevel

8.6.6

#!/usr/bin/tclsh

puts $tcl_precision

0

#!/usr/bin/tclsh

puts $tcl_rcFileName

~/.tclshrc

#!/usr/bin/tclsh

puts "Hello, World!" 

$ tclsh test.tcl

Hello, World!

#!/usr/bin/tclsh

# my first program in Tcl
puts "Hello World!" 

Hello World!

#!/usr/bin/tclsh

if 0 {
   my first program in Tcl program
   Its very simple
}
puts "Hello World!" 

Hello World!

#!/usr/bin/tclsh

puts "Hello World!" ;# my first print in Tcl program

Hello World!

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

#!/usr/bin/tclsh

puts "Hello World!" 

#!/usr/bin/tclsh

puts [expr 3 + 2] ;# print sum of the 3 and 2

5

commandName argument1 argument2 ... argumentN

#!/usr/bin/tclsh

puts "Hello, world!"

Hello, world!

#!/usr/bin/tclsh

puts stdout "Hello, world!"

Hello, world!

#!/usr/bin/tclsh

puts [expr 1 + 6 + 9]

16

#!/usr/bin/tclsh

set a 3
puts $a

3

#!/usr/bin/tclsh

puts "HellonWorld"

Hello
World

#!/usr/bin/tclsh

set myVariable 18
puts $myVariable

18

#!/usr/bin/tclsh

set myVariable 18
puts [expr $myVariable + 6 + 9]

33

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

hello

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable
set myVariable {hello world}
puts $myVariable

hello world
hello world

#!/usr/bin/tclsh

set myVariable {red green blue}
puts [lindex $myVariable 2]
set myVariable "red green blue"
puts [lindex $myVariable 1]

blue
green

#!/usr/bin/tclsh

set  marks(english) 80
puts $marks(english)
set  marks(mathematics) 90
puts $marks(mathematics)

80
90

set myfile [open "filename" r]

set variableName value

#!/usr/bin/tclsh

set variableA 10
set {variable B} test
puts $variableA
puts ${variable B}

10
test

#!/usr/bin/tclsh

set variableA "10"
puts $variableA
set sum [expr $variableA +20];
puts $sum

10
30

#!/usr/bin/tclsh

set variableA "10"
set result [expr $variableA / 9];
puts $result
set result [expr $variableA / 9.0];
puts $result
set variableA "10.0"
set result [expr $variableA / 9];
puts $result

1
1.1111111111111112
1.1111111111111112

#!/usr/bin/tclsh

set variableA "10"
set tcl_precision 5
set result [expr $variableA / 9.0];
puts $result

1.1111

Exp1 ? Exp2 : Exp3;

#!/usr/bin/tclsh

set a 10;
set b [expr $a == 1 ? 20: 30]
puts "Value of b is $bn"
set b [expr $a == 10 ? 20: 30]
puts "Value of b is $bn" 

Value of b is 30
Value of b is 20

while {1} {
   puts "This loop will run forever."
}

set ArrayName(Index) value

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts $languages(0)
puts $languages(1)

Tcl
C Language

[array size variablename]

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts  [array size languages]

2

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
for { set index 0 }  { $index < [array size languages] }  { incr index } {
   puts "languages($index) : $languages($index)"
}

languages(0) : Tcl
languages(1) : C Language

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts  $personA(Name)
puts  $personA(Age)

Dave
14

[array names variablename]

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts [array names personA]

Age Name

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
foreach index [array names personA] {
   puts "personA($index): $personA($index)"
}

personA(Age): 14
personA(Name): Dave

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

hello

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable
set myVariable {hello world}
puts $myVariable

hello world
hello world

#!/usr/bin/tclsh

puts "HellotWorldnnTutorialspoint";

Hello   World

Tutorialspoint

#!/usr/bin/tclsh

set s1 "Hello"
set s2 "World"
set s3 "World"
puts [string compare s1 s2]
if {[string compare s2 s3] == 0} {
   puts "String 's1' and 's2' are same."; 
} 

if {[string compare s1 s2] == -1} {
   puts "String 's1' comes before 's2'.";
}

if {[string compare s2 s1] == 1} {
   puts "String 's2' comes after 's1'.";
}

-1
String 's1' comes before 's2'.
String 's2' comes after 's1'.

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "o"
puts "First occurrence of $s2 in s1"
puts [string first $s2 $s1]
puts "Character at index 0 in s1"
puts [string index $s1 0]
puts "Last occurrence of $s2 in s1"
puts [string last $s2 $s1]
puts "Word end index in s1"
puts [string wordend $s1 20]
puts "Word start index in s1"
puts [string wordstart $s1 20]

First occurrence of o in s1
4
Character at index 0 in s1
H
Last occurrence of o in s1
7
Word end index in s1
11
Word start index in s1
6

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Length of string s1"
puts [string length $s1]

Length of string s1
11

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Uppercase string of s1"
puts [string toupper $s1]
puts "Lowercase string of s1"
puts [string tolower $s1]

Uppercase string of s1
HELLO WORLD
Lowercase string of s1
hello world

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "World"
puts "Trim right $s2 in $s1"
puts [string trimright $s1 $s2]

set s2 "Hello"
puts "Trim left $s2 in $s1"
puts [string trimleft $s1 $s2]

set s1 " Hello World "
set s2 " "
puts "Trim characters s1 on both sides of s2"
puts [string trim $s1 $s2]

Trim right World in Hello World
Hello 
Trim left Hello in Hello World
 World
Trim characters s1 on both sides of s2
Hello World

#!/usr/bin/tclsh

set s1 "test@test.com" 
set s2 "*@*.com"
puts "Matching pattern s2 in s1"
puts [string match "*@*.com" $s1 ]
puts "Matching pattern tcl in s1"
puts [string match {tcl} $s1]

Matching pattern s2 in s1
1
Matching pattern tcl in s1
0

#!/usr/bin/tclsh

set s1 "Hello" 
append s1 " World"
puts $s1

Hello World

#!/usr/bin/tclsh

puts [format "%f" 43.5]
puts [format "%e" 43.5]
puts [format "%d %s" 4 tuts]
puts [format "%s" "Tcl Language"]
puts [format "%x" 40]

43.500000
4.350000e+01
4 tuts
Tcl Language
28

#!/usr/bin/tclsh

puts [scan "90" {%[0-9]} m]
puts [scan "abc" {%[a-z]} m]
puts [scan "abc" {%[A-Z]} m]
puts [scan "ABC" {%[A-Z]} m]

1
1
0
1

set listName { item1 item2 item3 .. itemn }
# or
set listName [list item1 item2 item3]
# or 
set listName [split "items separated by a character" split_character]

#!/usr/bin/tclsh

set colorList1 {red green blue}
set colorList2 [list red green blue]
set colorList3 [split "red_green_blue" _]
puts $colorList1
puts $colorList2
puts $colorList3

red green blue
red green blue
red green blue

append listName split_character value
# or
lappend listName value

#!/usr/bin/tclsh

set var orange
append var " " "blue"
lappend var "red" 
lappend var "green" 
puts $var

orange blue red green

llength listName

#!/usr/bin/tclsh

set var {orange blue red green}
puts [llength $var] 

4

lindex listname index

#!/usr/bin/tclsh

set var {orange blue red green}
puts [lindex $var  1]

blue

linsert listname index value1 value2..valuen

#!/usr/bin/tclsh

set var {orange blue red green}
set var [linsert  $var 3 black white]
puts $var

orange blue red black white green

lreplace listname firstindex lastindex value1 value2..valuen

#!/usr/bin/tclsh

set var {orange blue red green}
set var [lreplace $var 2 3 black white]
puts $var

orange blue black white

lset listname index value 

#!/usr/bin/tclsh

set var {orange blue red green}
lset var 0 black 
puts $var

black blue red green

lassign listname variable1 variable2.. variablen

#!/usr/bin/tclsh

set var {orange blue red green}
lassign $var colour1 colour2
puts $colour1
puts $colour2

orange
blue

lsort listname

#!/usr/bin/tclsh

set var {orange blue red green}
set var [lsort $var]
puts $var

blue green orange red

dict set dictname key value
# or 
dict create dictname key1 value1 key2 value2 .. keyn valuen

#!/usr/bin/tclsh

dict set colours  colour1 red 
puts $colours
dict set colours  colour2 green
puts $colours

set colours [dict create colour1 "black" colour2 "white"]
puts $colours

colour1 red
colour1 red colour2 green
colour1 black colour2 white

[dict size dictname]

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
puts [dict size $colours]

2

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
foreach item [dict keys $colours] {
   set value [dict get $colours $item]
   puts $value
}

black
white

[dict get $dictname $keyname]

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set value [dict get $colours colour1]
puts $value

black

[dict keys $dictname]

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set keys [dict keys $colours]
puts $keys

colour1 colour2

[dict values $dictname]

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set values [dict values $colours]
puts $values

black white

[dict exists $dictname $key]

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set result [dict exists $colours colour1]
puts $result

1

proc procedureName {arguments} {
   body
}

#!/usr/bin/tclsh

proc helloWorld {} {
   puts "Hello, World!"
}
helloWorld

Hello, World!

#!/usr/bin/tclsh

proc add {a b} {
   return [expr $a+$b]
}
puts [add 10 30]

40

#!/usr/bin/tclsh

proc avg {numbers} {
   set sum 0
   foreach number $numbers {
      set sum  [expr $sum + $number]
   }
   set average [expr $sum/[llength $numbers]]
   return $average
}
puts [avg {70 80 50 60}]
puts [avg {70 80 50 }]

65
66

#!/usr/bin/tclsh

proc add {a {b 100} } {
   return [expr $a+$b]
}
puts [add 10 30]
puts [add 10]

40
110

#!/usr/bin/tclsh

proc factorial {number} {
   if {$number <= 1} {
      return 1
   } 
   return [expr $number * [factorial [expr $number - 1]]]

}
puts [factorial 3]
puts [factorial 5]

6
120

# /Users/rajkumar/Desktop/helloworld/HelloWorld.tcl 
# Create the namespace
namespace eval ::HelloWorld {
 
  # Export MyProcedure
  namespace export MyProcedure
 
  # My Variables
   set version 1.0
   set MyDescription "HelloWorld"
 
  # Variable for the path of the script
   variable home [file join [pwd] [file dirname [info script]]]
 
}
 
# Definition of the procedure MyProcedure
proc ::HelloWorld::MyProcedure {} {
   puts $HelloWorld::MyDescription
}

package provide HelloWorld $HelloWorld::version
package require Tcl 8.0

% cd /Users/rajkumar/Desktop/helloworld 
% pkg_mkIndex . *.tcl

% lappend auto_path "/Users/rajkumar/Desktop/helloworld"

% package require HelloWorld 1.0

% puts [HelloWorld::MyProcedure]

HelloWorld

lappend auto_path "/Users/rajkumar/Desktop/helloworld"
package require HelloWorld 1.0
puts [HelloWorld::MyProcedure]

HelloWorld

#!/usr/bin/tclsh

namespace eval MyMath {
  # Create a variable inside the namespace
  variable myResult
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
  set ::MyMath::myResult [expr $a + $b]
}
MyMath::Add 10 23

puts $::MyMath::myResult

33

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
}

namespace eval extendedMath {
   # Create a variable inside the namespace
   namespace eval MyMath {
      # Create a variable inside the namespace
      variable myResult
   }
}
set ::MyMath::myResult "test1"
puts $::MyMath::myResult
set ::extendedMath::MyMath::myResult "test2"
puts $::extendedMath::MyMath::myResult

test1
test2

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
   namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
   return [expr $a + $b]
}

namespace import MyMath::*
puts [Add 10 30]

40

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
   namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
   return [expr $a + $b]
}
namespace import MyMath::*
puts [Add 10 30]
namespace forget MyMath::*

40

open fileName accessMode

close fileName 

puts $filename "text to write"

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test"
close $fp

set file_data [read $fp]

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test"
close $fp
set fp [open "input.txt" r]
set file_data [read $fp]
puts $file_data
close $fp

test

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "testntest"
close $fp
set fp [open "input.txt" r]

while { [gets $fp data] >= 0 } {
   puts $data
}
close $fp

test
test

error message info code

catch script resultVarName

#!/usr/bin/tclsh

proc Div {a b} {
   if {$b == 0} {
      error "Error generated by error" "Info String for error" 401
   } else {
      return [expr $a/$b]
   }
}

if {[catch {puts "Result = [Div 10 0]"} errmsg]} {
   puts "ErrorMsg: $errmsg"
   puts "ErrorCode: $errorCode"
   puts "ErrorInfo:n$errorInfon"
}

if {[catch {puts "Result = [Div 10 2]"} errmsg]} {
   puts "ErrorMsg: $errmsg"
   puts "ErrorCode: $errorCode"
   puts "ErrorInfo:n$errorInfon"
}

ErrorMsg: Error generated by error
ErrorCode: 401
ErrorInfo:
Info String for error
   (procedure "Div" line 1)
   invoked from within
"Div 10 0"

Result = 5

#!/usr/bin/tclsh

catch {set file [open myNonexistingfile.txt]} result
puts "ErrorMsg: $result"
puts "ErrorCode: $errorCode"
puts "ErrorInfo:n$errorInfon"

ErrorMsg: couldn't open "myNonexistingfile.txt": no such file or directory
ErrorCode: POSIX ENOENT {no such file or directory}
ErrorInfo:
couldn't open "myNonexistingfile.txt": no such file or directory
   while executing
"open myNonexistingfile.txt"

#!/usr/bin/tclsh

namespace import ::tcl::mathfunc::*
puts [tan 10]
puts [pow 10 2]
puts [ceil 10.34]
puts [hypot 10 20]
puts [srand 45]
puts [log 10]
puts [srand 45]

0.6483608274590866
100.0
11.0
22.360679774997898
0.0003521866166741525
2.302585092994046
0.0003521866166741525

#!/usr/bin/tclsh

#get seconds
set currentTime [clock seconds]
puts $currentTime
#get format 
puts "The time is: [clock format $currentTime -format %H:%M:%S]"
puts "The date is: [clock format $currentTime -format %D]"

set date "Jun 15, 2014"
puts [clock scan $date -format {%b %d, %Y}]

puts [exec ls]
puts [exec dir]

set a  [open input.txt]
puts [read $a];
puts $a
close $a

1402819756
The time is: 03:09:16
The date is: 06/15/2014
1402808400
input.txt
main.tcl
input.txt  main.tcl
This is the file you can use to provide input to your program and later on open
   it inside your program to process the input.

file3

regexp optionalSwitches patterns searchString fullMatch subMatch1 ... subMatchn

#!/usr/bin/tclsh

regexp {([A-Z,a-z]*)} "Tcl Tutorial" a b 
puts "Full Match: $a"
puts "Sub Match1: $b"

Full Match: Tcl
Sub Match1: Tcl

#!/usr/bin/tclsh

regexp {([A-Z,a-z]*).([A-Z,a-z]*)} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b"
puts "Sub Match2: $c"

Full Match: Tcl Tutorial
Sub Match1: Tcl
Sub Match2: Tutorial

#!/usr/bin/tclsh

regexp {([A-Z,a-z]*.([A-Z,a-z]*))} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b"
puts "Sub Match2: $c"

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

#!/usr/bin/tclsh

regexp -nocase {([A-Z]*.([A-Z]*))} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b"
puts "Sub Match2: $c"

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

#!/usr/bin/tclsh

regexp -nocase -line -- {([A-Z]*.([A-Z]*))} "Tcl nTutorial" a b 
puts "Full Match: $a"
puts "Sub Match1: $b"
regexp -nocase -start 4 -line -- {([A-Z]*.([A-Z]*))} "Tcl nTutorial" a b  
puts "Full Match: $a"
puts "Sub Match1: $b"

Full Match: Tcl 
Sub Match1: Tcl 
Full Match: Tutorial
Sub Match1: Tutorial

#!/usr/bin/wish

grid [ttk::button .mybutton -text "Hello World"] 

C:Tcl> wish helloWorld.tcl

$ yum install tcl tk

$ wish helloWorld.tcl

$ sudo apt-get install tcl tk

$ wish helloWorld.tcl

$ wish helloWorld.tcl

$ tar zxf tk8.6.1-src.tar.gz
$ cd tcl8.6.1
$ cd unix
$ ./configure —with-tcl=../../tcl8.6.1/unix —prefix=/opt —enable-gcc
$ make
$ sudo make install

#!/usr/bin/wish

puts $tk_version

8.5

#!/usr/bin/wish

puts $tk_library

/Library/Frameworks/Tk.framework/Versions/8.6/Resources/Scripts

#!/usr/bin/wish

puts $tk_patchLevel

8.6.1

#!/usr/bin/wish

puts $tk_strictMotif

0

type variableName arguments options

#!/usr/bin/wish

grid [label .myLabel -background red -text "Hello World" -relief ridge -borderwidth 3]
   -padx 100 -pady 100

#!/usr/bin/wish

grid [label .myLabel -text "Label Widget" -textvariable labelText] 
grid [text .myText -width 20 -height 5]
.myText insert 1.0 "TextnWidgetn"
grid [entry .myEntry -text "Entry Widget"]
grid [message .myMessage -background red -foreground white -text "MessagenWidget"]
grid [button .myButton1  -text "Button" -command "set labelText clicked"]