Skip to main content

AnzioWin Programming Notes

The AnzioWin API consists of 5 different interface techniques for automating AnzioWin, each with its own capabilities and reason for use. With these procedures you can control AnzioWin’s features in number of these different ways.

AnzioWin API Options

1. Macros (key remapping)
You can assign a set of commands or textual responses to a single character or a special key, much like remapping the keyboard.

2. Host-based Scripting
You can have a host program or host script issue commands for AnzioWin or commands through AnzioWin for the PC.

3. PC Script Running Anzio
A PC scripting language or programming language, such as Visual Basic, PerlScript or Java Script, can pass keystrokes to AnzioWin, forcing actions to take place.

4. Anzio Running A PC Script
You can issue commands through the Microsoft Script Control engine to control AnzioWin.

5. DDE
This is a limited programmers interface for DDE access to other applications.

Understanding the differences between these options, when to use each and what each can do for you, is the object of this paper.

Macros

Introduction

Macros represent the simplest method of adding user functionality to AnzioWin. Macros are text or special character strings associated with either a special key, such as the function keys, page up, page down, the arrow keys, control sequences, etc., or associated with a single keystroke.

Macros are stored in a similar manner as redefined (remapped) keys are. They are saved in the currently used key file and called in when AnzioWin is loaded.

The very first time you run AnzioWin for a new connection, AnzioWin will ask which terminal type you want to use. It will then load the appropriate key file for that terminal type. The path to the key file is then saved in the default file when you save your defaults. Each subsequent running of AnzioWin with that default file will load that key file, including your defined macros. Several terminal types have multiple key files available depending on the various keyboard layouts for those terminals. Or you can save your new macros into a new key file to load next time (be sure to also save your default file). Again this file will contain the appropriate terminal type definitions and your new macros.

When To Use

Macros are meant to provide a quick way of redefining what a key will send to the host (remapping a key) or a particular function to perform when a key is pressed. Macros cannot handle “case” statements and conditionals (if-else’s), it cannot manipulate text strings, it cannot handle external DLLs and it cannot read and write files (except as they pertain to basic file transfers).

How To

Building a macro in AnzioWin is identical to remapping a key. This is done from the “Function” line as a simple textual command. You access the Function line of AnzioWin by doing a

Ctrl-shift-f

You then enter the command using the “Define” statement

define <macro name> <macro command>

If you assign your macro to a special key that is already defined by the terminal type, this remapped key will overwrite what the default is. However if you assign the macro to a normal character, it does not overwrite that key. In order to run this macro, you would need to precede it by the necessary function, usually an alt-f1 or by “invoking” it from the Function line (more on this later).                                     

where “<macro name >” is a special key, such as F1 through F12, Home, etc., or a letter or number off the keyboard, such as L or H or 8 (special keys will show in reverse video on the Function line, i.e. f6) followed by a space and the command string. If you assign the macro name with a question mark, “?”, the previously defined macro string will be displayed for you to edit, i.e.

define <macro name>?

 

(no space after the macro name). The “macro command” can be any string of characters destined for the host or for the PC, including control and escape sequences, Anzio commands or host commands.

Special Characters

There are times when you may need to do special keystrokes within a command that are normally used for other editing. These are entered in special ways within a macro.

Ctrl-p<keystroke>                                                                 Special key prefix
Many times it is necessary to include certain key combinations that may otherwise be used by AnzioWin in it’s editing features, such as the escape key (ESC), the END key, etc. To include these as part of a macro, precede the key by a control-p. As an example, to include an escape, press Ctrl-p and then the escape key. A reverse video 1B will be displayed.

|                                                                                               Enter or newline
Wherever the vertical bar, “|”, appears, it is assumed that a return or enter needs to be performed. As an example, commands for AnzioWin need to not only be preceded by pressing the F6 function key, but the command must be followed by a return for it to be performed. So to send a command to start a file transfer, you would do
F6zsend \temp\test|

#                                                                                              Request user input
Sometimes you want to request user input from the user. You do this with the “#” symbol.

{…}                                                                                         Display local-only text
Text surrounded by curly brackets indicates that this text is to be displayed on the screen, but not actually sent to the host system. Local text may be used to do prompts for the user, or to show a status message locally. As an example, to request a users name, you may want to do

