 | |
| Paradigm | Multi-paradigm:event-driven,functional,imperative,object-oriented |
|---|---|
| Designed by | John Ousterhout |
| Developer | Tcl Core Team[1] |
| First appeared | 1988; 37 years ago (1988) |
| Stable release | |
| Typing discipline | Dynamic typing, everything is astring |
| License | BSD-style[3] |
| Filename extensions | .tcl, .tbc[4] |
| Website | www www |
| Majorimplementations | |
| ActiveTclAndrowish | |
| Dialects | |
| Jim,Eagle | |
| Influenced by | |
| AWK,Lisp | |
| Influenced | |
| PHP,[5]PowerShell,[6]Tea, TH1[7] | |
Tcl (pronounced "tickle" or "TCL";[8] originallyTool Command Language) is ahigh-level,general-purpose,interpreted,dynamic programming language. It was designed with the goal of being very simple but powerful.[9] Tcl casts everything into the mold of acommand, even programming constructs like variable assignment and procedure definition.[10] Tcl supports multipleprogramming paradigms, includingobject-oriented,imperative,functional, andprocedural styles.
It is commonly used embedded intoC applications,[11] forrapid prototyping, scripted applications, GUIs, and testing.[12] Tcl interpreters are available for manyoperating systems, allowing Tcl code to run on a wide variety of systems. Because Tcl is a very compact language, it is used onembedded systems platforms, both in its full form and in several other small-footprint versions.[13]
The popular combination of Tcl with theTk extension is referred to asTcl/Tk (pronounced "tickle teak"[citation needed] or "tickle TK") and enables building agraphical user interface (GUI) natively in Tcl. Tcl/Tk is included in the standardPython installation in the form ofTkinter.
The Tcl programming language was created in the spring of 1988 byJohn Ousterhout while he was working at theUniversity of California, Berkeley.[14][15] Originally "born out of frustration",[11] according to the author, with programmers devising their own languages for extendingelectronic design automation (EDA) software and, more specifically, theVLSI design toolMagic, which was a professional focus for John at the time.[16] Later Tcl gained acceptance on its own. Ousterhout was awarded theACM Software System Award in 1997 for Tcl/Tk.[17]
The name originally comes from "Tool Command Language", but is conventionally writtenTcl rather thanTCL.[18]
| Date | Event |
|---|---|
| January 1990 | Tcl announced beyond Berkeley (WinterUSENIX). |
| June 1990 | Expect announced (Summer USENIX). |
| January 1991 | First announcement ofTk (Winter USENIX). |
| June 1993 | First Tcl/Tk conference (Berkeley). [table] geometry manager (forerunner of [grid]),[incr Tcl], TclDP and Groupkit, announced there. |
| August 1997 | Tcl 8.0 introduced a bytecode compiler.[19] |
| April 1999 | Tcl 8.1 introduces fullUnicode support[20] and advancedregular expressions.[21] |
| August 1999 | Tcl 8.2 introduces Tcl Extension Architecture (TEA)[22] |
| August 2000 | Tcl Core Team formed, moving Tcl to a more community-oriented development model.[1] |
| September 2002 | Ninth Tcl/Tk conference (Vancouver). Announcement of starkit packaging system. Tcl 8.4.0 released.[23] |
| December 2007 | Tcl 8.5 added new datatypes, a new extension repository,bignums,[24]lambdas.[25][26] |
| December 2012 | Tcl 8.6 added built-in dynamic object system, TclOO, and stackless evaluation.[27] |
| September 2024 | Tcl 9.0 added 64-bit capabilities, support for the full Unicode code point range, usesepoll &kqueue[28] |
Tcl conferences and workshops are held in both the United States and Europe.[29] Several corporations, includingFlightAware[30] use Tcl as part of their products.
Tcl's features include
uplevel andupvar allowing procs to interact with the enclosing functions' scopes.Safe-Tcl is a subset of Tcl that has restricted features so that Tcl scripts cannot harm their hosting machine or application.[33] File system access is limited and arbitrary system commands are prevented from execution. It uses a dual interpreter model with the untrusted interpreter running code in an untrusted script. It was designed byNathaniel Borenstein andMarshall Rose to include active messages in e-mail. Safe-Tcl can be included in e-mail when theapplication/safe-tcl andmultipart/enabled-mail are supported. The functionality of Safe-Tcl has since been incorporated as part of the standard Tcl/Tk releases.[34][35]
The syntax and semantics of Tcl are covered by twelve rules[36] known as the Dodekalogue.[37]
A Tcl script consists of a series of command invocations. A command invocation is a list of words separated by whitespace and terminated by anewline or semicolon. The first word is the name of a command, which may be built into the language, found in an availablelibrary, or defined in the script itself. The subsequent words serve as arguments to the command:
commandName argument1 argument2 ... argumentN
The following example uses theputs (short for "put string") command to display a string of text on the host console:
puts"Hello, World!"
This sends the string "Hello, World!" to thestandard output device along with an appended newline character.
Variables and the results of other commands can be substituted into strings, such as in this example which uses theset andexpr commands to store the result of a calculation in a variable (note that Tcl does not use= as an assignment operator), and then usesputs to print the result together with some explanatory text:
# expr evaluates text string as an expressionsetsum[expr1+2+3+4+5]puts"The sum of the numbers 1..5 is $sum."
The# character introduces acomment. Comments can appear anywhere the interpreter is expecting a command name.
# with curly braces, variable substitution is performed by exprsetx1setsum[expr{$x+2+3+4+5}];# $x is not substituted before passing the parameter to expr;# expr substitutes 1 for $x while evaluating the expressionputs"The sum of the numbers 1..5 is $sum.";# sum is 15
# without curly braces, variable substitution occurs at the definition site (lexical scoping)setx2setop*sety3setres[expr$x$op$y];# $x, $op, and $y are substituted, and the expression is evaluated to 6puts"$x $op $y is $res.";# $x, $op, $y, and $res are substituted and evaluated as strings
As seen in these examples, there is one basic construct in the language: the command. Quoting mechanisms and substitution rules determine how the arguments to each command are processed.
One special substitution occursbefore the parsing of any commands or arguments. If the final character on a line (i.e., immediately before a newline) is a backslash, then the backslash-newline combination (and any spaces or tabs immediately following the newline) are replaced by a single space. This provides aline continuation mechanism, whereby long lines in the source code can be wrapped to the next line for the convenience of readers.
Continuing with normal argument processing, a word that begins with a double-quote character (") extends to the next double-quote character. Such a word can thus contain whitespace and semicolons without those characters being interpreted as having any special meaning (i.e., they are treated as normal text characters). A word that begins with an opening curly-brace character ({) extends to the next closing curly-brace character (}). Inside curly braces all forms of substitution are suppressed except the previously mentioned backslash-newline elimination. Words not enclosed in either construct are known as bare words.
In bare and double-quoted words, three types of substitution may occur:
[expr 1+2+3] is replaced by the result of evaluating the contained expression (in this case 6).$foo is replaced by the contents of the variable called "foo". The variable name may be surrounded by curly braces to separate it from subsequent text in otherwise ambiguous cases (e.g.,${foo}ing).\n is replaced by a newline.Substitution proceeds left-to-right in a single scan through each word. Any substituted text will not be scanned again for possible further substitutions. However, any number of substitutions can appear in a single word.
From Tcl 8.5 onwards, any word may be prefixed by{*}, which causes the word to be split apart into its constituent sub-words for the purposes of building the command invocation (similar to the,@ sequence ofLisp's quasiquote feature).
As a consequence of these rules, the result of any command may be used as an argument to any other command. Note that, unlike inUnix command shells, Tcl does not reparse any string unless explicitly directed to do so, which makes interactive use more cumbersome, but scripted use more predictable (e.g., the presence of spaces in filenames does not cause difficulties).
The single equality sign (=) serves no special role in the language at all. The double equality sign (==) is the test for equality which is used in expression contexts such as theexpr command and in the first argument toif. (Both commands are part of the standard library; they have no special place in the library and can be replaced if desired.)
The majority of Tcl commands, especially in the standard library, arevariadic, and theproc (the constructor for scripted command procedures) allows one to define default values for unspecified arguments and a catch-all argument to allow the code to process arbitrary numbers of arguments.
Tcl is not statically typed: each variable may contain integers, floats, strings, lists, command names, dictionaries, or any other value; values are reinterpreted (subject to syntactic constraints) as other types on demand. However, values areimmutable and operations that appear to change them actually just return a new value instead.
The most important commands that refer to program execution and data operations are:
set writes a new value to a variable (creates a variable if did not exist). If used only with one argument, it returns the value of the given variable (it must exist in this case).proc defines a new command, whose execution results in executing a given Tcl script, written as a set of commands.return can be used to immediately return control to the caller.The usual execution control commands are:
if executes given script body (second argument), if the condition (first argument) is satisfied. It can be followed by additional arguments starting fromelseif with the alternative condition and body, orelse with the complementary block.while repeats executing given script body, as long as the condition (first argument) remains satisfiedforeach executes given body where the control variable is assigned list elements one by one.for shortcut for initializing the control variable, condition (as inwhile) and the additional "next iteration" statement (command executed after executing the body)Those above looping commands can be additionally controlled by the following commands:
break interrupts the body execution and returns from the looping commandcontinue interrupts the body execution, but the control is still given back to the looping command. Forwhile it means to loop again, forfor andforeach, pick up the next iteration.return interrupts the execution of the current body no matter how deep inside a procedure, until reaching the procedure boundary, and returns given value to the caller.expr passes the argument to a separate expression interpreter and returns the evaluated value. Note that the same interpreter is used also for "conditional" expression forif and looping commands.list creates alist comprising all the arguments, or an empty string if no argument is specified. Thelindex command may be used on the result to re-extract the original arguments.array manipulatesarray variables.dict manipulatesdictionary (since 8.5), which are lists with an even number of elements where every two elements are interpreted as a key/value pair.regexp matches a regular expression against a string.regsub Performs substitutions based on regular expression pattern matching.uplevel is acommand that allows a command script to be executed in ascope other than the current innermost scope on the stack.upvar creates a link to variable in a different stack frame.namespace lets you create, access, and destroy separate contexts for commands and variables.apply applies an anonymous function (since 8.5).coroutine,yield, andyieldto create and produce values fromcoroutines (since 8.6).try lets you trap and process errors and exceptions.catch lets you trap exceptional returns.zlib provides access to the compression and checksumming facilities of the Zlib library (since 8.6).uplevel allows a command script to be executed in ascope other than the current innermost scope on the stack. Because the command script may itself call procedures that use theuplevel command, this has the net effect of transforming thecall stack into a call tree.[38]
It was originally implemented to permit Tcl procedures to reimplement built-in commands (likefor,if orwhile) and still have the ability to manipulate localvariables. For example, the following Tcl script is a reimplementation of thefor command (omittingexception handling):
procfor{initCmdtestExpradvanceCmdbodyScript}{uplevel1$initCmdsettestCmd[listexpr$testExpr]while{[uplevel1$testCmd]}{uplevel1$bodyScriptuplevel1$advanceCmd}}
upvar arranges for one or morelocal variables in the current procedure to refer to variables in an enclosing procedure call or toglobal variables. 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.[39]
A decr command that works like the built-inincr command except it subtracts the value from the variable instead of adding it:
procdecr{varName{decrement1}}{upvar1$varNamevarincrvar[expr{-$decrement}]}
Tcl 8.6 added a built-in dynamic object system, TclOO, in 2012.[31] It includes features such as:
oo::classcreatefruit{methodeat{}{puts"yummy!"}}oo::classcreatebanana{superclassfruitconstructor{}{myvariablepeeledsetpeeled0}methodpeel{}{myvariablepeeledsetpeeled1puts"skin now off"}methodedible?{}{myvariablepeeledreturn$peeled}methodeat{}{if{![myedible?]}{mypeel}next}}setb[banananew]$beat→prints"skin now off"and"yummy!"fruitdestroy$beat→error"unknown command"
Tcl did not haveobject oriented (OO) syntax until 2012,[31] so various extension packages emerged to enable object-oriented programming. They are widespread in existing Tcl source code. Popular extensions include:
TclOO was not only added to build a strong object oriented system, but also to enable extension packages to build object oriented abstractions using it as a foundation. After the release of TclOO,incr Tcl was updated to use TclOO as its foundation.[27]
Tcl Web Server is a pure-Tcl implementation of an HTTP protocol server. It runs as a script on top of a vanilla Tcl interpreter.
Apache Rivet is an open source programming system forApache HTTP Server that allows developers to use Tcl as a scripting language for creating dynamic web applications. Rivet is similar toPHP,ASP, andJSP. Rivet was primarily developed by Damon Courtney, David Welton, Massimo Manghi, Harald Oehlmann andKarl Lehenbauer. Rivet can use any of the thousands of publicly available Tcl packages that offer countless features such as database interaction (Oracle, PostgreSQL, MySQL, SQLite, etc.), or interfaces to popular applications such as theGD Graphics Library.
Tcl interfaces natively with theC language.[40] This is because it was originally written to be a framework for providing a syntactic front-end to commands written in C, and all commands in the language (including things that might otherwise bekeywords, such asif orwhile) are implemented this way. Each command implementationfunction is passed an array of values that describe the (already substituted) arguments to the command, and is free to interpret those values as it sees fit.
Digitallogic simulators often include a Tcl scripting interface for simulatingVerilog,VHDL and SystemVeriloghardware languages.
Tools exist (e.g.SWIG,Ffidl) to automatically generate the necessary code to connect arbitrary C functions and the Tcl runtime, andCritcl does the reverse, allowing embedding of arbitrary C code inside a Tcl script and compiling it at runtime into aDLL.
The Tcl language has always allowed for extension packages, which provide additional functionality, such as a GUI, terminal-based application automation, database access, and so on. Commonly used extensions include:
| General | |||
|---|---|---|---|
| Software packages | |||
| Community | |||
| Organisations | |||
| Licenses |
| ||
| Challenges | |||
| Related topics | |||
