Jim Tcl(n) Manual Page

Interactive mode reads Tcl commands from standard input, evaluates those commands and prints the results.

If jimsh is configured with line editing (it is by default) and a VT-100-compatible terminal is detected, Emacs-style line editing commands are available, including: arrow keys, ^W to erase a word, ^U to erase the line, ^R for reverse incremental search in history. Additionally, the h command may be used to display the command history.

Command line history is automatically saved and loaded from ~/.jim_history

In interactive mode, jimsh automatically runs the script ~/.jimrc at startup if it exists.

If the system supports POSIX regular expressions, and UTF-8 support is not enabled, this support will be used by default. The type of regular expressions supported are Extended Regular Expressions (ERE) rather than Basic Regular Expressions (BRE). See REG_EXTENDED in the documentation.

Using the system-supported POSIX regular expressions will typically make for the smallest code size, but some features such as UTF-8 and \w, \d, \s are not supported.

See regex(3) and regex(7) for full details.

The Jim built-in regulare expression engine may be selected with ./configure --with-jim-regexp or it will be selected automatically if UTF-8 support is enabled.

This engine supports UTF-8 as well as some ARE features. The differences with both Tcl 7.x/8.x and POSIX are highlighted below.

In addition to procedure arguments, Jim procedures may declare static variables. These variables scoped to the procedure and initialised at procedure definition. Either from the static variable definition, or from the enclosing scope.

Consider the following example:

The static variable a has no initialiser, so it is initialised from the enclosing scope with the value 1. (Note that it is an error if there is no variable with the same name in the enclosing scope). However b has an initialiser, so it is initialised to 2.

Unlike a local variable, the value of a static variable is retained across invocations of the procedure.

See the proc command for information on how to define procedures and what happens when they are invoked. See also NAMESPACES.

A reference can be thought of as holding a value with one level of indirection, where the value may be garbage collected when unreferenced. Consider the following example:

The operation ref creates a references to the value specified by the first argument. (The second argument is a "type" used for documentation purposes).

The operation getref is the dereferencing operation which retrieves the value stored in the reference.

The operation setref replaces the value stored by the reference. If the old value is no longer accessible by any reference, it will eventually be automatically be garbage collected.

Normally, all values in Tcl are passed by value. As such values are copied and released automatically as necessary.

With the introduction of references, it is possible to create values whose lifetime transcend their scope. To support this, case, the Jim system will periodically identify and discard objects which are no longer accessible by any reference.

The collect command may be used to force garbage collection. Consider a reference created with a finalizer:

Note that once the reference, r, was modified so that it no longer contained a reference to the value, the garbage collector discarded the value (after calling the finalizer).

The finalizer for a reference may be examined or changed with the finalize command

Jim provides a garbage collected lambda function. This is a procedure which is able to create an anonymous procedure. Consider:

This create an anonymous procedure (with the name stored in f), with a static variable which is incremented by the supplied value and the result returned.

Once the procedure name is no longer accessible, it will automatically be deleted when the garbage collector runs.

The procedure may also be delete immediately by renaming it "". e.g.

Commands such as string match, lsearch -glob, array names and others use string pattern matching rules. These commands support UTF-8. For example:

format %c allows a unicode codepoint to be be encoded. For example, the following will return a string with two bytes and one character. The same as \ub5

format respects widths as character widths, not byte widths. For example, the following will return a string with three characters, not three bytes.

Similarly, scan … %c allows a UTF-8 to be decoded to a unicode codepoint. The following will set a to 181 (0xb5) and b to 65 (0x41).

scan %s will also accept a character class, including unicode ranges.

string is has not been extended to classify UTF-8 characters. Therefore, the following will return 0, even though the string may be considered to be alphabetic.

This does not affect the string classes ascii, control, digit, double, integer or xdigit.

Jim provides a simplified unicode case mapping. This means that case conversion and comparison will not increase or decrease the number of characters in a string. (Although it may change the number of bytes).

string toupper will convert any lowercase letters to their uppercase equivalent. Any character which is not a letter or has no uppercase equivalent is left unchanged. Similarly for string tolower and string totitle.

Commands which perform case insensitive matches, such as string compare -nocase and lsearch -nocase fold both strings to uppercase before comparison.

Some UTF-8 character sequences are invalid, such as those beginning with 0xff, those which represent character sequences longer than 3 bytes (greater than U+FFFF), and those which end prematurely, such as a lone 0xc2.

In these situations, the offending bytes are treated as single characters. For example, the following returns 2.

If UTF-8 support is enabled, the built-in regular expression engine will be selected which supports UTF-8 strings and patterns.

See REGULAR EXPRESSIONS

alarm seconds

Delivers the SIGALRM signal to the process after the given number of seconds. If the platform supports ualarm(3) then the argument may be a floating point value. Otherwise it must be an integer.

Note that unless a signal handler for SIGALRM has been installed (see signal), the process will exit on this signal.

alias name args...

Creates a single word alias (command) for one or more words. For example, the following creates an alias for the command info exists.

alias returns name, allowing it to be used with local.

See also proc, curry, lambda, local, info alias, exists -alias

append varName value ?value value …?

Append all of the value arguments to the current value of variable varName. If varName doesn’t exist, it is given a value equal to the concatenation of all the value arguments.

This command provides an efficient way to build up long variables incrementally. For example, "append a $b" is much more efficient than "set a $a$b" if $a is long.

apply lambdaExpr ?arg1 arg2 ...?

The command apply provides for anonymous procedure calls, similar to lambda, but without command name being created, even temporarily.

The function lambdaExpr is a two element list {args body} or a three element list {args body namespace}. The first element args specifies the formal arguments, in the same form as the proc and lambda commands.

array option arrayName ?arg...?

This command performs one of several operations on the variable given by arrayName.

Note that in general, if the named array does not exist, the array command behaves as though the array exists but is empty.

The option argument determines what action is carried out by the command. The legal options (which may be abbreviated) are:

break

This command may be invoked only inside the body of a loop command such as for or foreach or while. It returns a JIM_BREAK code to signal the innermost containing loop command to return immediately.

case string ?in? patList body ?patList body …?

case string ?in? {patList body ?patList body …?}

Note that the switch command should generally be preferred unless compatibility with Tcl 6.x is desired.

Match string against each of the patList arguments in order. If one matches, then evaluate the following body argument by passing it recursively to the Tcl interpreter, and return the result of that evaluation. Each patList argument consists of a single pattern or list of patterns. Each pattern may contain any of the wild-cards described under string match.

If a patList argument is default, the corresponding body will be evaluated if no patList matches string. If no patList argument matches string and no default is given, then the case command returns an empty string.

Two syntaxes are provided.

The first uses a separate argument for each of the patterns and commands; this form is convenient if substitutions are desired on some of the patterns or commands.

The second form places all of the patterns and commands together into a single argument; the argument must have proper list structure, with the elements of the list being the patterns and commands.

The second form makes it easy to construct multi-line case commands, since the braces around the whole list make it unnecessary to include a backslash at the end of each line.

Since the patList arguments are in braces in the second form, no command or variable substitutions are performed on them; this makes the behaviour of the second form different than the first form in some cases.

Below are some examples of case commands:

will return 3,

will return 1, and

will return 2.

catch ?-?no?code ...? ?--? command ?resultVarName? ?optionsVarName?

The catch command may be used to prevent errors from aborting command interpretation. catch evaluates command, and returns a JIM_OK code, regardless of any errors that might occur while executing command (with the possible exception of JIM_SIGNAL - see below).

The return value from catch is a decimal string giving the code returned by the Tcl interpreter after executing command. This will be 0 (JIM_OK) if there were no errors in command; otherwise it will have a non-zero value corresponding to one of the exceptional return codes (see jim.h for the definitions of code values, or the info returncodes command).

If the resultVarName argument is given, then it gives the name of a variable; catch will set the value of the variable to the string returned from command (either a result or an error message).

If the optionsVarName argument is given, then it gives the name of a variable; catch will set the value of the variable to a dictionary. For any return code other than JIM_RETURN, the value for the key -code will be set to the return code. For JIM_RETURN it will be set to the code given in return -code. Additionally, for the return code JIM_ERR, the value of the key -errorinfo will contain the current stack trace (the same result as info stacktrace), the value of the key -errorcode will contain the same value as the global variable $::errorCode, and the value of the key -level will be the current return level (see return -level). This can be useful to rethrow an error:

Normally catch will not catch any of the codes JIM_EXIT, JIM_EVAL or JIM_SIGNAL. The set of codes which will be caught may be modified by specifying the one more codes before command.

e.g. To catch JIM_EXIT but not JIM_BREAK or JIM_CONTINUE

The use of -- is optional. It signifies that no more return code options follow.

Note that if a signal marked as signal handle is caught with catch -signal, the return value (stored in resultVarName) is name of the signal caught.

cd dirName

Change the current working directory to dirName.

Returns an empty string.

This command can potentially be disruptive to an application, so it may be removed in some applications.

close fileId

fileId close

Closes the file given by fileId. fileId must be the return value from a previous invocation of the open command; after this command, it should not be used anymore.

collect

Normally reference garbage collection is automatically performed periodically. However it may be run immediately with the collect command.

See GARBAGE COLLECTION, REFERENCES, LAMBDA for more detail.

concat arg ?arg ...?

This command treats each argument as a list and concatenates them into a single list. It permits any number of arguments. For example, the command

will return

as its result.

continue

This command may be invoked only inside the body of a loop command such as for or foreach or while. It returns a JIM_CONTINUE code to signal the innermost containing loop command to skip the remainder of the loop’s body but continue with the next iteration of the loop.

alias args...

Similar to alias except it creates an anonymous procedure (lambda) instead of a named procedure.

the following creates a local, unnamed alias for the command info exists.

curry returns the name of the procedure.

See also proc, alias, lambda, local.

dict option ?arg...?

Performs one of several operations on dictionary values.

The option argument determines what action is carried out by the command. The legal options are:

env ?name? ?default?

If name is supplied, returns the value of name from the initial environment (see getenv(3)). An error is returned if name does not exist in the environment, unless default is supplied - in which case that value is returned instead.

If no arguments are supplied, returns a list of all environment variables and their values as {name value ...}

See also the global variable ::env

eof fileId

fileId eof

Returns 1 if an end-of-file condition has occurred on fileId, 0 otherwise.

fileId must have been the return value from a previous call to open, or it may be stdin, stdout, or stderr to refer to one of the standard I/O channels.

error message ?stacktrace?

Returns a JIM_ERR code, which causes command interpretation to be unwound. message is a string that is returned to the application to indicate what went wrong.

If the stacktrace argument is provided and is non-empty, it is used to initialize the stacktrace.

This feature is most useful in conjunction with the catch command: if a caught error cannot be handled successfully, stacktrace can be used to return a stack trace reflecting the original point of occurrence of the error:

See also errorInfo, info stacktrace, catch and return

errorInfo error ?stacktrace?

Returns a human-readable representation of the given error message and stack trace. Typical usage is:

See also error.

eval arg ?arg...?

eval takes one or more arguments, which together comprise a Tcl command (or collection of Tcl commands separated by newlines in the usual way). eval concatenates all its arguments in the same fashion as the concat command, passes the concatenated string to the Tcl interpreter recursively, and returns the result of that evaluation (or any error generated by it).

exec arg ?arg...?

This command treats its arguments as the specification of one or more UNIX commands to execute as subprocesses. The commands take the form of a standard shell pipeline; | arguments separate commands in the pipeline and cause standard output of the preceding command to be piped into standard input of the next command (or |& for both standard output and standard error).

Under normal conditions the result of the exec command consists of the standard output produced by the last command in the pipeline.

