![]() | |
Paradigm | Multi-paradigm: event-driven, functional, imperative, object-oriented |
---|---|
Designed by | John Ousterhout |
Developer | Tcl Core Team [1] |
First appeared | 1988 |
Stable release | |
Typing discipline | Dynamic typing, everything can be treated as a string |
License | BSD-style [3] |
Filename extensions | .tcl, .tbc [4] |
Website | www www |
Major implementations | |
ActiveTcl Androwish | |
Dialects | |
Jim, Eagle | |
Influenced by | |
AWK, Lisp | |
Influenced | |
PHP, [5] PowerShell, [6] Tea, TH1 [7] |
Tcl (pronounced "tickle" or as an initialism [8] ) is a high-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 a command, even programming constructs like variable assignment and procedure definition. [10] Tcl supports multiple programming paradigms, including object-oriented, imperative, functional, and procedural styles.
It is commonly used embedded into C applications, [11] for rapid prototyping, scripted applications, GUIs, and testing. [12] Tcl interpreters are available for many operating systems, allowing Tcl code to run on a wide variety of systems. Because Tcl is a very compact language, it is used on embedded systems platforms, both in its full form and in several other small-footprint versions. [13]
The popular combination of Tcl with the Tk extension is referred to as Tcl/Tk (pronounced "tickle teak" or as an initialism) and enables building a graphical user interface (GUI) natively in Tcl. Tcl/Tk is included in the standard Python installation in the form of Tkinter.
The Tcl programming language was created in the spring of 1988 by John Ousterhout while he was working at the University of California, Berkeley. [14] [15] Originally "born out of frustration", [11] according to the author, with programmers devising their own languages for extending electronic design automation (EDA) software and, more specifically, the VLSI design tool Magic, which was a professional focus for John at the time. [16] Later Tcl gained acceptance on its own. Ousterhout was awarded the ACM Software System Award in 1997 for Tcl/Tk. [17]
The name originally comes from Tool Command Language, but is conventionally written Tcl rather than TCL. [18]
Date | Event |
---|---|
January 1990 | Tcl announced beyond Berkeley (Winter USENIX). |
June 1990 | Expect announced (Summer USENIX). |
January 1991 | First announcement of Tk (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 full Unicode support [20] and advanced regular 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] |
Tcl conferences and workshops are held in both the United States and Europe. [28]
Tcl's features include
uplevel
and upvar
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. [31] 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 by Nathaniel Borenstein and Marshall Rose to include active messages in e-mail. Safe-Tcl can be included in e-mail when the application/safe-tcl and multipart/enabled-mail are supported. The functionality of Safe-Tcl has since been incorporated as part of the standard Tcl/Tk releases. [32] [33]
The syntax and semantics of Tcl are covered by twelve rules [34] known as the Dodekalogue. [35]
A Tcl script consists of a series of command invocations. A command invocation is a list of words separated by whitespace and terminated by a newline or semicolon. The first word is the name of a command, which may be built into the language, found in an available library, or defined in the script itself. The subsequent words serve as arguments to the command:
commandName argument1 argument2 ... argumentN
The following example uses the puts (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 the standard 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 the set and expr commands to store the result of a calculation in a variable (note that Tcl does not use =
as an assignment operator), and then uses puts 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 a comment. 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 occurs before 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 a line 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 of Lisp'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 in Unix 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 the expr
command and in the first argument to if
. (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, are variadic, and the proc
(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 are immutable 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 from elseif
with the alternative condition and body, or else
with the complementary block. while
repeats executing given script body, as long as the condition (first argument) remains satisfied foreach
executes given body where the control variable is assigned list elements one by one.for
shortcut for initializing the control variable, condition (as in while
) 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. For while
it means to loop again, for for
and foreach
, 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 for if
and looping commands.list
creates a list comprising all the arguments, or an empty string if no argument is specified. The lindex
command may be used on the result to re-extract the original arguments.array
manipulates array variables.dict
manipulates dictionary (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 a command that allows a command script to be executed in a scope 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
, and yieldto
create and produce values from coroutines (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 a scope other than the current innermost scope on the stack. Because the command script may itself call procedures that use the uplevel command, this has the net effect of transforming the call stack into a call tree. [36]
It was originally implemented to permit Tcl procedures to reimplement built-in commands (like for, if or while) and still have the ability to manipulate local variables. For example, the following Tcl script is a reimplementation of the for command (omitting exception handling):
procfor{initCmdtestExpradvanceCmdbodyScript}{uplevel1$initCmdsettestCmd[listexpr$testExpr]while{[uplevel1$testCmd]}{uplevel1$bodyScriptuplevel1$advanceCmd}}
upvar
arranges for one or more local variables in the current procedure to refer to variables in an enclosing procedure call or to global 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. [37]
A decr command that works like the built-in incr
command except it subtracts the value from the variable instead of adding it:
procdecr{varName{decrement1}}{upvar1$varNamevar incrvar[expr{-$decrement}]}
Tcl 8.6 added a built-in dynamic object system, TclOO, in 2012. [29] It includes features such as:
oo::classcreatefruit{methodeat{}{puts"yummy!"}}oo::classcreatebanana{superclassfruit constructor{}{myvariablepeeled setpeeled0}methodpeel{}{myvariablepeeled setpeeled1puts"skin now off"}methodedible?{}{myvariablepeeled return$peeled}methodeat{}{if{![myedible?]}{mypeel }next}}setb[banananew]$beat→prints"skin now off"and"yummy!"fruitdestroy $beat→error"unknown command"
Tcl did not have object oriented (OO) syntax until 2012, [29] 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 for Apache HTTP Server that allows developers to use Tcl as a scripting language for creating dynamic web applications. Rivet is similar to PHP, ASP, and JSP. Rivet was primarily developed by Damon Courtney, David Welton, Massimo Manghi, Harald Oehlmann and Karl 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 the GD Graphics Library.
Tcl interfaces natively with the C language. [38] 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 be keywords, such as if
or while
) are implemented this way. Each command implementation function 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.
Digital logic simulators often include a Tcl scripting interface for simulating Verilog, VHDL and SystemVerilog hardware languages.
Tools exist (e.g. SWIG, Ffidl) to automatically generate the necessary code to connect arbitrary C functions and the Tcl runtime, and Critcl does the reverse, allowing embedding of arbitrary C code inside a Tcl script and compiling it at runtime into a DLL.
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:
AWK is a domain-specific language designed for text processing and typically used as a data extraction and reporting tool. Like sed and grep, it is a filter, and is a standard feature of most Unix-like operating systems.
Rebol is a cross-platform data exchange language and a multi-paradigm dynamic programming language designed by Carl Sassenrath for network communications and distributed computing. It introduces the concept of dialecting: small, optimized, domain-specific languages for code and data, which is also the most notable property of the language according to its designer Carl Sassenrath:
Although it can be used for programming, writing functions, and performing processes, its greatest strength is the ability to easily create domain-specific languages or dialects
Scheme is a dialect of the Lisp family of programming languages. Scheme was created during the 1970s at the MIT Computer Science and Artificial Intelligence Laboratory and released by its developers, Guy L. Steele and Gerald Jay Sussman, via a series of memos now known as the Lambda Papers. It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations. It had a significant influence on the effort that led to the development of Common Lisp.
A shell script is a computer program designed to be run by a Unix shell, a command-line interpreter. The various dialects of shell scripts are considered to be scripting languages. Typical operations performed by shell scripts include file manipulation, program execution, and printing text. A script which sets up the environment, runs the program, and does any necessary cleanup or logging, is called a wrapper.
The Microsoft Windows Script Host (WSH) is an automation technology for Microsoft Windows operating systems that provides scripting abilities comparable to batch files, but with a wider range of supported features. This tool was first provided on Windows 95 after Build 950a on the installation discs as an optional installation configurable and installable by means of the Control Panel, and then a standard component of Windows 98 and subsequent and Windows NT 4.0 Build 1381 and by means of Service Pack 4. The WSH is also a means of automation for Internet Explorer via the installed WSH engines from IE Version 3.0 onwards; at this time VBScript became means of automation for Microsoft Outlook 97. The WSH is also an optional install provided with a VBScript and JScript engine for Windows CE 3.0 and following and some third-party engines including Rexx and other forms of Basic are also available.
In computer science, conditionals are programming language commands for handling decisions. Specifically, conditionals perform different computations or actions depending on whether a programmer-defined Boolean condition evaluates to true or false. In terms of control flow, the decision is always achieved by selectively altering the control flow based on some condition . Although dynamic dispatch is not usually classified as a conditional construct, it is another way to select between alternatives at runtime. Conditional statements are the checkpoints in the programme that determines behaviour according to situation.
In computer programming, glob patterns specify sets of filenames with wildcard characters. For example, the Unix Bash shell command mv *.txttextfiles/
moves all files with names ending in .txt
from the current directory to the directory textfiles
. Here, *
is a wildcard and *.txt
is a glob pattern. The wildcard *
stands for "any string of any length including empty, but excluding the path separator characters ".
In some programming languages, eval
, short for the English evaluate, is a function which evaluates a string as though it were an expression in the language, and returns a result; in others, it executes multiple lines of code as though they had been included instead of the line including the eval
. The input to eval
is not necessarily a string; it may be structured representation of code, such as an abstract syntax tree, or of special type such as code
. The analog for a statement is exec, which executes a string as if it were a statement; in some languages, such as Python, both are present, while in other languages only one of either eval
or exec
is.
In computer programming, a one-liner program originally was textual input to the command line of an operating system shell that performed some function in just one line of input. In the present day, a one-liner can be
Expect is an extension to the Tcl scripting language written by Don Libes. The program automates interactions with programs that expose a text terminal interface. Expect, originally written in 1990 for the Unix platform, has since become available for Microsoft Windows and other systems.
GNU Ubiquitous Intelligent Language for Extensions is the preferred extension language system for the GNU Project and features an implementation of the programming language Scheme. Its first version was released in 1993. In addition to large parts of Scheme standards, Guile Scheme includes modularized extensions for many different programming tasks.
In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.
Coding conventions are a set of guidelines for a specific programming language that recommend programming style, practices, and methods for each aspect of a program written in that language. These conventions usually cover file organization, indentation, comments, declarations, statements, white space, naming conventions, programming practices, programming principles, programming rules of thumb, architectural best practices, etc. These are guidelines for software structural quality. Software programmers are highly recommended to follow these guidelines to help improve the readability of their source code and make software maintenance easier. Coding conventions are only applicable to the human maintainers and peer reviewers of a software project. Conventions may be formalized in a documented set of rules that an entire team or company follows, or may be as informal as the habitual coding practices of an individual. Coding conventions are not enforced by compilers.
incr Tcl is a set of object-oriented extensions for the Tcl programming language. It is widely used among the Tcl community, and is generally regarded as industrial strength. Its name is a pun on "C++". Itcl implementations exist as both a package that may be dynamically loaded by a Tcl application, as well as an independent standalone language with its own interpreter.
Tk is a cross-platform widget toolkit that provides a library of basic elements of GUI widgets for building a graphical user interface (GUI) in many programming languages. It is free and open-source software released under a BSD-style software license.
wish
is a Tcl interpreter extended with Tk commands, available for Unix-like operating systems supporting the X Window System, as well as macOS, Microsoft Windows, and Android. It provides developers the ability to create GUI widgets using the Tk toolkit and the Tcl programming language.
Rexx is a programming language that can be interpreted or compiled. It was developed at IBM by Mike Cowlishaw. It is a structured, high-level programming language designed for ease of learning and reading. Proprietary and open source Rexx interpreters exist for a wide range of computing platforms; compilers exist for IBM mainframe computers.
A command-line interface (CLI) is a means of interacting with a computer program by inputting lines of text called command-lines. Command-line interfaces emerged in the mid-1960s, on computer terminals, as an interactive and more user-friendly alternative to the non-interactive interface available with punched cards.
The structure of the Perl programming language encompasses both the syntactical rules of the language and the general ways in which programs are organized. Perl's design philosophy is expressed in the commonly cited motto "there's more than one way to do it". As a multi-paradigm, dynamically typed language, Perl allows a great degree of flexibility in program design. Perl also encourages modularization; this has been attributed to the component-based design structure of its Unix roots, and is responsible for the size of the CPAN archive, a community-maintained repository of more than 100,000 modules.