Tool_Command_Language资源-CSDN文库

需积分: 15 200 浏览量 2015-05-17 07:59:19 上传评论收藏 497KB PDF 举报

资源详情

资源评论

Bonus Chapter A

Tcl: Tool Command Language

In this chapter, we’ll take a look at an exciting development in the Linux world: an extensible, embeddable

programming language that is taking the community by storm. Tcl (pronounced tickle) has been

developed by John Ousterhout and others over a number of years and is now maintained by Scriptics

(http://www.scriptics.com). It has become a popular choice of programming language for a diverse range of

applications, ranging from fast prototype tools through extension languages to industrial control

applications. Tcl is also available on other platforms, including Microsoft Windows and Apple MacOS.

We’ll take a look at some of the key features of Tcl, including its extensibility and its use as the interactive

interface to new applications, and you’ll also see some of the extensions and applications that have been

created. Some of the things we’ll be covering in this chapter are

❑ Tcl commands and control structures

❑ Quoting and substitution

❑ Strings and lists in Tcl

❑ Input and output

❑ Tcl extensions and applications

A Tcl Overview

We begin our look at Tcl with the basics: how to write and execute Tcl programs and the features of the

language.

Our First Tcl Program

To see how Tcl programs are created and executed, let’s write a very simple “Hello World“ program,

hello.tcl. Here’s the source of such a program:

set s "Hello World"

puts $s

Tcl is an interpreted language, and Tcl programs are often referred to as scripts. In this respect, Tcl and the

UNIX shell have a lot in common. In fact, Tcl scripts need to be executed by a Tcl shell, called tclsh.

Let’s run our sample script using tclsh. Note that running a Tcl program this way requires only file read

permission.

$ tclsh hello.tcl

Hello World

As with other Linux command interpreters, we can run tclsh and it will prompt us for Tcl commands to

execute immediately. We could have just as well typed in the two lines directly:

$ tclsh

% set s "Hello World"

Hello World

% puts $s

Hello World

Notice that tclsh prompts with % and executes our commands as soon as they are typed. It keeps reading

lines until it gets a complete command. We can use the source command to make tclsh take commands

from a file. Let’s make Tcl read our program again:

% source hello.tcl

Hello World

% exit

The exit command causes the Tcl shell to end and returns us to the UNIX shell. We can turn our script

into a UNIX program by specifying which interpreter to use on the first line, just as we did for the UNIX

shell. Save the program in a file, hello2.tcl:

#!/usr/bin/tclsh

set s "Hello World - 2"

puts $s

Now, if we make this script executable, we can run it in the usual way. The location of the Tcl shell,

tclsh, may vary from system to system. In this case, it has been installed in /usr/bin.

Generally, you can use the whereis or which command to show where tclsh is

located within the search path.

$ chmod +x hello2.tcl

$ ./hello2.tcl

Hello World - 2

Tcl Commands

In general, all Tcl commands take the same form. They begin with a keyword and are followed by zero or

more arguments. A command is usually terminated by the end of the line, although you can use a

backslash (\) at the end of the line to extend a long command over multiple lines.

Quoting and variable substitution (to which we’ll come shortly) take place first. Then the resulting

command is executed. Some of these commands cause a result to be produced; others cause further

commands to be stored for later execution, such as when procedures are defined or loops are encountered.

Because of the fairly simple syntax, Tcl is easy to learn and simple to extend. However, it does mean that

some operations, such as assignment and calculations, can seem a little awkward at first.

You can place multiple Tcl commands on the same line if you separate them with semicolons.

In this chapter, when we look at the syntax of Tcl commands, we’ll use a notation like this:

command argument1 argument2 ?option1? ?option2? …

This means that the (fictitious) Tcl command, command, takes two mandatory arguments, plus some

optional arguments that may be used to change its behavior. You’ll find this type of syntax used in the

official Tcl/Tk documentation.

Variables and Values

Tcl deals essentially with strings and groups of strings. Most values can be dealt with as strings, and

where necessary, Tcl will automatically convert between types, for example to perform arithmetic on

numbers. To assign to a variable, creating the variable if necessary, we use the set command. You can

follow the rest of this section as a walk-through example in the Tcl shell.

$ tclsh

% set a 123

123

% set hello there

there

Variable names are case-sensitive and can be any length. Special characters (such as whitespace) in

variable names and values need to be quoted, which you do by enclosing the name or value in double

quotes. As in the UNIX shell, you need to take care with quoting. We’ll learn more about different quoting

methods in Tcl shortly.

% set "hello there" "fare well"

fare well

To examine the current value of a variable, use the set command again, but this time don’t give it a value

argument.

% set hello

there

% set "hello there"

fare well

When using Tcl interactively like this, the interpreter prints the result of each command. In the case of the

set command, we see the variable’s new value printed after an assignment, or the variable’s present

value if no new value is given. This is because the set command itself returns the current value of the

variable.

To use the value of a variable in another command, we prefix its name with a $, just as we do in the UNIX

shell. In our example program, we assigned a string to the variable s and then used it in the puts

command, which wrote it to the screen, by referring to it as $s. You can use braces to quote variable

names that contain spaces.

% puts $a

123

% puts [expr $a + $a]

246

% puts ${hello there}

fare well

To use the result of one command in another, we place the command in square brackets, as in the second

example above. This causes the Tcl interpreter to execute the command and return a result that is used in

its place. This is very like the way we use $(command) in the UNIX shell. In the same example, we use the

expr command, which evaluates a Tcl expression and returns the result.

We can also use braces for storing procedure bodies. We want any variable and command substitutions to

be performed when the procedure is executed, not when it is defined.

% set moe {Our fruits are orange: $orange, and pear: $pear}

Our fruits are orange: $orange, and pear: $pear

The difference between joe and moe is clear. The variable substitutions in moe have been prevented by

the braces.

When a group surrounded by braces is evaluated, the outermost set of braces is effectively removed. If

further evaluated, the resulting group will have substitutions performed. Braces can be nested. For

example:

% set fred 1234

1234

% set cmd1 [puts $fred]

1234

% set cmd2 {[puts $fred]}

[puts $fred]

% set cmd1

% set cmd2

[puts $fred]

The variable cmd1 takes a null value, the result of printing the variable fred. The variable cmd2 takes the

value of the command itself, not the result. Here, the braces prevent the evaluation of puts and the

expansion of $fred.

This can all seem quite confusing, so let’s look at what the Tcl shell is actually doing when it encounters

different types of quoting.

Tcl Interpreter Substitution

Tcl always performs a single round of substitutions. When a command is executed, the line is broken up

into a series of “words” by separating on white spaces (except new lines, which are command separators).

Anything contained by two double quotes "...", two square brackets [...], or two braces {...} is

viewed as a single “word.” Each “word” is then processed by the interpreter as follows:

❑ If the “word” starts with a $, Tcl performs variable substitution.

❑ If the “word” starts with an open square bracket ([), Tcl performs “command

substitution,” invoking the Tcl interpreter again and processing this “word” as a new

Tcl script. The results replace the original “word.”

❑ If the “word” starts with an open brace ({), everything within the “word” (minus the

opening and closing braces) is left as is. This includes white space, $, and so on.

❑ If the “word” contains a backslash \, Tcl performs “backslash substitution.”

So to summarize:

Word Substitution Result

variable value of a

[commands]

command result of interpreting commands

{the formatted

text}

none

the formatted text

剩余29页未读，继续阅读

评论收藏

内容反馈

Tool_Command_Language

评论0

最新资源

Tool_Command_Language

评论0

最新资源

相关推荐

Tool Command Language

TCL（Tool Command Language）入门教材

TCL (Tool Command Language) 教程

TCL 入门简介TCL (Tool Command Language)

UISpy .exe UIAutomation自动化测试工具

tcl中文教程

Tool_Command_Language.zip_tool_tool command langua

TCL (Tool Command Language) 环境配置

TCL（Tool Command Language）练习题及答案

TCL 培训 教程 华为 Tool Command Language

Language Tutor Tool-开源

The.Go.Programming.Language.0134190440.epub

oratcl45_win.zip/Tcl脚本实现连接Oracle数据库的资源包

Oracle Enterprise Manager 12c Command-Line Interface(Apress,2014)

A Multilingual Language Processing Tool for Uyghur Kazak and Kirghiz

Zebra Program Language Command Reference

Japanese Language Study Tool-开源

NETDRAW Batch Command Language

Tcl脚本测试入门.doc

Synopsys Design Compiler 概述

Learning TCL in 2 Hours

TCL中文教程

Tcl简介

CHA Command File Language

OpenSees Command Language Manual.pdf

NanoCL Command Language-开源

Structured Digital Command Language-开源

TCL 培训教程华为 Tool Command Language