If any of the commands in the pipeline exit abnormally or are killed or suspended, then exec will return an error and the error message will include the pipeline’s output followed by error messages describing the abnormal terminations.

If any of the commands writes to its standard error file, then exec will return an error, and the error message will include the pipeline’s output, followed by messages about abnormal terminations (if any), followed by the standard error output.

If the last character of the result or error message is a newline then that character is deleted from the result or error message for consistency with normal Tcl return values.

An arg may have one of the following special forms:

If there is no redirection of standard input, standard error or standard output, these are connected to the corresponding input or output of the application.

If the last arg is & then the command will be executed in background. In this case the standard output from the last command in the pipeline will go to the application’s standard output unless redirected in the command, and error output from all the commands in the pipeline will go to the application’s standard error file. The return value of exec in this case is a list of process ids (pids) in the pipeline.

Each arg becomes one word for a command, except for |, <, <<, >, and & arguments, and the arguments that follow <, <<, and >.

The first word in each command is taken as the command name; the directories in the PATH environment variable are searched for an executable by the given name.

No glob expansion or other shell-like substitutions are performed on the arguments to commands.

If the command fails, the global $::errorCode (and the -errorcode option in catch) will be set to a list, as follows:

The environment for the executed command is set from $::env (unless this variable is unset, in which case the original environment is used).

exists ?-var|-proc|-command|-alias? name

Checks the existence of the given variable, procedure, command or alias respectively and returns 1 if it exists or 0 if not. This command provides a more simplified/convenient version of info exists, info procs and info commands.

If the type is omitted, a type of -var is used. The type may be abbreviated.

exit ?returnCode?

Terminate the process, returning returnCode to the parent as the exit status.

If returnCode isn’t specified then it defaults to 0.

Note that exit can be caught with catch.

expr arg

Calls the expression processor to evaluate arg, and returns the result as a string. See the section EXPRESSIONS above.

Note that Jim supports a shorthand syntax for expr as $(...) The following two are identical.

file option name ?arg...?

Operate on a file or a file name. name is the name of a file.

option indicates what to do with the file name. Any unique abbreviation for option is acceptable. The valid options are:

The file commands that return 0/1 results are often used in conditional or looping commands, for example:

finalize reference ?command?

If command is omitted, returns the finalizer command for the given reference.

Otherwise, sets a new finalizer command for the given reference. command may be the empty string to remove the current finalizer.

The reference must be a valid reference create with the ref command.

See GARBAGE COLLECTION, REFERENCES, LAMBDA for more detail.

flush fileId

fileId flush

Flushes any output that has been buffered for fileId. fileId must have been the return value from a previous call to open, or it may be stdout or stderr to access one of the standard I/O streams; it must refer to a file that was opened for writing. This command returns an empty string.

for start test next body

for is a looping command, similar in structure to the C for statement. The start, next, and body arguments must be Tcl command strings, and test is an expression string.

The for command first invokes the Tcl interpreter to execute start. Then it repeatedly evaluates test as an expression; if the result is non-zero it invokes the Tcl interpreter on body, then invokes the Tcl interpreter on next, then repeats the loop. The command terminates when test evaluates to 0.

If a continue command is invoked within body then any remaining commands in the current execution of body are skipped; processing continues by invoking the Tcl interpreter on next, then evaluating test, and so on.

If a break command is invoked within body or next, then the for command will return immediately.

The operation of break and continue are similar to the corresponding statements in C.

for returns an empty string.

foreach varName list body

foreach varList list ?varList2 list2 ...? body

In this command, varName is the name of a variable, list is a list of values to assign to varName, and body is a collection of Tcl commands.

For each field in list (in order from left to right), foreach assigns the contents of the field to varName (as if the lindex command had been used to extract the field), then calls the Tcl interpreter to execute body.

If instead of being a simple name, varList is used, multiple assignments are made each time through the loop, one for each element of varList.

For example, if there are two elements in varList and six elements in the list, the loop will be executed three times.

If the length of the list doesn’t evenly divide by the number of elements in varList, the value of the remaining variables in the last iteration of the loop are undefined.

The break and continue statements may be invoked inside body, with the same effect as in the for command.

foreach returns an empty string.

format formatString ?arg ...?

This command generates a formatted string in the same way as the C sprintf procedure (it uses sprintf in its implementation). formatString indicates how to format the result, using % fields as in sprintf, and the additional arguments, if any, provide values to be substituted into the result.

All of the sprintf options are valid; see the sprintf man page for details. Each arg must match the expected type from the % field in formatString; the format command converts each argument to the correct type (floating, integer, etc.) before passing it to sprintf for formatting.

The only unusual conversion is for %c; in this case the argument must be a decimal string, which will then be converted to the corresponding ASCII character value.

format does backslash substitution on its formatString argument, so backslash sequences in formatString will be handled correctly even if the argument is in braces.

The return value from format is the formatted string.

getref reference

Returns the string associated with reference. The reference must be a valid reference create with the ref command.

See GARBAGE COLLECTION, REFERENCES, LAMBDA for more detail.

gets fileId ?varName?

fileId gets ?varName?

Reads the next line from the file given by fileId and discards the terminating newline character.

If varName is specified, then the line is placed in the variable by that name and the return value is a count of the number of characters read (not including the newline).

If the end of the file is reached before reading any characters then -1 is returned and varName is set to an empty string.

If varName is not specified then the return value will be the line (minus the newline character) or an empty string if the end of the file is reached before reading any characters.

An empty string will also be returned if a line contains no characters except the newline, so eof may have to be used to determine what really happened.

If the last character in the file is not a newline character, then gets behaves as if there were an additional newline character at the end of the file.

fileId must be stdin or the return value from a previous call to open; it must refer to a file that was opened for reading.

glob ?-nocomplain? pattern ?pattern ...?

This command performs filename globbing, using csh rules. The returned value from glob is the list of expanded filenames.