{Enter your name}#

{}                                                                                             Undefine a macro

Occasionally you will want to undefined a macro, stop it from doing the user-defined macro command. To do this, include curly brackets with nothing between.

Alt-xxx                                                                                    Alternate characters
By doing an alt, followed by a three digit number off of the numeric keypad, you can enter any alternate key sequence you wish, such as those not available through a normal key.

${<variable>}                                                                         Environment variables
AnzioWin has several variables that it carries, based on the environmentr it is working in. The can be passed to the host or used within an AnzioWin command, by preceding the variable by a dollar sign. Available environment variables are

ANZ_IP                                 The PC’s IP address
ANZ_USERNAME                  The default username
ANZ_PASSWORD                 The default password
ANZ_HOSTNAME                  The hostname you attached to
ANZ_LAST_RECD                 The name of the last file transferred
ANZ_TITLE                            The AnzioWin window title
ANZ_PROGRAM                   “ANZIOWIN” or “ANZIOLITE”
ANZ_WINDIR                        Windows default directory
ANZ_CURDIR                        Current working directory on the PC
ANZ_DOWNDIR                   Current download directory on the PC
ANZ_COMPUTERNAME     Windows computer name
ANZ_WINNAME                    Windows logged in username
ANZ_TCPNAME                   TCP/IP driver name
ANZ_LAST_LAUNCH           Name of the last program launched

Invoke <macro name>                                                           Invoke a macro
You can run a macro direct from the Function line by doing an “invoke <macro name>”, or by including the “invoke” within another macro (to run another macro from within the current one). Control is not returned to the user or to the initiating macro until this macro is complete.

Call <macro name>                                                                Call a macro
You can run a macro direct from the Function line by doing an “call <macro name>”, or by including the “call” within another macro (to run another macro from within the current one). Control is returned to the user or to the initiating macro immediately.

Reference Commands

See Appendix B for a list of commands. Not all commands are logical to be performed from a macro however. As an example, you would not want to change the connection method while you are attached to a host system.

Example

A macro to automatically log in on startup

Within AnzioWin, you can include a single character on the command line that will fire off as a startup macro. This is entered at the Function prompt (do a Ctrl-shift-f ).

define L f6waitfor ogin:|myloginname|f6waitfor assw|mypassword|f6waitfor erminal|wyse50|

This macro will wait for “ogin:”, then send the “myloginname” string. It then waits for “assw” before sending “mypassword”, it waits for “erminal” and then send the terminal type. You can then initiate this on startup by including it as part of the command line for your shortcut. Any single character on the command line is assumed to be a macro to run when AnzioWin starts up.

C:\anzio\anzio32.exe L

Host-based Scripting

Introduction

AnzioWin provides a way to control much of its functionality from the host end. By bracketing commands for AnzioWin within certain delimiters, you can control much of how AnzioWin works. The format is

Hex-1C<command>Hex-1D

By having your shell script or your application program send bracketed commands to the screen, you can control AnzioWin. This can be from a bash or ksh script, from C or C++, or from your database language, such as filePro or Oracle. In Appendix C we have also given numerous examples of using Perl to control many of AnzioWin’s features.

When To Use

When you have special needs from the host to control AnzioWin, you would use this approach. The advantage of doing host-end scripting is that you would NOT have to program a macro for every PC. Instead, you can make this global for all users.

How To

AnzioWin commands are sent from the host to the AnzioWin session by bracketing the command within specific delimiters. The format is

Hex-1C<command>Hex-1D

Depending on the shell you are using on the host, the steps to do this would look like:

printf "\034 <command> \035 "
echo "\034 <command> \035 "
echo -e "\034 <command> \035 "
echo "\\034 <command> \\035 "

Normally one of these, or some combination, will work with your shell.
Likewise to do this from an application, such as Perl, would require you send the string to the screen (standard out).

$begCMD = "\034"; # Start a command for Anzio
$endCMD = "\035"; # End a command for Anzio
print "$begCMD <command string> $endCMD";

Reference Commands

