Page 1 System Software Library TACL Programming Guide Abstract This manual describes the Tandem Advanced Command Language (TACL) and provides information and examples for creating TACL programs. Part Number 107365 Edition Second Published December 1994 Product Version TACL D30 Release ID D30.00 Supported Releases This manual supports D30.00 and all subsequent releases until otherwise indicated in a new edition.
Page 2 Document History Edition Part Number Product Version Earliest Supported Release Published First 085797 TACL C20 November 1992 Update 086700 TACL D10 February 1993 Second 107365 TACL D30 D30.00 December 1994 New editions incorporate any updates issued since the previous edition.
Page 3: New And Changed Information
New and Changed Information This is the second edition of the TACL Programming Guide . This edition documents the following new TACL features: A new built-in function, #SETCONFIGURATION, sets the TACL flags that can change the behavior of TACL for a specified TACL image or configure the currently running TACL process.
Page 4 New and Changed Information (This page left intentionally blank) 105919 Tandem Computers Incorporated...
Page 5: Table Of Contents
Contents About This Manual xi Notation Conventions xv Section 1 An Overview of TACL Running the Examples in This Manual 1-1 Style Conventions 1-2 Exceptions to the Style Conventions 1-3 Conventions Specific to This Manual 1-3 Section 2 Developing TACL Programs...
Page 6 Contents Section 3 Developing TACL Routines Processing Arguments 3-1 How #ARGUMENT Works 3-3 Using #ARGUMENT 3-4 Examining the Contents of Arguments 3-9 Parsing Arguments for a Caller 3-11 Returning Results 3-15 Calling a Routine Recursively 3-16 Exiting From a Routine 3-17...
Page 7 Processing NetBatch Jobs and Completion Codes 5-32 Monitoring Job Status ENQUIRY 5-35 Section 6 Running TACL as a Server Running a TACL Process as a Server 6-1 Starting TACL as a Server Process 6-1 Sending Requests to a TACL Server 6-2 Directing Output From TACL 6-4...
Page 8 Figure 2-5. Extracting a Volume Name from a Variable 2-12 Figure 2-6. Retrieving Disk Names From DSAP 2-15 Figure 2-7. Relationships Between System Timestamps and TACL Functions 2-20 Figure 2-8. Relationships Between #FILEINFO Timestamps and TACL Functions 2-21 Figure 2-9.
Page 9 Checking Completion Codes 5-33 Figure 5-14 Retrieving TACL Output 5-36 Figure 6-1 Starting and Sending Requests to a TACL Server 6-2 Figure 6-2 Running a TACL Program as a Server 6-7 Figure 6-3 Screen COBOL Code That Accesses a TACL Server 6-9...
Page 10 Table 5-5 Functions to Use With $RECEIVE 5-21 Table 6-1 Functions That Support Interprocess Communication 6-2 Table 7-1 TACL Functions That Support SPI 7-4 Table 7-2 SPI Token Data Types 7-6 Table 7-3 Functions That Support EMS 7-12 107365 Tandem Computers Incorporated...
Page 11: About This Manual
This manual describes the Tandem Advanced Command Language (TACL) and provides information and examples for creating TACL programs. Audience This manual is intended for users of TACL who are familiar with TACL commands and built-in functions and who want to create TACL programs. Organization This manual contains the following sections: Section 1, “An Overview of TACL,”...
Page 12 (TEXT, MACRO, and ROUTINE), including basic programming concepts and terminology such as “pushing” and “popping” (creating and deleting) variables, the use of arguments, and so on. Elements of the TACL language are described in the TACL Reference Manual. Corequisites...
Page 13 About This Manual Related Reading Figure 1 lists the recommended sequence for reading TACL related manuals. Figure 1. Documentation Road Map Prerequisite Manuals TACL Guardian Reference User's Guide Manual TACL Programming Guide Related Manuals NetBatch Guardian Manual Programmer's Guide Introduction to...
Page 14 About This Manual Related Reading (This page left intentionally blank) 107365 Tandem Computers Incorporated...
Page 15: Notation Conventions
A vertical line separates alternatives in a horizontal list that is enclosed in brackets or Vertical Line | braces. For example: INSPECT { OFF | ON | SAVEABEND } Note also that TACL uses vertical lines to surround labels in enclosures. 107365 Tandem Computers Incorporated...
Page 16 Notation Conventions General Syntax Notation An ellipsis immediately following a pair of brackets or braces indicates that you can Ellipsis ... repeat the enclosed sequence of syntax items any number of times. For example: #PUSH variable [ [,] variable ] ... [ + | - ] {0|1|2|3|4|5|6|7|8|9}...
Page 17: Section 1 An Overview Of Tacl
Tandem NonStop kernel. In addition to providing full command interpreter facilities, TACL is a high-level programming language. As a programming language, the TACL product is most often used for managing systems and processes. You can, for example, use TACL to: Automate system startup and shutdown procedures.
Page 18: Style Conventions
TACL, and they return results and provide easier programmatic access to error information. Error checking is as important in TACL programs as it is in programs written in other languages. Possible sources for errors include terminal input and file system operations.
Page 19: Exceptions To The Style Conventions
When you supply a variable name as all or part of an expression, you can enclose the variable name in square brackets or omit the square brackets. Either way, TACL retrieves the contents of the variable.
Page 20 An Overview of TACL Style Conventions (This page left intentionally blank 1–4 107365 Tandem Computers Incorporated...
Page 21: Section 2 Developing Tacl Programs
Accessing terminals Debugging TACL programs The TACL Reference Manual contains information about TACL statements, programs, and the TACL environment. This information is prerequisite to the topics in this and later sections. Choosing a Type of The choice of a type of procedural variable depends on the type of work you plan to Variable do.
Page 22: Defining Program Structure
FUP process, and is therefore more efficient. When you run copier, your TACL process must be named (using the NAME option with the TACL command). To run copier, load the file that contains the macro and then type: copier Figure 2-1.
Page 23: Figure 2-2. Performing A Bubble Sort With Nested #Loop Statements
Developing TACL Programs Defining Program Structure You can define a macro that increments a loop variable (passed as the argument); for example: [#DEF next MACRO |BODY| #SET %1% [#COMPUTE %1% + 1] Use the macro in Figure 2-2, bubble, with its nested #LOOP statements, to perform a bubble sort.
Page 24 Note When you run checkfiles, you must access your local system and your node name must not be included in your current #DEFAULTS. To remove a node name, if present, enter SYSTEM at the TACL prompt before running checkfiles. 2–4...
Page 25: Figure 2-3. Deleting Files In A Subvolume
Developing TACL Programs Defining Program Structure When you run checkfiles, the routine displays the following: Where do you want to start (default = beginning of subvol)? To start checking files in the middle of the subvolume, enter a text constant with the desired starting characters.
Page 26 Developing TACL Programs Defining Program Structure Figure 2-3. Deleting Files in a Subvolume (Page 2 of 2) [#IF [#MATCH Y* [#SHIFTSTRING/UP/[reply]]] |THEN| #SET resp [#PURGE [filenm]] [#CASE [resp] #OUTPUT [filenm] purged |OTHERWISE| #OUTPUT [filenm] could not be purged #OUTPUT Error [resp]...
Page 27: Nesting Tacl Code
== Call self without current == argument. To run this macro, type the file name from the TACL prompt and supply one or more arguments. The macro displays the arguments you supply. In the following example, the file name that contains the macro is called ARGS: 12>...
Page 28: Saving Levels Of Variables
The #PUSH built-in function creates a new level for a user-defined or built-in variable. If you push a variable twice, TACL creates two levels of the variable. A new level remains in existence until you request a #POP, #UNFRAME, or #RESET FRAMES operation.
Page 29: Exiting From Programs
#FRAME operation. For more information about frames, see the TACL Reference Manual. Exiting From Programs TACL exits from a macro or text variable as soon as it encounters either of the following conditions: Successful completion of the code; TACL executes each line and exits when finished.
Page 30: Line And Character
Note Variable levels that contain TACL code contain special internal multicharacter representations of [, |, and ]. When you use character oriented functions, be aware that these representations are counted as multiple characters; they contain unprintable characters that are subject to change from one release of TACL to another.
Page 31 Developing TACL Programs Processing Character Data A character address specifies a particular character within a variable, counting from the first character, whose character address is 1. Each end-of-line character (except the last one in the variable) counts as one character. If a specified character address is...
Page 32: Figure 2-5. Extracting A Volume Name From A Variable
#SET vol [#CHARGET mylist begin TO [#COMPUTE end - 1]] #OUTPUT The volume name is vol #UNFRAME For examples showing the use of these functions for argument processing in routines, see “Processing Arguments” in Section 3, “Developing TACL Routines.” 2–12 107365 Tandem Computers Incorporated...
Page 33: Global Editing Commands
Finds all lines containing occurrences of a specified string in a range of lines in a variable. VFIND is not case-sensitive. VINSERT Inserts lines from the TACL IN file at a given line position in a variable. VLIST Lists a range of consecutive lines in a variable.
Page 34 Developing TACL Programs Processing Character Data To display the contents of sample2, enter: 14> VLIST sample2 The name of this variable is "sample2." There are 37 characters in this line. This is the last line in the variable. To find all occurrences of the word “line” in sample2, enter: 15>...
Page 35: Figure 2-6. Retrieving Disk Names From Dsap
Developing TACL Programs Processing Character Data Use the macro in Figure 2-6, volnames, to display the volume names on your system, using the VFIND global editing command. To run this macro, load the file and type volnames: 12> volnames The volume names are:...
Page 36: Additional Data Manipulation Capabilities
Developing TACL Programs Processing Character Data Use the built-in functions and commands in Table 2-3 to perform other data Additional Data Manipulation Capabilities manipulation tasks. A dash indicates that there is no equivalent function or command. Table 2-3. Data Manipulation Functions...
Page 37: Data Types
For more information, see “Processing Arguments” in Section 3, “Developing TACL Routines.” Accessing Time Data The system clock keeps track of time as a numeric value known as a timestamp. TACL supports timestamps in four formats for arithmetic operations, comparisons, and display purposes.
Page 38: Retrieving A Timestamp
Developing TACL Programs Accessing Time Data Local timestamp, a three-word timestamp. This timestamp represents the number of centiseconds (.01 second) since 00:00 December 31, 1974. An example is: 45553140000 A local timestamp can represent one of the following three time zones: Local civil time (LCT): The time of day locally.
Page 39: Converting A Timestamp
In addition, the _MONTH3 function translates a two-digit month number to a three- letter month abbreviation. Figure 2-7 shows the TACL functions that transform system timestamps from four- word and three-word formats to display format. Figure 2-8 shows how to convert timestamps returned by #FILEINFO into different formats.
Page 40: Figure 2-7. Relationships Between System Timestamps And Tacl Functions
Developing TACL Programs Accessing Time Data Figure 2-7. Relationships Between System Timestamps and TACL Functions NonStop System #TIMESTAMP #JULIANTIMESTAMP 45553140000 211479971400000000 #CONTIME #INTERPRETTIMESTAMP 1989 6 7 8 30 0 0 2447685 1989 6 7 8 30 0 0 0 [#SETMANY _ yy mm dd hh mn ss ms,...
Page 41: Figure 2-8. Relationships Between #Fileinfo Timestamps And Tacl Functions
Developing TACL Programs Accessing Time Data Figure 2-8. Relationships Between #FILEINFO Timestamps and TACL Functions Disk #FILEINFO /CREATION_GMT/ #FILEINFO /MODIFICATION/ #FILEINFO /LASTOPEN_GMT/ 45553140000 211479971400000000 #INTERPRETTIMESTAMP #CONTIME 1989 6 7 8 30 0 0 2447685 1989 6 7 8 30 0 0 0...
Page 42: Figure 2-9. Computing The Current Day
Developing TACL Programs Accessing Time Data Computing the Day of the Week Use the macro in Figure 2-9, dayofweek, to calculate the day of the week, as follows: 16> dayofweek Tuesday 17> Figure 2-9. Computing the Current Day ?SECTION dayofweek MACRO...
Page 43: Figure 2-10. Converting Timestamps
SQL format (yyyy-mm-dd), for use by report generators or other programs. This type of macro could be used to generate SQL reports. Figure 3-9 in Section 3, “Developing TACL Routines,” contains a modification of this example that shows how a nested routine can return dates as results.
Page 44: Accessing Terminals
TACL recognizes 16 function keys. In the unshifted position they are named F1 through F15 (TACL predefines F16 as its help key). In the shifted position the function keys are named SF1 through SF16. You can define each function key to perform a sequence of operations that are useful in your environment.
Page 45: Figure 2-11. Sending Special Characters To A Screen
To define an escape sequence using #DELTA, specify a decimal number followed by the I command; for information about #DELTA, see the TACL Reference Manual. Use the macro in Figure 2-11, display, to define several escape sequences and send them to the home terminal.
Page 46 Developing TACL Programs Accessing Terminals Figure 2-11. Sending Special Characters to a Screen (Page 2 of 2) == Clear the screen #OUTPUT [ascii:clr(0:1)] #OUTPUT The screen was just cleared. == Display text with special video attributes #OUTPUT Blinking text: [ascii:esc]6b These words are &...
Page 47: Figure 2-12. Displaying A Screen Of Text
Developing TACL Programs Accessing Terminals Use the routine in Figure 2-12, displayinfo, to list a screen full of lines and prompt the user to continue. To use this routine, load the associated file and enter: displayinfo This routine does not display an entire screen of text, but shows how the prompt works.
Page 48: Figure 2-13. Locking A Terminal
Developing TACL Programs Accessing Terminals Use the macro in Figure 2-13, lock, to lock a terminal until the user types the password. Figure 2-13. Locking a Terminal ?SECTION lock MACRO #FRAME #PUSH pw == password #PUSH prompt == prompt variable...
Page 49: Changing The Tacl Prompt
Developing TACL Programs Accessing Terminals The SETPROMPT command allows you to change the standard TACL prompt so that Changing the TACL Prompt it includes the current volume or subvolume name. To make additional modifications, define a variable called _PROMPTER that contains the definition of the prompt.
Page 50: Implementing Menus
Developing TACL Programs Accessing Terminals You can use TACL to define menus. A menu displays a screen and allows users to Implementing Menus press function keys to access information and utilities. Use the text variable in Figure 2-14, menu, to generate a menu. The user can press function keys to start applications and utilities.
Page 51 Developing TACL Programs Accessing Terminals Figure 2-14. Displaying a Menu (Page 2 of 2) [#LOOP |DO| #OUTPUTV displayvar SINK [#INPUT /FUNCTIONKEY fkey/ [prompt]] [#CASE [fkey] | F1 | SINK [psmail] | F2 | #INPUTV temp prompt1 TEDIT [temp] | F3 |...
Page 52: Debugging Tacl Programs
The debugger displays the current history number: - nnn - At this point, you can enter a command. If you enter a TACL command, the debugger passes the command to TACL for execution. If you enter a _DEBUGGER command, _DEBUGGER executes the command.
Page 53: A Sample Debugging Session
To reenter the debugger after using STEP, set a breakpoint on a variable that will be invoked later in your program. Next, type RESUME to run your program until TACL encounters the breakpoint or finishes the program. Note that setting a variable (such as #SET x 123) is not an invocation of the variable;...
Page 54: Figure 2-15. Starting Tedit From Tacl
Developing TACL Programs Debugging TACL Programs without accessibility to the #ARGUMENT built-in function, you would need to check that the argument is a valid file name. Figure 2-15. Starting TEDIT From TACL ?SECTION tedsave ROUTINE #FRAME #PUSH editfile == Retrieve the first argument and place it into editfile:...
Page 55 You can also force choices based on variable values without having to change the function and rerun it. For example, you can alter the contents of the text in a #CASE function to force TACL to take a path that you want to test. 2–35...
Page 56 Developing TACL Programs Debugging TACL Programs (This page left intentionally blank) 2–36 107365 Tandem Computers Incorporated...
Page 57: Section 3 Developing Tacl Routines
3 Developing TACL Routines TACL routines provide features that you cannot obtain from any other type of TACL variable. In a routine, you can: Use #ARGUMENT to check the syntax and validity of several types of arguments or to parse data within your program...
Page 58 Developing TACL Routines Processing Arguments To process the f ile-name argument from a macro: ?SECTION process_argm MACRO == This macro does not check argument type or validity. == Separate coding is required to validate the argument. #FRAME #PUSH fname == Store the first argument in fname.
Page 59: How #Argument Works
TEXT specifies a variable to contain an exact copy of the argument. VALUE specifies a variable to contain the TACL interpretation of the argument sequence. For example, FILENAME returns a fully-qualified file name, using defaults if the user did not specify all components of the file name.
Page 60: Using #Argument
If an argument does not match any of the listed alternatives, a TACL error occurs unless you specify the OTHERWISE alternative. If you use OTHERWISE, an invalid argument does not produce a TACL error;...
Page 61: Figure 3-1. Processing Arguments
#UNFRAME Using #ARGUMENT for Data Within a Program TACL itself does not provide data type declarations and functions, but you can write a function that uses #ARGUMENT to determine the type and return the information. The following routine returns TRUE (not zero) if you pass it a number; otherwise, it...
Page 62 Developing TACL Routines Processing Arguments The following examples illustrate two ways to retrieve a number from a position within a line of text (as returned by FUP or other processes). First, you can use the #CHARGET function: #PUSH pfree line...
Page 63 (/). If present, the routine checks for the word OUT, followed by a file name and an ending slash. The routine then sets the TACL OUT file to the file specified in the argument list. If the user does not specify an OUT option, this routine displays the current setting of the OUT file.
Page 64 Developing TACL Routines Processing Arguments The following routine expects both a file name and a properly formatted variable name, but accepts them in either sequence. To run this routine, type the name of the file that contains this code: ?TACL ROUTINE...
Page 65: Examining The Contents Of Arguments
Developing TACL Routines Processing Arguments Processing Arguments Recursively You can use the #ROUTINENAME built-in function to process arguments recursively. For more information, see “Calling a Routine Recursively,” later in this section. Examining the Contents of The following routines examine the contents of arguments. These routines return Arguments results;...
Page 66: Figure 3-3. Returning A Set Of Characters From A Variable
[#RESULT [#CHARFINDV [var] [num] txt]] #UNFRAME Note If you do not include square brackets around the variable names in the #CHARxxx calls, TACL uses the declared variables (var and num) instead of the variables passed to the routine and referenced by var and num.
Page 67: Parsing Arguments For A Caller
You can use the #ARGUMENT built-in function to provide a general parser for other Caller TACL programs. Figure 3-7 contains two sample programs: getargs, a macro that parses arguments for a routine that calls it and returns the value in a variable (the calling program supplies a name)
Page 68: Figure 3-7. Assigning Values To Arguments
Developing TACL Routines Processing Arguments The syntax for getargs is: getargs triplet [ triplet ]... where triplet contains three parts: REQUIRED type variable OPTIONAL REQUIRED or OPTIONAL specifies whether the corresponding argument is required or optional. Type is an #ARGUMENT alternative such as FILENAME. The specified type must not permit spaces.
Page 69 Developing TACL Routines Processing Arguments Figure 3-7. Assigning Values to Arguments (Page 2 of 2) |ELSE| == More triplets; argument can be followed by a comma [#CASE [#ARGUMENT/TEXT %3%/ %2% COMMA END] SINK [#ARGUMENT COMMA END] #SET %3% ] == end #IF...
Page 70: Figure 3-8. Sending Arguments To A Parsing Program
Developing TACL Routines Processing Arguments The following shows a sample invocation of call_getargs: 11> call_getargs data1, data2, 4 file1 = data1 file2 = data2 n1 = 4 12> Figure 3-8. Sending Arguments to a Parsing Program ?SECTION call_getargs ROUTINE #FRAME...
Page 71: Returning Results
Developing TACL Routines Returning Results Returning Results Function results come from one or more #RESULT built-in functions within the routine. This is an important distinction between macros and routines: a macro invocation returns the expansion of the text of the macro; a routine returns only what the #RESULT function provides.
Page 72: Calling A Routine Recursively
%0% in a routine. If you call #ROUTINENAME for a routine defined with a ?TACL ROUTINE directive, #ROUTINENAME returns the name of the variable TACL uses to hold the active copy of the routine. Use the macro in Figure 3-10, caller, to process one or more arguments. To use this macro, load the associated file and enter: caller { file-name | TACL | TAL | PASCAL | system-name }...
Page 73: Exiting From A Routine
Developing TACL Routines Exiting From a Routine Use the routine in Figure 3-11, argrec, to process one or more file names, checking for syntax but not for file existence. File names can be separated by spaces or commas. After processing each file name, the routine scans ahead and skips over commas. It calls itself to process each additional file name.
Page 74: Writing An Exception Handler
For example, if a TACL routine opens one or more files and then purges them when finished, the user could press the BREAK key while the files are still open. TACL would then close any open files, but would not purge them.
Page 75: Types Of Exception Handlers
Handler Table 3-2. Functions That Support Exception Handlers Function Description #ERRORNUMBERS Returns the most recent TACL error. #ERRORTEXT Intercepts error text that would have been written to the OUT file if there had been no exception handler. #EXCEPTION Returns the type of exception that invoked the exception handler: _CALL if the routine containing #EXCEPTION was invoked normally.
Page 76: Creating A Release Exception Handler
Developing TACL Routines Writing an Exception Handler Figure 3-12. Sample Release Handler Template ?SECTION name ROUTINE == Exception handler == [#CASE [#EXCEPTION] |_CALL | == No action required when first called |_BREAK| == Code to handle BREAK goes here |_ERROR|...
Page 77: Figure 3-13. Sample Release Handler
Developing TACL Routines Writing an Exception Handler If the user presses the BREAK key while the processing loop is running, TACL raises the _BREAK exception and reinvokes the routine. The #CASE function executes the _BREAK case, displays a message, and exits. If the user enters anything other than ADD or SUB, the #CASE in the loop raises _ERROR, and TACL reinvokes the routine;...
Page 78: Figure 3-14. Returning Information From A Release Handler
#OUTPUT Number of files purged = [filespurged] #OUTPUT Number of files not purged = [filesnotpurged] #UNFRAME #RETURN #FRAME == Filter _BREAK and TACL errors #FILTER _BREAK _ERROR [#PUSH filetemplate exclude prevname purgeerr opt firsttime filespurged filesnotpurged 3–22 107365 Tandem Computers Incorporated...
Page 79 Developing TACL Routines Writing an Exception Handler Figure 3-14. Returning Information From a Release Handler (Page 2 of 3) [#DEF wanttopurge ROUTINE |BODY| #RESULT -1 [#IF [exclude] |THEN| #RETURN [#IF [#MATCH y [#INPUT Purge [prevname] (Y/N)?]] |THEN| #RETURN #RESET results...
Page 80: Creating A Keep Exception Handler
Use the routine in Figure 3-15, restricted_cmd_processor, as a sample keep exception handler. If the BREAK key is pressed while the processing loop is running, TACL raises the _BREAK exception and reinvokes the routine; the #CASE function takes the _BREAK path and then reenters the loop.
Page 81: Figure 3-15. Sample Keep Exception Handler
?SECTION restricted_cmd_processor ROUTINE [#CASE [#EXCEPTION] |_CALL | #FRAME #PUSH cmd |_BREAK| #OUTPUT BREAK key pressed. |_ERROR| #OUTPUT TACL error occurred. |EXIT| == For demo only #RESET FRAMES RESULTS #RETURN |OTHERWISE| #OUTPUT Unknown exception occurred. == End #CASE == Filters predefined exceptions only...
Page 82 When finished, coldstart resets the condition and recovery flags. Warmstart—Attempts to purge a file with an invalid file name; this attempt forces a TACL error to show exception handler operation. Shutdown —Performs a cleanup operation and sets condition to 0.
Page 83: Figure 3-16. Sample Command Shell
Developing TACL Routines Writing an Exception Handler Figure 3-16. Sample Command Shell (Page 1 of 4) ?SECTION restrictive_command_shell ROUTINE #PUSH #OUTFORMAT #SET #OUTFORMAT PRETTY == Define the code that handles exceptions [#CASE [#EXCEPTION] |_CALL| #FRAME #PUSH err cmd prompt condition recovery...
Page 84 Developing TACL Routines Writing an Exception Handler Figure 3-16. Sample Command Shell (Page 2 of 4) #INPUTV /UNTIL TACL/ cmd prompt [#IF ([#INPUTEOF]) |THEN| #RAISE EOF [#CASE [cmd] |WARMSTART| warmstart |COLDSTART| coldstart |SHUTDOWN| shutdown |EXIT| EXIT |OTHERWISE | #OUTPUT Invalid command...
Page 85 Developing TACL Routines Writing an Exception Handler Figure 3-16. Sample Command Shell (Page 3 of 4) #SET step 2 #PUSH c d #DELAY 200 #PURGE filewithlongname #OUTPUT == end #IF ?SECTION coldstart MACRO == COLDSTART the application [#CASE [recovery] |REQUIRED...
Page 86: Combining Keep And Release Handlers
The #CASE function takes the OTHERWISE path, which performs an orderly deallocation of resources and then raises the same exception. TACL then pops that routine (the #FILTER function has not yet been executed in the reinvocation) and returns to restricted_caller. The #CASE function in that routine takes the appropriate path to deal with the exception and restarts the processing loop.
Page 87: Figure 3-17. Using Nested Keep And Release Handlers (Page 1 Of 2)
[#CASE [#EXCEPTION] |_CALL| #FRAME #PUSH cmd exceptionlist #SET exceptionlist _BREAK _ERROR EXIT |_BREAK| #OUTPUT BREAK key pressed. |_ERROR| #OUTPUT TACL error occurred. | EXIT | == for demonstration purposes #RESET FRAMES RESULTS #RETURN |OTHERWISE| #OUTPUT Unknown exception occurred. == End CASE...
Page 88 Developing TACL Routines Writing an Exception Handler Figure 3-17. Using Nested Keep and Release Handlers (Page 2 of 2) ?SECTION protected_code ROUTINE [#CASE [#EXCEPTION] |_CALL | == No action required when first called |OTHERWISE| #RESET FRAMES RESULTS == Deallocate resources...
Page 89: Section 4 Accessing Files
The #REQUESTER function opens a file for waited or nowaited I/O. After you invoke the #REQUESTER function, TACL continues to execute code. For waited I/O operations, TACL stops at the next I/O request and ensures that each read or write is complete before processing the next request. For nowaited operations, call #WAIT to determine whether your request has been completed.
Page 90: Requesting Waited Reads
To initiate a read operation, append data to the prompt variable: #APPEND prompt_var *start read* When reading a disk file, TACL discards the data in prompt_var; you can specify any non-null data. TACL reads a record from FILE1 and places it into read_var. You can use #EXTRACT(V) to retrieve data from read_var;...
Page 91: Figure 4-1 Performing A Waited Read
Accessing Files Requesting Waited Reads Use the routine in Figure 4-1, waited_read, to perform waited reads from the file specified in the first argument in the invocation and display the records on the terminal. To invoke this routine, load the file and type: waited_read filename The routine stops when it detects an error or end-of-file.
Page 92: Requesting Nowaited Reads
To initiate a read operation, append data to the prompt variable: #APPEND prompt_var *start read* To read a disk file, TACL discards the data in prompt_var, reads a record from FILE1, and places it into read_var. You can use #EXTRACT(V) to retrieve data from read_var;...
Page 93: Figure 4-2 Performing A Nowaited Read
Accessing Files Requesting Nowaited Reads This routine uses #VARIABLEINFO/VARIABLE/ to return a variable name to the #CASE statement. #VARIABLEINFO/VARIABLE/ returns the name of a variable without the level number so that it will match one of the labels. The #WAIT built-in function, when used alone, returns the variable name with the level number.
Page 94: Requesting Waited Writes
You can add a record to a structured file but cannot replace a record. If you attempt to write a record that already exists, TACL returns an error. Each time you append a line to write_var, the TACL process writes the record to FILE1. TACL continues executing code until it encounters an #APPEND(V) call that refers to one of the #REQUESTER variables, signifying that you have more data to write.
Page 95: Figure 4-3 Reading From A Terminal And Performing A Waited Write
To invoke this routine , load the file and type: waited_write filename The #INPUT call in Figure 4-3 reads a line from the TACL IN file. Figure 4-3. Reading From a Terminal and Performing a Waited Write ?SECTION waited_write ROUTINE...
Page 96: Requesting Nowaited Writes
TACL returns an error. Each time you append a line to write_var, the TACL process writes a record to FILE1. TACL continues executing code. When you are ready to wait for completion of the read operation, use the #WAIT built-in function to wait until the write_var contains data.
Page 97: Figure 4-4 Reading From A Terminal And Performing A Nowaited Write
Accessing Files Requesting Nowaited Writes Use the routine in Figure 4-4, nowaited_write, to perform nowaited writes to the file specified in the first argument in the invocation. If the file already contains data, this routine appends the new data to the end of the file. To invoke this routine, load the file and type: nowaited_write filename Figure 4-4.
Page 98: Copying Records Between Files
Accessing Files Copying Records Between Files Copying Records Use the routine in Figure 4-5, copy, to read records from one file and write them to Between Files another file. The source file is specified as the first argument; the destination file is specified as the second argument;...
Page 99 Invalid source filename *** #UNFRAME The #EXTRACTV call that performs the write operation clears the contents of read_var and write_var. TACL moves a record out of read_var and into write_var. After TACL writes the data, TACL deletes the record from write_var.
Page 100: Comparing Files
Fcomp supports two options: you can limit the comparison to a range of columns within the files, and you can write the results to a file. Fcomp calls the getargs macro (from Section 3, “Developing TACL Routines”) and the defaultvars macro (from Section 2, “Developing TACL Programs”): Getargs parses the arguments of a calling routine;...
Page 101: Figure 4-6 Comparing Two Files
Accessing Files Comparing Files is an ending field range (optional). result is a file that will contain the results of the comparison (optional). Figure 4-6. Comparing Two Files (Page 1 of 3) ?SECTION fcomp ROUTINE #FRAME == Define a character array; the maximum line length is 239 == characters.
Page 102 Accessing Files Comparing Files Figure 4-6. Comparing Two Files (Page 2 of 3) == If a result file was specified, use it for output. == Otherwise, use the default OUT file. [#IF NOT [#EMPTYV results] |THEN| #PUSH #OUT #SET #OUT [results] == Display the user's request.
Page 103 Accessing Files Comparing Files Figure 4-6. Comparing Two Files (Page 3 of 3) == If the first read was successful, read a line from the == second file. [#IF file1_err <= 1 |THEN| #SET file2_prompt *start* #EXTRACTV file2_var line2 == If the second read was successful, perform the == comparison.
Page 104: Listing A File
Use the macro in Figure 4-7, tacllist, to format, paginate, and print TACL program files. This macro calls #REQUESTER to read the TACL file, copies the TACL file to a disk file designated as the OUT file in TFORM format, and then calls TFORM to format and print the file.
Page 105 Accessing Files Listing a File Figure 4-7. Listing a File (Page 2 of 5) [#DEF file STRUCT BEGIN CHAR input (0:33); CHAR output(0:33); END; ] == end DEF Output a banner [#DEF output_banner TEXT |BODY| #SET short_stars ********* #SET long_stars *********************************** #OUTPUT [long_stars] tacllist [long_stars] #OUTPUT/HOLD / &...
Page 106 Accessing Files Listing a File Figure 4-7. Listing a File (Page 3 of 5) == Get dates macro [#DEF get_dates TEXT |BODY| #SET bin_date [#FILEINFO/MODIFICATION/ [file:input(0:33)]] #SETMANY year month day file_hour file_min, & [#CONTIME [bin_date]] #SET file_date & [#COMPUTE ((year - 1900) * 100000) + (month * 100) + day] #SETMANY year month day list_hour list_min, &...
Page 107 Accessing Files Listing a File Figure 4-7. Listing a File (Page 4 of 5) == The following variables keep track of the line number, == page number, and number of lines already written to == a page (for calculation of automatic page break). #SET line_num #SET page_num #SET lines_out 0...
Page 108: Figure 4-8 Tacllist Output
Accessing Files Listing a File Figure 4-7. Listing a File (Page 5 of 5) [#IF err_inp <> 1 |THEN| == Error 1 is EOF (OK) #OUTPUT Error [err_inp]: Opening/reading file & [file:input(0:33)] #SET err_inp [#REQUESTER/WAIT/CLOSE rec_inp] #POP #OUT [#IF [#FILEINFO/CODE/ [file:output(0:33)]] = 101 |THEN| TFORM/IN [file:output(0:33)], OUT [printer], NOWAIT/ ] == end of #IF [err_inp] <>...
Page 109: Section 5 Initiating And Communicating With Processes
TACL processes. For example, you can: Run a program and wait to process TACL commands until the program is finished running. Run a program and continue to process TACL commands while the program is running.
Page 110: Initiating A Process
REPLY CLOSE Processing completion information You can use the Define Process (DP) facility (not part of TACL) to communicate with processes if your system has ViewPoint software. See “Using DefineProcess,” later in this section. Section 6, “Running TACL as a Server,” describes how to access TACL as a server process.
Page 111: Sending Information At Initiation Time
PARAM associates parameter values with parameter names. DEFINE allows you to specify a named set of attributes and values for a process. TACL stores the associated values until you log off or until you delete the association explicitly. The following paragraphs provide an overview of the use of these three commands.
Page 112: Communicating With A Process
Other processes, such as Pathway requesters, use $RECEIVE, write to their home terminal, or use INV and OUTV variables. The type of path also depends on whether the process opens your TACL process or your TACL process opens the other process.
Page 113 Note If TACL attempts to open a process for communication at the same time that process is attempting to open TACL for communication, a deadlock condition can occur. Coordinate your use of communication mechanisms to avoid simultaneous open operations.
Page 114: Using The Inline Facility
I/O as determined by your TACL code. Note Your TACL process must be started with a process name if you want to use the INLINE option—the operating system does not allow an unnamed process to be opened using a qualifying name, and TACL uses a qualifying name (of its own choosing) to recognize OPEN operations from processes using the INLINE option.
Page 115 INLPREFIX command. The following command sets the prefix to +: #SET #INLINEPREFIX + When TACL passes a prefixed line to a process, it first removes the prefix and the space. If a prefixed line contains square brackets, TACL evaluates them before sending the line.
Page 116: Figure 5-1 Communicating With Fup
Initiating and Communicating With Processes Using the INLINE Facility Figure 5-1. Communicating With FUP ?SECTION inline_fup MACRO #FRAME #PUSH #INLINEPREFIX == Create a new level of == #INLINEPREFIX #SET #INLINEPREFIX + == Set the prefix to "+" FUP /INLINE/ == Start FUP with the INLINE option + info taclcstm == Send FUP a command + info mykeys == Send FUP another command...
Page 117: Table 5-3 Variables And Commands For Inline Display
The settings of #INLINEOUT and #INLINETO are not related to each other. You can send process output to the current TACL OUT file, to a variable, to both, or to neither. You can change the setting of #INLINETO to distribute inline process output among multiple variables.
Page 118: Figure 5-3 Retrieving Output From Fup
Initiating and Communicating With Processes Using the INLINE Facility Use the routine in Figure 5-3, inline_fup_log, to interact with FUP and send output to a variable, log, for FUP output. The routine displays the entire output variable at the end. The routine accepts two file name arguments and retrieves information about each file.
Page 119: Figure 5-4 Omitting Terminal Output
Initiating and Communicating With Processes Using the INLINE Facility To control the output displayed by TACL, use the INLOUT command. To inhibit terminal output from the INLINE_FUP_LOG routine in Figure 5-3, add an #INLINEOUT call as shown in Figure 5-4. The syntax is: inline_fup_log2 file1 file2 Figure 5-4.
Page 120: Figure 5-5 Deleting Peruse Jobs
Initiating and Communicating With Processes Using the INLINE Facility The macro displays the PERUSE banner and spooled jobs; it then deletes the jobs and exits. Figure 5-5. Deleting PERUSE Jobs ?SECTION emptyspool MACRO #FRAME == Arrange for cleanup #PUSH #INLINEPREFIX == Save current prefix #PUSH #INLINETO == Save current INLINETO...
Page 121 The INLINE option cannot be combined with the IN or INV options. The INLINE option includes the effect of the NOWAIT option. TACL allows more than one inline process to exist at a time, but you can communicate with only the most recent one. You must delete the most recent INLINE environment before you can communicate with its predecessor.
Page 122: Using Inv And Outv
If the IN variable is empty, the process waits until you put data into the IN variable. When the process writes to your program, TACL appends the line to the end of the OUT variable associated with the process. You can capture the output into a queue, examine the contents of the queue, and enable and disable output to the queue.
Page 123: Figure 5-6 Retrieving The Tacl In File Name
Determining the Name of the IN File TACL assigns a name to the IN file used by the new process. The name consists of the name of your TACL process, followed by a period, a number sign, the letter S, and a number in the range 0 through 32767 ($T127.#S3, for example).
Page 124 IN variable is empty and a process is not waiting, a flag is set. The next time the process attempts to read from the empty IN variable, TACL sends an EOF and the flag is cleared. #EOF does not alter the state of the process or the IN variable, but it can cause the process to terminate.
Page 125: Figure 5-7 Communicating With Fup Using Inv And Outv
Define the variables: 9> #PUSH input_queue output_queue prompt_string termination_results Start a FUP process that runs concurrently with the TACL process: 10> FUP /INV input_queue DYNAMIC PROMPT prompt_string, OUTV output_queue, NOWAIT, STATUS termination_results/ Use #WAIT to make sure the previous operation has finished: 11>...
Page 126: Figure 5-8 Directing Fup Output To A Log File
Initiating and Communicating With Processes Using INV and OUTV Use the macro in Figure 5-8, fup2, to modify a FUP operation so that user requests and FUP responses are recorded in a log file. The syntax is: fup2 fup-command where fup-command is a valid FUP command. The macro logs the request, the time of the request, and the FUP output to a file called LOGFILE.
Page 127: Figure 5-9 Displaying Peruse Jobs
Initiating and Communicating With Processes Using INV and OUTV Use the macro in Figure 5-9, show_spooler_jobs, to interact with the PERUSE utility and display a list of jobs without PERUSE banner lines. To use this macro, load the associated file and enter: show_spooler_jobs Figure 5-9.
Page 128 TACL. If you use the variable as a DYNAMIC INV variable, any further references to the variable by the process receive a file system error 66 once all data has been transferred.
Page 129: Using $Receive
The process reads the data from its $RECEIVE file. When the process or device replies, TACL stores the reply into the read variable associated with the process or device.
Page 130: Figure 5-10 Sending Messages To A Terminal
Using $RECEIVE For nowaited communication, TACL sends the WRITEREAD and continues executing code. Each time you append a line to prompt_var, the TACL process reads a record from $T1 and appends it to read_var. To open a running process and specify nowaited communication, issue a #REQUESTER READ call without the WAIT option.
Page 131 Initiating and Communicating With Processes Using $RECEIVE Figure 5-10. Sending Messages to a Terminal (Page 2 of 3) |_BREAK| #OUTPUT Send Terminated - Break Pressed #UNFRAME #RETURN ] {End CASE} [#DEF L25 STRUCT == Set address to line 25 BEGIN BYTE BYTE (0:1) VALUE 27 111 ;...
Page 132 Initiating and Communicating With Processes Using $RECEIVE Figure 5-10. Sending Messages to a Terminal (Page 3 of 3) |OTHERWISE| == The user did not supply a device name. Display help == text. output_help_text #UNFRAME #RETURN ] == end of outer #CASE == Obtain the current time == Note: the underscores act as placeholders for unwanted...
Page 133: Figure 5-11 Creating Cmon Messages
Initiating and Communicating With Processes Using $RECEIVE Testing Server Programs You can use TACL to test server programs. One way to do this is to perform the following steps: Define a request STRUCT and a reply STRUCT. Verify that the server process is running.
Page 134 Initiating and Communicating With Processes Using $RECEIVE Figure 5-11. Creating CMON Messages (Page 2 of 4) ?SECTION logon_reply STRUCT BEGIN replycode; CHAR replytext(0:131); END; ?SECTION logoff_msg STRUCT BEGIN msgcode VALUE -51; STRUCT LIKE cmon_ci; END; ?SECTION logoff_reply STRUCT BEGIN replycode; CHAR replytext(0:131);...
Page 135 Initiating and Communicating With Processes Using $RECEIVE Figure 5-11. Creating CMON Messages (Page 3 of 4) STRUCT run_info REDEFINES replytext; BEGIN FNAME progname; priority; processor; END; END; ?SECTION talk_to_cmon ROUTINE == This routine accepts the names of two STRUCTs as its == arguments.
Page 136 #DEF msg STRUCT LIKE logon_msg; #DEF reply STRUCT LIKE logon_reply; talk_to_cmon msg reply == Do a simulated processcreation #DEF msg STRUCT LIKE processcreation_msg; #SET msg:progname tacl == These are simulated RUN options #SET msg:priority 148 #SET msg:processor 13 #SET msg:proginfile taclin...
Page 137: Using #Server
To create a server path for your TACL process, use the #SERVER built-in function. After TACL creates the name, other processes can open your TACL as if it were a file so that you can write to and read from those processes. For example: #PUSH server_name in_var out_var prompt_var #SET server_name [#PROCESSINFO/PROCESSID/].#A39...
Page 138: Figure 5-12 Communicating With Fup Using #Server
Using #SERVER Sending Commands When your TACL program has a server path, other processes can open it and issue WRITEREAD operations. TACL receives a prompt; your TACL process can then write to the other process. This code is exactly the same as that used with #REQUESTER in “Using $RECEIVE,”...
Page 139: Using Define Process
Using Define Process Limitations on the Use of #SERVER TACL supports only one active READ at a time from each server path. If more than one process sends a READ or WRITEREAD to a server path, TACL process the first such request that arrives and returns a file system error 28 to each of the other processes.
Page 140: Processing Completion Information
Initiating and Communicating With Processes Processing NetBatch Jobs and Completion Codes Processing Depending on how you run a process and how the process handles termination, TACL Completion can access several types of completion information: Information TACL supports a STATUS option that stores an indication of why the process terminated.
Page 141: Figure 5-13 Checking Completion Codes
Initiating and Communicating With Processes Processing NetBatch Jobs and Completion Codes If you incur a syntax error while trying to start a process, TACL sets MESSAGECODE to 0, COMPLETIONCODE to 4, and TERMINATIONINFO to 0. If a NEWPROCESS failure occurs while you are trying to start a process, TACL sets MESSAGECODE to 0, COMPLETIONCODE to 4, and TERMINATIONINFO to the NEWPROCESS error code.
Page 142 Initiating and Communicating With Processes Processing NetBatch Jobs and Completion Codes Figure 5-13. Checking Completion Codes (Page 2 of 2) == Check the completion code; if an error occurred, display == it and exit [#IF [:_COMPLETION:COMPLETIONCODE] <> 0 |THEN| #OUTPUT *** Error during preprocessing #OUTPUT Completion code = [:_COMPLETION:COMPLETIONCODE] #UNFRAME #RETURN...
Page 143: Monitoring Job Status Enquiry
To limit open access to a TACL process, use the #TACLSECURITY built-in function. The following considerations apply: If a line in the buffer is less than 80 bytes long, TACL does not pad the remaining bytes. The byte length of the line can be used to determine the amount of valid information on the line.
Page 144: Figure 5-14 Retrieving Tacl Output
Initiating and Communicating With Processes Monitoring Job Status: ENQUIRY To run this routine, load the associated file and enter: enquiry TACL-process-name Figure 5-14. Retrieving TACL Output (Page 1 of 2) ?SECTION enquiry ROUTINE #FRAME [#PUSH last_line last_char max_chars status r_error r_rec prompt...
Page 145 Initiating and Communicating With Processes Monitoring Job Status: ENQUIRY Figure 5-14. Retrieving TACL Output (Page 2 of 2) == Successful open: == Send our message and get a reply (like a WRITEREAD) #APPENDV prompt enquiry_message == The WRITE #EXTRACTV r_rec enquiry_reply...
Page 146 Initiating and Communicating With Processes Monitoring Job Status: ENQUIRY (This page left intentionally blank) 5–38 107365 Tandem Computers Incorporated...
Page 147: Section 6 Running Tacl As A Server
The following subsections describe how to create both types of servers. Note When operating as a server, TACL does not act as a fault-tolerant server (it does not check the sync ID). Therefore, do not use TACL to check correct operation of a fault-tolerant application.
Page 148: Sending Requests To A Tacl Server
Running TACL as a Sever Running a TACL Process as a Server When operating as a server, TACL starts up, logs on under its process accessor ID, and processes input in the usual way. A requesting TACL process sends requests as described in Section 5, “Initiating and...
Page 149 “Running TACL Code as a Server.” When TACL is operating as a server, it queues messages if they arrive while TACL is already working on a message. The depth of this queue is limited solely by the availability of space in the TACL segment.
Page 150: Directing Output From Tacl
After TACL processes all of the message text, it replies with the results of the second message and the results from the leftover text in the first message.
Page 151: Running Tacl Code As A Server
Running TACL Code as a Server Running TACL Code To provide TACL code for use by a TACL server process, you must provide a link to a as a Server TACL process that is running your code. There are several ways to accomplish this, including: ASSIGN the TACLCSTM file to a TACL macro or routine that contains the code.
Page 152: Using Tacl As A Pathway Server
When the application runs, it presents a screen that lists the three functions. If you type a request, TACL processes the request and returns a response. The application displays this response on your screen. To clear the screen, type F1. You can then enter another request or exit the application.
Page 153: Figure 6-2 Running A Tacl Program As A Server
Use the code in Figure 6-2 as a sample Pathway server. This file is known as TACLIN in the Pathway configuration file; if you use a different file name, modify the configuration file. Figure 6-2. Running a TACL Program as a Server (Page 1 of 2) ?TACL ROUTINE #FRAME...
Page 154 Running TACL as a Sever Using TACL as a Pathway Server Figure 6-2. Running a TACL Program as a Server (Page 2 of 2) | 4 | {invalid request} #RESULT Invalid request ! #UNFRAME #RETURN #UNFRAME [#DEF reply ROUTINE |BODY|...
Page 155: Figure 6-3 Screen Cobol Code That Accesses A Tacl Server
Figure 6-3 contains the Screen COBOL source code for the requester. This requester displays a screen and waits until the user presses the F1 key to send a request to TACL or SF16 to exit the program. If the user sends a request, the requester displays the response from TACL and waits until the user presses the F1 key to clear the message.
Page 156 Running TACL as a Sever Using TACL as a Pathway Server Figure 6-3. Screen COBOL Code That Accesses a TACL Server (Page 2 of 2) Procedure Division. 0-DEBUT. Display Base FRAME Perform 1-LOOP Until EXI Stop Run. 1-LOOP. Accept FRAME Until F1 Escape SF16...
Page 157: Figure 6-4 Configuring The Pathway Environment
The commands in Figure 6-4 configure the sample Pathway environment. This file is used as input when you start the Pathway environment. Note that the server program file is $SYSTEM.SYS01.TACL and the commands assign the TACLCSTM file to the TACLIN file.
Page 158 Running TACL as a Sever Using TACL as a Pathway Server To run this application, type the following: 12> O PWYOBEY (Pathway displays startup information here) 13> PATHCOM $TST =RUN TEST-TACL (Pathway displays the application screen. When finished, press SF16 instead of entering a request.)
Page 159: Section 7 Using Programmatic Interfaces
This section does not provide detailed information about SPI or EMS; it does, however, show how to use TACL to communicate with SPI and EMS. For additional information, see the Introduction to Distributed Systems Management (DSM), the Distributed Systems Management (DSM) Programming Manual, and the Event Management Service (EMS) Manual.
Page 160 Using Programmatic Interfaces Overview of SPI and EMS request for action.) EMS allows you to monitor the status of system and application components. EMS messages are a type of SPI message; to communicate with EMS, you use SPI and EMS procedures. The following diagram shows a sample flow of EMS messages from subsystems to management applications.
Page 161 For example, you can use EMS to monitor a large array of subsystems. If a significant situation arises, you can use SPI to initiate a dialog with the appropriate subsystem. You can also use TACL to learn about SPI and EMS interactively. 7–3...
Page 162: Using Spi
Know the names of individual tokens of interest. You can find the necessary files in the ZSPIDEF subvolume supplied by Tandem; load them from within your TACL code or attach segment files (in the ZSPISEGF subvolume) that contain the information.
Page 163: Defining An Spi Buffer
Note TACL has a maximum I/O buffer size of 5000 bytes and STRUCT variables are also limited to 5000 bytes. In addition, TACL cannot perform nowaited I/O to files opened by #REQUESTER for buffers larger than 239 bytes.
Page 164: Table 7-2 Spi Token Data Types
Tandem subsystems. The following considerations apply to the use of subsystem IDs in TACL: The null subsystem ID (all binary zeroes) is expressed as 0.0.0 in TACL. TACL performs automatic conversion between text and the internal format used by SPI for subsystem IDs.
Page 165 Any valid user name; a user number cannot be used. TACL interprets an unknown token data type as if the data type were ZSPI^TDT^INT. Variable-Length Data Items In TACL, the byte length appears before the data, separated from it by a space. 7–7 107365 Tandem Computers Incorporated...
Page 166 Token Maps In TACL, a token map is stored in a STRUCT variable. The definition of the STRUCT is irrelevant to TACL. Token map definitions, as generated by DDL, are included in the TACL definition files for subsystems that define extensible structured tokens.
Page 167: Using Spi Functions
If the actual token length is not evenly divisible by the basic data-type length, the last bytes cannot be set or seen. TACL shows each item in its usual external representation. All elements pertaining to the Subsystem Programmatic Interface are described in detail in the Distributed Systems Management (DSM) Programming Manual.
Page 168 Using Programmatic Interfaces Using SPI Use the routine in Figure 7-2, dumplog, to retrieve the name of the current EMS log file using SPI. The example then calls EMSDIST to read the current log and display the message on the home terminal. To invoke this routine, load the associated file and enter: dumplog [ time ] Figure 7-2.
Page 169: Figure 7-2 Displaying The Ems Log
Using Programmatic Interfaces Using SPI Figure 7-2. Displaying the EMS Log (Page 2 of 2) == Send the request (the open was waited, so we do not need == to wait for the variable to become empty.) #APPENDV request spi_buf == Retrieve the results #EXTRACTV reply spi_buf [#IF NOT [#EMPTYV io_err] |THEN|...
Page 170: Using Ems
Using Programmatic Interfaces Using EMS The following session shows sample output: 17>dumplog 16:50 92-05-28 16:51:22 \SYS.003,000 TANDEM.MSGSYS.C20 000104 Receive Queue for CPU 3, PIN 50 Greater Than 10 LCBs 92-05-28 17:00:34 \SYS.004,013 TANDEM.EMS.C20 000165 LDEV 0056 CU %120 CSS SUBDEVICE ERROR, CIU SUBDEV #000003 F, M=%043200 STATUS %000005 To generate a request for EMS, see the following subsection, “Using EMS.”...
Page 171: Generating An Ems Event
Using EMS You can find the necessary definitions in the ZSPIDEF subvolume; load them from within your TACL code or create and attach segment files (in the ZEMSSEGF subvolume) that contain the information. Follow these steps to generate an EMS event:...
Page 172: Figure 7-3 Generating An Ems Event
Using Programmatic Interfaces Using EMS Figure 7-3. Generating an EMS Event (Page 2 of 3) == Build the event and initialize the EMS buffer [#SET evt_error [#EMSINIT evt_buf [ZEMS^VAL^EXTERNAL^SSID] [evt_num] ZEMS^TKN^TEXT [#charcount evt_text] [evt_text]] [#IF [evt_error] |THEN| #OUTPUT *ERROR* EMSINIT error [evt_error] #RETURN == If emphasis is TRUE, set the CRITICAL flag [#IF [emphasis] |THEN|...
Page 173 Using Programmatic Interfaces Using EMS Figure 7-3. Generating an EMS Event (Page 3 of 3) == Main logic ================================================== #SET collector $0 #SET action_id 0 == Open the Collector for WRITEREADs; $0 expects a WRITEREAD #SET evt_error [#REQUESTER /WAIT/ READ [collector] & req_error req_read req_prompt] == If open fails, display an error message.
Page 174 Using Programmatic Interfaces Using EMS (This page left intentionally blank) 7–16 107365 Tandem Computers Incorporated...
Page 175: Section 8 Example Of A System Management Program
Portions of ckup require a version of TACL released at C20 or later. In addition, your TACL process must be named. The macro runs as a batch file; you start it and it runs through several tests, displaying results.
Page 176 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 1 of 12) ?SECTION ckup MACRO #FRAME == Definitions for terminal I/O [#DEF esc STRUCT BEGIN BYTE byte_escape VALUE 27; CHAR char_escape REDEFINES byte_escape; END; ] == end def == The following #DEFs must be on single lines for == later replacement in #OUTPUT calls...
Page 177: Figure 8-1 Monitoring System Status
Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 2 of 12) == --------------------------------------------------------- == Display general system information == --------------------------------------------------------- #PUSH release version #OUTPUT #OUTPUT status for [#MYSYSTEM] #OUTPUT [_CONTIME_TO_TEXT_DATE [#CONTIME [#TIMESTAMP]]] #SETMANY release version , [#TOSVERSION] [#IF [#MATCH [release] L ] |THEN| #SET release B ] [#IF [#MATCH [release] M ] |THEN| #SET release C ] #OUTPUT OPSYS: [release][version]...
Page 178 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 3 of 12) == For CPU status, -1 = up and 0 = down [#IF cpustatus |THEN| #OUTPUT [type] Processor [cpucounter] is up. |ELSE| #OUTPUT [Tcr][type] Processor [cpucounter] & is down.[Tce] ] == end if #SET cpucounter [#COMPUTE cpucounter + 1]...
Page 179 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 4 of 12) #POP filename maxext size termout eof pri sec #OUTPUT == --------------------------------------------------------- == Display an analysis of disk space == --------------------------------------------------------- #PUSH maxfragments minfreespace addr dsapout dsapout2 #PUSH disk pfree line fragments == Set the number to flag for maximum fragments: #SET maxfragments 100...
Page 180 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 5 of 12) [#LOOP |WHILE| NOT [#EMPTYV dsapout2] |DO| #EXTRACTV dsapout2 line == data line #SET disk [#CHARGET line 1 FOR 8] == disk name #SET fragments [#CHARGET line 45 FOR 4] == fragment count [#IF fragments >...
Page 181 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 6 of 12) ] == end def #OUTPUT == --------------------------------------------------------- == Report on databases. == (Insert database files that you want to monitor.) == The format is: filename AcceptableIndexlevelNumber == Example: LVL $SYSTEM.SYSTEM.USERID 1...
Page 182 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 7 of 12) [#IF NOT deverror |THEN| #OUTPUT #OUTPUT All Spooler devices OK. ] == end if #POP deverror spoolout line collector state size device #POP errornum #OUTPUT == ---------------------------------------------------------...
Page 183 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 8 of 12) == Get the percent full for TMF audit trail files #OUTPUT [#LOOP |DO| #SET file [#FILENAMES/MAXIMUM 1, PREVIOUS [file]/$*.AUDIT.*] [#IF (NOT [#EMPTYV file]) |THEN| [#SETMANY eof primary secondary code , [#FILEINFO/EOF,PRIMARY,SECONDARY,CODE /[file]] ] == end setmany...
Page 184 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 9 of 12) [#IF NOT [#CHARFINDV scanline 6 "?"] |THEN| [#IF NOT [#CHARFINDV scanline 8 "-P"] NOT [#CHARFINDV scanline 8 "-M "] AND [#CHARFINDV scanline 18 " *"] |THEN| #OUTPUT [#CHARGET scanline 6 FOR 10] using &...
Page 185 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 10 of 12) #LINEDEL pupout 1 for 2 == delete banner == Remove "#listbad" #SET addr [#CHARFIND pupout 1 #LISTBAD] [#LOOP |WHILE| [addr] > 0 |DO| #CHARDEL pupout [addr] for 9 #SET addr [#CHARFIND pupout addr #listbad] ] == end loop...
Page 186 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 11 of 12) == --------------------------------------------------------- == Check the status of other devices == --------------------------------------------------------- #PUSH puplistdev scanline state device otherdevs #OUTPUT Checking status of other devices ... PUP /OUTV puplistdev/ LISTDEV #EXTRACTV puplistdev scanline == headings #EXTRACTV puplistdev scanline == blank...
Page 187 Example of a System Management Program Monitoring System Operation Figure 8-1. Monitoring System Status (Page 12 of 12) [#CASE [state] |D| #OUTPUT [#CHARGET scanline 6 FOR 10] down |H| #OUTPUT [#CHARGET scanline 6 FOR 10] Hard down |R| #OUTPUT [#CHARGET scanline 6 FOR 10] reviving |S| #OUTPUT [#CHARGET scanline 6 FOR 10] Special state |I| #OUTPUT [#CHARGET scanline 6 FOR 10] Inaccessible |OTHERWISE|...
Page 188 Example of a System Management Program Monitoring System Operation (This page left intentionally blank) 8–14 107365 Tandem Computers Incorporated...
Page 189: Section 9 Syntax Summary
The specialized forms of the #DEF function used to create and redefine structured variables (STRUCT declarations) The specialized forms of the #SET function used to assign values to TACL built-in variables The commands of the #DELTA character processor :UTILS:TACL...
Page 190 Syntax Summary :UTILS:TACL Commands and Functions ALL ASSIGN CLEAR ALL PARAM ASSIGN logical-unit PARAM param-name COLUMNIZE list COMMENT [ comment-text ] _COMPAREV string-1 string-2 COMPUTE expression _CONTIME_TO_TEXT contime-list _CONTIME_TO_TEXT_DATE contime-list _CONTIME_TO_TEXT_TIME contime-list COPYDUMP [ / run-option [ , run-option ] … / ]...
Page 191 Syntax Summary :UTILS:TACL Commands and Functions FILES [ / OUT list-file / ] [ subvol-template [ [,] subvol-template ] … ] FILETOVAR file-name variable-level HELP HISTORY [ num ] HOME [ directory-name ] INFO [ / OUT list-file / ] DEFINE define-name-list [, DETAIL ]...
Page 192 Syntax Summary :UTILS:TACL Commands and Functions PAUSE [ [\ node-name .]{$ process-name | cpu , pin } ] PMSEARCH subvol-spec [ [,] subvol-spec ] … PMSG { ON | OFF } POP variable [ [,] variable ] … PPD [ / OUT list-file / ] [ [\ node-name .][ { $ process-name | cpu , pin | * } ] ]...
Page 193 SWITCH SYSTEM [ \ node-name ] SYSTIMES [\ node-name .]TACL [ / run-option [ , run-option ] … / ] [ backup-cpu-num ] [ ; parameter [ , parameter ] ] TIME USE [ directory-name [ [,] directory-name ] … ] USERS [ / run-option [ , run-option ] …...
Page 194: Built-In Functions And Variables
The following summarizes the syntax of the built-in functions and variables used for Variables programming in TACL: #ABEND [ / option [ , option ] … / ] [ [\ node-name .]{$ process-name | cpu , pin } [ text ] ] #ABORTTRANSACTION #ACTIVATEPROCESS [ [\ node-name .]{$ process-name | cpu , pin } ]...
Page 195 Syntax Summary Built-In Functions and Variables #CHARFIND [ / EXACT / ] variable-level char-addr text #CHARFINDR [ / EXACT / ] variable-level char-addr text #CHARFINDRV [ / EXACT / ] variable-level char-addr string #CHARFINDV [ / EXACT / ] string-1 char-addr string-2 FOR˚char-count #CHARGET variable-level char-addr-1 TO˚char-addr-2...
Page 196 Syntax Summary Built-In Functions and Variables #DEFINEDELETE define-name #DEFINEDELETEALL #DEFINEINFO define-name #DEFINEMODE #DEFINENAMES define-template #DEFINENEXTNAME [ define-name ] define-name attribute-name #DEFINEREADATTR cursor˚˚mode #DEFINERESTORE [ / option [ , option ] … / ] buffer #DEFINERESTOREWORK #DEFINESAVE [ / WORK / ] define-name buffer #DEFINESAVEWORK #DEFINESETATTR attribute-name [ attribute-value ] #DEFINESETLIKE define-name...
Page 197 Syntax Summary Built-In Functions and Variables #ENDTRANSACTION #EOF variable-level #ERRORNUMBERS / option [ option ] … / #ERRORTEXT #EXCEPTION #EXIT #EXTRACT variable-level #EXTRACTV from-variable-level to-variable-level #FILEGETLOCKINFO [ / option / ] fvname control lockdesc participants #FILEINFO / option [ , option ] … / file-name #FILENAMES [ / option [ , option ] …...
Page 198 Syntax Summary Built-In Functions and Variables #INPUTEOF #INPUTV [ / option [ , option ] … / ] variable-level prompt-string #INSPECT #INTERACTIVE [ / CURRENT / ] #INTERPRETJULIANDAYNO julian-day-num #INTERPRETTIMESTAMP four-word-timestamp #INTERPRETTRANSID transid #JULIANTIMESTAMP [ type [ tuid-request ] ] #KEEP num variable #KEYS #LINEADDR variable-level char-addr...
Page 199 Syntax Summary Built-In Functions and Variables #MOM #MORE #MYGMOM #MYPID #MYSYSTEM #MYTERM #NEWPROCESS program-file [ / option [, option ]… / ] [ param-set ] #NEXTFILENAME [ file-name ] #OPENINFO / option [ , option ] / { file-name | device-name } #OUT #OUTFORMAT #OUTPUT [ / option [ , option ] …...
Page 200 #SERVER / option [ , option ] … / [ server-name ] [ / option [‚ option ] / ] variable-level [ text ] #SET built-in-variable [ built-in-text ] #SETBYTES destination source #SETCONFIGURATION / option [, option ] .../[ tacl-image-name ] #SETMANY variable-name-list , [ text ] #SETPROCESSSTATE LOGGEDON TSNLOGON...
Page 201 Syntax Summary Built-In Functions and Variables #SORT [ / option / ] [ text ] #SPIFORMATCLOSE #SSGET [ / option [ , option ] … / ] buffer-var get-op #SSGETV [ / option [ , option ] … / ] buffer-var get-op result-var #SSINIT [ / TYPE 0 / ] buffer-var ssid command [ / type-0-option [ , type-0-option ] …...
Page 202 Syntax Summary Built-In Functions and Variables #WAIT variable-level [ variable-level ] … #WAKEUP #WIDTH 9–14 107365 Tandem Computers Incorporated...
Page 203: Struct Declarations
Syntax Summary STRUCT Declarations STRUCT Declarations The following summarizes the forms of the #DEF function used to create and redefine structured variables: #DEF variable STRUCT BEGIN declaration [ declaration ] … END ; LIKE structure-identifier ; type identifier [ VALUE initial-value ] ; type identifier ( lower-bound : upper-bound ) [ VALUE initial-value ] ;...
Page 204: Set Summary
#SET #HELPKEY [ key-name ] #SET #HIGHPIN { OFF | ON } #SET #HOME directory #SET #IN file-name #SET #INFORMAT { PLAIN | QUOTED | TACL } #SET #INLINEECHO num #SET #INLINEOUT num #SET #INLINEPREFIX [ prefix ] #SET #INLINETO [ variable-level ]...
Page 205: Delta Command Summary
Syntax Summary #DELTA Command Summary #SET #WAKEUP num #SET #WIDTH num #DELTA Command Table 9-1 summarizes the syntax of the #DELTA character processor commands. Summary Table 9-1. #DELTA Commands (Page 1 of 2) Command Description Convert ASCII y,xA Convert ASCII with error return Beginning Character move Character move with return code...
Page 206 Syntax Summary #DELTA Command Summary Table 9-1. #DELTA Commands (Page 2 of 2) Command Description Write lines y,xP Write characters Qvar$ Get value from variable level xStext$ Search x:Stext$ Search with return code Type lines y,xT Type characters @Tvar$ Type variable level contents :Ttext$ Type text xUvar$...
Page 207: Appendix A Supplemental Information For D-Series Systems
Changes to completion code handling Changes to the EMS and SPI interfaces For detailed information about D-series changes to the TACL product, including a list of required and optional changes, see the TACL Reference Manual. The following manuals contain additional information about D-series software: The Introduction to D-series Systems provides an overview of D-series enhancements.
Page 208 $CMON process and run processes at high PINs, note that the format of the ALTERPRIORITY message has been extended to support process handles. When a user attempts to alter the priority of a process, the TACL process sends an ALTERPRIORITY (-56) message to $CMON. This message contains the process identifier of the target process.
Page 209 == phandle of target process END; TACL sends the new message to a C-series $CMON if a user on a D-series operating system attempts to alter the priority of a process running on a C-series system. The C-series $CMON process can extract a valid process identifier and ignore the extra words in the message.
Page 210 Supplemental Information for D-Series Systems Processing Completion Information TACLSEGF (supplied by Tandem) defines :_COMPLETION^PROCDEATH as follows: [#DEF :_completion^procdeath STRUCT BEGIN z^msgnumber; STRUCT z^base REDEFINES z^msgnumber; BEGIN CHAR byte(0:1); END; PHANDLE z^process handle; INT4 z^cputime; z^jobin; z^completion^code; z^termination^code; z^killer^craid; REDEFINES z^termination^code; SSID z^subsystem;...
Page 211 (as returned by #SSGET or #OUTVAR). Each integer can range from 0 to 65535. Use this external form whenever you send a process handle to TACL (as used by #SSPUT and #SET). The following example shows a process handle in TACL external form: 1.3.5.7.9.11.13.15.17.19...
Page 212 Supplemental Information for D-Series Systems Communicating With Programmatic Interfaces ten integers, each ranging from 0 to 65535. A null process handle consists of ten integers, each of which has the value 65535. A new built-in function, #CONVERTPHANDLE, converts process file identifiers to process handles and process handles back to process descriptors.
Page 213: Glossary
A text string that directs the computer to perform a task. Commands are usually composed of a verb that tells the computer what to do and an object or list of objects that is acted on by the verb. TACL commands are interpreted by TACL and are extensible.
Page 214 RUN or RUND command, an implied RUN, or a #NEWPROCESS built-in function, or for which TACL was most recently paused by a PAUSE proc-spec command or a #PAUSE proc-spec built-in function; if that process is no longer running, there is no default process.
Page 215 A unit composed of one or more labels, such as |THEN| or |DO|, and the text associated with each label. Enclosures are found only in the TACL built-in functions #DEF, #IF, #CASE, and #LOOP, which are enclosed in brackets to provide boundaries for their enclosures.
Page 216 The mechanism by which a processor module is notified of an asynchronous event that requires immediate processing. invoke. A request to execute TACL code. To invoke a variable, (1) list its name (like an implied RUN statement) without regard to results or (2) surround the variable name in square brackets ([]) to replace the name with its expansion (text or macro variable) or results (routine).
Page 217 A named sequence of one or more instructions invoked by the appearance of the macro name. When a macro is invoked, TACL replaces arguments of the form %n% with actual arguments passed to it and returns, as a result, the instructions that define the macro, including argument values.
Page 218 I/O process. Contrast with conversational mode. PAID. See process access ID. PARAM. An association of an ASCII value with a parameter name made by the TACL PARAM command. You can use PARAMs to pass parameter values to processes.
Page 219 The time represented by a processor clock. program. A sequence of instructions and data. In TACL, variables of type TEXT, MACRO, and ROUTINE can define programs. real time. See wall-clock time.
Page 220 See also primary extent. segment. A unit of storage consisting of up to 64 pages of 1,024 words each. segment file. As used by TACL, a file accessible by TACL that can contain TACL code and data.
Page 221 A set of characters from the ISO 8859.1 character set. The length of text can be limited by a specific function or command. TACL interprets a text argument as all remaining text on the line, with leading and trailing spaces and end-of-line characters removed.
Page 222 Glossary user process. A process whose primary purpose is to solve a user’s problem. A user process is not essential to the availability of a processor module and is created only when the user explicitly creates it. Contrast with system process. variable.
Page 223 Index Accessing structured data Address, character 2-11 ALIAS variables 2-24 Argrec example 3-17 Arguments alternatives (such as NUMBER and STRING) 3-3 parsing for a caller 3-11 processing a space-separated list 3-8 processing file names 3-7 processing variables 3-8 to routines 3-1 ASSIGN command 5-3 ATTRIBUTENAME argument alternative 3-3 BREAK, for debugging 2-32...
Page 224 Index Built-in functions (continued) #EMSADDSUBJECT(V) 7-12 #EMSGET(V) 7-12 #EMSINIT(V) 7-12 #EMSTEXT(V) 7-12 #EOF 5-16, 5-19 #ERRORTEXT 3-22, 3-27 #EXCEPTION 3-19, 3-24, 3-27, 3-32 #EXTRACT 2-15, 4-2, 5-1, 5-5, 5-16 #EXTRACT(V) 7-3 #EXTRACTV 2-28, 4-11, 5-31, 5-37 #FILEINFO 2-5, 2-34, 4-16, 8-4, 8-8 #FILENAMES 8-8 #FILTER 3-22, 3-25, 3-32 #FRAME 2-3, 2-8, 5-4...
Page 225 Index Built-in functions (continued) #PROCESSINFO 8-3 #PROCESSORSTATUS 8-3 #PROCESSORTYPE 8-3 #PROMPT 2-29 #PURGE 2-5, 4-16 #PUSH 2-3, 2-8 #RAISE 3-29, 3-32 #REPLYPREFIX 6-5, 6-8 #REPLYV 6-5, 7-5 #REQUESTER 2-17, 4-2, 5-1, 5-5, 5-21, 5-25, 5-37, 6-2, 7-3, 7-15 #RESET 3-17, 3-21, 3-27, 3-32 #RESET FRAMES 2-8 #REST 3-5, 3-16 #RESULT 3-8, 3-15...
Page 226 Checkfiles example 2-4 Ckup example 8-1 CLOSEPAREN argument alternative 3-3 CMON process 5-25 COMMA argument alternative 3-3, 3-12 Commands for debugging TACL programs 2-32 ASSIGN 5-3 FILETOVAR 2-16 for data manipulation 2-16 for global editing 2-13 INLPREFIX 5-7 PARAM 5-3...
Page 227 DEFINE 5-4 Define Process (DP) facility 5-31 Display example 2-25 Displayinfo example 2-27 Distributed System Management See DSM DSM and TACL 7-1 Dumplog example 7-10 Editing commands 2-13 Editing variables 2-11 Emptyspool example 5-11 and TACL 7-1/15 calling EMSDIST 7-12...
Page 228 Index Examples (continued) caller 3-16 checkfiles 2-4 ckup 8-1 command_processor 3-21 copier 2-2 copy 4-10 dayofweek 2-22 defaultvars 2-8 display 2-25 displayinfo 2-27 dumplog 7-10 emptyspool 5-11 enquiry 5-35 fcomp 4-12 fup2 5-18 fupin 5-17 getdates 2-23 inline_fup 5-7 inline_fup_log 5-10 inline_fup_log2 5-11 lock 2-28 menu 2-30...
Page 229 Index Examples (continued) TACL as a Pathway server 6-6 taclevent 7-13 tacllist 4-16 tedsave 2-33 volname 2-12 volnames 2-15 waited_read 4-3 waited_write 4-7 Exception handlers description of elements of 3-19 keep type 3-24 release type 3-20 types 3-19 Exception handlers, description of 3-18...
Page 230 Index IN file 5-1, 5-3 setting to $RECEIVE 6-3 INLINE facility description of 5-1, 5-6/13 handling _BREAK exception 5-13 INLINE run option 5-6 limitations 5-13 stopping processes 5-13 Inline_fup example 5-7 Inline_fup_log example 5-10 Inline_fup_log2 example 5-11 INLPREFIX command 5-7 INV option limitations 5-20 INV option (RUN and NEWPROCESS), NEWPROCESS)
Page 231 Index OPENPAREN argument alternative 3-3 OTHERWISE alternative for ARGUMENT built-in function OTHERWISE argument alternative 3-6 OUT file 5-1, 5-3 reading from 5-35 saving 2-8 setting to $RECEIVE 6-4 OUTV option limitations 5-20 OUTV option (RUN and NEWPROCESS), NEWPROCESS) OUTV run option 2-15 PARAM command 5-3 Pathway example 6-6 Process handles A-5...
Page 232 Same_ssid example 7-9 Script example 5-8 Send example 5-22 Serv example 5-30 Server programs testing 5-25 Server, TACL as a 6-1/12 SETPROMPT Command 2-29 Show_spooler_jobs example 5-19 SINK command 2-30 SLASH argument alternative 3-3 and D-series software A-5 and TACL 7-1/12...
Page 233 SYSTEM command 2-29 TACL D-series features A-1 programs, nesting 2-7 running as a server TACL Error example 3-26 TACL, running as a server 6-1 TACLCSTM file 6-5 Taclevent example 7-13 Tacllist example 4-16 Tedsave example 2-33 TEMPLATE argument alternative 3-24 Index–11...
Page 234 Index Templates example 3-22 Terminals sending escape sequences to 2-25 TIME command 8-13 Timestamps 2-17 TOKEN argument alternative 3-3 Token code 7-3 Token code (SPI) 7-8 Token map (SPI) 7-8 USER argument alternative 3-3 Variable levels, using 2-3 variable INV 5-1 OUTV 5-1 :_COMPLETION 5-32 VARIABLE argument alternative 3-8...
Page 235 See Built-in functions #built-in variable See Built-in variables $CMON 5-25, A-2 $RECEIVE 5-1, 5-5, 7-3 and TACL as a server 6-1 using for process communication 5-21/29 %0%, using to call a macro recursively 2-7 :_COMPLETION’ variable; 5-32 _COMPAREV command 2-5...

HP TACL Programming Manual

Section 1 an Overview of TACL

Section 2 Developing TACL Programs

Index

Section 3 Developing TACL Routines

Section 4 Accessing Files

Section 5 Initiating and Communicating with Processes

Section 6 Running TACL as a Server

Section 7 Using Programmatic Interfaces

Section 8 Example of a System Management Program

Section 9 Syntax Summary

Appendix A Supplemental Information for D-Series Systems

Glossary

Quick Links

Related Manuals for HP TACL

Summary of Contents for HP TACL

Table of Contents