You can use scripts to automate PowerTerm tasks. Scripts are written in Power Script Language (PSL) and are saved with a .PSL extension.

For example, you can create a script to login to PowerTerm, execute a file, display a message and so on. Scripts can be run upon startup or during a PowerTerm session.

Power Script Language (PSL) is a special feature of PowerTerm which provides commands for creating scripts. These scripts can be used to automate tasks. For example, you can create a script to login to PowerTerm automatically. PSL is intended for users with programming skills.

PowerTerm provides several sample scripts designed for frequent tasks. The following table lists the sample scripts and their parameters:

Additional sample scripts are also included as part of PowerTerm.

A command consists of one or more fields separated by spaces or tabs. The first field is the name of a command, which may be either a built-in command or a procedure consisting of a sequence of PSL commands. Newline characters are used as command separators, and semicolons may be used to separate commands on the same line. Each PSL command returns either a string result, or an empty string.

PSL has four additional syntactic constructs:

Curly braces are used to group complex arguments. They act as nestable quote characters. If the first character of an argument is an open brace, then the argument is not terminated by white space. Instead, it is terminated by the matching close brace. The argument passed to the command consists of everything between the braces, with the enclosing braces stripped off.

For example:

The variable host will receive one argument:

"vms unix {aix hp sun} aos".

This particular command will set the variable host to the specified string.

If an argument is enclosed in braces, then none of the other substitutions described below is made on the argument. One of the most common uses of braces is to specify a PSL sub-program as an argument to a PSL command.

Square brackets are used to invoke command substitution. If an open bracket appears in an argument, then everything from the open bracket up to the matching close bracket is treated as a command and executed recursively by PSL. The result of the command is then substituted into the argument in place of the bracketed string.

For example, the format command:

does print-like formatting (from the C language) and returns the string "Data is 99 bytes long", which is then assigned to the variable msg.

The dollar sign is used for variable substitution. If the dollar sign appears in an argument, then the following characters are treated as a variable name; and the contents of the variable are substituted into the argument in place of the dollar sign and name.

For example:

num = 99

msg = [format {Data is %s bytes long} $num]

The result is the same as the single command in the previous example.

The following are examples of common functions for the dollar sign in Power Script Language:

The backslash character may be used to insert special characters into arguments, such as curly braces or nonprinting characters.

Such special characters include the following:

[ ] { } $ t b r m

\xFF will send the hex code FF (where F can be any hex character: 0-9, A-F).

For example:

send \x1B\[m

This command will send the three characters: escape, [ and m.

PSL uses only one type of data: strings. All commands, arguments to commands, results returned by commands and variable values are ASCII strings.

Although everything in PSL is a string, many commands expect their string arguments to have particular formats. There are three particularly common formats for strings:

A list is just a string containing one or more fields separated by white space, similar to a command. Curly braces may be used to enclose complex list elements. These complex list elements are often lists in their own right.

For example:

{vms unix {aix hp sun} aos}

This is a list with four elements, the third of which is a list with three elements.

PSL provides commands for a number of list-manipulation operations, such as creating lists, extracting elements and computing list lengths.

The second common form for a string is a numeric expression. PSL expressions have the same operators and rules of precedence as expressions in the C language.

The expr PSL command evaluates a string as an expression and returns the result (as a string, of course).

For example:

expr {($x < $y) || ($z != 0)}

Returns "1'' if the numeric value of variable x is less than that of variable y, or if variable z is not zero; otherwise it returns "0''. Several other commands, such as if and for, expect one or more of their arguments to be expressions.

The third common interpretation of strings is as commands (or sequences of commands). Arguments of this form are used in PSL commands that implement control structures.

For example:

if {$x < $y} {

swap = $x

x = $y

y = $swap

}

The if command receives two arguments here, each of which is delimited by curly braces. if is a built-in command that evaluates its first argument as an expression; if the result is non-zero, it executes its second argument as a PSL command. This particular command swaps the values of the variables x and y if x is less than y.

PSL also allows users to define command procedures written in the PSL language. The proc built-in command is used to create a PSL procedures (PSLproc).

For example:

proc factorial x {

if {$x == 1} {return 1}

return [expr {$x * [factorial [expr $x - 1]]}]

}

This PSL command defines a recursive factorial procedure. The proc command takes three arguments: a name for the new PSLproc, a list of variable names (in this case the list has only a single element, x), and a PSL command that comprises the body of the PSLproc. After this proc command has been executed, factorial may be invoked just like any other PSL command.

For example:

factorial 4

returns the string "24''.

In addition to the commands already mentioned, PSL provides commands for manipulating strings (comparison, matching and printf/scanf-like C language operations), commands for manipulating files and file names. The built-in PSL commands provide a simple but complete programming language.

varName = value

varName[index] = value

A variable containing a single value is a scalar variable and the majority of the time fits ones needs. Other times, it's convenient to assign more than one related value to a single variable. Then you can create an array variable that can contain a series of values. Array variables and scalar variables are declared in the same way, except that the declaration of an array variable uses parentheses [ ] following the variable name.

A host application may activate a script file or script commands via special escape sequences.

An example activating the message.psl script:

ESCP$smessage.pslESC\

An example activating the "message testing ; send end" commands:

ESCP$tmessage testing ; send endESC\

PowerTerm enables you to use the standard Microsoft DDE mechanism to communicate with other Windows applications. PowerTerm can be a DDE client application or a DDE server application.

The DDE server application waits for requests from DDE clients, and allows them to supply it with information or receive information.

For example:

A spreadsheet DDE server will let clients get data from cells and put data into cells of a file.

As a DDE server, PowerTerm uses the server name PTW with topic PSL. Any application can request it to execute commands and return the related return data.

A client application can access PowerTerm with the dde execute command or the dde request command and an item that is any valid PSL commands separated with ";".

The single DDE server PSL command is:

dde return value

After a dde request command is executed, the PowerTerm DDE server sends the value from the last dde return command executed in this request. If no dde return command executed, it returns an empty answer.

Examples for PowerTerm as a DDE server might be:

As a DDE client, PowerTerm performs one of several dde operations, depending on the option. The legal options are:

dde initiate applicationName topicName

Connects to the applicationName DDE server with topicName. Returns a conversation id for use with successive dde commands.

dde execute convId command

Executes a server command. Returns an empty string.

dde request convId item

Returns an item from the server.

dde poke convId item value

Changes an item of the server to the new value. Returns an empty string.

dde terminate convId

Terminates a DDE conversation with the server.

Returns a value according to the option.

Examples

1 Assigns three numbers on the emulation screen to array "cel"

for {i = 1} {$i < 4} {incr i} {

row = [expr $i + 3]

cel($i) = [screen-rect $row 10 $row 15]}

Initiates a DDE conversation with MicroSoft Excel file TEST.XLS.

conv = [dde initiate EXCEL TEST.XLS]

Pokes the three numbers to three cels in TEST.XLS.

for {i = 1} {$i < 4} {incr i} {dde poke $conv R1C$i $cel($i)}

Requests the sum of those numbers from a result cel in TEST.XLS.

sum = [dde request $conv "R2C1"]

Terminates the DDE conversation.

dde terminate $conv

Sends the result to the host application.

send $sum

2 Initiates a DDE conversation with another PowerTerm which is connected to another computer. Reads information from the screen (of the other host) and sends it to its own host.

conv = [dde initiate PTW PSL-B]

data = [dde request $conv {

dde return [screen 10 1 15 80]}]

dde execute $conv{send joe}

For an explanation of each DDE command, see PowerTerm's online help. To access the online help for DDE commands, select Contents from the Help menu and click the Index tab. Type dde and click Display.

PowerTerm enables you to create a script to run upon startup or at any time during a PowerTerm session.

PowerTerm enables you to edit an existing script (.PSL) file.

PowerTerm enables you to create a script by recording all the actions that you perform in the PowerTerm window. Actions can include selecting a menu option, typing an entry on the screen, making selections in a dialog box and so on.

PowerTerm enables you to run scripts, upon startup or during a PowerTerm session, to automate specific tasks.

Soft buttons are named by default from F1 to F12. If you have assigned a script to F1, left-clicking on the F1 button is equivalent to sending the script to the host.

Power Pad buttons are named by default from F1, F2, F3 and so on with a few default function names, such as Clear, Enter and Insert.
If you have assigned a script to the F1 button, left-clicking on the F1 button is equivalent to sending the script to the host. For more information, see the section Programming the Power Pad.

PowerTerm enables you to specify the name of a script to be run after communication is established. The name of the script file needs to be specified in the Script File text box in the Connect Dialog box. For more information, see the section Step 6: Connecting to a Host.

PowerTerm enables you to run a script (.PSL) file to automate tasks. For example, you can create a script to login to PowerTerm automatically.

PowerTerm enables you to run a script upon startup by creating a Windows shortcut to PowerTerm and the specific script file. This option enables you to automatically connect to a host using a PSL script. For more information, see Step 6: Connecting to a Host, page 84.

Or

In the Target area, position your cursor after the PSL script name, add a space and type the required parameters. Parameters should be separated by a space.

Example:

\PTW32\PTW32.EXE COMM.PSL 1 9600 xonxoff

PowerTerm enables you to run individual script commands which you have created.

Once you have recorded a script in memory, you can run it.

PowerTerm enables you to save a script from memory to a specific file.