See Appendix B for more information. In brief, almost any AnzioWin command that you can access from the Function line can be sent from the host. However, some may not
make sense, such as changing the connection type or baud rate in the middle of a connection.

Examples

Have the host play a PC sound file

printf "\034receive quiet \035 " printf "\034playsound c:\windows\msremind.wav \035" printf "\034message Error on file grp343.dat on $HOSTNAME \035" printf "\034receive quiet off \035"

Passthrough print a file

printf " File To Print: $1 \n" printf "\034receive quiet\035" tput mc5 cat $1 tput mc4 printf "\034receive quiet off\035"

Send a file to the host via Zmodem

printf " Transfer File: $1 from c:\\\temp \n" printf "\034log c:\\\temp \035" printf "\034zsend -qa $1\035"

More examples are available at our web site. These procedures can easily be translated into shell script commands.

PC Script Running AnzioWin

Introduction

While AnzioWin does provide some basic DDE support (described below) there is really not too much one can do from an external PC program to control AnzioWin. However, we do have the capability of receiving “pushed” keystrokes from an external script or program.

When To Use

The most likely place where this is used is when you need to telnet from a PC application to a host system, capture some data or perform a set function, and then exit the telnet session.

PC scripting of AnzioWin is done by simply “pushing” keystrokes at it. This is not the most reliable method, and the script or program on the PC will not necessarily know whether responses from the host to AnzioWin are correct, but it works.

How To

From within a script, application or program, you can “push” keystrokes to AnzioWin The example here uses Windows Script Host, which includes a “SendKeys” routine.
You would start the Anzio script as follows:

wscript //e:vbscript anziocontrol.ws

In this example the script is a basic Windows Script Host script (see reference material on Windows Script Host) that starts an Anzio session and logs the user in. Your script might look something like this:

strAnzio = "anzio32"
strArg = " c:\anzio\host1.def"
strUser = “username”
strPasswd = “xxeee”
WshShell.Run strAnzio + strArg
WshShell.AppActivate("Anzio32")
WScript.Sleep 1000
WshShell.SendKeys strUser + vbLf
WScript.Sleep 1000
WshShell.SendKeys strPasswd + vbLf
WScript.Sleep 1000

So much of this script is based on timing that, while not necessarily reliable, it can usually be tweaked and made to work.

Reference Commands

Again, as with the other procedures for scripting AnzioWin, most any command that you can access from the Function line can be sent to AnzioWin. See Appendix B for more information.

Examples

A more complete example is below. This example starts AnzioWin with a default file for a particular host. It logs in the user, starts a transfer, waits, hoping it finishes in the allotted time, and then exits.

Set WshShell = WScript.CreateObject("WScript.Shell")
Set WshNetwork = WScript.CreateObject("WScript.Network")
Set WshFs = WScript.CreateObject("Scripting.FileSystemObject")
Set ObjArgs = WScript.Arguments
strAnzio = "anzio32"
strArg = "c:\anzio\host1.def"
strFile = "testfile"
strPath = "c:\temp\"
if ObjArgs.Count > 0 then
   strPasswd = objArgs.Item(0)
   if WshFs.FileExists(strPath + strFile) then
       WshFs.DeleteFile(strPath + strFile)
    end if
    WshShell.Run strAnzio + strArg
    WshShell.AppActivate("Anzio32")
    WScript.Sleep 1000
    WshShell.SendKeys
    WshNetwork.UserName + vbLf
    WScript.Sleep 1000
    WshShell.SendKeys strPasswd + vbLf
    WScript.Sleep 500
    WshShell.SendKeys "%TD" + strPath + "{enter}"
    WScript.Sleep 500
    WshShell.SendKeys vbLf + "sz " + strFile + "{enter}"
    WScript.Sleep 5000
    if WshFs.FileExists(strPath + strFile) then
       WshShell.SendKeys vbLf + "exit" + vbLf
    else
        MsgBox "File " + strPath + strFile + " did not transfer"
    end if
else
    MsgBox "No Password given"
end if

Sleep timers may have to be adjusted to make sure they are long enough.

AnzioWin Running A PC Script

Introduction

The latest versions of AnzioWin have the ability to run a more complex scripting language from within the AnzioWin program. This is done through the use of the Microsoft Script Engine Control and a script language such as Visual Basic Script, PerlScript, JavaScript or Windows Script Host.