If -nocomplain is specified as the first argument then an empty list may be returned; otherwise an error is returned if the expanded list is empty. The -nocomplain argument must be provided exactly: an abbreviation will not be accepted.

global varName ?varName ...?

This command is ignored unless a Tcl procedure is being interpreted. If so, then it declares each given varName to be a global variable rather than a local one. For the duration of the current procedure (and only while executing in the current procedure), any reference to varName will be bound to a global variable instead of a local one.

An alternative to using global is to use the :: prefix to explicitly name a variable in the global scope.

if expr1 ?then? body1 elseif expr2 ?then? body2 elseif ... ?else? ?bodyN?

The if command evaluates expr1 as an expression (in the same way that expr evaluates its argument). The value of the expression must be numeric; if it is non-zero then body1 is executed by passing it to the Tcl interpreter.

Otherwise expr2 is evaluated as an expression and if it is non-zero then body2 is executed, and so on.

If none of the expressions evaluates to non-zero then bodyN is executed.

The then and else arguments are optional "noise words" to make the command easier to read.

There may be any number of elseif clauses, including zero. bodyN may also be omitted as long as else is omitted too.

The return value from the command is the result of the body script that was executed, or an empty string if none of the expressions was non-zero and there was no bodyN.

incr varName ?increment?

Increment the value stored in the variable whose name is varName. The value of the variable must be integral.

If increment is supplied then its value (which must be an integer) is added to the value of variable varName; otherwise 1 is added to varName.

The new value is stored as a decimal string in variable varName and also returned as result.

If the variable does not exist, the variable is implicitly created and set to 0 first.

join list ?joinString?

The list argument must be a valid Tcl list. This command returns the string formed by joining all of the elements of list together with joinString separating each adjacent pair of elements.

The joinString argument defaults to a space character.

kill ?SIG|-0? pid

Sends the given signal to the process identified by pid.

The signal may be specified by name or number in one of the following forms:

The signal name may be in either upper or lower case.

The special signal name -0 simply checks that a signal could be sent.

If no signal is specified, SIGTERM is used.

An error is raised if the signal could not be delivered.

lambda args ?statics? body

The lambda command is identical to proc, except rather than creating a named procedure, it creates an anonymous procedure and returns the name of the procedure.

See proc and GARBAGE COLLECTION, REFERENCES, LAMBDA for more detail.

lappend varName value ?value value ...?

Treat the variable given by varName as a list and append each of the value arguments to that list as a separate element, with spaces between elements.

If varName doesn’t exist, it is created as a list with elements given by the value arguments. lappend is similar to append except that each value is appended as a list element rather than raw text.

This command provides a relatively efficient way to build up large lists. For example,

is much more efficient than

when $a is long.

lassign list varName ?varName ...?

This command treats the value list as a list and assigns successive elements from that list to the variables given by the varName arguments in order. If there are more variable names than list elements, the remaining variables are set to the empty string. If there are more list ele- ments than variables, a list of unassigned elements is returned.

local cmd ?arg...?

First, local evaluates cmd with the given arguments. The return value must be the name of an existing command, which is marked as having local scope. This means that when the current procedure exits, the specified command is deleted. This can be useful with lambda, local procedures or to automatically close a filehandle.

In addition, if a command already exists with the same name, the existing command will be kept rather than deleted, and may be called via upcall. The previous command will be restored when the current procedure exits. See upcall for more details.

In this example, a local procedure is created. Note that the procedure continues to have global scope while it is active.

In this example, the lambda is deleted at the end of the procedure rather than waiting until garbage collection.

loop var first limit ?incr? body

Similar to for except simpler and possibly more efficient. With a positive increment, equivalent to:

If incr is not specified, 1 is used. Note that setting the loop variable inside the loop does not affect the loop count.

lindex list index

Treats list as a Tcl list and returns element index from it (0 refers to the first element of the list). See STRING AND LIST INDEX SPECIFICATIONS for all allowed forms for index.

In extracting the element, lindex observes the same rules concerning braces and quotes and backslashes as the Tcl command interpreter; however, variable substitution and command substitution do not occur.

If index is negative or greater than or equal to the number of elements in value, then an empty string is returned.

linsert list index element ?element element ...?

This command produces a new list from list by inserting all of the element arguments just before the element index of list. Each element argument will become a separate element of the new list. If index is less than or equal to zero, then the new elements are inserted at the beginning of the list. If index is greater than or equal to the number of elements in the list, then the new elements are appended to the list.

See STRING AND LIST INDEX SPECIFICATIONS for all allowed forms for index.

list arg ?arg ...?

This command returns a list comprised of all the arguments, arg. Braces and backslashes get added as necessary, so that the lindex command may be used on the result to re-extract the original arguments, and also so that eval may be used to execute the resulting list, with arg1 comprising the command’s name and the other args comprising its arguments. list produces slightly different results than concat: concat removes one level of grouping before forming the list, while list works directly from the original arguments. For example, the command

will return

while concat with the same arguments will return

llength list

Treats list as a list and returns a decimal string giving the number of elements in it.

lset varName ?index ..? newValue

Sets an element in a list.

The lset command accepts a parameter, varName, which it interprets as the name of a variable containing a Tcl list. It also accepts zero or more indices into the list. Finally, it accepts a new value for an element of varName. If no indices are presented, the command takes the form:

In this case, newValue replaces the old value of the variable varName.

When presented with a single index, the lset command treats the content of the varName variable as a Tcl list. It addresses the index’th element in it (0 refers to the first element of the list). When interpreting the list, lset observes the same rules concerning braces and quotes and backslashes as the Tcl command interpreter; however, variable substitution and command substitution do not occur. The command constructs a new list in which the designated element is replaced with newValue. This new list is stored in the variable varName, and is also the return value from the lset command.

If index is negative or greater than or equal to the number of elements in $varName, then an error occurs.

See STRING AND LIST INDEX SPECIFICATIONS for all allowed forms for index.