When To Use

If you have the need for complex “case” statements, if-else, file manipulation, DLL’s , etc., the scripting capabilities of AnzioWin are for you. Everything from screen scraping to string manipulation, from database handling to interfacing with other applications, can be done through the AnzioWin Script command.

How It Works

From within AnzioWin, you can run various modules and procedures written in any of the script languages available and handle the returned data. To do this, the Microsoft Script Control components, the Microsoft Script Engine and the scripting language engine are all necessary.

There are various components that must be in place for this to all work smoothly, but the functionality is well worth the little effort to install these. At the writing of this document, all of these components are free, most are installed by Internet Explorer (version 4 or later), and Windows 2000 ships with some of them in place. However, we recommend you download the latest versions from Microsoft.

All of the needed components can be downloaded from the Microsoft Script Technologies page at the Microsoft web site. In most cases these packages or the most recent version, will already be installed and running on your PC.

The packages are:

Windows Script 5.5 or later

This is the current script engines and script components available from Microsoft. Included in the package is support for WSH (Windows Script Host), Visual Basic Script and Java Script. Additional third party script engines are available, i.e. PerlScript.

 

Microsoft Script Debugger

Debugging scripts can be painful, since they are edited in something like NotePad and run without a user interface. Microsoft has developed a free-standing script debugger that you can use with the Microsoft provided script engines from above (I have not tested it with 3rd party script engines) that does aid a little.

Microsoft Script Control

This is the ActiveX Control component required to make scripting available to other applications.

First off, AnzioWin interacts with the Script Control engine to start a script (using one of the Windows registered script engines) and runs a single routine at a time. A string argument can be sent to the script module and a command string returned from the script module. It is then up to the script module as to what the returned string does. AnzioWin runs it as if it were a command for it to take action on, either to send it to the host, run it as a command or perform a required function.

Second, AnzioWin will respond to a script controlling it in a basic way, by responding to keystrokes pushed at it. In fact if you have loaded the Microsoft script engine, you will be able to make this work on your current AnzioWin or Anzio Lite. See below for more information.

A new command has been added to AnzioWin to allow a script to run. This script can be built as part of an AnzioWin macro for startup or user initiation, or it can be a command either issued from a host script or ran manually from within AnzioWin.
The command in AnzioWin is "script" and is done as an AnzioWin function. You initiate this from the Function line or from within a macro (do a Ctrl-Shift-f to bring up the Function line).

The general format is:

script <filename> [E:<lang>] [M:<module>] [T:<timeout>] [<args>]

with defaults being "E:vbscript", "M:Main" (main), "T:0" (no timeout). Some examples:

script c:\anzio123\script\demo.vbs
script c:\anzio123\script\demo.vbs m:AnzioReturn
script c:\anzio123\script\demo.vbs m:HostReturn test argument

There are basically two types of modules (chunks of code) within a script, a Function or a Procedure. Either of these two optionally can be passed a string containing some argument. The difference between the two is that a Function will return some value to AnzioWin, while a Procedure will not. What AnzioWin does with a returned value is totally dependent on the content of the returned string. It comes in to AnzioWin as a command.

Since Visual Basic is easy to read and understand, these examples will focus on VBScript. You do need to watch your character case, some script engines are very case sensitive, as an example when giving the script module name in the script command, be sure to have the correct upper and lower case.

The following script is a small, one Procedure script you can type in via Notepad. Save it as demo1.vbs. In this example, the script simply displays the PC date in a message box:

Sub Main()
    Const TITLE = "AnzioWin Test"
    Dim MyDate
    GetDate MyDate
    Msgbox("Today is " & MyDate, vbInformation, TITLE
End Sub

Sub GetDate(X)
    X = CStr(Date())
End Sub

Within AnzioWin do the following command from the Function line (either example should work as the default procedure is "Main"):

Ctrl-Shift-f
script c:\anzio\demo1.vbs m:Main      OR
script c:\anzio\demo1.vbs

A one script Function example is below. This one accepts an argument from AnzioWin as well as returns a command to AnzioWin to change its Window Title.

Function AnzioReturn(X)
    Call Msgbox("I received " & X & " from Anzio.", vbInformation, TITLE)
    X = "title This Is The Test Title"
    AnzioReturn = X
End Function

Within AnzioWin do the following:

Ctrl-Shift-f
script c:\anzio\demo1.vbs m:AnzioReturn HI THERE!!!

See further examples below.

Reference Commands

From within these script modules, you can send most any AnzioWin command you wish (see Appendix B for more information). Likewise, you have access to the whole realm of the scripting language you are using. Also see Appendix A for a list of reference sources.

Examples

The one script below contains several Functions and Procedures that can be called at different times by AnzioWin.

Sub Main()
    Dim MyDate
    Select Case Msgbox("Hello! Do you want to know the Date ?", _ vbYesNo +
          vbQuestion, TITLE)
    Case vbYes
        GetDate MyDate
        If Msgbox("Today is " & MyDate & vbCrLf & "And also want to know the
             time ?" & _ vbCrLf & "Dont say no or I will Raise an Exception !!!", _
             vbYesNo + vbExclamation + vbDefaultButton2, TITLE) = vbYes
        then
            Msgbox "The time is " & GetTime(), vbInformation, TITLE
            Msgbox "See ya!!"
        else
            Err.Raise 1000, "Script Runner Demo", "Refuse to get time error :)"
        end If

    Case vbNo
        Call Msgbox("Bye!!", vbInformation, TITLE)

    End Select
End Sub

Sub GetDate(X)
    X = CStr(Date())
End Sub

Function GetTime()
    GetTime = CStr(Time())
End Function

Function MyGetDate(X)
    X = CStr(Date())
    Call Msgbox("Here is myGetDate Routine, Bye!!", vbInformation, TITLE)
    MyGetDate = X   ' return the X string
End Function

Function AnzioReturn(X)
    Call Msgbox("I received " & X & " from Anzio, thanks.", vbInformation,
            TITLE) X = InputBox("Please enter command to return to Anzio")
    AnzioReturn = X ' return the X string
End Function

Function HostReturn()
    HostReturn = "send """ & Cstr(Time()) & """"
End Function

Function HostReturn2()
    HostReturn2 = "send " & chr(34) & Cstr(Time()) & chr(34)
End Function

Note that the above example contains several modules. These modules can call each other or be standalone. When called from AnzioWin, a single module is accessed at a time, but any one of them can be called. As an example, to call the Function routine AnzioReturn, you would do

Ctrl-shift-f
script c:\anzio\demo.vbs m:AnzioReturn Test Argument #1

and this would return whatever command the user puts in the vbscript input box, i.e. if they entered "title AnzioWin Test Title", then AnzioWin would change its default window title.

DDE

Introduction

Dynamic Data Exchange (DDE) is a method of interprogram communications, whereby data and commands can be sent from a DDE client to a DDE server. AnzioWin can act as a DDE client, exchanging data with other DDE servers on your PC.

Through a series of calls, you can establish a communications session with a DDE server and either request data from the server or poke data to the server. You can also send the server commands to be carried out, much like a remote control for the application.

When To Use

Of course not all applications can support DDE for interprogram communications, however many office type applications can, such as WinFax Pro, Microsoft Word, Excel and Access.

If you have a specific need to paste data from the host into an application on the PC through AnzioWin, or if you have the need to grab data out of a spreadsheet or document and pass it to a host program, DDE should be a consideration.

How To

AnzioWin supports a series of commands to initiate a conversation, send and receive data and commands, and to terminate the conversation. While the body of these commands may vary greatly from application to application, these are sufficient to do just about anything you need – provided the PC application supports DDE. At this point, AnzioWin can have only one conversation going on at a time.

To hold a conversation with a DDE server application, you would follow these steps:

a) Initiate the conversation
b) Poke or request data and/or
c) Send commands
d) Terminate the conversation

Reference Commands

The following AnzioWin commands are normally done from within a macro or initiated from a script.

DDEInitiate <service> <topic>             Start a DDE conversation with a server
DDEPoke <item> <data>                     Send data to a specific “topic” on the server
DDERequest <item>                            Request specific data from the server
DDEExecute                                        <command string> Send commands to the server
DDETerminate                                     End the DDE conversation

DDEInitiate <service> <topic>
This begins a session with the server application.

• The <service> refers to the application name as advertised to Windows, i.e. Microsoft Excel is “excel”, Microsoft Word is “winword” and Microsoft Access is “msaccess”. Check the specific applications documentation.

• The <topic> is the subject item to be passed to the application, i.e. for opening a Word or Excel document, you would pass the name of the file. You can include the full path, or let the application look in its default directory. The topic will vary from application to application, so check their documentation.

AnzioWin will first see if the application is running. If not, it will try to start the application. If you receive an error message after this process, check to see that the file exists. If it does, then try manually starting the application and the document before doing the ddeinitiate.

A topic of “system” is a special call to the server to request information on the application. As an example, from within the “system” topic in Excel, you can request the following information (returned to Anzio as a string). Again refer to your applications documentation: DDERequest 'SysItems' DDERequest 'Formats' DDERequest 'Topics'

DDEPoke <item> <data>

The <item> refers to a reference for where you wish to put the <data>. Refer to your applications documentation. As an example, within Word you can specify an <item> of \endofdoc to place data at the end of the document, \startofdoc to place data at the beginning or <item> can be a specific bookmark within the document. In Excel, the <item> usually represents the cell to place the data in to, i.e. r4c4 for row 4 and column 4.

DDERequest <item>
The <item> is the reference point for the data you wish to grab. The data is returned as a string to AnzioWin. As an example, if you wish to retrieve the text of a Word document, you would enter an item of \doc for the whole document.

DDEExecute
This command allows you to send a string as a command to the DDE server application. Again, commands differ from application to application, so check your documentation.

DDETerminate
This simply closes the channel of communications between the two programs.

Examples

Word

The following AnzioWin macro starts MS Word with a test.doc document, goes to the end of the document, grabs data from the screen (in this case the whole screen) and pastes it in. It then prints the file, saves the document and quits.

Define f8 f6ddeinit winword c:\temp\test.doc|f6wait 20|f6ddepoke \endofdoc f6send ||f6ddeexec [FilePrint]|f6wait 15|f6ddeexec [FileSave ]|f6wait 50|f6ddeexec [FileQuit]|

Excel

The following AnzioWin macro starts MS Excel with a test.xls spreadsheet. It then pastes screen data at a couple of locations, prints the file, saves it and quits.

Define f8 f6ddeinit excel c:\temp\test.xls|f6ddepoke r4c5 f6send ||f6ddepoke rc f6send || f6ddepoke r[+1]c f6send 4 10 7 10 || f6 ddeexecute [Print]|f6wait 15|f6ddeexec [Save ]|f6wait 50|f6ddeexecute [Quit]|

Appendix A Reference Material

 We recommend several books that are useful when working with both the PC and host scripts. If you are looking into the AnzioWin API, these are well worth having.

VBScript Programmer's Reference

Susanne Clark, et al

Wrox Press Ltd., ©1999

Windows Script Host Programmer's Reference

Dino Esposito

Wrox Press Ltd., ©1999

Instant JavaScript

Nigel McFarlane

Wrox Press Ltd., ©1997

Scripting Windows 2000

Jeffrey Honeyman

Osborne/McGraw Hill © 2000

Programming Perl

Larry Wall & Randal Schwartz

O’Reilly & Associates ©1991

CDO & Mapi Programming with Visual Basic

Dave Grundgeiger

O’Reilly & Associates ©2000

UNIX Power Tools 2nd Edition

Peek, O’Reilly, Loukides

O’Reilly & Associates ©1997

The New Kornshell

Morris Bolsky, David Korn

Prentice Hall PTR ©1995

Microsoft Word Developer’s Kit

 

Microsoft Press ©1995

 

Appendix B AnzioWin Commands

Refer to the AnzioWin manual for more information on these commands. These are listed here as point of reference only. Further descriptions of each command can be found in the manual. You can download a copy of the manual from our web site, or order a copy online.

7E1
7E2
7N1
7N2
7O1
7O2
8E1
8E2
8N1
8N2
8O1
8O2
ACTIVATE
ADD128
ALLOW-QUIT
ANSWERBACK
ASEND
AUTO-LF
AUX
AUX-DEBUG
AUX-SETUP
BACKSPACE
BAUD
BEEP
BLOCKTYPE
BMP
BMP-ADJUST
BMP-CLOSE
BMP-VIEW
BMP-WINDOW
BOX
BREAK
C332_NEXT
C332_PREV
CALC
CALL
CAPTURE
CD
CHARSET
CHARSET/S
CHOOSEPRINTER
CLIP
CLONE
CLOSEI
CLOSEI/S
CLOSEO
CLOSEO/S
COLOR
COMMTYPE
COMPOSE/S
CONNECT
COPY
COPY/S
CPM
CURSOR
DATA
DATE
DDEEXECUTE
DDEINITIATE
DDEPOKE
DDEREQUEST/S
DDETERMINATE
DEFAULTS
DEFINE
DELAY
DELAY/S
DELETE
DELETE/N
DELETE/S
DIAL
DIR
DIR/S
DOWNLOAD-DIR
DOWNLOAD-LOCK
DROPOUT
E
EJECT
END
ENV/S
ENVIRONMENT
F2
FILL
FIND/S
FINDNEXT/S
FLUSH
FLUSHTIMER
FONT
FTPGET
FTPGET/S
FTPPUT
FTPPUT/S
FULL
GAUGE
HALF
HANGUP
HELP
HEXPATCH
HOLD
HOSTNAME/S
HOTKEY
IGNULL
IMOS
INTERPRET
INVOKE
IRQ
IRX
ITX
JUMP
KCOMMAND
KEEP
KEEP/N
KEYMAP
KEYS
KILL
KRCV
KRECEIVE
KSEND
KSND
LAUNCH
LAUNCH/S
LINE
LOCK
LOG
MAPISENDFAX
MENUBAR
MENULANGUAGE
MERGE
MESSAGE
MKDIR
MKDIR/S
MODE-132
MONITOR
NO
ONERROR
ONSTARTUP
OPENE
OPENE/N
OPENE/S
OPENI
OPENI/S
OPENO
OPENO/N
OPENO/S
PAN
PARITY
PASSTHRU
PASSTHRU-CP
PASSTHRU-CP/S
PASSWORD
PASSWORD/S
PASTE
PICK
PITCH
PLAY
PLAYSOUND
POLL
PORT
PRINT
PRINT/N
PRINTER
PRINTER-SETUP
PRINTFILE
PRINTFONT
PRINTINIT
PRINTLEVEL
PRINTLINE
PRINTLN
PRINTLOW
PRINTMACRO
PRINTTOFILE
PROMPT-ID
PROMPT/S
PROPOGATE
PURGE
RAW-SETUP
READ
REC
RECEIVE
RECONNECT
REGTELNET
RENAME
RESET
RETRANSMIT
REVIEW
RMCOS
RTS-MODE
RUN
RUN/N
RUN/S
RZ
SAVE
SCREENMODE
SCREENMODE/S
SCREENSIZE/S
SCRIPT
SCROLL
SCROLL-LOCK
SEND
SEND/N
SERIALNUMBER
SETCOLOR
SLEEP
SPOOLER
STATUS
STAY
STAY/G
STOP
SYNC
SZ
TAB
TERM
TERMNAME
TIME
TIMEOUT
TITLE
TOPTIONS
TRACK-WINDOW
TRANSMIT
TTY
TYPE
UNICODE/S
UNIX
UPPERCASE
USERNAME
USERNAME/S
VERSION
VERSION/S
VRX
WAIT
WAITFOR
WF
WIDTH WINDOW
WINDOWCLOSE
WINPRINT
WINSTART
WRITE
WRITELINE
WRITELN
XN
XRECEIVE
XSEND
YRECEIVE
YSEND
ZRECEIVE
ZSEND

Appendix C - Perl Script Examples

All of the examples relating to PERL can be found in a file called: anziosample.pl available at our web site. Also check out various knowledgebase articles and other support documents at Anzio.Com.

Copyright © 2020 Rasmussen Software, Inc. Legal Information & Privacy Policy
Send comments and suggestions to rsi@anzio.com