If additional index arguments are supplied, then each argument is used in turn to address an element within a sublist designated by the previous indexing operation, allowing the script to alter elements in sublists. The command,

replaces element 2 of sublist 1 with newValue.

The integer appearing in each index argument must be greater than or equal to zero. The integer appearing in each index argument must be strictly less than the length of the corresponding list. In other words, the lset command cannot change the size of a list. If an index is outside the permitted range, an error is reported.

lmap varName list body

lmap varList list ?varList2 list2 ...? body

lmap is a "collecting" foreach which returns a list of its results.

For example:

If the body invokes continue, no value is added for this iteration. If the body invokes break, the loop ends and no more values are added.

load filename

Loads the dynamic extension, filename. Generally the filename should have the extension .so. The initialisation function for the module must be based on the name of the file. For example loading hwaccess.so will invoke the initialisation function, Jim_hwaccessInit. Normally the load command should not be used directly. Instead it is invoked automatically by package require.

lrange list first last

list must be a valid Tcl list. This command will return a new list consisting of elements first through last, inclusive.

See STRING AND LIST INDEX SPECIFICATIONS for all allowed forms for first and last.

If last is greater than or equal to the number of elements in the list, then it is treated as if it were end.

If first is greater than last then an empty string is returned.

Note: "lrange list first first" does not always produce the same result as "lindex list first" (although it often does for simple fields that aren’t enclosed in braces); it does, however, produce exactly the same results as "list [lindex list first]"

lreplace list first last ?element element ...?

Returns a new list formed by replacing one or more elements of list with the element arguments.

first gives the index in list of the first element to be replaced.

If first is less than zero then it refers to the first element of list; the element indicated by first must exist in the list.

last gives the index in list of the last element to be replaced; it must be greater than or equal to first.

See STRING AND LIST INDEX SPECIFICATIONS for all allowed forms for first and last.

The element arguments specify zero or more new arguments to be added to the list in place of those that were deleted.

Each element argument will become a separate element of the list.

If no element arguments are specified, then the elements between first and last are simply deleted.

lrepeat number element1 ?element2 ...?

Build a list by repeating elements number times (which must be a positive integer).

lreverse list

Returns the list in reverse order.

lsearch ?options? list pattern

This command searches the elements list to see if one of them matches pattern. If so, the command returns the index of the first matching element (unless the options -all, -inline or -bool are specified.) If not, the command returns -1. The option arguments indicates how the elements of the list are to be matched against pattern and must have one of the values below:

Note that this command is different from Tcl in that default match type is -exact rather than -glob.

lsort ?-index listindex? ?-integer|-command cmdname? ?-decreasing|-increasing? list

Sort the elements of list, returning a new list in sorted order. By default, ASCII sorting is used, with the result in increasing order.

If -integer is specified, numeric sorting is used.

If -command cmdname is specified, cmdname is treated as a command name. For each comparison, cmdname $value1 $value2 is called which should compare the values and return an integer less than, equal to, or greater than zero if the $value1 is to be considered less than, equal to, or greater than $value2, respectively.

If -decreasing is specified, the resulting list is in the opposite order to what it would be otherwise. -increasing is the default.

If -index listindex is specified, each element of the list is treated as a list and the given index is extracted from the list for comparison. The list index may be any valid list index, such as 1, end or end-2.

If -index listindex is specified, each element of the list is treated as a list and the given index is extracted from the list for comparison. The list index may be any valid list index, such as 1, end or end-2.

open fileName ?access?

open |command-pipeline ?access?

Opens a file and returns an identifier that may be used in future invocations of commands like read, puts, and close. fileName gives the name of the file to open.

The access argument indicates the way in which the file is to be accessed. It may have any of the following values:

access defaults to r.

If a file is opened for both reading and writing, then seek must be invoked between a read and a write, or vice versa.

If the first character of fileName is "|" then the remaining characters of fileName are treated as a list of arguments that describe a command pipeline to invoke, in the same style as the arguments for exec. In this case, the channel identifier returned by open may be used to write to the command’s input pipe or read from its output pipe, depending on the value of access. If write-only access is used (e.g. access is w), then standard output for the pipeline is directed to the current standard output unless overridden by the command. If read-only access is used (e.g. access is r), standard input for the pipeline is taken from the current standard input unless overridden by the command.

The pid command may be used to return the process ids of the commands forming the command pipeline.

See also socket, pid, exec

package provide name ?version?

Indicates that the current script provides the package named name. If no version is specified, 1.0 is used.

Any script which provides a package may include this statement as the first statement, although it is not required.

package require name ?version?*

Searches for the package with the given name by examining each path in $::auto_path and trying to load $path/$name.so as a dynamic extension, or $path/$name.tcl as a script package.

The first such file which is found is considered to provide the the package. (The version number is ignored).

If $name.so exists, it is loaded with the load command, otherwise if $name.tcl exists it is loaded with the source command.

If load or source fails, package require will fail immediately. No further attempt will be made to locate the file.

pid

pid fileId

The first form returns the process identifier of the current process.

The second form accepts a handle returned by open and returns a list of the process ids forming the pipeline in the same form as exec ... &. If fileId represents a regular file handle rather than a command pipeline, the empty string is returned instead.

See also open, exec

proc name args ?statics? body

The proc command creates a new Tcl command procedure, name. When the new command is invoked, the contents of body will be executed. Tcl interpreter. args specifies the formal arguments to the procedure. If specified, static, declares static variables which are bound to the procedure.

See PROCEDURES for detailed information about Tcl procedures.

The proc command returns name (which is useful with local).

When a procedure is invoked, the procedure’s return value is the value specified in a return command. If the procedure doesn’t execute an explicit return, then its return value is the value of the last command executed in the procedure’s body.

If an error occurs while executing the procedure body, then the procedure-as-a-whole will return that same error.

puts ?-nonewline? ?fileId? string

fileId puts ?-nonewline? string

Writes the characters given by string to the file given by fileId. fileId must have been the return value from a previous call to open, or it may be stdout or stderr to refer to one of the standard I/O channels; it must refer to a file that was opened for writing.

In the first form, if no fileId is specified then it defaults to stdout. puts normally outputs a newline character after string, but this feature may be suppressed by specifying the -nonewline switch.

Output to files is buffered internally by Tcl; the flush command may be used to force buffered characters to be output.

pwd

Returns the path name of the current working directory.

rand ?min? ?max?

Returns a random integer between min (defaults to 0) and max (defaults to the maximum integer).

If only one argument is given, it is interpreted as max.

range ?start? end ?step?

Returns a list of integers starting at start (defaults to 0) and ranging up to but not including end in steps of step defaults to 1).

read ?-nonewline? fileId

fileId read ?-nonewline?

read fileId numBytes

fileId read numBytes

In the first form, all of the remaining bytes are read from the file given by fileId; they are returned as the result of the command. If the -nonewline switch is specified then the last character of the file is discarded if it is a newline.

In the second form, the extra argument specifies how many bytes to read; exactly this many bytes will be read and returned, unless there are fewer than numBytes bytes left in the file; in this case, all the remaining bytes are returned.

fileId must be stdin or the return value from a previous call to open; it must refer to a file that was opened for reading.

regexp ?-nocase? ?-line? ?-indices? ?-start offset? ?-all? ?-inline? ?--? exp string ?matchVar? ?subMatchVar subMatchVar ...?

Determines whether the regular expression exp matches part or all of string and returns 1 if it does, 0 if it doesn’t.

See REGULAR EXPRESSIONS above for complete information on the syntax of exp and how it is matched against string.

If additional arguments are specified after string then they are treated as the names of variables to use to return information about which part(s) of string matched exp. matchVar will be set to the range of string that matched all of exp. The first subMatchVar will contain the characters in string that matched the leftmost parenthesized subexpression within exp, the next subMatchVar will contain the characters that matched the next parenthesized subexpression to the right in exp, and so on.

Normally, matchVar and the each subMatchVar are set to hold the matching characters from string, however see -indices and -inline below.

If there are more values for subMatchVar than parenthesized subexpressions within exp, or if a particular subexpression in exp doesn’t match the string (e.g. because it was in a portion of the expression that wasn’t matched), then the corresponding subMatchVar will be set to "-1 -1" if -indices has been specified or to an empty string otherwise.

The following switches modify the behaviour of regexp

regsub ?-nocase? ?-all? ?-line? ?-start offset? ?--? exp string subSpec ?varName?

This command matches the regular expression exp against string using the rules described in REGULAR EXPRESSIONS above.

If varName is specified, the commands stores string to varName with the substitutions detailed below, and returns the number of substitutions made (normally 1 unless -all is specified). This is 0 if there were no matches.

If varName is not specified, the substituted string will be returned instead.

When copying string, the portion of string that matched exp is replaced with subSpec. If subSpec contains a & or \0, then it is replaced in the substitution with the portion of string that matched exp.

If subSpec contains a \n, where n is a digit between 1 and 9, then it is replaced in the substitution with the portion of string that matched the n'-th parenthesized subexpression of exp. Additional backslashes may be used in subSpec to prevent special interpretation of & or \0 or \n or backslash.

The use of backslashes in subSpec tends to interact badly with the Tcl parser’s use of backslashes, so it’s generally safest to enclose subSpec in braces if it includes backslashes.

The following switches modify the behaviour of regsub

ref string tag ?finalizer?

Create a new reference containing string of type tag. If finalizer is specified, it is a command which will be invoked when the a garbage collection cycle runs and this reference is no longer accessible.

The finalizer is invoked as:

See GARBAGE COLLECTION, REFERENCES, LAMBDA for more detail.

rename oldName newName

Rename the command that used to be called oldName so that it is now called newName. If newName is an empty string (e.g. {}) then oldName is deleted. The rename command returns an empty string as result.

return ?-code code? ?-errorinfo stacktrace? ?-errorcode errorcode? ?-level n? ?value?

Return immediately from the current procedure (or top-level command or source command), with value as the return value. If value is not specified, an empty string will be returned as result.

If -code is specified (as either a number or ok, error, break, continue, signal, return or exit), this code will be used instead of JIM_OK. This is generally useful when implementing flow of control commands.

If -level is specified and greater than 1, it has the effect of delaying the new return code from -code. This is useful when rethrowing an error from catch. See the implementation of try/catch in tclcompat.tcl for an example of how this is done.

Note: The following options are only used when -code is JIM_ERR.

If -errorinfo is specified (as returned from info stacktrace) it is used to initialize the stacktrace.

If -errorcode is specified, it is used to set the global variable $::errorCode.

scan string format varName1 ?varName2 ...?

This command parses fields from an input string in the same fashion as the C sscanf procedure. string gives the input to be parsed and format indicates how to parse it, using % fields as in sscanf. All of the sscanf options are valid; see the sscanf man page for details. Each varName gives the name of a variable; when a field is scanned from string, the result is converted back into a string and assigned to the corresponding varName. The only unusual conversion is for %c. For %c conversions a single character value is converted to a decimal string, which is then assigned to the corresponding varName; no field width may be specified for this conversion.

seek fileId offset ?origin?

fileId seek offset ?origin?

Change the current access position for fileId. The offset and origin arguments specify the position at which the next read or write will occur for fileId. offset must be a number (which may be negative) and origin must be one of the following:

The origin argument defaults to start.

fileId must have been the return value from a previous call to open, or it may be stdin, stdout, or stderr to refer to one of the standard I/O channels.

This command returns an empty string.

set varName ?value?

Returns the value of variable varName.

If value is specified, then set the value of varName to value, creating a new variable if one doesn’t already exist, and return its value.

If varName contains an open parenthesis and ends with a close parenthesis, then it refers to an array element: the characters before the open parenthesis are the name of the array, and the characters between the parentheses are the index within the array. Otherwise varName refers to a scalar variable.

If no procedure is active, then varName refers to a global variable.

If a procedure is active, then varName refers to a parameter or local variable of the procedure, unless the global command has been invoked to declare varName to be global.

The :: prefix may also be used to explicitly reference a variable in the global scope.

setref reference string

Store a new string in reference, replacing the existing string. The reference must be a valid reference create with the ref command.

See GARBAGE COLLECTION, REFERENCES, LAMBDA for more detail.

Command for signal handling.

See kill for the different forms which may be used to specify signals.

Commands which return a list of signal names do so using the canonical form: "SIGINT SIGTERM".

Note that signal handle and signal ignore represent two forms of signal handling. signal handle is used in conjunction with catch -signal or try -signal to immediately abort execution when the signal is delivered. Alternatively, signal ignore is used in conjunction with signal check to handle signal synchronously. Consider the two examples below.

Prevent a processing from taking too long

Handle SIGHUP to reconfigure:

sleep seconds

Pauses for the given number of seconds, which may be a floating point value less than one to sleep for less than a second, or an integer to sleep for one or more seconds.

source fileName

Read file fileName and pass the contents to the Tcl interpreter as a sequence of commands to execute in the normal fashion. The return value of source is the return value of the last command executed from the file. If an error occurs in executing the contents of the file, then the source command will return that error.

If a return command is invoked from within the file, the remainder of the file will be skipped and the source command will return normally with the result from the return command.

split string ?splitChars?

Returns a list created by splitting string at each character that is in the splitChars argument.

Each element of the result list will consist of the characters from string between instances of the characters in splitChars.

Empty list elements will be generated if string contains adjacent characters in splitChars, or if the first or last character of string is in splitChars.

If splitChars is an empty string then each character of string becomes a separate element of the result list.

splitChars defaults to the standard white-space characters. For example,

returns "comp unix misc" and

returns "H e l l o { } w o r l d".

stackdump stacktrace

Creates a human readable representation of a stack trace.

stacktrace

Returns a live stack trace as a list of proc file line proc file line .... Iteratively uses info frame to create the stack trace. This stack trace is in the same form as produced by catch and info stacktrace

See also stackdump.

string option arg ?arg ...?

Perform one of several string operations, depending on option. The legal options (which may be abbreviated) are:

subst ?-nobackslashes? ?-nocommands? ?-novariables? string

This command performs variable substitutions, command substitutions, and backslash substitutions on its string argument and returns the fully-substituted result. The substitutions are performed in exactly the same way as for Tcl commands. As a result, the string argument is actually substituted twice, once by the Tcl parser in the usual fashion for Tcl commands, and again by the subst command.

If any of the -nobackslashes, -nocommands, or -novariables are specified, then the corresponding substitutions are not performed. For example, if -nocommands is specified, no command substitution is performed: open and close brackets are treated as ordinary characters with no special interpretation.

Note: when it performs its substitutions, subst does not give any special treatment to double quotes or curly braces. For example, the following script returns xyz {44}, not xyz {$a}.

switch ?options? string pattern body ?pattern body ...?

switch ?options? string {pattern body ?pattern body ...?}

The switch command matches its string argument against each of the pattern arguments in order. As soon as it finds a pattern that matches string it evaluates the following body and returns the result of that evaluation. If the last pattern argument is default then it matches anything. If no pattern argument matches string and no default is given, then the switch command returns an empty string. If the initial arguments to switch start with - then they are treated as options. The following options are currently supported:

Two syntaxes are provided for the pattern and body arguments. The first uses a separate argument for each of the patterns and commands; this form is convenient if substitutions are desired on some of the patterns or commands. The second form places all of the patterns and commands together into a single argument; the argument must have proper list structure, with the elements of the list being the patterns and commands. The second form makes it easy to construct multi-line switch commands, since the braces around the whole list make it unnecessary to include a backslash at the end of each line. Since the pattern arguments are in braces in the second form, no command or variable substitutions are performed on them; this makes the behaviour of the second form different than the first form in some cases.

If a body is specified as - it means that the body for the next pattern should also be used as the body for this pattern (if the next pattern also has a body of - then the body after that is used, and so on). This feature makes it possible to share a single body among several patterns.

Below are some examples of switch commands:

will return 2,

will return 1, and

will return 3.

tailcall cmd ?arg...?

The tailcall command provides an optimised way of invoking a command whilst replacing the current call frame. This is similar to exec in Bourne Shell.

The following are identical except the first immediately replaces the current call frame.

tailcall is useful as a dispatch mechanism:

tell fileId

fileId tell

Returns a decimal string giving the current access position in fileId.

fileId must have been the return value from a previous call to open, or it may be stdin, stdout, or stderr to refer to one of the standard I/O channels.

throw code ?msg?

This command throws an exception (return) code along with an optional message. This command is mostly for convenient usage with try.

The command throw break is equivalent to break. The command throw 20 message can be caught with an on 20 ... clause to try.

time command ?count?

This command will call the Tcl interpreter count times to execute command (or once if count isn’t specified). It will then return a string of the form

which indicates the average amount of time required per iteration, in microseconds.

Time is measured in elapsed time, not CPU time.

try ?catchopts? tryscript ?on returncodes {?resultvar? ?optsvar?} handlerscript ...? ?finally finalscript?

The try command is provided as a convenience for exception handling.

This interpeter first evaluates tryscript under the effect of the catch options catchopts (e.g. -signal -noexit --, see catch).

It then evaluates the script for the first matching on handler (there many be zero or more) based on the return code from the try section. For example a normal JIM_ERR error will be matched by an on error handler.

Finally, any finalscript is evaluated.

The result of this command is the result of tryscript, except in the case where an exception occurs in a matching on handler script or the finally script, in which case the result is this new exception.

The specified returncodes is a list of return codes either as names (ok, error, break, etc.) or as integers.

If resultvar and optsvar are specified, they are set as for catch before evaluating the matching handler.

For example:

If break, continue or error are raised, they are dealt with by the matching handler.

In any case, the file will be closed via the finally clause.

See also throw, catch, return, error.

unknown cmdName ?arg arg …?

This command doesn’t actually exist as part of Tcl, but Tcl will invoke it if it does exist.

If the Tcl interpreter encounters a command name for which there is not a defined command, then Tcl checks for the existence of a command named unknown.

If there is no such command, then the interpreter returns an error.

If the unknown command exists, then it is invoked with arguments consisting of the fully-substituted name and arguments for the original non-existent command.

The unknown command typically does things like searching through library directories for a command procedure with the name cmdName, or expanding abbreviated command names to full-length, or automatically executing unknown commands as UNIX sub-processes.

In some cases (such as expanding abbreviations) unknown will change the original command slightly and then (re-)execute it. The result of the unknown command is used as the result for the original non-existent command.

unset ?-nocomplain? ?--? ?name name …?

Remove variables. Each name is a variable name, specified in any of the ways acceptable to the set command.

If a name refers to an element of an array, then that element is removed without affecting the rest of the array.

If a name consists of an array name with no parenthesized index, then the entire array is deleted.

The unset command returns an empty string as result.

An error occurs if any of the variables doesn’t exist, unless -nocomplain is specified. The -- argument may be specified to stop option processing in case the variable name may be -nocomplain.

upcall command ?args …?

May be used from within a proc defined as local proc in order to call the previous, hidden version of the same command.

If there is no previous definition of the command, an error is returned.

uplevel ?level? command ?command …?

All of the command arguments are concatenated as if they had been passed to concat; the result is then evaluated in the variable context indicated by level. uplevel returns the result of that evaluation. If level is an integer, then it gives a distance (up the procedure calling stack) to move before executing the command. If level consists of # followed by a number then the number gives an absolute level number. If level is omitted then it defaults to 1. level cannot be defaulted if the first command argument starts with a digit or #.

For example, suppose that procedure a was invoked from top-level, and that it called b, and that b called c. Suppose that c invokes the uplevel command. If level is 1 or #2 or omitted, then the command will be executed in the variable context of b. If level is 2 or #1 then the command will be executed in the variable context of a.

If level is 3 or #0 then the command will be executed at top-level (only global variables will be visible). The uplevel command causes the invoking procedure to disappear from the procedure calling stack while the command is being executed. In the above example, suppose c invokes the command

where d is another Tcl procedure. The set command will modify the variable x in b’s context, and 'd will execute at level 3, as if called from b. If it in turn executes the command

then the set command will modify the same variable x in b’s context: the procedure 'c does not appear to be on the call stack when d is executing. The command info level may be used to obtain the level of the current procedure.

uplevel makes it possible to implement new control constructs as Tcl procedures (for example, uplevel could be used to implement the while construct as a Tcl procedure).

upvar ?level? otherVar myVar ?otherVar myVar …?

This command arranges for one or more local variables in the current procedure to refer to variables in an enclosing procedure call or to global variables.

level may have any of the forms permitted for the uplevel command, and may be omitted if the first letter of the first otherVar isn’t # or a digit (it defaults to 1).

For each otherVar argument, upvar makes the variable by that name in the procedure frame given by level (or at global level, if level is #0) accessible in the current procedure by the name given in the corresponding myVar argument.

The variable named by otherVar need not exist at the time of the call; it will be created the first time myVar is referenced, just like an ordinary variable.

upvar may only be invoked from within procedures.

upvar returns an empty string.

The upvar command simplifies the implementation of call-by-name procedure calling and also makes it easier to build new control constructs as Tcl procedures. For example, consider the following procedure:

add2 is invoked with an argument giving the name of a variable, and it adds two to the value of that variable. Although add2 could have been implemented using uplevel instead of upvar, upvar makes it simpler for add2 to access the variable in the caller’s procedure frame.

while test body

The while command evaluates test as an expression (in the same way that expr evaluates its argument). The value of the expression must be numeric; if it is non-zero then body is executed by passing it to the Tcl interpreter.

Once body has been executed then test is evaluated again, and the process repeats until eventually test evaluates to a zero numeric value. continue commands may be executed inside body to terminate the current iteration of the loop, and break commands may be executed inside body to cause immediate termination of the while command.

The while command always returns an empty string.

The following commands allow a script to be invoked when the given condition occurs. If no script is given, returns the current script. If the given script is the empty, the handler is removed.

For compatibility with Tcl, these may be prefixed with fileevent. e.g.

Time-based execution is also available via the eventloop API.

Scripts are executed at the global scope. If an error occurs during a handler script, an attempt is made to call (the user-defined command) bgerror with the details of the error. If the bgerror commands does not exist, it is printed to stderr instead.

If a file event handler script generates an error, the handler is automatically removed to prevent infinite errors. (A time event handler is always removed after execution).

Various socket types may be created.

This command creates a socket connected (client) or bound (server) to the given address.

The returned value is channel and may generally be used with the various file I/O commands (gets, puts, read, etc.), either as object-based syntax or Tcl-compatible syntax.

Server sockets, however support only accept, which is most useful in conjunction with the EVENTLOOP API.

The address, addr, can be given in one of the following forms:

Note that on many systems, listening on an IPv6 address such as [::] will also accept requests via IPv4.

Where a hostname is specified, the first returned address is used which matches the socket type is used.

The special type pipe isn’t really a socket.

syslog ?options? ?priority? message

This command sends message to system syslog facility with given priority. Valid priorities are:

If a message is specified, but no priority is specified, then a priority of info is used.

By default, facility user is used and the value of global tcl variable argv0 is used as ident string. However, any of the following options may be specified before priority to control these parameters:

The optional pack extension provides commands to encode and decode binary strings.