HP NonStop TACL Reference Manual Abstract This publication describes the syntax and use of the HP Tandem Advanced Command Language (TACL) variables, commands, and built-in functions. Product Version T9205D46, T9205H01 Supported Release Version Updates (RVUs) This publication supports J06.03 and all subsequent J-series RVUs, H06.03 and all subsequent H-series RVUs, G06.20 and all subsequent G-series RVUs, and D46.00 and all subsequent D-series RVUs, until otherwise indicated by its replacement publications.
Document History Part Number Product Version Published 429513-014 T9205D46, T9205H01 August 2011 429513-015 T9205D46, T9205H01 February 2012 429513-016 T9205D46, T9205H01 August 2012 429513-017 T9205D46, T9205H01 August 2013 429513-018 T9205D46, T9205H01 April 2014
Legal Notices © Copyright 2014 Hewlett-Packard Development Company L.P. Confidential computer software. Valid license from HP required for possession, use or copying. Consistent with FAR 12.211 and 12.212, Commercial Computer Software, Computer Software Documentation, and Technical Data for Commercial Items are licensed to the U.S. Government under vendor's standard commercial license. The information contained herein is subject to change without notice.
HP NonStop TACL Reference Manual Glossary Legal Notices Index Examples Figures Tables 1 What’s New in This Manual xvi Manual Information xvi New and Changed Information About This Manual xix Audience xix Organization xix Related Reading xx Notation Conventions xxii HP Encourages Your Comments xvi xxvi 1. Overview of TACL SPR Requirements for Increased Enscribe Limits for the H06.28/J06.
3. Expressions Contents Constants 2-8 Text Constants 2-8 String Constants 2-9 Reserved Words 2-9 Comments 2-10 3. Expressions Operators 3-1 Arithmetic Operations 3-2 Logical Operations 3-2 4.
5. Statements and Programs Contents Redefining a Structure 4-23 Setting or Altering Structured Data 4-25 Accessing Structured Data 4-26 DIRECTORY Variables 4-28 Declaring a Directory Variable 4-29 Accessing a Directory Variable 4-29 Directories Supplied With TACL 4-30 DELTA Variables 4-30 5.
Contents 7. Summary of Commands and Built-In Functions _EXECUTE Variables 6-13 Running a TACL Process in the Background 6-13 Initializing TACL and Specifying Input 6-13 Default Files 6-14 7.
Contents 8.
Contents 8.
9.
9.
9.
Contents 9.
9.
Contents 9.
A.
Contents C. Mapping TACL Built-In Functions to Guardian Procedures RELOAD Error Messages for H-Series Only B-58 Omitslice Information and Error Messages B-61 B-62 RELOAD Error Messages for H-Series, G-Series and D-Series EMS Messages B-69 Error Numbers B-70 B-62 C. Mapping TACL Built-In Functions to Guardian Procedures Glossary Index Examples Figures Figure 6-1. TACL Segment File and Directory Relationships 6-11 Tables Table 2-1. Table 2-2. Table 2-3. Table 3-1. Table 4-1. Table 4-2. Table 4-3.
Contents Table 7-12. Table 7-13. Table 7-14. Table 7-15. Table 8-1. Table 8-2. Table 8-3. Table 8-4. Table 8-5. Table 8-6. Table 8-7. Table 8-8. Table 8-9. Table 9-1. Table 9-2. Table 9-3. Table 9-4. Table 9-5. Table 9-6. Table 9-7. Table 9-8. Table 9-9. Table 9-10. Table 9-11. Table 9-12. Table 9-13. Table 9-14. Table 9-15. Table 9-16. Table A-1. Table B-1. Table B-2. Table C-1.
What’s New in This Manual Manual Information HP NonStop TACL Reference Manual Abstract This publication describes the syntax and use of the HP Tandem Advanced Command Language (TACL) variables, commands, and built-in functions. Product Version T9205D46, T9205H01 Supported Release Version Updates (RVUs) This publication supports J06.03 and all subsequent J-series RVUs, H06.03 and all subsequent H-series RVUs, G06.20 and all subsequent G-series RVUs, and D46.
Changes to the 429513-017 manual What’s New in This Manual • Added information on SET _DO_NOT_PROMPT_TACL_STOP Command on page 8-195. • • • Updated the Considerations section of the STATUS Command on 8-211. • • • Updated the information in Table 9-1, Built-In Functions, on page 9-2. • Updated the information in Table C-1, TACL Built-In Functions and Guardian Procedures on page C-6. • Added SPR Requirements for Increased Enscribe Limits for the H06.28/J06.17 Release on page 1-1.
Changes to the 429513-016 manual What’s New in This Manual Changes to the 429513-016 manual • • • Updated the IPUCOM Program Considerations on page 88. Updated the RUN[D|V] Command on page 8-156. Added SEMSTAT Program on page 8-169. Changes to the 429513-015 manual • Added CLICVAL program and its function in Commands and Programs table. Changes to the 429513-014 manual • • • Added IPUCOM program and its brief function in Commands and Programs table.
About This Manual This manual contains reference material describing the HP Tandem Advanced Command Language (TACL). It presents the syntax and operations of all standard commands and functions available in the :UTILS:TACL directory (embodying the command interpreter capability of the TACL product), as well as the syntax and description of TACL built-in functions and built-in variables (the programming language aspect of the TACL product).
Related Reading About This Manual Appendix A, Syntax Summary Provides a syntax summary of all TACL functions. Appendix B, Error Messages Describes types of error messages and includes a list of TACL error messages. Appendix C, Mapping TACL Built-In Functions to Guardian Procedures Maps TACL built-in functions to Guardian procedures. Related Reading The following paragraphs list manuals that are related to the use of the TACL product, either as a command interpreter or as a programming language.
Corequisites About This Manual ° ° ° ° ° Guardian Programmer’s Guide Guardian Procedure Calls Reference Manual Guardian Procedure Errors and Messages Manual NonStop S-Series Operations Guide Security Management Guide HP NonStop TACL Reference Manual—429513-018 xxi
Notation Conventions About This Manual Notation Conventions Hypertext Links Blue underline is used to indicate a hypertext link within text. By clicking a passage of text with a blue underline, you are taken to the location described. For example: This requirement is described under Backup DAM Volumes and Physical Disk Drives on page 3-2. General Syntax Notation This list summarizes the notation conventions for syntax presentation in this manual. UPPERCASE LETTERS.
General Syntax Notation About This Manual { } Braces. A group of items enclosed in braces is a list from which you are required to choose one item. The items in the list can be arranged either vertically, with aligned braces on each side of the list, or horizontally, enclosed in a pair of braces and separated by vertical lines. For example: LISTOPENS PROCESS { $appl-mgr-name } { $process-name } ALLOWSU { ON | OFF } | Vertical Line.
Notation for Messages About This Manual a blank line. This spacing distinguishes items in a continuation line from items in a vertical list of selections. For example: ALTER [ / OUT file-spec / ] LINE [ , attribute-spec ]… !i and !o. In procedure calls, the !i notation follows an input parameter (one that passes data to the called procedure); the !o notation follows an output parameter (one that returns data to the calling program).
Notation for Management Programming Interfaces About This Manual lowercase italic letters. Lowercase italic letters indicate variable items whose values are displayed or returned. For example: p-register process-name [ ] Brackets. Brackets enclose items that are sometimes, but not always, displayed.
Change Bar Notation About This Manual UPPERCASE LETTERS. Uppercase letters indicate names from definition files. Type these names exactly as shown. For example: ZCOM-TKN-SUBJ-SERV lowercase letters. Words in lowercase letters are words that are part of the notation, including Data Definition Language (DDL) keywords. For example: token-type !r. The !r notation following a token or field name indicates that the token or field is required. For example: ZCOM-TKN-OBJNAME !o. token-type ZSPI-TYP-STRING.
1 Overview of TACL TACL is a software application that provides an interface to the HP NonStop operating system. You can use TACL either as an interactive command interface or as an interpreted programming language to construct programs. This manual describes the syntactical elements of TACL. • • The Guardian User’s Guide describes how to use TACL interactively. The TACL Programming Guide describes how to construct TACL programs.
Using TACL Interactively Overview of TACL collective term. To achieve these increased limits with H06.18 and J06.17 RVUs, the following SPRs are required. (These SPR requirements could change or be eliminated with subsequent RVUs.
Developing TACL Programs Overview of TACL To obtain syntax help while you are typing a command, press the F16 key (or the appropriate help key defined in your environment) at the point in the command where you want help.
Language Features Overview of TACL This manual describes TACL syntax and semantics. For more information about how to use TACL for specific programming tasks, see the TACL Programming Guide. Language Features TACL provides a set of predefined commands, functions, and data variables. These entities are built into the TACL language and are the building blocks with which you construct TACL programs: • TACL built-in functions are intended for use in TACL programs.
Program Development Tools Overview of TACL • Argument passing. You can pass arguments to TACL programs. The mechanism depends on the type of program (text, macro, or routine). • Data operations. You can compare, move, and manipulate the contents of variables that contain text or TACL statements. For additional information about TACL programs, see Section 5, Statements and Programs.
2 Lexical Elements TACL consists of these lexical elements: • • • • • Character Set Special Characters Constants Reserved Words Comments Character Set TACL supports the ISO 8859.1 (International Organization for Standardization) character set, also called the ECMA-94 (European Computer Manufacturers Association) character set, which is an 8-bit character set with 256 character positions.
Special Characters Lexical Elements Special Characters There are six types of characters that have special meaning to TACL: Character Name Description Metacharacters Requests that TACL interpret subsequent text in a special way Separator Delineates keywords, variable names, and so forth Question mark Command line editing directive Ampersand Continues current line on the next physical line Template Provides wild-card matching for file names Operator Specifies arithmetic, relational, or logical
Metacharacters Lexical Elements Table 2-1 lists TACL metacharacters. Table 2-1. TACL Metacharacters Character(s) Name Description [] Square brackets Causes TACL to expand the enclosed text Double equal signs Specifies a comment from the equal signs to the end of the line == For additional information, see Square Brackets ([ ]) on page 2-3. For additional information, see Comments on page 2-10.
Metacharacters Lexical Elements you can enclose var1 in square brackets to obtain the contents of var1 or you can omit the brackets to obtain the text var1: 12> #OUTPUT [var1] 3 13> #OUTPUT var1 var1 14> If the variable is a routine that contains executable TACL statements, TACL interprets the executable statements and replaces the variable name with the result of the statements.
Separator Characters Lexical Elements In the third case, line 20, TACL expands #OUTPUT entirely within the limits of the square brackets, producing a blank line of output; then TACL invokes #PMSEARCHLIST. If you need to output a square bracket from a TACL program, you can use the ~[ combination described in Table 2-1 on page 2-3.
Question Mark (?) Lexical Elements Question Mark (?) TACL uses the question mark character for two purposes: • • Displaying previous command lines Specifying the start of a TACL directive To start a line with a question mark for any other purpose, use two question marks. TACL then discards the first question mark and any adjacent spaces and treats the remainder of the line as text.
Template Characters Lexical Elements Subvolume Templates Several TACL commands and built-in functions allow you to supply subvolume templates in place of actual subvolume names. The TACL command or built-in function then operates on one or more similarly named files. A subvolume specification includes these fields: [[[\node-name.]$volume-name.] subvolume-name.
Operators Lexical Elements Operators Operators perform mathematical or logical operations on values. The operators provided by TACL can be divided into three categories: • • • Arithmetic Logical String For a complete list of operators, see Section 3, Expressions. Constants A constant is a value that you can store in a variable, use as a literal, or specify as part of an expression. There are two types of TACL constants: text constants and string constants.
String Constants Lexical Elements in the Transaction Application Language (TAL). The internal representation is a 64-bit fixed-point binary number. The valid range is: -9223372036854775808 to +9223372036854775807 This range is called max-int in command descriptions and function descriptions in this manual. These integers are valid • • • 145 4 -89776 TACL uses integer values for logical operations and comparisons. TACL interprets zero as FALSE and nonzero integers as TRUE.
Comments Lexical Elements preserving the former value. For more information about variables and variable levels, see Section 4, Variables. Note. TACL does not prevent you from redefining TACL commands. You can, for example, define a macro or function with the name TIME-a standard TACL command. You can also load a segment file that has the same name as a TACL command. If you make such a change, TACL will not act in its standard manner; it will, instead, execute your code.
Comments Lexical Elements processes as such all subsequent lines of text until it encounters a right bracket. ° If the text contains braces, the rules for that form of comment also apply.
3 Expressions An expression can be a text, string, or integer constant, a variable, or a value obtained by combining constants, variables, and other expressions with operators. This section describes operators and how to use them in expressions. Operators Operators perform operations on values.
Arithmetic Operations Expressions Table 3-1. TACL Operators (page 2 of 2) Operator Function Type of Operation Precedence '=' or '!' Equal to Relational (strings) 3 '<>' or '!<>' Not equal to3 Relational (strings) 3 AND AND Logical 4 OR OR Logical 5 String operators that include an exclamation point (!) are case-sensitive; those without exclamation points make no distinction between uppercase and lowercase letters.
Logical Operations Expressions If you use a variable as an operand, you do not need to enclose the variable name in square brackets. Note. TACL evaluates all operands in a logical expression, even after the first FALSE (in an AND expression) or the first TRUE (in an OR expression). Therefore, all variables used in such expressions must first be initialized using #SET or a similar command or built-in function.
4 Variables In many other languages, the term variable refers to a simple variable that contains a single element, such as the number 10, or a more complex variable that contains an set of elements. In TACL, a variable can contain a single element, a set of elements, or information as diverse as a hierarchy of variables or a series of TACL statements. You can create, set, and delete variables. You can access variables interactively or load them into memory from a file.
Variable Names Variables Table 4-1. TACL Variables and Their Uses (page 2 of 2) Variable Type Description STRUCT Contains binary data and a set of type definitions that control the conversion of the binary information to and from associated textual representations DELTA Contains a sequence of commands for the TACL low-level text manipulator (#DELTA) You cannot execute a DELTA variable as a TACL function. DIRECTORY Contains an entire set of variables A DIRECTORY has a hierarchical structure.
Variable Levels Variables list of necessary directories depends on the TACL software RVU and must not be hard coded in your TACL programs. Variable Levels A variable level is an important organizational concept associated with TACL variables. Whenever you create a variable, TACL creates a stack for the variable. Each element of the stack is known as a variable level. The stack organization allows you to create local copies of a variable.
Specifying a Level of a Variable Variables The choice of a declaration mechanism depends on whether you want to define the variable interactively, within a file, or in a library. For more information about files and libraries, see Section 5, Statements and Programs. When you create a variable, TACL creates level 1 of the variable. To create additional levels, push or define the same variable. TACL then creates a new level of the variable and increments the level number.
Deleting a Variable Variables Deleting a Variable Table 4-3 lists TACL functions that delete variables. Table 4-3.
Using a Variable as an Argument Variables |ELSE| #OUTPUT Value is OK ] • To expand a result or the contents of a variable, include an extra set of brackets beyond any others required by the foregoing rules.
Sample Declarations Variables For example, if you replace the TACL STATUS command with a macro called STATUS, you can no longer use the TACL STATUS command. To access the TACL STATUS command, you must make the variable S an alias for :UTILS:TACL:STATUS. You can also use alias variables to define function keys. For more information, see the Guardian User’s Guide.
Macro Arguments Variables For information about TACL statements, see Section 5, Statements and Programs. For additional examples of TACL macros, see the TACL Programming Guide. Macro Arguments A macro accesses arguments by position. To access an argument, specify the position, enclosed in percent signs (% n%). For example, %1% references the first argument supplied when the variable is invoked. Table 4-4 lists several ways to access macro arguments from within a macro. Table 4-4.
ROUTINE Variables Variables This macro displays each of its arguments on a separate line: ?TACL MACRO #OUTPUT %1% == Output the current argument [#IF NOT [#EMPTY %2 TO *%] == Test for additional arguments |THEN| %0% %2 TO *% == Call self with first arg. gone ] ROUTINE Variables A routine variable contains TACL statements. When TACL encounters a routine, it executes the routine and replaces the invocation with the results returned by the routine.
Sample Declaration Variables exist to be a valid file-name argument, but if you specify SYNTAX, TACL checks only for correctness of the file-name syntax.) If the argument matches a listed type, the argument is placed into a specified variable, and TACL returns a number that indicates the argument type. If the argument does not fit any of the specified types, the routine terminates and generates an error message, listing the types of arguments that were expected.
Comparing Argument Handling in Macros and Routines Variables ] #UNFRAME The SINK commands discard the results of #ARGUMENT and prevent TACL from echoing to the TACL OUT file. A successful evaluation returns 1; otherwise, the routine terminates with an error. You could also use a #SET call to evaluate the results. Comparing Argument Handling in Macros and Routines These examples show the difference in argument processing between macros and routines.
STRUCT Variables Variables The VALUE option of the #ARGUMENT function returns the fully qualified form of the file-name argument. STRUCT Variables A STRUCT variable, or structure, is a special-purpose variable that contains a set of named and typed data items that you can access individually or as a group. Use STRUCTs to access the Subsystem Programmatic Interface (SPI), the Event Management Service (EMS), or if you need to store binary data such as 6530 terminal escape sequences.
Declaring a Structure Body Variables • Assigning values to the STRUCT using #SET (programmatic), SET VARIABLE (interactive), #SETBYTES, or #SETV • Comparing the STRUCT to another structure or structure item using #COMPAREV (programmatic) or _COMPAREV (interactive) • Specifying a STRUCT as the source variable for #OUTPUTV (programmatic), OUTVAR (interactive), #APPENDV, or #REPLYV • • • • • Specifying a STRUCT as the destination variable for #EXTRACTV Appearing as the prompt or destination variable f
Declaring a Structure Body Variables Considerations • • The BEGIN ... END form can contain declarations for: ° ° ° ° ° Simple data items Array data items Substructures FILLER bytes Redefinitions The use of LIKE conserves variable space, because like structures and substructures use the same structure-accessing information. Accessing information is not part of a particular structure. The original structure and all like structures merely point to the access information.
Declaring a Simple Data Item Variables an even number of bytes. In this case, either all occurrences of the substructure are word-aligned or none are. Declaring a Simple Data Item A simple data item declaration associates an identifier with a single-element data item.
Declaring a Simple Data Item Variables FNAME32 is a 16-word internal file name of the form used by the Distributed Name Service (DNS), consisting of a 4-word internal-format node name followed by a 12-word internal-format local file name. INT is a 16-bit signed integer; its value is in the range -32768 to +32767. INT2 is a 32-bit signed integer; its value is in the range -2147483648 to +2147483647. INT4 is a 64-bit signed integer; its value is in the range -9223372036854775808 to +9223372036854775807.
Declaring a Simple Data Item Variables USERNAME is an 8-word internal-format user name in the same form as that produced by the USERIDTOUSERNAME procedure. identifier is a name, 1 to 32 characters in length, which can include alphanumeric, underscore, and circumflex characters; the first character cannot be numeric. identifier is a name, 1 to 32 characters in length, which can include alphanumeric, underscore, and circumflex characters; the first character cannot be numeric.
Declaring an Array Data Item Variables • To describe a high-PIN process, use a PHANDLE item in place of a process identifier (CRTPID). • TACL uses ten unsigned integers, separated by periods, to represent a process handle in external form. Each integer can range from 0 to 65535. Use this external form whenever you send a process handle to TACL (#SSPUT or #SET). This example shows a process handle in TACL external form: 1.3.5.7.9.11.13.15.17.
Declaring a Substructure Variables For CHAR items, initial-value is the same as that defined for a simple data item (in the previous subsection). If you include VALUE but supply an incorrect number of initial values, TACL returns a syntax error. For all other items, initial-value is a space-separated list of values appropriate to the type of the item. End-of-line may also be used as a separator. The list ends when the semicolon is reached.
Declaring FILLER Bytes Variables structure-body contains the declarations that define the substructure. Considerations • You can nest substructures to any practical level. For additional information on substructure alignment, see Declaring a Structure Body on page 4-13. • TACL treats a data item declared without bounds as though it had been declared with bounds (0:0, which is one byte long).
Declaring FILLER Bytes Variables Sample STRUCT Declarations These examples illustrate several STRUCT declarations. 1. This example declares a two-dimensional array. It consists of two occurrences of a substructure, each of which contains 50 occurrences of a substructure. [#DEF buildings STRUCT BEGIN STRUCT warehouse (0:1); BEGIN STRUCT inventory (0:49); BEGIN INT item^number; INT price; INT on^hand; END; END; END; ] 2. This example shows a structure that holds a start-up message.
Declaring FILLER Bytes Variables ] END; x aa b c aa b c aa b c y 4. This example shows storage for substructure occurrences that begin on word boundaries because the substructure starts with an INT item (“a^a”). [#DEF t1 STRUCT BEGIN CHAR x; STRUCT t2 (0:1); BEGIN INT a^a; INT b; CHAR c; END; INT y; END; ] x a^a b c a^a b c y 5.
Redefining a Structure Variables ] LIKE startup_message; END; Redefining a Structure A redefinition declares a new name and description for an existing data item or substructure. This functionality is similar to a redefine in TAL or a variant record in Pascal. The syntax for a redefinition declaration is: type identifier [ ( lower-bound : upper-bound ) ] REDEFINES previous-identifier ; [ structure-body ] type is one of the data types defined in Declaring a Simple Data Item on page 4-15.
Redefining a Structure Variables • The new item must be capable of the same alignment as the previous item. Caution. Data stored by one definition might not be readable when retrieved by using another definition. TACL does not ensure that the data being retrieved is valid under the definition by which it is being retrieved. Examples Examples of redefinition declarations follow. 1. This example redefines part of an INT array as an INT2 array.
Setting or Altering Structured Data Variables 3. In this substructure redefinition, both substructures (“b” and “c”) have the same alignment as required. In this case, both begin on an odd-byte boundary: [#DEF a STRUCT BEGIN CHAR xx; STRUCT b; BEGIN CHAR yy; END; STRUCT c REDEFINES b; BEGIN CHAR zz; END; END; ] Definition xx Redefinition yy xx zz 4.
Accessing Structured Data Variables • If you are storing data in a substructure or array (except of type CHAR) you must enter it into a space-separated list of representations appropriate for the types of those items. If the data is shorter than the substructure or array, TACL sets remaining numeric binary items to binary zero and sets other types of items to spaces. • Data that is being stored into an array of type CHAR is not separated by spaces and may even include spaces.
Accessing Structured Data Variables You can use the #SETV built-in function to copy structures (as well as other types of variables). The output variable level must already exist; its original type and data are lost. The output variable level becomes a structure identical to the input structure and has its own copy of the data. This is a brief summary of what you can and cannot do when copying STRUCT data.
DIRECTORY Variables Variables Data retrieved from a substructure is presented in a space-separated list of standard representations appropriate for the types of those items. Spaces are not inserted between CHAR items, however. Caution. If one or more of the elementary items consists of or contains spaces, be careful if you later access this data with commands or functions that use spaces as delimiters; otherwise, TACL might overlook an item.
Declaring a Directory Variable Variables Directory variables allow you to keep your variables grouped together in a segment file, for your use or for sharing with other users. Segment files are explained in Section 5, Statements and Programs. Declaring a Directory Variable To create a directory, use #DEF or ?SECTION (in a library) and specify the variable type as DIRECTORY. You can also create directories by creating variables.
Directories Supplied With TACL Variables command, and then successively by the directories named in the most recent USE command, until it finds a variable by that name. For example, HOME :a:one USE :b :b:two : :c:d:three OUTVAR d outputs the first one of these that it finds: :a:one:d :b:d :b:two:d :d :c:d:three:d Directories Supplied With TACL TACL keeps product variables separate from your user variables by organizing them into directories within the root directory (:).
5 Statements and Programs A TACL program consists of one or more statements. A TACL statement consists of one of these: • • A function call A directive This section describes the syntax for TACL statements and directives, and then discusses how to create TACL programs, handle completion codes, and process errors. For additional examples of TACL programs, see the TACL Programming Guide.
Function Calls Statements and Programs enclosure specifies that TACL defers expansion of enclosed code until a specific path is selected. (See Considerations.) An enclosure can be used only in a #CASE, #DEF, #IF, or #LOOP built-in function call. An enclosure consists of one or more pairs of labels and text: label A label is a text constant or a space-separated list of text constants, enclosed in vertical lines. Each label precedes and identifies a given portion of text (which may be empty).
Function Calls Statements and Programs • To call your program recursively, use %0% for a macro or #ROUTINENAME to obtain the name of your routine. For examples, see the TACL Programming Guide. • The ?FORMAT directive and #INFORMAT built-in function affect how TACL interprets an argument.
Function Calls Statements and Programs file name. If, however, you specify a volume name, you must specify a subvolume name. This file name is not syntactically correct: $VOLUME.FILE If you specify a partial file name, TACL expands the file name using the current default names for system, volume, and subvolume where necessary. If you specify MYFILE, for example, TACL assumes you mean the file named MYFILE in the current default subvolume, volume, and system.
Directives Statements and Programs • Process handle A process handle contains ten unsigned integers that identify a single named or unnamed process among all processes that are running or have run in one or more system nodes. The process handle is an internal form of identification for a process. System messages, completion code STRUCTs, and SPI buffers contain process handle information. Note. The format of a process handle is defined by the TACL software and is subject to change in future RVUs.
?BLANK Directive Statements and Programs ?BLANK Directive Use the ?BLANK directive to insert a blank line into a variable; this can be useful when you load text that is to be displayed. The syntax is: ?BLANK ?FORMAT Directive Use the ?FORMAT directive to specify how TACL interprets metacharacters in the TACL statements following the directive. The ?FORMAT directive is similar to the #INFORMAT built-in variable, but acts on statements in a file instead of text from the IN file.
?FORMAT Directive Statements and Programs Considerations • • The ?FORMAT value for a library file is set to TACL at every ?SECTION directive. The ?FORMAT value for a macro or routine file that starts with a ?TACL directive is set to TACL at the beginning of the file.
?SECTION Directive Statements and Programs == This output appears as "$" #OUTPUT "[#MYTERM]" If you load the preceding file and invoke this section, TACL produces this output when #OUTFORMAT is set to PLAIN: 14> this^section Using ?FORMAT PLAIN: +------------------------+ | COMMENT [ ] | +------------------------+ Using ?FORMAT QUOTED: "+------------------------+" "| COMMENT [ ] |" "+------------------------+" ?FORMAT TACL, with quotes: "$LM1.
?TACL Directive Statements and Programs example shows how to load two libraries, retaining only one level of each variable in the libraries: 17> LOAD /KEEP 1/ mykeys mymacs • • To invoke a variable after it is loaded, type the variable name. • As a library is loaded, comments are removed to conserve variable space. Any line that is blank, or that becomes blank because of comment removal, is discarded.
Program Structure Statements and Programs Program Structure When you write a TACL program, you define the program as a type of TACL variable. There are four types of variables that can contain executable statements: TEXT, MACRO, ROUTINE, and ALIAS. A program can contain of one or more TACL statements: • A directive, ?TACL or ?SECTION, that indicates that the following lines define a program. • • A #FRAME call that defines a local environment.
How TACL Interprets Statements Statements and Programs If you try to purge TEMP a second time, TACL returns an error message: 19> PRG TEMP Error 11 20> An error 11 indicates that the file was not found: 20> Error 11 011 file not in directory or record not in file, or the specified tape file is not present on a labeled tape How TACL Interprets Statements TACL requires read access to interpret a TACL program. TACL uses a 32,767-byte text buffer to execute statements.
Creating Program Files Statements and Programs • Very large macros or routines. As a rule, macros should never exceed 15,000 bytes after dummy argument substitution; routines should never exceed 15,000 bytes. Nesting reduces these numbers further. • Uncontrolled nesting of macros.
Creating Program Files Statements and Programs if executed in a routine stored in a ?TACL ROUTINE file, returns :_TACL_ROUTINE, allowing the routine to invoke itself. Creating a Library of TACL Statements: The ?SECTION Directive A library is an edit file that contains a sequential list of one or more TACL variable definitions. For each variable, enter a ?SECTION directive at the beginning of the definition, followed by the name of each variable and its type.
Creating Program Files Statements and Programs partial code interpretation, the greater the number of variables you use regularly, the more efficiency you can gain by using personal segment files instead of loading the variables into the default segment. Sharing a Segment File A segment file can be restricted to your TACL process or shared among multiple TACL processes. You can read and modify variables in a private segment file; variables in a shared segment file can be read but not modified.
Creating Program Files Statements and Programs Creating and Accessing a Segment File: An Example This example shows one method for setting up a segment file; it demonstrates most of the commands and functions that relate to segment files, the home directory, the use list, and #PMSEARCHLIST.
Creating Program Files Statements and Programs #OUTPUT Unknown TACL version: [taclversion] ] == End CASE ] == End IF [#CASE [taclversion] | t9205c00 t9205c10 | USE :mydir | OTHERWISE | ] #POP taclversion #SET #PMSEARCHLIST $SYSTEM.SYSTEM [#DEFAULTS] Note. To provide shared access to a segment file, you must specify shared when you attach the file.
Creating Program Files Statements and Programs • :_COMPLETION^PROCDEATH supports D-series process handles TACL defines both variables when you log on, and the variables remain unless you pop (delete) them. The default values are zeros for numeric items and spaces for text items. TACL sets specific items within these STRUCT variables whenever you try to start a process, whenever you successfully start a process, and whenever a process you started terminates (successfully or otherwise).
Creating Program Files Statements and Programs If a process fails to start, TACL sets MESSAGECODE to 0, COMPLETIONCODE to 4, and TERMINATIONINFO to an error code that describes the failure. For more information, see the #NEWPROCESS Built-In Function on page 9-266. If you start a process successfully, TACL sets MESSAGECODE to 0, COMPLETIONCODE to 0, and TERMINATIONINFO to 0.
Creating Program Files Statements and Programs ] REDEFINES z^msgnumber; BEGIN CHAR byte(0:1); END; PHANDLE z^process^handle; INT4 z^cputime; INT z^jobid; INT z^completion^code; INT z^termination^code; INT z^killer^craid; REDEFINES z^termination^code; SSID z^subsystem; PHANDLE z^killer; INT z^termtext^len; STRUCT z^procname; BEGIN INT zoffset; INT zlen; END; INT z^flags; INT z^reserved(0:2); STRUCT z^data; BEGIN CHAR byte(0:111); END; STRUCT z^termtext REDEFINES z^data; BEGIN CHAR byte(0:111); END; STRUCT
Creating Program Files Statements and Programs To access the process name: #PUSH proc^offset proc^len proc^lwa procname #SET proc^len & [:_completion^procdeath:z^procname:zlen] [#IF proc^len > 0 |THEN| #SET proc^offset & [:_completion^procdeath:z^procname:zoffset] #SET proc^lwa [#compute proc^offset+proc^len-1] #SET procname & [:_completion^procdeath:z^procname^:byte([proc^offset]:& [proc^lwa])] ] To access the termination text: #PUSH termtext^len termtext^lwa termtext #SET termtext^len & [:_completion^pr
Handling TACL Errors Statements and Programs Handling TACL Errors TACL can generate several types of errors. Table 5-1 lists the types of errors, a sample display, and a description and action for each type of error. Table 5-1. Error Types Error Example Description Syntax error Expecting an existing variable, unqualified In this example, TACL required a variable. In general, TACL required one or more types of elements and did not find them.
Handling TACL Errors Statements and Programs Table 5-1. Error Types Error Example Description Error defined by program None The program detected a condition defined as an error in the local TACL environment; this error could be a volume name that should not be accessed by a particular user. Action depends on the code. The program can exit or raise a user-defined exception, which causes TACL to invoke an exception handler if one is defined. Fatal error ABENDED: $TCL2 CPU TIME 0:00:00.
6 The TACL Environment This section describes these operational topics: • • • • Files that are required and recommended for TACL operation Starting a TACL process and subordinate processes Using TACL directories Running TACL as a background process For information about the use of TACL with other subsystems, see the TACL Programming Guide. Section 7, Summary of Commands and Built-In Functions, provides an overview of TACL commands and functions.
Starting a TACL Process The TACL Environment • TACLBASE, an edit file that contains the same functionality as TACLSEGF. This file resides on the same subvolume as the TACL file. Along with providing functionality, TACLBASE provides a readable source of examples of TACL programs. • TACLCOLD, a segment file that TACL uses when running as the coldload command interpreter.
Logging On The TACL Environment • • • • • • • Can run at a high PIN Can create a high-PIN process Can be created by a high-PIN process Can communicate with a high-PIN requester Can communicate with a high-PIN server Recognizes high-PIN process identifiers Does not default to run at a high PIN Processes that run at high PINs cannot open and write to processes that do not allow high-PIN openers. For example, a TACL process that runs at a high PIN cannot open a process on a C-series node.
TACL Initialization The TACL Environment contains any commands you supply, can include a request to load all your personal command definitions. TACL passes one argument to TACLCSTM, indicating whether the loading of TACLBASE was suppressed because you are the most recent user to log off from this TACL and are now logging back on. (The same segment is still in effect.) The argument is nonzero if loading was suppressed, and zero if it occurred.
Starting New Processes The TACL Environment Starting New Processes To start a new process from a TACL process, use the RUN command or the #NEWPROCESS built-in function, or specify the program file name (an implicit RUN command). If you use an implicit RUN command, ensure that the #PMSEARCHLIST setting includes the location of the program file. For more information, see Section 9, Built-In Functions and Variables. You can request to run a process at a high or low PIN.
Starting New Processes The TACL Environment These conditions must be met before TACL can start a process at a high PIN: • • The HIGHPIN option for the code file must be enabled at compile or bind time • There must be a high PIN available Either the RUN /HIGHPIN ON/ option or the #HIGHPIN built-in variable (or both) must be ON Table 6-1 describes how TACL resolves each combination of HIGHPIN settings. A dash (-) indicates that the option is not specified. Table 6-1.
Customizing the TACL Environment The TACL Environment To check the setting of the #HIGHPIN variable from an interactive terminal, type SHOW HIGHPIN. To check the setting of the BINDER HIGHPIN option for an object file (type 100 or 700), enter: BIND; SHOW SET * FROM file-name For additional information about the BINDER HIGHPIN option, see the Binder Manual.
Local Customization The TACL Environment Local Customization The TACLLOCL file provides a mechanism for environment customization for all users on a given system (you might think of TACLLOCL as the system manager’s version of TACLCSTM). This example shows a sample TACLLOCL file: ?TACL MACRO == TACLLOCL sets up variables, macros needed for operations RUN $system.system.opertool == defines _oper^tools variables [#IF %1% |THEN| == A fast logon |ELSE| == A slow logon SINK [#LOAD /KEEP 1/ [_oper^tools].
The TACL Environment Command Interpreter Monitor Interface (CMON) Command Interpreter Monitor Interface (CMON) The purpose of a command interpreter monitor ($CMON) process is to control and monitor: • Logons and logoffs, including illegal logon attempts (LOGON and LOGOFF commands) • • • Addition or deletion of users (ADDUSER, DELUSER programs) Alteration of priorities at execution time (ALTPRI command) Process startups (RUN command and #NEWPROCESS built-in function) If a $CMON process exists on a sys
Using Directories The TACL Environment TACL sends these types of messages to $CMON: • A CMON configuration message, which establishes the TACL configuration for the new process or user. • A pre-LOGON message, which allows $CMON to invoke additional security provisions (for example, requiring a user to log on under one ID before being able to log on under some other ID). If the $CMON process is not running, TACL uses stored defaults.
Creating Your Own Directories The TACL Environment Figure 6-1. TACL Segment File and Directory Relationships Root UTILS_GLOBALS user-variables UTILS ... ZAP TACL zap-globals tacl-globals Private Segment File Private/Read-Write One per TACL Process ... ZAP TACL zap-commands tacl-commands TACLSEGF Segment File Shared/Read-Only Shared by all TACL Processes VST001.vsd Creating Your Own Directories You can create your own directories of variables. For more information, see Section 4, Variables.
Avoiding Naming Conflicts With TACL The TACL Environment • • • Provides for read-only sharing of variables among TACL users Removes the need for loading each library of variables before each use Removes the need for predicting the maximum segment file size a given TACL user will require Other application products (that are part of a software RVU) can also create directories. TACL requires you to specify where to put the associated variables or, by default, stores them in your current home directory.
_EXECUTE Variables The TACL Environment _EXECUTE Variables If you try to invoke a variable that is itself a directory, TACL searches that directory for a variable named “_EXECUTE” and invokes that variable instead.
Default Files The TACL Environment Default Files Instead of using your saved defaults, a background TACL takes on the same file-name defaults as those of the process that started it. This procedure occurs as follows: 1. TACL saves the inherited defaults in the variable :UTILS_GLOBALS:TACL:_DEFAULTS_INITIAL and switches to your saved defaults (saved under your user ID on the system where the background TACL is running).
7 Summary of Commands and Built-In Functions TACL provides three types of standard capabilities: • • Commands, which are implemented as TACL variables • Built-in data variables Built-in functions, which are not implemented as TACL variables but are accessed in the same manner as TACL variables This section provides an overview of these standard capabilities, followed by tables that summarize commands, functions, and variables by functional group.
Summary of Commands and Built-In Functions Built-In Functions The :UTILS:TACL directory contains all the TACL commands, including commandinterpreter commands and additional commands, programs, and functions used by TACL. For example, the :UTILS:TACL variable VOLUME refers to the command named VOLUME that is executable by the TACL program. For more information about directories, see Section 6, The TACL Environment. Most :UTILS:TACL commands are available to every user.
Summary of Commands and Built-In Functions Built-In Variables If you type a built-in function that produces a result and you do not enclose it in square brackets, TACL automatically displays the result; for example: 56> #WIDTH #WIDTH expanded to: 80 Built-In Variables TACL built-in variables provide basic elements of TACL on which all other features, including TACL commands, are based.
Summary of Commands and Built-In Functions Summary of Functionality descriptions in Section 9, Built-In Functions and Variables, explain the ways in which those variables can be used.
Summary of Commands and Built-In Functions Obtaining Help and Information Table 7-1.
Summary of Commands and Built-In Functions Interfacing With the Operating System Table 7-2.
Summary of Commands and Built-In Functions Interfacing With the Operating System Table 7-4 lists the built-in functions and variables that support file and device handling. Table 7-4.
Summary of Commands and Built-In Functions Interfacing With the Operating System Controlling Processes Table 7-5 lists the commands that support process control. Table 7-5.
Summary of Commands and Built-In Functions Interfacing With the Operating System Table 7-5. Process Control Commands (page 2 of 2) Command Description SUSPEND Prevents a process from running until it is reactivated by an ACTIVATE command TACL (program) Starts TACL process on your local system or a remote system WAKEUP Sets wakeup mode Table 7-6 lists the built-in functions and variables that support process control. Table 7-6.
Summary of Commands and Built-In Functions Interfacing With the Operating System Table 7-6.
Summary of Commands and Built-In Functions Interfacing With the Operating System Table 7-6.
Summary of Commands and Built-In Functions Interfacing With the Operating System Table 7-7.
Summary of Commands and Built-In Functions Managing the TACL Environment Table 7-8. System Environment Management Built-In Functions and Variables (page 2 of 2) Function Description #TACLSECURITY (variable) Represents TACL security #USERID Specifies a user by user ID #USERNAME Specifies a user by user name #XLOGON Implements the LOGON command Managing the TACL Environment Table 7-9 lists the commands that support the TACL environment. Table 7-9.
Summary of Commands and Built-In Functions Processing Text in Variables Processing Text in Variables TACL provides two types of mechanisms that manipulate text in variables: • • Built-in functions and commands The #DELTA low-level text processor, accessed through the #DELTA built-in function For more information about other functions and commands that process text, see the individual function and command descriptions in Section 8, UTILS:TACL Commands and Functions and Section 9, Built-In Functions and
Summary of Commands and Built-In Functions Processing Text in Variables Table 7-11. Data Manipulation Commands (page 2 of 2) Command Description VINSERT Inserts lines from current TACL IN file at a specified line position VLIST Lists a range of lines in a variable VMOVE Deletes a range of lines from a variable, inserts them at a specified line position in another variable Table 7-12 summarizes the built-in functions and variables that manipulate text in variables. Table 7-12.
Summary of Commands and Built-In Functions Processing Text in Variables Table 7-12.
Summary of Commands and Built-In Functions Controlling Program Flow Table 7-12.
Summary of Commands and Built-In Functions Debugging TACL Statements Debugging TACL Statements Table 7-14 lists the commands that provide debugging support. Table 7-14.
8 UTILS:TACL Commands and Functions This section describes the TACL commands and functions that are located in the :UTILS:TACL directory. These commands and functions are typically used for interactive tasks.
Commands and Programs UTILS:TACL Commands and Functions Table 8-1.
Commands and Programs UTILS:TACL Commands and Functions Table 8-1.
Commands and Programs UTILS:TACL Commands and Functions Table 8-1.
Restricted Commands UTILS:TACL Commands and Functions Table 8-1.
Restricted Commands UTILS:TACL Commands and Functions Table 8-2.
:UTILS:TACL Command Descriptions UTILS:TACL Commands and Functions Only super-group users (user ID 255,n) can execute the commands in Table 8-3. Table 8-3.
UTILS:TACL Commands and Functions ACTIVATE Command ACTIVATE Command Use the ACTIVATE command to restart a process previously suspended by the SUSPEND Command on page 8-220 or the #SUSPENDPROCESS Built-In Function on page 9-396. ACTIVATE [ [\node-name.]{$process-name | cpu,pin } ] \node-name is the system where the process resides. $process-name is the name of the process or process pair you want to restart. cpu,pin is the CPU number and process identification number for the process you want to restart.
UTILS:TACL Commands and Functions ADD DEFINE Command ADD DEFINE Command Use the ADD DEFINE command to create one or more DEFINEs in the process file segment (PFS) of the current TACL. For a description of DEFINEs, see Section 5, Statements and Programs. ADD DEFINE {define-name} {define-name [, define-name ] ... )} [ , LIKE define-name ] [ , attribute-spec ] ... define-name is the name to be assigned to the DEFINE created by this command.
UTILS:TACL Commands and Functions ADD DEFINE Command an ADD DEFINE command that does not make a complete attribute set (that is, if a required attribute is still missing), TACL displays this message: Current attribute set is incomplete • If you include a LIKE clause in an ADD DEFINE command, it is processed first, before any attribute-spec clauses. Then each attribute-spec clause is processed in order.
UTILS:TACL Commands and Functions ADD DEFINE Command the first one on the tape. Data is to be translated from the ASCII format to EBCDIC. The USE EXTEND attribute indicates that data is to be added to the end of the file.
UTILS:TACL Commands and Functions ADDDSTTRANSITION Command (Super-Group Only) ADDDSTTRANSITION Command (Super-Group Only) Use the ADDDSTTRANSITION command to add entries to the daylight savings time (DST) transition table. ADDDSTTRANSITION start-date-time , stop-date-time , offset start-date-time is the beginning of the period where offset is applicable.
UTILS:TACL Commands and Functions ADDDSTTRANSITION Command (Super-Group Only) Example To add two periods of daylight savings time (from April 1, 1986, to September 1, 1986, and from April 1, 1986, to September 1, 1987), enter: 69> ADDDSTTRANSITION 01 APR 1986, 2:00 LST, 01 SEP 1986, & 69> &2:00 LST, 1:00 70> ADDDSTTRANSITION 01 SEP 1986, 2:00 LST, 01 APR 1987, & 70> &2:00 LST, 0:00 71> ADDDSTTRANSITION 01 APR 1987, 2:00 LST, 01 SEP 1987, & 71> &2:00 LST, 1:00 HP NonStop TACL Reference Manual—429513-018 8
UTILS:TACL Commands and Functions ADDUSER Program (Group Managers Only) ADDUSER Program (Group Managers Only) Run the ADDUSER program to add new group IDs and user IDs to the system. To use the ADDUSER program, you must have a group-manager ID (group,255)or the super ID (255,255). ADDUSER [ / run-option [ , run-option ] ... / ] group-name.user-name , group-id, user-id run-option is any of the options described in the RUN[D|V] Command on page 8-156. group-name.
UTILS:TACL Commands and Functions ADDUSER Program (Group Managers Only) 2. The super ID can also add a manager to the MANUF group by adding a user with user ID 255 and group ID 8: 13> ADDUSER MANUF.HONCHO, 8,255 MANUF.HONCHO (8,255) HAS BEEN ADDED TO THE USERID FILE. 3. The new manager can now add other users to the group: 14> ADDUSER MANUF.MABEL, 8,2 MANUF.MABEL (8,2) HAS BEEN ADDED TO THE USERID FILE. 15> ADDUSER MANUF.FRED, 8,44 MANUF.FRED (8,44) HAS BEEN ADDED TO THE USERID FILE.
UTILS:TACL Commands and Functions ALARMOFF Program (Super-Group Only) ALARMOFF Program (Super-Group Only) Run the ALARMOFF program to turn off the NonStop VLX system audio alarm. If you issue this command for systems other than a NonStop VLX, TACL returns the error message: THIS SYSTEM DOES NOT HAVE AN ALARM. You must use a super-group user ID (255,user-id) to issue this command.
UTILS:TACL Commands and Functions ALTER DEFINE Command ALTER DEFINE Command Use the ALTER DEFINE command to change the attributes of one or more existing DEFINEs in the process file segment (PFS) of the current TACL. For a description of DEFINEs, see Section 5, Statements and Programs. ALTER DEFINE define-name-list {‚ attribute-spec} {‚ RESET reset-list} define-name-list is a list of one or more existing DEFINEs whose attributes you want to alter.
UTILS:TACL Commands and Functions ALTER DEFINE Command Considerations • An ALTER DEFINE command affects existing DEFINE statements only and does not change the working attribute set. Similarly, an ALTER DEFINE command affects DEFINEs for the current TACL process only; any DEFINE that was propagated from the current TACL to another process is unchanged.
UTILS:TACL Commands and Functions ALTER DEFINE Command FILEID JUNRCDS DEVICE $TAPE 28> ALTER DEFINE ( =ONE, =TWO ), DEVICE $TAPE1 29> INFO DEFINE (=ONE, =TWO), DETAIL DEFINE NAME =ONE CLASS TAPE VOLUME 4335 LABELS ANSI FILEID MAYRCDS DEVICE $TAPE1 DEFINE NAME =TWO CLASS TAPE VOLUME 4335 LABELS ANSI FILEID JUNRCDS DEVICE $TAPE1 HP NonStop TACL Reference Manual—429513-018 8-19
UTILS:TACL Commands and Functions ALTPRI Command ALTPRI Command Use the ALTPRI command to change the execution priority of a process or process pair. ALTPRI [\node-name.]{$process-name | cpu,pin } , pri \node-name is the system where the process resides. $process-name is the name of the process or process pair. cpu,pin is the CPU number and process identification number for the process. pri is the new execution priority of the process.
UTILS:TACL Commands and Functions ASSIGN Command ASSIGN Command Use the ASSIGN command to assign names of actual files to logical file names used in programs (such as those written in COBOL, FORTRAN, and other programming languages) and, optionally, to specify the characteristics of such files. If you omit the parameters of the ASSIGN command, ASSIGN displays the assigned values for all assignments currently in effect. ASSIGN [ logical-unit [ , [ actual-file-name ] [ , create-open-spec ] ...
UTILS:TACL Commands and Functions ASSIGN Command extent-spec exclusion-spec access-spec CODE file-code REC record-size BLOCK block-size extent-spec is the size of the file extents allocated to the file. Specify either of these: EXT [ ( ] pri-extent-size [ ) EXT ( [ pri-extent-size ] , sec-extent-size ) pri-extent-size is the size of the primary file extent to be allocated to the file. It is an integer in the range from 1 through 65535.
UTILS:TACL Commands and Functions ASSIGN Command For more information about exclusion modes, see the ENSCRIBE Programmer’s Guide. access-spec is the access mode for logical-unit. It specifies the file operations that can be performed. Specify access-spec as one of these: I-O INPUT OUTPUT I-O processes can both read the file and write to it. INPUT processes can only write to the file. OUTPUT processes can only read the file. For more information about access modes, see the ENSCRIBE Programmer’s Guide.
ASSIGN Command UTILS:TACL Commands and Functions Considerations • • Use the CLEAR command to delete existing ASSIGNs. • TACL creates an assign message for each ASSIGN command in effect. A new process must request its assign messages (if any) following receipt of the startup message. The COBOL and FORTRAN compilers provide the code for this function. TAL programs that use ASSIGN commands must provide their own code for handling assign messages. • The LOGOFF command deletes existing assignments.
ASSIGN Command UTILS:TACL Commands and Functions Exclusion: Access: EXCLUSIVE OUTPUT 4.
UTILS:TACL Commands and Functions ATTACHSEG Command ATTACHSEG Command Use the ATTACHSEG command to load an existing TACL segment file into memory and associate it with a directory so that TACL can gain quick access to its variables. ATTACHSEG {PRIVATE | SHARED} file-name directory-name PRIVATE specifies that the segment is to be opened for use by only one process (yours) and that data can be written into it.
UTILS:TACL Commands and Functions • ATTACHSEG Command For more information about segment files, see the CREATESEG Command on page 8-46. Note. The PRIVATE option allows access by only one process. You cannot access a segment file if you have opened it with PRIVATE access with another TACL process. Examples This command loads the segment file MYSEGFIL into memory and records the names of the loaded variables in the directory MYDIR. Other users can access the segment as well.
UTILS:TACL Commands and Functions BACKUPCPU Command BACKUPCPU Command Use the BACKUPCPU command to start a backup process for the current TACL process or to replace an existing backup process. The BACKUPCPU command is an alias for the #BACKUPCPU built-in function. BACKUPCPU [ cpu ] cpu is the number of the processor where the backup TACL process is to be started. Specify cpu as an integer in the range from 0 through 15. If you omit cpu, BACKUPCPU deletes the existing backup process.
UTILS:TACL Commands and Functions BACKUPCPU Command • When a backup TACL process takes over, an initial logon state is established. All variables, ASSIGNs, PARAMs, and DEFINEs are reset, and the TACLLOCL file and your TACLCSTM file are invoked. The history buffer index is set to 1. • If an error occurs while TACL is trying to create the backup process or if the backup CPU is down, TACL waits 3 minutes before trying to create the backup. Examples 1.
UTILS:TACL Commands and Functions BREAK Command BREAK Command Use the BREAK command to set a debugging breakpoint on a specified variable level. BREAK [ variable-level ] variable-level is the name of an existing variable level or built-in variable. Considerations • • The specified variable level cannot be in a shared segment. • Just before invoking any variable level on which a breakpoint has been set, TACL automatically invokes _DEBUGGER.
BUILTINS Command UTILS:TACL Commands and Functions BUILTINS Command Use the BUILTINS command to display the names of the TACL built-in functions, builtin variables, or both. BUILTINS [ / { FUNCTIONS | VARIABLES } / ] FUNCTIONS displays a list of the built-in functions. VARIABLES displays a list of the built-in variables. Considerations If you specify neither FUNCTIONS nor VARIABLES, TACL displays all built-in functions and variables.
BUSCMD Program (Super-Group Only) UTILS:TACL Commands and Functions BUSCMD Program (Super-Group Only) Use the BUSCMD program to affect the status of the X or Y interprocessor bus (Dseries RVUs) or the X or Y ServerNet fabric (S-series RVUs) between two or more processors. You must use a super-group user ID (255,your-id) to issue this command. BUSCMD [ / run-option [ , run-option ] ...
UTILS:TACL Commands and Functions CLEAR Command CLEAR Command Use the CLEAR command to delete logical-file assignments made with the ASSIGN command or parameters set with the PARAM command. CLEAR { ALL } | { ALL ASSIGN | ALL PARAM | ASSIGN logical-unit | PARAM param-name } ALL deletes all logical-file assignments and parameters. ALL ASSIGN deletes all logical-file assignments made with the ASSIGN command. ALL PARAM deletes all parameters set with the PARAM command.
UTILS:TACL Commands and Functions CLICVAL Program CLICVAL Program Use the CLICVAL program to validate a Core License file. CLICVAL [-help | help ] -help or help displays CLICVAL help text. CLICVAL validates whether the Core License file is located in the correct location for use by the operating system and is valid for the system. CLICVAL also displays the name of the file that was validated along with the validation results such as OK, Missing, Corrupt, Invalid, Serial Number mismatch, and so on.
COLUMNIZE Command UTILS:TACL Commands and Functions COLUMNIZE Command Use the COLUMNIZE command to read a list of elements and display those elements in one or more columns, taking into consideration the widest element in the list and the value of the #WIDTH Built-In Variable on page 9-422. COLUMNIZE list list is a list of elements separated by spaces. Example This example has an effect similar to that of the BUILTINS /VARIABLES/ command, displaying a columnar list of TACL built-in variables.
UTILS:TACL Commands and Functions COMMENT Command COMMENT Command The COMMENT command causes TACL to ignore the rest of the command line. COMMENT [ comment-text ] comment-text is any descriptive text you wish to include. Considerations • • A space is required between COMMENT and comment-text. • COMMENT is a command, interpreted by TACL, although it does not perform an action and returns a null result.
UTILS:TACL Commands and Functions _COMPAREV Function _COMPAREV Function Use the _COMPAREV function to compare one string with another. The _COMPAREV function is an alias for the #COMPAREV built-in function. _COMPAREV string-1 string-2 string-1 and string-2 are the names of existing variable levels or STRUCT items, text enclosed in quotation marks, or a concatenation of such elements. The concatenation operator is '+' (the apostrophes are required). Variables must not be of type DIRECTORY.
UTILS:TACL Commands and Functions COMPUTE Command COMPUTE Command Use the COMPUTE command to display the value of an expression. COMPUTE expression expression is an expression containing integer or string values and one or more operators, as defined in Expressions on page 3-1. Considerations • To obtain the value of an expression from within a TACL macro or routine, use the #COMPUTE Built-In Function on page 9-71; it returns the result of the specified arithmetic expression.
UTILS:TACL Commands and Functions _CONTIME_TO_TEXT Function _CONTIME_TO_TEXT Function Use the _CONTIME_TO_TEXT function to convert a numeric date and time to a textual date and time. _CONTIME_TO_TEXT contime-list contime-list is the date and time represented as seven numbers in this format: yyyy mm dd hh mm ss hh Result _CONTIME_TO_TEXT returns the textual date and time representation of the sevennumber date and time returned by the #CONTIME Built-In Function on page 9-75.
UTILS:TACL Commands and Functions _CONTIME_TO_TEXT_DATE Function _CONTIME_TO_TEXT_DATE Function Use the _CONTIME_TO_TEXT_DATE function to convert a numeric date and time to a textual date.
UTILS:TACL Commands and Functions _CONTIME_TO_TEXT_TIME Function _CONTIME_TO_TEXT_TIME Function Use the _CONTIME_TO_TEXT_TIME function to convert a numeric date and time to a textual time.
UTILS:TACL Commands and Functions COPYDUMP Program COPYDUMP Program Use the COPYDUMP program to copy a tape dump onto a disk file or to compress an existing disk dump file that is not compressed. COPYDUMP [ / run-option [ , run-option ] ... / ] source-file , dest-file run-option is any of the options described for the RUN[D|V] Command on page 8-156. source-file specifies the dump file that is to be copied and compressed.
UTILS:TACL Commands and Functions COPYVAR Command COPYVAR Command Use the COPYVAR command to copy the contents of one variable level to another. COPYVAR variable-level-in variable-level-out variable-level-in is the name of an existing variable level. variable-level-out is the name of a variable level. COPYVAR performs an implicit PUSH command to create a variable-level-out with the same data type as variable-level-in, regardless of whether variable-level-out already exists.
UTILS:TACL Commands and Functions CREATE Command CREATE Command Use the CREATE command to create an unstructured disk file. An unstructured disk file can contain a data-record structure that the file system does not recognize, or it can be made up of an array of bytes without data-record structure. CREATE file-name [ , parameter [ , parameter ] ] file-name is the name of the file to be created.
UTILS:TACL Commands and Functions CREATE Command the size of all extents that are subsequently allocated (secondary extents). With the FUP CREATE command, however, you can specify different sizes for primary and secondary extents and can partition files into more than one volume. You can also create files of a type other than unstructured. See the File Utility Program (FUP) Reference Manual for a description of the FUP CREATE command.
UTILS:TACL Commands and Functions CREATESEG Command CREATESEG Command Use the CREATESEG command to create a TACL segment file. CREATESEG file-name file-name is the name to be assigned to the created segment file. Considerations • A segment file is a memory-mapped file that can be loaded rapidly into an extended memory segment. When you log on, TACL creates a default segment file to hold the variables in the root (:) directory.
UTILS:TACL Commands and Functions • • CREATESEG Command ° #SEGMENTCONVERT converts a segment file from a C00 or C10 format to a format version later than C10 or the reverse. ° #SEGMENTINFO returns information about a segment in use by your TACL process. ° #SEGMENTVERSION returns the format (C00/C10 or later) of a segment file. You cannot create a segment on a remote system. TACL allocates virtual memory on a demand basis for its own private segment.
UTILS:TACL Commands and Functions DEBUG Command DEBUG Command Use the DEBUG command to initiate debugging for a process that is already running. Entering the DEBUG command is one way to invoke the Debug program or the Inspect debugger. If you do not specify a process ($process-name or cpu,pin), the Debug and Inspect programs begin debugging the process most recently started by TACL, if that process is still in existence. For information on the Debug program, see the Debug Manual.
UTILS:TACL Commands and Functions DEBUG Command read access to the program file. (For a description of process accessor IDs, see the Guardian User’s Guide.) • A group manager can debug any process whose process accessor ID matches the user ID of any user in the group. The manager must also have read access to the program file. • The super ID can debug any process. Only the super ID can debug privileged processes.
UTILS:TACL Commands and Functions • DEBUG Command To use the terminal $WHITE to debug the process whose process ID is 8,45, enter: 15> DEBUG 8,45, TERM $WHITE A DEBUG or INSPECT prompt then appears on terminal $WHITE.
UTILS:TACL Commands and Functions DEBUGGER Function DEBUGGER Function If tracing is enabled (see #TRACE Built-In Variable on page 9-408), the TACL trace facility displays the next line to be executed, then immediately invokes the _DEBUGGER function before executing that code. You can set breakpoints, modify variables, and invoke TACL commands while debugging. For an example of _DEBUGGER function use, see the TACL Programming Guide.
UTILS:TACL Commands and Functions DEBUGGER Function R[ESUME] exits the debugger and continues execution of TACL statements. ST[EP] invokes the next function, then waits for you to press RETURN before performing the next action. You can continue in this way, stepping through the function. You can abbreviate each of these commands to the letter or letters outside the square brackets; that is, you can issue DISPLAY as D or STEP as ST. Caution.
UTILS:TACL Commands and Functions DEFAULT Program DEFAULT Program Use the DEFAULT program to set your logon (saved) default system, volume, and subvolume names, and to set your logon disk file security. The logon defaults are in effect whenever you log on. DEFAULT [ / run-option [ , run-option ] ... / ] default-names [‚"default-security"] ‚"default-security" run-option is any of the options described in the RUN[D|V] Command on page 8-156.
UTILS:TACL Commands and Functions DEFAULT Program default-security is the default disk file security that is to be in effect when you log on or enter the VOLUME command without any parameters. (The current default file security is assigned to newly created disk files unless you explicitly assign a different security setting when you create a file.
UTILS:TACL Commands and Functions DEFAULT Program different security. For more information about changing the default values and about disk file security, see the Guardian User’s Guide. • Any new logon default values you set with the DEFAULT program do not take effect until the next time you log on or until you enter the VOLUME command with no parameters. • The current default settings are often different from your saved logon default settings.
UTILS:TACL Commands and Functions DELETE DEFINE Command DELETE DEFINE Command Use the DELETE DEFINE command to remove one or more existing DEFINEs from the process file segment (PFS) of the current TACL. For information on DEFINEs, see Section 5, Statements and Programs. DELETE DEFINE define-name-list define-name-list specifies one or more existing DEFINEs to be deleted. For define-name-list, specify either of these: define-template ( define-template [ , define-template ] ...
UTILS:TACL Commands and Functions DELUSER Program (Group Managers Only) DELUSER Program (Group Managers Only) Use the DELUSER program to delete users from a system. To use the DELUSER program, you must have a user ID of n,255. DELUSER [ / run-option [ , run-option ] ... / ] group-name.user-name run-option is any of the options described in the RUN[D|V] Command on page 8-156. group-name.user-name are the group and user names of the user who is to be deleted.
UTILS:TACL Commands and Functions DETACHSEG Command DETACHSEG Command Use the DETACHSEG command to relinquish use of a segment file. DETACHSEG directory-name directory-name is the name of a directory whose variables are in another segment file. Considerations • • Executing the DETACHSEG command is equivalent to popping the directory. • The DETACHSEG command does not allow you to relinquish use of the segment file whose root is :UTILS because you would lose all your commands if you did so.
UTILS:TACL Commands and Functions • DETACHSEG Command If the CPU on which your TACL process is running fails while you are in the act of detaching a private segment file, the segment file may be corrupted. Any future attempts to attach that file will fail. You must purge it and re-create it. Note. ATTACHSEG operates by pushing and defining a directory variable that refers to the specified segment file; DETACHSEG operates by popping that directory variable.
UTILS:TACL Commands and Functions ENV Command ENV Command Use the ENV command to display the settings of one or all the environmental parameters for your TACL. ENV [ environment-parameter ] environment-parameter is one of these: HOME INLECHO INLOUT INLPREFIX INLTO PMSEARCH SYSTEM USE VOLUME HOME displays the name of your current home directory. You set this value with the HOME command.
ENV Command UTILS:TACL Commands and Functions PMSEARCH displays the search list that your TACL uses to find program and macro files when they are invoked implicitly. This list is set with the PMSEARCH Command on page 8-118. SYSTEM displays the (possibly null) name of your current default system. You set and clear this value with the SYSTEM Command on page 8-224. USE displays the directories that TACL searches for variables not found in your home directory.
UTILS:TACL Commands and Functions EXIT Command EXIT Command Use the EXIT command to stop the current TACL process or TACL process pair. Pressing CTRL-y is the same as typing EXIT. EXIT Considerations • To use the EXIT command to delete a TACL process on your home system, you must be logged onto that system. You can, however, use EXIT to delete a TACL process you started on a remote system without logging onto the remote system.
UTILS:TACL Commands and Functions FC Command FC Command Use the FC command to retrieve, edit, and reexecute lines in the history buffer. FC [ num | -num | text ] num is a positive integer that refers to the specific command-line number you want to retrieve from the history buffer. - num is a negative number that refers to a command line in the history buffer relative to the current command line. text is the most recent command line in the history buffer that begins with the text you specify.
UTILS:TACL Commands and Functions FC Command To correct the spelling error in this example, you could enter: 12> RENMAE JUNK, TESTFILE 12.. AM 12> RENAME JUNK, TESTFILE 12.. Editing Template The syntax of the editing template is: subcommand [ // subcommand ] ... subcommand is any of these: { R | r } replacement-text { I | i } insertion-text { D | d } replacement-text // is a separator, allowing multiple subcommands on a given line.
UTILS:TACL Commands and Functions FC Command replacement-text is any text that does not begin with R, I, or D (or r, i, or d). Characters in replacement-text replace characters immediately above them on a one-forone basis. For example, a D in replacement-text replaces the character displayed above it instead of deleting it. Considerations • • If you enter FC alone, the last command entered is displayed.
UTILS:TACL Commands and Functions FC Command 4. This example retrieves the most recent line in your history buffer that begins with the text “STA”: 15> FC STA 15> STATUS *, TERM 15..
FILEINFO Command UTILS:TACL Commands and Functions FILEINFO Command Use the FILEINFO command to display information about one or more disk files. The FILEINFO command allows the use of a file-name template. The FILEINFO command is an alias for the #XFILEINFO Built-In Function on page 9-423. FILEINFO [ / OUT list-file / ] [ file-name-template [ [,] file-name-template ] ...
FILEINFO Command UTILS:TACL Commands and Functions of its owner, its file security, and the number of primary and secondary extents allocated to it. If the request is for a file that does not exist, the TACL process returns an error message: No files match \TSII.$SPOOL.LINDA.BFILE If the request is formatted as $volume.filename, the TACL process returns an error message: FILEINFO $SPOOL.
FILEINFO Command UTILS:TACL Commands and Functions Character Position in Output Display [19 - 22] Field Description CODE: FLAGS Field Value "A" File is audited by TMF. "L" File is licensed. See file licensing information in the File Utility Program (FUP) Reference Manual. “P” The PROGID attribute of the file is on. See file PROGID information in the File Utility Program (FUP) Reference Manual. "+" File is a format 2 file. See format 2 file information in the File Utility Program (FUP) Reference Manual.
FILEINFO Command UTILS:TACL Commands and Functions Character Position in Output Display Field Description [60] blank [61 - 64] RWEP Field Value File security assigned to the file for read, write, execute, and purge access. "****" File access is controlled with Safeguard security. "####" File access is controlled with OSS security.
UTILS:TACL Commands and Functions FILENAMES Command FILENAMES Command Use the FILENAMES command to display the names of all files that satisfy the filename specifications in the file-name-template. The FILENAMES command is an alias for the #XFILENAMES built-in function. FILENAMES [ / OUT list-file / ] [ file-name-template [ [,] file-name-template ] ... ] OUT list-file specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the output from FILENAMES.
UTILS:TACL Commands and Functions FILENAMES Command list the name of any file whose name has SECT in the first four positions, any character in the fifth position, and a 2 in the sixth position: 18> FILENAMES $smith.book*.sect?2 $SMITH.BOOK1 SECT02 $SMITH.
UTILS:TACL Commands and Functions FILES Command FILES Command Use the FILES command to display the names of files in one or more subvolumes. FILES [ / OUT list-file / ] [ subvol-template [ [,] subvol-template ] ... ] OUT list-file specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the output from FILES. If you omit this option, TACL writes the listing to its current OUT file.
UTILS:TACL Commands and Functions FILETOVAR Command FILETOVAR Command The FILETOVAR command copies data from a file and appends it to a variable level. FILETOVAR file-name variable-level file-name is the name of an existing file from which data is to be copied. It must be readable by the sequential I/O facility (SIO). Both format1 and format 2 files are supported. variable-level is the name of an existing variable level to which the copied data is to be appended.
UTILS:TACL Commands and Functions HELP Command HELP Command The HELP command displays a single screen of general information about TACL.
UTILS:TACL Commands and Functions HISTORY Command HISTORY Command Use the HISTORY command to display the most recently executed command lines. HISTORY [ num ] num is the number of commands to display. By default, num is 10. Considerations • The HISTORY command displays the specified number of lines in the history buffer. The history buffer is 1000 characters long and contains zero or more lines. Each line stored in the history buffer requires as many bytes as the line contains, plus one extra byte.
HOME Command UTILS:TACL Commands and Functions HOME Command Use the HOME command to specify the first directory in which your TACL process searches for variables before searching any other directories. HOME [ directory-name ] directory-name is the name of an existing variable level of type DIRECTORY. If omitted, the root (:) is assumed. Considerations • TACL is said to be “creating a variable” when using (#)PUSH, #DEF, or (#)LOAD.
UTILS:TACL Commands and Functions INFO DEFINE Command INFO DEFINE Command Use the INFO DEFINE command to display the attributes and values associated with one or more existing DEFINEs in the process file segment (PFS) of the current TACL process. For more information about DEFINEs and their usage, see the Guardian User’s Guide.
INFO DEFINE Command UTILS:TACL Commands and Functions • You cannot display the names of attributes to which no values have been assigned. • You can display all DEFINEs by entering INFO DEFINE ** or INFO DEFINE =*. DEFINEs are displayed in ASCII sort sequence by name. • To obtain error information, use the #ERRORNUMBERS Built-In Variable on page 9-160. Examples 1.
UTILS:TACL Commands and Functions INITTERM Command INITTERM Command Use the INITTERM (initialize terminal) command to reinstate the default attributes of your home terminal. The INITTERM command is an alias for the #INITTERM Built-In Function on page 9-200. INITTERM Considerations Typically, you use the INITTERM command when an application program has left your terminal in an abnormal state. INITTERM calls the SETMODE procedure, function 28.
UTILS:TACL Commands and Functions INLECHO Command INLECHO Command Use the INLECHO command to specify whether lines sent as input to an inline process are to be copied to the current TACL OUT file. (Use of the INLINE facility is described in the TACL Programming Guide.) INLECHO { OFF | ON } OFF disables echoing of input lines. ON enables echoing of input lines to the TACL OUT file. Considerations • The INLECHO command offers a simplified method of setting the #INLINEECHO Built-In Variable on page 9-201.
UTILS:TACL Commands and Functions INLEOF Command INLEOF Command Use the INLEOF command to send an end-of-file indication to an inline process. (Use of the INLINE facility is described in the TACL Programming Guide.) INLEOF Considerations • The INLEOF command is a simplified interface to the #INLINEEOF Built-In Function on page 9-202. • TACL waits until the inline process accepts the end-of-file and either prompts again or terminates.
UTILS:TACL Commands and Functions INLOUT Command INLOUT Command Use the INLOUT command to specify whether lines written by inline processes to their OUT files are to be copied to the current TACL OUT file as well. (Use of the INLINE facility is described in the TACL Programming Guide.) INLOUT { OFF | ON } OFF disables copying of output lines. ON enables copying of output lines to the TACL OUT file.
UTILS:TACL Commands and Functions INLPREFIX Command INLPREFIX Command Use the INLPREFIX command to establish the prefix that identifies lines that are to be passed as input to inline processes. (Use of the INLINE facility is described in the TACL Programming Guide.
UTILS:TACL Commands and Functions INLTO Command INLTO Command Use the INLTO command to establish a variable level that is to receive copies of lines written by inline processes to their OUT files. TACL appends copied lines to the end of the variable level. (Use of the INLINE facility is described in the TACL Programming Guide. INLTO [ variable-level ] variable-level is the name of an existing variable level.
UTILS:TACL Commands and Functions IPUCOM Program IPUCOM Program Use the IPUCOM program for a command line interface which can be used to set, reset, or display an IPU number associated with a process. It can also be used to set or display CPU-wide controls. Note. • • • The keywords in each of the command line syntaxes such as -pname, -bname, -pin and so on are case-insensitive. The numeric values (pin, cpu number, ipu number) must be in decimal format.
UTILS:TACL Commands and Functions IPUCOM Program Syntax to reset an association: IPUCOM {-pname | -bname | -pin } [-cpu ] unbind Syntax to display an association: IPUCOM {-pname |-bname | -pin } [-cpu ] info The IPU associated with the process is displayed, which may dynamically change if the IPU assignment is not currently set via IPUCOM or IPUAFFINITY_SET_.
UTILS:TACL Commands and Functions IPUCOM Program Considerations • The IPUCOM program can be run without super-group or other privileges, but to alter any of the process or CPU-wide settings, the user must conform to the security requirements of a corresponding call to IPUAFFINITY_SET_ or IPUAFFINITY_CONTROL_. See the Guardian Procedure Calls Reference Manual for details on the requirements of those interfaces.
UTILS:TACL Commands and Functions JOIN Command JOIN Command Use the JOIN command to convert a multiple-line variable level into a single-line variable level, replacing each internal end-of-line with a single space. JOIN variable-level variable-level is the name of an existing variable level.
UTILS:TACL Commands and Functions KEEP Command KEEP Command Use the KEEP command to remove all but the top num definition levels of one or more variables. KEEP [ / LIST / ] num variable [ variable ] ... LIST causes KEEP to display each variable name followed by the number of levels removed from that variable. num is the number of levels to keep. variable is the name of an existing variable. Consideration KEEP 0 deletes the variable.
UTILS:TACL Commands and Functions KEYS Command KEYS Command Use the KEYS command to display the current function key definitions. KEYS Example This example is a sample KEYS command display; the values vary depending on how the TACL environment is set up: 127> KEYS F16 = (The Help Key) F1 = #OUTPUT TEDIT %1%; %2 to *% TEDIT %1%; %2 to *% #OUTPUT Finished editing [#SHIFTSTRING/UP/%1%] F2 = #OUTPUT TFORM /IN %1%, OUT $S.#%2%, NOWAIT/ %3 to *% TFORM /IN %1%, OUT $S.
UTILS:TACL Commands and Functions LIGHTS Program (Super-Group Only) LIGHTS Program (Super-Group Only) Use the LIGHTS program to control the processor panel lights (also known as the switch-register display). You must use a super-group user ID (255,your-id) to issue this command. This command is not supported on NonStop S-series systems after the G06.04 RVU.
UTILS:TACL Commands and Functions LIGHTS Program (Super-Group Only) ALL turns on every sys-option at once (DISPATCHES, SYSPROCS, and PAGING). BEAT flashes light 0 (zero) once every second to indicate that the processor is functioning. Considerations • • To run the LIGHTS program, you must have a group ID of 255. Processor lights are lit for these reasons: ° Lights 0 through 10 indicate processor usage. Light 0 is always lit (or flashing if BEAT was specified).
UTILS:TACL Commands and Functions LOAD Command LOAD Command Use the LOAD command to load one or more TACL library files into the TACL memory. LOAD [ / KEEP num / ] file-name [ file-name ] ... KEEP num causes TACL, after executing the LOAD command, to perform an implicit KEEP command on all the variables modified by the LOAD command. file-name is the name of one or more TACL libraries.
UTILS:TACL Commands and Functions LOADEDFILES Command LOADEDFILES Command Use the LOADEDFILES command to display information about the load files that are being used by the specified process. LOADEDFILES [ / OUT list-file / ][ \node-name ] & { $Process-name | CPU, PIN|} OUT list-file specifies a device or sequential file accessible to the sequential I/O (SIO) facility that is to receive the output from the command. If you omit this option, TACL writes the listing to the current OUT file.
UTILS:TACL Commands and Functions LOADEDFILES Command SRL: a Shared Run-time Library (including a non-PIC native UL) DLL: a Dynamic-Link Library (including a PIC native UL) ERR: Loadedfile unloaded in between execution of program ERROR: Unrecognized loadfile type Considerations • If you do not specify a process ($process-name or CPU, PIN), LOADEDFILES lists all the loaded files for the current TACL processes. • • If you omit the node name, the default system is assumed.
UTILS:TACL Commands and Functions LOGOFF Command LOGOFF Command Use the LOGOFF command to log off from the current TACL process. The LOGOFF command is an alias for the #LOGOFF Built-In Function on page 9-253. LOGOFF [ / option [, option ] ... / ] option is one of these options: CLEAR clears the terminal screen after you log off (for use when TACL is not configured to clear the screen automatically).
UTILS:TACL Commands and Functions • LOGOFF Command If the ancestor of your current TACL process is a process running in another system and you enter the LOGOFF command, the current TACL process is deleted and control returns to the ancestor process. This message is displayed: Exiting from TACL on \node-name • If you are accessing a remote node through a modem on your local node, TACL does not issue a modem disconnect.
UTILS:TACL Commands and Functions LOGON Command LOGON Command Use the LOGON command to establish communication with a TACL process. To enter TACL commands interactively, you must first log on. However, when you execute TACL commands from a command file (by specifying a disk file containing TACL commands as the IN file when you start a new TACL process), you do not need to include the LOGON command in the file. Note. The LOGON command behavior depends on the Safeguard environment.
UTILS:TACL Commands and Functions LOGON Command password is the password associated with the user. You must include password if a password has been established for you. If you have a password, you must separate it from your user name with a comma if you enter it before pressing RETURN. You can also use the blind password feature by omitting the comma and password from the LOGON command, then entering your password when prompted. For more information about passwords, see the PASSWORD Program on page 8-115.
UTILS:TACL Commands and Functions LOGON Command abends or stops with an abnormal completion code. If, however, the subordinate process was started in the NOWAIT mode or with any JOBID value, including 0, the parent TACL process does not stop. In such a case, TACL displays the error message but continues to run. If the CPU of a single process fails, the condition is treated as if the process abended.
UTILS:TACL Commands and Functions • ° ° The operating system RVU number and date ° The current system date and time LOGON Command The number of the processor in which the primary and backup TACL process is running When you enter a full LOGON command, your identity and password are displayed on the terminal screen; if you want to assure security, you can use the blind password feature.
UTILS:TACL Commands and Functions LOGON Command • When you enter a full LOGON command, your identity and password are displayed on the terminal screen. You can use the blind password feature in the TACL configuration or in Safeguard to ensure security. • The process accessor ID and creator accessor ID of the user logging on are propagated to any descendant processes of TACL. (For a description of accessor IDs, see the Guardian User’s Guide.
UTILS:TACL Commands and Functions ° LOGON Command If the CMON process does return the configuration information, then the TACL process uses this information. If the TACL process is in the no-user-logged-on state when a LOGON command is received and REQUESTCMONUSERCONFIG is ON, the TACL process sends a request to the CMON process for configuration information, then sends the LOGON request, and then sends an additional request for the configuration information.
UTILS:TACL Commands and Functions LOGON Command In this case, ABENDONABEND overrides the default setting (STOPONABEND) just for this logon session: 12> TACL /NAME/ ;STOPONABEND TACL 1> LOGON SOFTWARE.JANE ;ABENDONABEND Password: When TACL abends as result of the ABENDONABEND being specified at TACL startup or at logon, and a process started by this TACL abends or stops with an abnormal completion code, this abend message is displayed.
LOGON Command UTILS:TACL Commands and Functions Z^DATA(0) BYTE(0:111) \PRUNE.$MP:150608489 Examples 1. User SOFTWARE.JANE, whose password is STAR, can log on interactively by entering: TACL 1> LOGON SOFTWARE.JANE,STAR 2. Using the blind logon feature, SOFTWARE.JANE can log on in this sequence: TACL 1> LOGON SOFTWARE.JANE Password: At the “Password:” prompt, she enters her password, which does not appear on the screen.
UTILS:TACL Commands and Functions _LONGEST Function _LONGEST Function Use the _LONGEST function to obtain the length of the longest element in a list of elements. _LONGEST list list is a list of elements separated by spaces, or a variable level containing such a list. Result _LONGEST returns the length of the longest element supplied in its argument.
UTILS:TACL Commands and Functions _MONTH3 Function _MONTH3 Function Use the _MONTH3 function to obtain the three-letter abbreviation for month num. _MONTH3 num num is a one- or two-digit number indicating a month. Result _MONTH3 returns the three-letter abbreviation for the specified month.
UTILS:TACL Commands and Functions O[BEY] Command O[BEY] Command Use the OBEY command to execute a series of TACL commands or built-in functions contained in a file. O[BEY] command-file command-file is either the name of an existing disk file that contains TACL commands or built-in functions, or the name of a running process.
UTILS:TACL Commands and Functions OUTVAR Command OUTVAR Command Use the OUTVAR command to display the contents of a variable without executing or invoking it. The OUTVAR command is an alias for the #OUTPUTV built-in function. OUTVAR [ / option [ , option ] ... / ] string option is an option that qualifies the write operation. Options are not permitted if variable is of type STRUCT. Specify option as one of these: COLUMN num begins writing data at column num.
UTILS:TACL Commands and Functions OUTVAR Command string is the data to be output. It is the name of an existing variable level, text enclosed in quotation marks, or a concatenation of such entities. The concatenation operator is '+' (the apostrophes are required). Considerations • If options are supplied, the options are applied to each line of the variable as though you had called the #OUTPUT built-in with the same options for each line of the variable.
UTILS:TACL Commands and Functions OUTVAR Command Example This example illustrates the use of OUTVAR to display the contents of a variable. First, define a variable name vara: 15> [#DEF vara MACRO |BODY| 15> #OUTPUT [#FILEINFO / EXISTENCE / tempfile ] 15> ] At this point, if you type vara, TACL returns 0 (false) as the result of vara if TEMPFILE does not exist and -1 (true) if it does exist.
UTILS:TACL Commands and Functions PARAM Command PARAM Command Use the PARAM command to create a parameter and give it a value or to display all current parameters and their values. PARAM [ param-name param-value [ , param-name param-value ] ... ] param-name is a user-defined parameter name to be assigned a value. param-name can consist of 1 to 31 alphanumeric, circumflex (^), and/or hyphen (-) characters. param-value is the value assigned to param-name.
UTILS:TACL Commands and Functions Example To assign the value ON to the parameter TRACE: 19> PARAM TRACE ON HP NonStop TACL Reference Manual—429513-018 8-114 PARAM Command
UTILS:TACL Commands and Functions PASSWORD Program PASSWORD Program Use the PASSWORD program to create, change, or delete your password. (Passwords are optional and might not be required on your system.) PASSWORD [ / run-option [ , run-option ] ... / ][ password ] run-option is any of the options described in the RUN[D|V] Command on page 156. password is the new password that you must enter when you log on.
UTILS:TACL Commands and Functions PAUSE Command PAUSE Command You can run more one or more processes simultaneously from within your TACL process. Use the PAUSE command to cause TACL to wait for prompting from-or completion of-another process. PAUSE [ [\node-name.]{$process-name | cpu,pin } ] \node-name is the name of the system where the process identified by $process-name or cpu,pin is running. If you omit \node-name, the current default system is used.
UTILS:TACL Commands and Functions PAUSE Command ° If WAKEUP is set to ON, TACL regains control of the terminal when any process started from it is deleted. ° If WAKEUP is set to OFF (the default setting), TACL regains control of the terminal when the process specified in the PAUSE command is deleted. If no process was specified in the PAUSE command, TACL regains control of the terminal when the last process started from it is deleted.
UTILS:TACL Commands and Functions PMSEARCH Command PMSEARCH Command Use the PMSEARCH command to define the list of subvolumes that TACL is to search to find program and macro files in response to an implied RUN command. PMSEARCH subvol-spec [ [,] subvol-spec ] ... subvol-spec specifies a subvolume to be searched. subvol-spec takes one of these forms: [\node-name.][$volume.] subvol is a syntactically correct name of an existing subvolume.
UTILS:TACL Commands and Functions PMSEARCH Command PMSEARCH places in the search list intact; it is invoked later when an implied RUN command is executed, causing TACL to access the list. The PMSEARCH command in the preceding example causes the program/macro search list to contain: $SYSTEM.SYSTEM #DEFAULTS $OLD.HOME At that time, #DEFAULTS also represents $OLD.HOME. The next VOLUME command changes the current default volume and subvolume; #DEFAULTS now represents $NEW.PLACE.
UTILS:TACL Commands and Functions PMSG Command PMSG Command Use the PMSG (process message) command to control logging of creation and deletion messages about processes you create with the RUN command. PMSG { ON | OFF } ON specifies that whenever a process started by the current TACL process is created or deleted, a message is sent to the TACL OUT file (usually the home terminal). OFF specifies that process creation and deletion messages are not to be displayed. (OFF is the default setting.
UTILS:TACL Commands and Functions PMSG Command Each process deletion message is followed by a CPU time-usage message on the next line. The form of CPU time-usage messages is: CPU TIME: hh:mm:ss.fff hh is the number of hours since the process started. mm is the number of minutes past the number of hours since the process started. ss is the number of seconds past the number of hours and minutes since the process started.
UTILS:TACL Commands and Functions POP Command POP Command Use the POP command to delete the top-level definition of a variable. The POP command is an alias for the #POP built-in function. POP variable [ [,] variable ] ... variable is the name of an existing variable or the name of a built-in variable. Considerations • If the top level is the only level, the POP command deletes the variable, except for built-in variables.
UTILS:TACL Commands and Functions POSTDUMP Utility POSTDUMP Utility The POSTDUMP utility enables explicit postdump processing of an existing full dump file to produce an extracted dump file. It is provided for processing an existing full dump produced by either the TNet dump method or the PARALLEL dump method.
UTILS:TACL Commands and Functions POSTDUMP Utility [-]DP2_CACHE Exclude | Include DP2 cache pages. [-]DP2_SHARED Exclude | Include DP2 shared segment pages. [-]IMPLICIT_DLLS Exclude | Include implicit DLL pages. [-]LOCKED Exclude | Include locked pages. [-]OTHER Exclude | Include possibly unclassified pages. [-]SYS_LIBRARY Exclude | Include system/public library pages. [-]SYS_PROCESS Exclude | Include sysgenned process pages. [-]SYSTEM Exclude | Include KSEG0/VKSEG64 pages.
UTILS:TACL Commands and Functions POSTDUMP Utility Examples To process a full dump file CPU01 and create an extracted dump CPU01P, run the following command: 10> POSTDUMP CPU01 Note. Whether installed by default or explicitly installed, the POSTDUMP utility can be used to produce an extracted dump from a full dump of any NS-series processor that was running the H06.13 RVU or later, or from a full dump of any HP Integrity NonStop™ BladeSystems (which runs a J-series RVU).
UTILS:TACL Commands and Functions PPD Command PPD Command Use the PPD (process-pair directory) command to display the names, cpu,pin designations, and ancestors of one or more processes in the destination control table (DCT). The PPD command is an alias for the #XPPD built-in function. PPD [ / OUT list-file / ] [ [ \node-name] [.{ $process-name | cpu,pin | * } ] ...
UTILS:TACL Commands and Functions PPD Command pname is the name of the process. The name $Z000 identifies the initial process that was started when the system was cold loaded from disk. pcpu is the CPU number and process number of the primary process in a process pair, or of the specified process only if it is not a member of a pair. bcpu is the CPU number and process number of the backup process in a process pair. If backup is not displayed, the process has no backup.
UTILS:TACL Commands and Functions To view the entry in the DCT for the process $WOW, enter: 15> PPD $WOW Name Primary Backup Ancestor $WOW 04,054 05,009 $Z000 HP NonStop TACL Reference Manual—429513-018 8-128 PPD Command
UTILS:TACL Commands and Functions PURGE Command PURGE Command Use the PURGE command to delete one or more disk files. PURGE [ / option / ] file-name-template [ , file-name-template ... ] option qualifies the purge operation. Specify option as one of these: CONFIRM specifies that TACL is to prompt for confirmation for each file, specified by name or by matching a template, before purging the file. NOCONFIRM specifies that TACL is to purge the file without requesting confirmation.
UTILS:TACL Commands and Functions PURGE Command • If you specify a file-name template with wild-card characters and do not include CONFIRM or NOCONFIRM, TACL confirms only the template (not individual file names) before purging all files that match the template. • CONFIRM and NOCONFIRM are mutually exclusive. Examples If you have purge access to the files OCT and NOV (in your current default system, volume, and subvolume) and to the file $RECORDS.DUE.
UTILS:TACL Commands and Functions PUSH Command PUSH Command Use the PUSH command to create a new top level for one or more variables or built-in variables. The PUSH command is an alias for the #PUSH built-in function. PUSH variable [ [,] variable ] ... variable is a valid variable or a built-in variable name. Considerations • For existing variables that are not built-in variables, PUSH creates an empty top level of type TEXT.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) RCVDUMP Program (Super-Group or Super ID Only) Use the RCVDUMP program to dump the memory of a processor to a disk file. The processor being dumped can be running or halted. The processor from which the RCVDUMP program is run must have X or Y fabric (G-series and H-series RVUs) or X bus or Y bus (D-series RVUs) access to the processor being dumped.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) If on a non-NSAA system, the halted processor to be dumped is running at minimum the version of Halted State Services included in either the H06.17 RVU on H-series or the J06.06 RVU on J-series, RCVDUMP by default creates an extracted dump file only, without first creating a full dump file.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) Caution. This command should be used only as part of a documented processor dumping and recovery procedure. See the sections Processors: Monitoring and Recovery and Starting and Stopping the System in the NonStop S-Series Operations Guide or the Integrity NonStop NSSeries Operations Guide.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) operations. By default, both the full dump and extracted dump files are created. You may use either PARALLEL or ONLINE but not both. Note. When neither ONLINE nor PARALLEL is specified: • • On an NSAA system, a full dump file is always created. An extracted dump file is created, by default.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) START n... is the byte address where the dump will start. The default value is 0. END n... is the byte address where the dump will stop. Using a value of -1 is the same as specifying the end of memory. The default value is -1. ONLINE If this option is specified, a dump can be taken of a processor while it is running. Only memory pages are included in this type of dump.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) 1 = Y bus param is either one of these parameters: FULL specifies that the entire physical memory is to be dumped. FULL is the default for a processor if the size of physical memory is less than or equal to sixteen megabytes. This option is ignored if the processor is not a VLX. PARTIAL specifies that only those pages of physical memory that are mapped in the page table cache are to be dumped.
UTILS:TACL Commands and Functions RCVDUMP Program (Super-Group or Super ID Only) Example For G-series RVUs, if you have the super-group user ID, you can initiate a dump from processor 6 of your system over the X fabric and send the dump to file $SYSTEM.DUMP.DUMP1 by entering: 14> RCVDUMP $SYSTEM.DUMP.DUMP1 , 6 , X CPU 06 HAS BEEN DUMPED TO $SYSTEM.DUMP.DUMP1.
UTILS:TACL Commands and Functions RECEIVEDUMP Command (Super-Group Only) RECEIVEDUMP Command (Super-Group Only) Use the RECEIVEDUMP command to dump the memory of a processor to a disk file. The processor being dumped can be running or halted. This command executes the RCVDUMP program. The processor from which the RECEIVEDUMP command is run must have X or Y fabric (G-series RVUs) or X bus or Y bus (D-series RVUs) access to the processor being dumped.
UTILS:TACL Commands and Functions RECEIVEDUMP Command (Super-Group Only) param is one or both of these parameters: ONLINE If this option is specified, a dump can be taken of a processor while it is running. Only memory pages are included in this type of dump. No registers, translation lookaside buffers (TLB) or caches are dumped. All other parameters are ignored, including fabric. RESET If this option is specified, a soft reset is issued to the processor being dumped.
UTILS:TACL Commands and Functions RECEIVEDUMP Command (Super-Group Only) param is either one of these parameters: FULL specifies that the entire physical memory is to be dumped. FULL is the default for a processor if the size of physical memory is less than or equal to sixteen megabytes. This option is ignored if the processor is not a VLX. PARTIAL specifies that only those pages of physical memory that are mapped in the page table cache are to be dumped.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) RELOAD Program (Super-Group Only) Run the RELOAD program to reload the remaining processors after the first processor in a system has been brought up, or to recover a processor that has failed. You must use a super-group user ID (255,your-id) to issue this command. This command should be used only as part of a documented system startup or processor recovery procedure.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) { cpu-range } [, option, option, ... ] { ( cpu-range, cpu-range, ...) } { * } cpu-range is one of these: cpu cpu-cpu cpu is the processor number, an integer from 0 through 15. cpu-cpu is two processor numbers separated by a hyphen, specifying a range of processors. In a range specification, the first processor number must be less than the second. option is one of these: NOSWITCH [PRIME|NOPRIME] OMITSLICE [A|B|C] <$volume [.sysnn.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) OMITSLICE [A|B|C] The PE on the selected slice will not be reloaded when other PEs in that logical processor are reloaded. If you do not provide an argument (A or B or C) the system will choose a slice to omit. <$volume [.sysnn.osdir]> specifies a volume other than $SYSTEM where the operating system image (sysnn.osdir) to be used for reloading the processor is located. This specification could take the form of $volume or $volume.sysnn.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) cpu-cpu is two processor numbers separated by a hyphen, specifying a range of processors. In a range specification, the first processor number must be less than the second. option is one of these: NOSWITCH [PRIME|NOPRIME] <$volume [.sysnn.osimage]> NOSWITCH specifies that, when a processor is reloaded, there is no default autoswitch of controller ownership to the configured primary processor.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) A help screen is displayed if you enter RELOAD with no parameters and no IN filename. D-Series Syntax RELOAD [ / run-option [ , run-option ] ... / ] cpu-set [; cpu-set ] ... [ HELP ] run-option is any of the options described in the RUN[D|V] Command on page 8-156. cpu-set is a set of processors (and associated options) to be reloaded. Specify cpu-set as: { cpu-range } [, option, option, ... ] { ( cpu-range, cpu-range, ...
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) NOSWITCH bus $volume subvolume.filename NOSWITCH specifies that, when a VLX, CLX, CYCLONE or NSR-L processor is reloaded, there is no default autoswitch of controller ownership to the configured primary processor. bus specifies whether the X bus or the Y bus is used for the transfer of the operating-system image to the processor during the RELOAD operation. 0 = X bus 1 = Y bus The default option is the X bus.
UTILS:TACL Commands and Functions • RELOAD Program (Super-Group Only) If your command repeats a processor number, RELOAD displays: CPU n already specified where n is the processor number you specified more than once in the RELOAD command. • The alternate operating-system image file (in H-series, the OS FileSet) option: ° ° Provides additional fault tolerance if the current file is unavailable. Distributes paging activity.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) lines, no controller ownership switch takes place. For these controllers, problems can arise if an automatic ownership switch occurs during data transmission. For other types of controllers (such as those for disks, tape drives, card readers, and nonserial printers), a controller ownership switch occurs if the reloaded processor was configured as the primary processor for the controller. Caution.
UTILS:TACL Commands and Functions RELOAD Program (Super-Group Only) 2> reload 2, omitslice A; 3 NONSTOP OS PROCESSOR RELOAD - T9070H02 - (01MAY05) Reload 2: Fabric: 0 (X) Reload 3: Fabric: 0 (X) Omitted slice. (CPU 2, Slice A) Sent reload start-up packet to cpu 2 Sent reload start-up packet to cpu 3 Sending OS FileSet pages to Reloadee(s) Integrating CPU 2 Starting system services on CPU 2 PROCESSOR RELOAD: 2 Services started successfully.
UTILS:TACL Commands and Functions REMOTEPASSWORD Command and RPASSWRD Program REMOTEPASSWORD Command and RPASSWRD Program Use the REMOTEPASSWORD command to run the system program RPASSWRD, which adds or deletes remote passwords. REMOTEPASSWORD [ \node-name [ , password ] ] \node-name is the name of the system where the remote password is to be in effect.
UTILS:TACL Commands and Functions REMOTEPASSWORD Command and RPASSWRD Program Examples 1. Suppose that you are user MANUF.FRED on system \ROME, and you need access to files on system \PARIS. First, log on to the \ROME system and establish the remote passwords YES for the \PARIS system and OK for the \ROME system by entering these commands: 14> REMOTEPASSWORD \PARIS, YES THE \PARIS REMOTE PASSWORD FOR MANUF.FRED (8,44) HAS BEEN CHANGED. 15> REMOTEPASSWORD \ROME, OK THE \ROME REMOTE PASSWORD FOR MANUF.
UTILS:TACL Commands and Functions RENAME Command RENAME Command Use the RENAME command to change the name of an existing disk file. RENAME old-file-name [,] new-file-name old-file-name is the name of the disk file to be renamed. new-file-name is the new name for the file. Considerations • You can rename a file only if it is not open with exclusive access, and you either have purge access to the file or are logged on as a super-group user.
UTILS:TACL Commands and Functions RESET DEFINE Command RESET DEFINE Command Use the RESET DEFINE command to restore one or more DEFINE attributes in the working attribute set to their initial settings. For more information about DEFINEs, see Section 5, Statements and Programs and the ADD DEFINE Command on page 8-9. RESET DEFINE { attribute-name [‚ attribute-name ] ... } {*} attribute-name is the name of a DEFINE attribute whose value is to be reset to its initial value.
RESET DEFINE Command UTILS:TACL Commands and Functions Example This RESET DEFINE command resets the USE attribute in the current working attribute set. Because USE is an optional attribute, it ceases to have any value. 71> SHOW DEFINE * CLASS VOLUME LABELS REELS OWNER FILESECT ... USE DEVICE ... TAPEMODE 72> RESET DEFINE USE 73> SHOW DEFINE * CLASS VOLUME LABELS REELS OWNER FILESECT ... USE DEVICE ...
RUN[D|V] Command UTILS:TACL Commands and Functions RUN[D|V] Command Use the RUN command to run programs or TACL macros. You invoke the RUND or RUNV command with the same parameters and options as the RUN command, but the RUND command runs programs under control of the INSPECT symbolic debugger or DEBUG, while the RUNV command runs programs under the control of the VISUAL INSPECT symbolic debugger. A RUN command must name an object file or TACL program file that contains the program you want to run.
RUN[D|V] Command UTILS:TACL Commands and Functions EXTSWAP INSPECT MAXNATIVEHEAPSIZE* OUTV TERM GUARANTEEDSWAPSPACE* INV MEM PFS WINDOW * These options are available when the default configuration settings of the TACL process are changed. To change the settings, set the TACL configuration parameter CONFIGRUN to PROCESSLAUNCH. For more information, see the #SETCONFIGURATION option, CONFIGRUN [ PROCESSCREATE | PROCESSLAUNCH ].
UTILS:TACL Commands and Functions RUN[D|V] Command For non-native processes running with D42 or later software RVU, omitting this option causes the Kernel-Managed Swap Facility (KMSF) to allocate swap space for the default extended data segment of the process. For more information about the KMSF facility, refer to the Kernel-Managed Swap Facility (KMSF) Manual.
UTILS:TACL Commands and Functions RUN[D|V] Command IN [ file-name | $process-name ] is the IN file for the new process. This file or process name is sent to the new process in its startup message. If you do not include the IN option, the new process uses the IN file of the current TACL (usually your home terminal). If you include IN with no name, spaces are sent as the name of the input file. TACL allows the IN file to be a DEFINE name, and passes the DEFINE name to the process being executed.
RUN[D|V] Command UTILS:TACL Commands and Functions To run a program file with a user library, you must have write access to the program file; the library file name is written into the object-file header of the program at run time. To run the program again with the same library, you can omit the LIB parameter. To run the program again with no library (or with a different library), include LIB (or LIB file-name).
UTILS:TACL Commands and Functions RUN[D|V] Command sign); the first character must be alphabetic. (For network access, the name must be no more than four characters.) If you omit this parameter, the new process is not named and has only a CPU number and process number. If you include NAME with no $process-name, TACL generates a name for the new process. The name of the process appears in the destination control table (DCT).
UTILS:TACL Commands and Functions RUN[D|V] Command If the priority of the TACL process is greater than 1 and priority for the new process is not specified, TACL starts the new process at 1 less than the priority of the TACL process. If a $CMON process exists, it might specify a different priority for the new process, depending on how it has been coded. See the Guardian Programmer’s Guide for information about $CMON processes.
UTILS:TACL Commands and Functions RUN[D|V] Command WINDOW [" text "] creates a window for the OUT file of the new process. The quotation marks are required; otherwise, TACL returns an error message. This option is for use in an X Windows environment. The home terminal is inherited from the parent TACL process; any I/O to the home terminal is directed to the parent TACL. Output to the home terminal is not displayed if there is a read or write pending on the home terminal.
UTILS:TACL Commands and Functions RUN[D|V] Command (8,000 bytes), and adds 32,000, resulting in 40,000 bytes. Ensure that your named swap file has enough extent file space. • To use either the INV or the OUTV option, your TACL process (the one from which you are starting the new process) must have a process name. • To use INV dynamically, you must include the NOWAIT option, so that control returns to your TACL process. To send information, wait for the prompt variable.
UTILS:TACL Commands and Functions RUN[D|V] Command USER2 (who does not have write access to PROG) can also run PROG, provided the library LIBFILE has not been altered since its last use. If LIBFILE has changed, however, and USER2 enters: 12> RUN PROG / LIB LIBFILE / the attempt to run the program fails because USER2 does not have write access to PROG so that external references can be resolved through the changed library file.
UTILS:TACL Commands and Functions RUN[D|V] Command Similarly, these commands also run a TEDIT process on the \CHICAGO system, because the current default node name is used for file-name expansion: 14> SYSTEM \CHICAGO 15> TEDIT A program file, however, must reside on the system where it runs; the command: 14> RUN \DETROIT.MYPROG attempts to run a program file named: \DETROIT. default-volume. default-subvolume.
UTILS:TACL Commands and Functions RUN[D|V] Command 2. This command runs the program APP1 in the current default subvolume: 15> RUN APP1 3.
SEGINFO Command UTILS:TACL Commands and Functions SEGINFO Command Use the SEGINFO command to display a table of information about all the TACL segment files in use by your TACL process. SEGINFO SEGINFO displays its information under this heading line: Segment File Access Pgs Now Pgs Max Bytes Now Bytes Max % UC Directory Access is the access mode: PR means private and SH means shared. If access is shared, the segment file is read-only.
UTILS:TACL Commands and Functions SEMSTAT Program SEMSTAT Program Use the SEMSTAT program to print the Binary Sempahore (BINSEM) usage information and statistics for a process whose ID or process name is provided. Syntax to invoke the command: SEMSTAT {-procname | -pin [-brief | -full | -wide |-clear_stats]} or specifies the process in the CPU where SEMSTAT is running. -brief or -full or -wide specifies how much information is displayed and the format used to display the data.
SEMSTAT Program UTILS:TACL Commands and Functions Examples The SEMSTAT program prints BINSEM statistics for each BINSEM used by the specified process. The statistics are printed in a tabular format and are categorized as the following heading rows: Sem ID The BINSEM ID in this process. Acquisitions The number of times the BINSEM is acquired. Tot. Cont. The number of times the BINSEM is found locked. Mult.Cont. The number of times the BINSEM is found locked and contended. Cur. Cont.
SEMSTAT Program UTILS:TACL Commands and Functions 2.Full Format semstat /cpu 1/ -pin 843 -full SEMSTAT utility -- T9050J01 - (01AUG12) - (18JUN12) - (AWT) (c) Copyright 2011 Hewlett Packard Development Company, L.P. --- Binary Semaphore Statistics for Process 1,843 --Sem ID Acquisitions Create Date Tot. Cont. Mult. Cont. Cur. Cont. Max.
SEMSTAT Program UTILS:TACL Commands and Functions The following example first displays BINSEM Statistics for Process 1,945, and then displays the cleared statistics after using -clear_stats option: SYSTEM STARTUP 49> semstat -pin 945 SEMSTAT utility -- T9050J01 - (01AUG12) - (18JUN12) - (AWT) (c) Copyright 2011 Hewlett Packard Development Company, L.P. --- Binary Semaphore Statistics for Process 1,945 --Sem ID Acquisitions Tot. Cont. Mult. Cont. Cur. Cont. Max.
UTILS:TACL Commands and Functions SET DEFINE Command SET DEFINE Command Use the SET DEFINE command to set a value for one or more DEFINE attributes in the working attribute set. Values in the working set determine the values for any attributes you omit from the ADD DEFINE command when you create a DEFINE. For more DEFINE information, see the Guardian User’s Guide. SET DEFINE { { attribute-spec } | { LIKE define-name } } [ , attribute-spec ] ...
UTILS:TACL Commands and Functions SET DEFINE Command REPORT report-name SELPRI num • For a SUBSORT DEFINE: BLOCK size CPU cpu-number PRI priority PROGRAM file-name SCRATCH file-name SEGMENT size SWAP file-name • For a TAPE DEFINE: BLOCKLEN block-length DENSITY { 800 | 1600 | 6250 } DEVICE device-name EBCDIC { IN | OUT | ON | OFF } EXPIRATION date FILEID file-name FILESECT volume-order FILESEQ file-order GEN gen-num LABELS { ANSI | IBM | OMITTED | BYPASS | BACKUP | IBMBACKUP } MOUNTMSG " text" OWNER ow
UTILS:TACL Commands and Functions SET DEFINE Command create DEFINE names that begin with these two characters, except for specific purposes that are described in application product documentation. • When an error occurs for the SET DEFINE command, no attributes or values are changed in the working attribute set. • After you have set an attribute value, it persists until you reset it. You can reset an attribute value explicitly with the RESET DEFINE command or with another SET DEFINE command.
UTILS:TACL Commands and Functions SET DEFINE Command TAPE is used for accessing labeled tapes. The CLASS attribute establishes a different initial working attribute set for each class: ° For CLASS CATALOG, the working attribute set always consists of the SUBVOL attribute only (a required attribute that has no default value): SUBVOL subvol-name For subvol-name, give the name of an existing subvolume; the format is: [[\node-name.]$volume.
UTILS:TACL Commands and Functions SET DEFINE Command LC_MESSAGES determines how messages and process interactive responses are formatted. LC_MONETARY determines how currency representations are formatted. LC_NUMERIC determines how numbers are represented. LC_TIME determines how dates and times are formatted. Each of these attributes is case-sensitive and can be up to 256 characters.
UTILS:TACL Commands and Functions • • • SET DEFINE Command ° For CLASS SPOOL, the working attribute set consists of the attributes listed in Table 8-5 on page 8-182. The only required attribute is the LOC attribute. ° For CLASS SUBSORT, the working attribute set consists of the attributes listed in Table 8-6 on page 8-184. The only required attribute is the SCRATCH attribute.
SET DEFINE Command UTILS:TACL Commands and Functions • The same set of DEFINE attributes can be configured for a generic process through SCF. For the syntax, see the SCF Reference Manual for the Kernel Subsystem. Creating a SORT DEFINE Table 8-4 describes the attributes that apply to the FastSort subsystem, and the values available for those attributes. See the FastSort Manual for a full description of the effects of these attributes. All SORT attributes (other than CLASS) are optional.
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-4. SORT DEFINE Attributes (page 2 of 3) Name and Value Function MINSPACE Limits the size of the extended memory segment to 64 pages (128 KB) For files up to 100 KB, FastSort makes no merge pass (or only one merge pass).
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-4. SORT DEFINE Attributes (page 3 of 3) Name and Value Function SEGMENT size Specifies the size, in pages, of an extended memory segment for FastSort to use; it must be at least 64%, but not over 90% of the memory not appropriated by the operating system If you specify SEGMENT, you must omit MODE. The default is the same as MODE AUTOMATIC. SUBSORTS ( DEFINE-name [ , DEFINE-name ] ...
SET DEFINE Command UTILS:TACL Commands and Functions Creating a SPOOL DEFINE Table 8-5 describes the attributes that apply to the Spooler subsystem, and the values available for those attributes. The only required SPOOL attribute (other than CLASS) is LOC. Table 8-5. SPOOL DEFINE Attributes (page 1 of 2) Name and Value Function BATCHNAME batch-name Specifies a batch name for a job It can be from 1 to 31 characters in length, and can contain hyphens as well as alphanumeric characters.
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-5. SPOOL DEFINE Attributes (page 2 of 2) Name and Value Function OWNER { group-name.user-name } | { group-num.user-num } Specifies the owner of all jobs created by any process using the DEFINE PAGESIZE num Specifies the number of lines per page, in the range from 1 through 32767, to be used by PERUSE when it performs a LIST or PAGE command The numeric form of user ID must be enclosed in quotes.
UTILS:TACL Commands and Functions SET DEFINE Command Creating a SUBSORT DEFINE Table 8-6 lists the attributes that apply to parallel sorts run under the FastSort subsystem and the values available for those attributes. See the FastSort Manual for a full description of the effects of these attributes. The only required attribute (other than CLASS) is SCRATCH. Table 8-6.
UTILS:TACL Commands and Functions SET DEFINE Command Creating a TAPE DEFINE Attribute values for a TAPE DEFINE must meet certain consistency rules, shown in Table 8-7. The specific rules for particular attributes are listed in Table 8-8 on page 8-186. You can display all the attributes that are currently set or defaulted with the SHOW DEFINE * command. This command also checks these attributes for consistency and returns the check number of the first consistency check that fails. Table 8-7.
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-8. TAPE DEFINE Attributes (page 1 of 4) Name and Value Function * BLOCKLEN block-length Specifies the data block size, in bytes, in a tape file The default is that the tape process does not check block length (input files). If RECFORM is F, BLOCKLEN must be a multiple of RECLEN. DENSITY {800 | 1600 | 6250} Specifies the tape density in bits per inch The specified density appears in mount messages sent to the operator.
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-8. TAPE DEFINE Attributes (page 2 of 4) Name and Value Function * GEN gen-number Indicates that this file is part of a generation group Specify an integer in the range 0001 to 9999 to indicate the absolute generation number. The default is 0001.
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-8. TAPE DEFINE Attributes (page 3 of 4) Name and Value Function * RECFORM { F | U } Specifies the record format If you include LABELS IBM, you must also specify RECFORM. F: Indicates fixed-length records (the default for ANSI tapes). U: Indicates undefined length (the default for IBM tapes). For input files, BLOCKLEN, RECFORM, and RECLEN values are not checked for consistency.
SET DEFINE Command UTILS:TACL Commands and Functions Table 8-8. TAPE DEFINE Attributes (page 4 of 4) Name and Value Function TAPEMODE { STARTSTOP | STREAM } Specifies the operating mode for a cartridge tape drive; for other types of drives, this attribute is ignored If you specify TAPEMODE, BLOCKSIZE must be greater than the default of 2 to speed the tape writing process and to produce a more compact tape. The default is STARTSTOP.
SET DEFINE Command UTILS:TACL Commands and Functions CLASS TAPE DEFINE that describes a tape file residing on volume 30 of an ANSI standard labeled tape mounted on tape drive $TAPE2. Next, a SHOW DEFINE command displays the status of the current working attribute set.
UTILS:TACL Commands and Functions SET DEFMODE Command SET DEFMODE Command Use the SET DEFMODE command to enable or disable the use of DEFINEs in the current TACL process. SET DEFMODE { ON | OFF } ON enables the use of DEFINEs in, and the propagation of DEFINEs from, the current TACL process. This means that unless you change the DEFMODE setting in a RUN command, the process started by that command has an initial DEFMODE setting of ON, and all DEFINEs are propagated to that new process.
UTILS:TACL Commands and Functions SET HIGHPIN Command SET HIGHPIN Command Use the SET HIGHPIN command to establish the default PIN range for processes started by the current TACL when there is no HIGHPIN directive on a RUN command or #NEWPROCESS call. SET HIGHPIN { ON | OFF } ON specifies that a process will run at a high PIN if the HIGHPIN bit is enabled in the object file (and in the library file, if any) and if a high PIN is available. ON is the default value for HIGHPIN.
UTILS:TACL Commands and Functions SET INSPECT Command SET INSPECT Command Use the SET INSPECT command to establish default debugging conditions for processes started by the current TACL. SET INSPECT { OFF | ON | SAVEABEND } OFF disables the Inspect symbolic debugger and selects the Debug program as the default debugger. (The Debug program is the system default debugging utility.
UTILS:TACL Commands and Functions SETPROMPT Command SETPROMPT Command Use the SETPROMPT command to change the TACL prompt. By default, TACL prompts with a history number and a greater-than sign (>) followed by a space. SETPROMPT { SUBVOL | VOLUME | BOTH | NONE } SUBVOL displays the current subvolume, followed by the command number, a greater-than sign, and a space. VOLUME displays the current volume, followed by the command number, a greater-than sign, and a space.
UTILS:TACL Commands and Functions SET _DO_NOT_PROMPT_TACL_STOP Command SET _DO_NOT_PROMPT_TACL_STOP Command Use the SET _DO_NOT_PROMPT_TACL_STOP command to display or not display a confirmation message before stopping one or more running processes after issuing the STATUS command with the STOP option. SET _DO_NOT_PROMPT_TACL_STOP [ON|OFF] ON A STATUS command with the STOP option is executed without asking for confirmation.
UTILS:TACL Commands and Functions SET SWAP Command SET SWAP Command Use the SET SWAP command to select the swap volume for all subsequent RUN commands, unless a swap volume is explicitly specified in the RUN command. SET SWAP [ $volume-name ] $volume-name is the name of the volume used to hold virtual data during memory swaps of the user data stack during process execution. Considerations • To clear any swap volume previously set, use the SET SWAP command without the $volume-name parameter.
UTILS:TACL Commands and Functions SETTIME Command (Super-Group Only) SETTIME Command (Super-Group Only) Use the SETTIME command to set the date and time-of-day clock for the system. You normally use SETTIME after you cold load the first processor from disk, but before you load the rest of the system using the RELOAD command. You can also use SETTIME to reset the system clocks after a power failure (the interval clock in a processor module stops when power is interrupted).
UTILS:TACL Commands and Functions SETTIME Command (Super-Group Only) Considerations • The valid date range is from 01 January 1975 0:00:00.000000 to 31 December 4000 23:59:59.999999. • If you execute this command while a system monitoring measurement is in process by the XRAY facility, invalid measurements result. • The CONVERTTIMESTAMP system procedure is invoked while setting the system clock.
UTILS:TACL Commands and Functions SET VARIABLE Command SET VARIABLE Command Use the SET VARIABLE command to change the contents of a variable level or built-in variable. The syntax and action of the SET VARIABLE command are the same as the #SET built-in function.
UTILS:TACL Commands and Functions SET VARIABLE Command MACRO specifies that text is a TACL macro. ROUTINE specifies that text is a TACL routine. TEXT specifies that text is simply text (it has no special meaning to TACL). variable-level is the name of an existing variable level, of the form: variable-name[. level-num] If you omit . level-num, the top level of the variable is assumed. text is the new contents of the variable level. If the IN option is supplied, you cannot specify text.
UTILS:TACL Commands and Functions SHOW Command SHOW Command Use the SHOW command to display the values of attributes set with the SET command. SHOW [ / OUT list-file / ] [ attribute [ , attribute ] ... ] OUT list-file specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive a listing of command output. If you omit this option, TACL writes the listing to its current OUT file.
UTILS:TACL Commands and Functions SHOW Command Examples 1. This command displays the status of the INSPECT and SWAP attributes: 13> SHOW SWAP,INSPECT Swap $RALPH Inspect ON 2. To see all attributes currently set, enter: 14> SHOW Defmode ON Highpin ON Inspect ON Swap The display shows that DEBUG is the debugging utility in effect, DEFMODE is set ON, and that no swap volume has been set.
UTILS:TACL Commands and Functions SHOW DEFINE Command SHOW DEFINE Command Use the SHOW DEFINE command to show the value associated with a specific DEFINE attribute, to show all attribute values that are currently set or defaulted, or to show all attributes in the current working set (that is, all the attributes associated with the current CLASS) and the current value of each. For more information about DEFINEs, see Section 5, Statements and Programs.
UTILS:TACL Commands and Functions SHOW DEFINE Command * LABELS OMITTED Current attribute set is inconsistent, check number 3 If the attributes are incomplete (that is, if a required attribute is missing), a warning message is displayed, and the value for the missing attribute is displayed as ??.
UTILS:TACL Commands and Functions MOUNTMSG SYSTEM HP NonStop TACL Reference Manual—429513-018 8-205 SHOW DEFINE Command
UTILS:TACL Commands and Functions SINK Command SINK Command Use the SINK command to invoke a function but discard its result. SINK can discard nonnumeric results as well as numeric ones. SINK [ text ] Consideration Use of the SINK command discards error indications returned by a function. Therefore, the use of SINK is not recommended unless you do not need to know if an error occurred.
UTILS:TACL Commands and Functions STATUS Command STATUS Command Use the STATUS command to display information about one or more running processes. The STATUS command is an alias for the #XSTATUS built-in function.. Note: The STATUS command is a macro, not an alias for #XSTATUS. STATUS [ / OUT list-file / ] [ range ] [ , condition ] ...
UTILS:TACL Commands and Functions STATUS Command If you omit range, STATUS reports on the last process started by the current TACL, or for which TACL last paused, if that process is still running. is any one of these: GMOMJOBID $process-name. num PRI [ priority ] PROG [ program-file-name | file-name-template ] TERM [ $terminal-name ] USER [ user-id ] GMOMJOBID $process-name.num specifies processes with the given job ancestor ID. num is a signed integer.
UTILS:TACL Commands and Functions STATUS Command TERM [ \node-name.$terminal-name ] specifies processes running on a given terminal. If you omit $ terminal-name, STATUS reports on processes running on the home terminal of the current TACL process. If you omit node-name, the STATUS command uses the system specified in range or, if not specified in either argument, uses the default system. USER [ ident ] specifies processes created by a particular user, where ident is either groupname.
STATUS Command UTILS:TACL Commands and Functions • If you specify a single process and the process does not exist, TACL returns “Process does not exist.” • If the node name for a process cannot be retrieved by the STATUS program, the node name for the home terminal will be displayed. • If you specify a range of processes and none of the processes exist, TACL displays nothing. • File-name-template is not supported for the options PROG and LOADED used together.
UTILS:TACL Commands and Functions • STATUS Command If the output of the STATUS command includes the Swap File Name parameter and no swap file name has been set with either (or both) the SWAP swap-file option of the RUN command or the SET SWAP [ $volume-name ] command, a dummy file name, "$vol.#0", is returned. In this case, #vol is the name of the physical volume that the operating system has selected for storing the swap file. In the following example, “$SYSTEM.#0” is a dummy file name.
UTILS:TACL Commands and Functions STATUS Command If the filename portion of the name is longer than 26 characters, then the filename is truncated to the first 23 characters and ellipses (...) are appended to the name, as illustrated in this example: STATUS *,USER Process Pri PFR %WT Userid Program file Hometerm $DCEE X 0,340 155 004 255,161 /opt/dcelocal/bin/abcsd... $ZTNT.#R If the file name portion of the name is not available, "No OSS file name" is output for the file name.
STATUS Command UTILS:TACL Commands and Functions Examples 1. To view the status of user 103, 141 enter: 14> STATUS *, user 103, 141 Process $Y09M 9 9 $Y09M 9 B 0,193 Pri 168 X 0,611 168 1,121 168 PFR R %WT 001 Userid 103,141 Program file $SYSTEM.SYS10.TACL Hometerm 000 103,141 /bin.sh $ZTNT.#PTA8AE 000 103,141 $SYSTEM.SYS10.TACL $ZTNT.#PTA8AE $ZTNT.#PTA8AE This information is displayed: • • The process name, if any. • • • The CPU and process number. • The wait state.
UTILS:TACL Commands and Functions • STATUS Command The name of the user library file, swap file, and extended swap file, if you requested the status of a single process (or a process pair) that is running with a user library (such as one specified with the LIB option of the RUN command) or swap files. 2.
UTILS:TACL Commands and Functions • • STATUS Command The wait-field value and the event that the process is waiting for. The values have this meaning: %000 Process is running; or process was waiting on an event that has since occurred and is now ready to run, process is in call to DELAY, or process is suspended. %001 Process is waiting for a message to occur on its $RECEIVE file. %002 Process is waiting for a TMF subsystem request to finish, or user process is waiting for ENDTRANSACTION to finish.
STATUS Command UTILS:TACL Commands and Functions DEBUG TRAP DEBUG REQUEST FORCED LOW INSPECT MAB INSPECT BREAKPOINT INSPECT TRAP INSPECT REQUEST SAVE ABEND TERMINATING TSN LOGON • The job ancestor of the process. 3. To stop all of your processes on the terminal where your TACL is running (except the TACL process itself): STATUS *, TERM, STOP, FORCED or SET _DO_NOT_PROMPT_TACL_STOP ON 4.
UTILS:TACL Commands and Functions STATUS Command Current Extended Swap File Name: $SYSTEM.#0 Process Time: 0:0:0.004 Process Creation Time: April 2, 2009 20:02:36.
STOP Command UTILS:TACL Commands and Functions STOP Command Use the STOP command to request termination of a running process. STOP [ [\node-name.]{$process-name | cpu,pin} ] \node-name is the system where the process resides. $process-name is the name of the process or process pair. cpu,pin is the CPU number and process number for the process. Considerations If a process terminates successfully, TACL does not display a message.
UTILS:TACL Commands and Functions • STOP Command STOP cannot stop the current TACL or its backup. Use the built-in function #STOP instead. Examples 1. To stop the last process you started from the current TACL, enter: 14> STOP 15> 2. If you started the process whose cpu,pin is 0,18, or if you are the super ID, you can stop the process by entering: 14> STOP 0,18 15> 3.
UTILS:TACL Commands and Functions SUSPEND Command SUSPEND Command Use the SUSPEND command to temporarily suspend a process (or process pair) to prevent it from competing for system resources. SUSPEND [ [\node-name.]{$process-name | cpu,pin } ] \node-name is the system where the process resides. $process-name is the name of the process or process pair. cpu,pin is the CPU number and process number for the process.
UTILS:TACL Commands and Functions SUSPEND Command Examples 1. To suspend the last process you started from the current TACL, enter: 14> SUSPEND 15> 2. If you started a process with cpu,pin 0,18, or if you are the super ID, you can suspend the process by entering: 14> SUSPEND 0,18 15> 3.
UTILS:TACL Commands and Functions SWITCH Command SWITCH Command Use the SWITCH command to make your TACL backup the primary process, initializing itself as though you had just logged on to it. The former primary process becomes the backup. The SWITCH command is an alias for the #SWITCH built-in function. SWITCH Considerations • To use the switch command, your TACL must have a backup process. To create a backup process, include it in the TACL RUN command or use the BACKUPCPU command.
UTILS:TACL Commands and Functions SWITCH Command You can switch the functions of these processes (make the TACL process running in CPU 4 the primary process and the process running in CPU 5 the backup) by entering the SWITCH command: 24> SWITCH HP NonStop TACL Reference Manual—429513-018 8-223
UTILS:TACL Commands and Functions SYSTEM Command SYSTEM Command Use the SYSTEM command to set the default system until you change it again or log off. This command applies only to systems that are available in a network. SYSTEM [ \node-name ] \node-name is the name of a new default system. If you omit \ node-name, the system on which your TACL is running becomes the current default. Considerations • The system you specify in a SYSTEM command is temporarily in effect.
SYSTIMES Command UTILS:TACL Commands and Functions SYSTIMES Command Use the SYSTIMES command to display the current date and time (in local civil time and Greenwich mean time), the date and time when the system was last cold loaded, and the date and time SYSGEN was last run. SYSTIMES Considerations • The SYSTIMES command displays four lines of information giving you the date and time as shown here: ddmmmyyyy, ddmmmyyyy, ddmmmyyyy, ddmmmyyyy, hh:mm:ss.mmmuuu hh:mm:ss.mmmuuu hh:mm:ss.mmmuuu hh:mm:ss.
UTILS:TACL Commands and Functions Example To display the various system times, enter: 37> SYSTIMES 6 Aug 1992, 12:09:54.589512 LCT 6 Aug 1992, 20:09:54.589512 GMT 30 Jul 1992, 19:18:03.750427 Cold Load (LCT) 9 Jul 1992, 11:52:13.
UTILS:TACL Commands and Functions TACL Program TACL Program Enter the TACL program name to start a TACL process on your local system or on a remote system (if your system is part of a network). [\node-name.]TACL [ / run-option [ , run-option ] ... / ] [ backup-cpu-num ] [ ; parameter [ , parameter ] ] \node-name is the name of the system on which TACL is to run. This parameter is valid only for systems that have a node name (those that are part of a network).
TACL Program UTILS:TACL Commands and Functions option. If the IN file is the same as the OUT file and the TACL process is not named, TACL does not set its home terminal. A process started by TACL inherits its home terminal unless the RUN command that initiates the process specifies a different home terminal. PORTTACL specifies that the TACL being started is a port TACL (for example, a modem port for a dial-in line or an X25 connection).
UTILS:TACL Commands and Functions TACL Program user to decide which TACL processes need to be started with the PORTTACL startup parameter. • If a backup CPU was specified for the TACL process being started with the PORTTACL startup option and the primary TACL fails, the backup TACL process inherits the PORTTACL setting from the primary TACL process. • The PORTTACL startup parameter is only valid as a TACL process startup parameter option. It is not a valid LOGON parameter option.
UTILS:TACL Commands and Functions TACL Program • To run TACL as a server process, set the IN file to $RECEIVE. For more information, see the TACL Programming Guide. • If the IN file is the same as the OUT file and the TACL process is not named, TACL does not set its home terminal.
UTILS:TACL Commands and Functions TACL Program command. In this case, ABENDONABEND overrides the default setting (STOPONABEND) just for this logon session. 12> TACL /NAME/ ;STOPONABEND TACL 1> LOGON SOFTWARE.JANE ;ABENDONABEND Password: If you start a TACL process with both the STOPONABEND and ABENDONABEND parameters, the last parameter specified in the list overrides the first one. In this example, STOPONABEND overrides ABENDONABEND. 12> TACL /NAME/ ;ABENDONABEND TACL 1> LOGON SOFTWARE.
UTILS:TACL Commands and Functions TACL Program 0 Z^PROCNAME(0) ZOFFSET(0:0) 82 ZLEN(0:0) 20 Z^FLAGS(0:0) 1 Z^RESERVED(0:2) 1 1 0 Z^DATA(0) BYTE(0:111) \PRUNE.$MP:150608489 Examples 1. This example shows how to start an interactive TACL process from an existing TACL process: 13> TACL / IN $term1, OUT $term1, CPU 2, PRI 150, NOWAIT,& 13> &NAME $C106 / 3 After you enter this command: • A new TACL process starts; it accepts commands from, and displays its output on, terminal $TERM1.
UTILS:TACL Commands and Functions TIME Command TIME Command Use the TIME command to display the current setting of the system date and time-ofday clock in the format: mmm dd, yyyy, hh:mm:ss TIME Considerations • • The year is the 4-digit calendar year, from 1975 through 9999. You can execute a TIME command without having logged on (with the LOGON command) to a system.
UTILS:TACL Commands and Functions USE Command USE Command The USE command defines the list of directories (in the built-in variable #USELIST) that your TACL searches to find existing variables if they are not in your home directory. USE [ directory-name [ [,] directory-name ] ... ] directory-name is the name of an existing variable level of type DIRECTORY.
UTILS:TACL Commands and Functions USERS Program USERS Program Use the USERS program to list user attributes for a particular user or range of users. USERS [ / run-option [ , run-option ] ... / ] [ range ] run-option is any of the options described in the RUN[D|V] Command on page 156. range specifies a particular user or group of users to be listed. Note that range refers to the local system only. The allowable range specifications and their meanings are: (blank) lists current user only.
UTILS:TACL Commands and Functions USERS Program 3. You can get this information for all users in the PARTS group by entering: 15> USERS PARTS.* GROUP USER I.D. # SECURITY DEFAULT VOLUMEID PARTS PARTS PARTS PARTS .CLYDE 001,000 GGGO $SYSTEM.ENGINE .JOE 001,001 CUCU $SYSTEM.TRANS .MARY 001,002 AOGO $SYSTEM.WHEELS .MANAGER 001,255 GGGA $SYSTEM.
UTILS:TACL Commands and Functions VARIABLES Command VARIABLES Command Use the VARIABLES command to display the names of all variables in a directory. VARIABLES [ directory-name ] directory-name is the name of an existing variable level of type DIRECTORY. Considerations • • If you omit directory-name, the home directory is assumed. If the directory being displayed contains a directory, that inner directory name is flagged with an asterisk (*). The names of variables in that directory are not listed.
UTILS:TACL Commands and Functions VARINFO Command VARINFO Command Use the VARINFO command to display attribute information about one or more of your variables. VARINFO [ variable [ [,] variable ] ... ] variable is the name of an existing variable. Considerations • If you omit variable, VARINFO displays information about all variables in your home directory. • VARINFO displays information similar to this: Variable L/D Type Frm Mode File Process MYDIR 1/1 DIRECTORY 0 SHARED $V1.SV2.
UTILS:TACL Commands and Functions VARINFO Command PRIVATE SHARED File is the name of #SERVER or the file opened by #REQUESTER. In the case of a segment, it is the name of the segment file with which the variable is associated. Process is the process associated with an implicit #SERVER; that is, the process that started with INV, OUTV, or STATUS specifying the variable. • For an unnamed process, a process ID (that is, cpu,pin) is returned in the Process field.
UTILS:TACL Commands and Functions VARTOFILE Command VARTOFILE Command Use the VARTOFILE command to copy the data in a variable to a file. VARTOFILE variable-level file-name variable-level is the name of an existing variable level from which data is to be copied. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. file-name is the name of the file that is to receive the copy. If the file exists, it must be of a type that can be written to by the sequential I/O (SIO) facility.
UTILS:TACL Commands and Functions VCHANGE Command VCHANGE Command Use the VCHANGE command to change all occurrences of one string to another string in a range of lines within a variable. VCHANGE [ / option [ , option ] ... / ] variable-level string-1 string-2 [ range ] option is any of these: OUT file-name QUIET TO variable-level OUT file-name specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the changed lines. The listing includes line numbers.
UTILS:TACL Commands and Functions VCHANGE Command string-2 is the string that is to replace string-1. range specifies the line or lines in which the change is to occur. If you omit it, all lines are included. A range specification can be any of these: A line-num line-num / line-num A specifies all lines in the variable level. line-num specifies an individual line number. It can be any of these: F L number F specifies the first line in the variable level. L specifies the last line in the variable level.
VCHANGE Command UTILS:TACL Commands and Functions #INFORMAT Built-In Variable on page 9-197 or the ?FORMAT Directive on page 5-6.
UTILS:TACL Commands and Functions VCOPY Command VCOPY Command Use the VCOPY command to copy a range of lines from one variable and insert them at a given line position in another variable. VCOPY [ / option [ , option ] ... / ] source-var range dest-var dest-line option is any of these: OUT file-name QUIET TO variable-level OUT file-name specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the copied lines. The listing includes line numbers.
UTILS:TACL Commands and Functions VCOPY Command A line-num line-num / line-num A specifies all lines in the variable level. line-num specifies an individual line number. It can be any of these: F L number F specifies the first line in the variable level. L specifies the last line in the variable level. number is an integer identifying a specific line. dest-var is an existing variable level that is to receive the copy.
VCOPY Command UTILS:TACL Commands and Functions number is an integer identifying a specific line. It must be greater than zero and not greater than the number of lines in the variable level, plus one (it can specify a new line past the last existing line). Considerations • • source-var and dest-var must not be identical. Copied lines are inserted immediately preceding dest-line.
UTILS:TACL Commands and Functions VDELETE Command VDELETE Command Use the VDELETE command to delete a range of lines from a variable. VDELETE [ / option [ , option ] / ... ] variable-level range option is any of these: OUT file-name QUIET TO variable-level OUT file-name specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the deleted lines. The listing includes line numbers. If you omit this option, TACL writes the listing to its current OUT file.
VDELETE Command UTILS:TACL Commands and Functions line-num specifies an individual line number. It can be any of these: F L number F specifies the first line in the variable level. L specifies the last line in the variable level. number is an integer identifying a specific line.
UTILS:TACL Commands and Functions VFIND Command VFIND Command Use the VFIND command to find all lines containing occurrences of a specified string in a range of lines within a variable. VFIND [ / option [ , option ] / ... ] variable-level string [ range ] option is any of these: OUT file-name QUIET TO variable-level OUT file-name specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the listing of lines in which string is found.
UTILS:TACL Commands and Functions VFIND Command range specifies the line or lines in which the search is to be made. If you omit it, TACL searches all lines. A range specification can be any of these: A line-num line-num / line-num A specifies all lines in the variable level. line-num specifies an individual line number. It can be any of these: F L number F specifies the first line in the variable level. L specifies the last line in the variable level.
VFIND Command UTILS:TACL Commands and Functions Example If these variables have the contents shown: Var Listvar THE QUICK BROWN 12345678910 FOX JUMPED OVER 11121314151617 THE LAZY DOG 18192021 TWICE A DAY EXCEPT TUESDAYS the command: VFIND /TO listvar/ var "THE" 1/4 causes them to contain: Var Listvar THE QUICK BROWN 12345678910 FOX JUMPED OVER 11121314151617 THE LAZY DOG 18192021 TWICE A DAY THE QUICK BROWN EXCEPT TUESDAYS THE LAZY DOG and causes this to be written to the TACL OUT fi
UTILS:TACL Commands and Functions VINSERT Command VINSERT Command Use the VINSERT command to insert lines from the current TACL IN file into a given line position in a variable. VINSERT variable-level line-num variable-level is an existing variable level into which lines are to be inserted. It must not be in a shared segment, and must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-num specifies the line number at which lines are to be inserted.
UTILS:TACL Commands and Functions VINSERT Command TWICE A DAY EXCEPT TUESDAYS. the command: VINSERT var 3 causes TACL to prompt with line numbers that the inserted lines will have in the variable; TACL continues to accept lines until a line consisting solely of two slashes is entered. The insertion can also be ended by CTRL-y. In this dialog at the current IN file, TACL prompts with line numbers and the user responds with text.
UTILS:TACL Commands and Functions VLIST Command VLIST Command Use the VLIST command to list a range of lines in a variable. VLIST [ / option [ , option ] / ... ] variable-level [ range ] option is any of these: OUT file-name QUIET TO variable-level OUT file-name specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive the listing. The listing includes line numbers. If you omit this option, TACL writes the listing to its current OUT file.
VLIST Command UTILS:TACL Commands and Functions F L number F specifies the first line in the variable level. L specifies the last line in the variable level. number is an integer identifying a specific line.
UTILS:TACL Commands and Functions VMOVE Command VMOVE Command Use the VMOVE command to delete a range of lines from one variable and insert them at a given line position in another variable. VMOVE [ / option [ , option ] / ... ] source-var range dest-var dest-line option is any of these: OUT file-name QUIET TO variable-level OUT file-name specifies a device, or a sequential file accessible to the sequential I/O (SIO) facility, that is to receive a listing of moved lines.
UTILS:TACL Commands and Functions VMOVE Command A line-num line-num / line-num A specifies all lines in the variable level. line-num specifies an individual line number. It can be any of these: F L number F specifies the first line in the variable level. L specifies the last line in the variable level. number is an integer identifying a specific line. dest-var is an existing variable level into which the moved lines are to be inserted.
VMOVE Command UTILS:TACL Commands and Functions number is an integer identifying a specific line. It must be greater than zero and not greater than the number of lines in the variable level, plus one (it can specify a new line past the last existing line). Considerations • • source-var and dest-var must not be the same variable level. Moved lines are inserted immediately preceding dest-line.
UTILS:TACL Commands and Functions VOLUME Command VOLUME Command Use the VOLUME command to change temporarily your current settings for default volume and subvolume or to return to your saved defaults. VOLUME [ [\node-name.] volume ] [ , "security" ] \node-name specifies your default system. If you omit \ node-name, your default system does not change. volume specifies your default volume and subvolume names. volume is one of these: $volume-name subvolume-name $volume-name.
UTILS:TACL Commands and Functions VOLUME Command • To display your logon default volume and subvolume names, and your logon default security, enter the USERS program or use the WHO command. • The security designations are: • O (Owner) Only the owner can access the file; the owner must be logged onto the local system. G (Group) Anyone in the owner’s group can access the file; the user must be logged onto the local system.
UTILS:TACL Commands and Functions VTREE Command VTREE Command Use the VTREE command to list the names of all the variables in a directory, and in directories below it, and so on. VTREE [ directory-name ] Considerations • • • If you omit directory-name, the home directory is assumed. One name is listed on each line. If a the name of a directory appears in the list, the names of the variables in it are indented on subsequent lines.
UTILS:TACL Commands and Functions WAKEUP Command WAKEUP Command You can use the WAKEUP command to set the TACL wakeup mode. WAKEUP { ON | OFF } ON means that TACL is awakened (returned from the paused state) when any process started by TACL is deleted. OFF means that TACL is awakened only when the latest process started by TACL is deleted or when a process you designate in a PAUSE command is deleted. This is the logon default setting.
UTILS:TACL Commands and Functions WHO Command WHO Command Use the WHO command to display information about your current TACL process. WHO Considerations • The WHO command is useful for verifying your current defaults. For example, if you are on a network and use the SYSTEM command to access another system, you can issue a WHO command to check your defaults before you run programs or purge files.
UTILS:TACL Commands and Functions WHO Command This information is shown in this example: • • The name of the TACL home terminal. • The CPU numbers and processor types of the current TACL primary and backup processes. If the primary TACL process is named but has no backup, the CPU number for the backup does not appear. • • • • • • • Information about the TACL default segment file. The process name of the current TACL. If the process is not named, its process ID (cpu,pin) is displayed.
XBUSDOWN/YBUSDOWN Command (Super-Group Only) UTILS:TACL Commands and Functions XBUSDOWN/YBUSDOWN Command (Super-Group Only) Use the XBUSDOWN or YBUSDOWN command to inform the operating system that an interprocessor bus is being brought down and should not be used. This command is equivalent to the BUSCMD process. The system reports the results of an XBUSDOWN or YBUSDOWN command at the operator console. To use the XBUSDOWN or YBUSDOWN command, you must have a group ID of 255.
UTILS:TACL Commands and Functions XBUSUP/YBUSUP Command (Super-Group Only) XBUSUP/YBUSUP Command (Super-Group Only) Use the XBUSUP or YBUSUP command to inform the operating system that an interprocessor bus is available for use. This command is equivalent to the BUSCMD process. The system reports the results of an XBUSUP or YBUSUP command at the operator console. To use the XBUSUP or YBUSUP command, you must have a group ID of 255.
UTILS:TACL Commands and Functions Exclamation Point (!) Command Exclamation Point (!) Command Use the exclamation point (!) command to reexecute immediately a previous command line, without modifications. ! [num] [- num] [text] num is an absolute history number. - num is a number relative to the current history number. text is a text string. Considerations • If you enter nothing but !, TACL reexecutes the previous command (! is the same as ! - 1).
UTILS:TACL Commands and Functions Question Mark (?) Command Question Mark (?) Command Use the question mark (?) command to display a previous command line. ? [num] [- num] [text] num is an absolute history number. - num is a number relative to the current history number. text is a text string. Considerations • If you enter a question mark (?) without an argument, TACL displays the previous command (? is the same as ? - 1).
UTILS:TACL Commands and Functions Question Mark (?) Command 2. This example shows the use of the ? command to see the most recent command that started with the text string “SET.” The user then enters the ! command to reexecute the last SET command. 11> 11> 11> 11> ?SET SET VARIABLE edstat STATUS *,PROG $SYSTEM.SYSTEM.TEDIT !SET SET VARIABLE edstat STATUS *,PROG $SYSTEM.SYSTEM.
9 Built-In Functions and Variables This section contains an alphabetic summary of all built-in functions and variables, followed by descriptions, in alphabetic order, of the syntax for each built-in function and built-in variable.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Functions Built-In Functions and Variables Table 9-1.
Summary of Built-In Variables Built-In Functions and Variables Table 9-1.
Summary of Built-In Variables Built-In Functions and Variables Table 9-2.
Summary of Built-In Variables Built-In Functions and Variables Table 9-2.
Built-In Functions and Variables Built-In Function and Variable Descriptions Built-In Function and Variable Descriptions The remainder of this section lists built-in functions and variables, in alphabetic order. #ABEND Built-In Function Use #ABEND to request that a process terminate immediately; you can also specify values for fields in the resulting process deletion message. #ABEND [ / option [ , option ] ... / ] [ [\node-name.
Built-In Functions and Variables #ABEND Built-In Function text is text, 0 to 80 characters, to be included in the process deletion message. Leading and trailing spaces are ignored. Result • If you do not specify the ERROR option, #ABEND returns -1 if it is successful, 0 if it is not. • If you include the ERROR option , #ABEND returns the file-system error code passed to it by the ABEND operating system procedure. In this case, zero indicates no error.
Built-In Functions and Variables #ABORTTRANSACTION Built-In Function ABENDED: $TMP2 CPU Time 0:00:00.018 Completion Code 20 Termination Info 2278 Subsystem #ABORTTRANSACTION Built-In Function Use #ABORTTRANSACTION to abort and back out a transaction. This function invokes the ABORTTRANSACTION operating system procedure.
Built-In Functions and Variables #ACTIVATEPROCESS Built-In Function #ACTIVATEPROCESS Built-In Function Use #ACTIVATEPROCESS to restart a suspended process or process pair. This function invokes the ACTIVATEPROCESS operating system procedure. #ACTIVATEPROCESS [ [\node-name.]{$process-name | cpu,pin} ] \node-name is the system where the process resides. $process-name is the name of the process or process pair. cpu,pin is the CPU number and process number for the process.
Built-In Functions and Variables #ADDDSTTRANSITION Built-In Function (SuperGroup Only) #ADDDSTTRANSITION Built-In Function (Super-Group Only) Use #ADDDSTTRANSITION to add an entry to the daylight savings time transition table. #ADDDSTTRANSITION low-gmt high-gmt offset low-gmt is an integer (see #COMPUTETIMESTAMP Built-In Function on page 9-73 for its format) that represents the Greenwich mean time when offset first applies. high-gmt is an integer that represents the GMT when offset no longer applies.
Built-In Functions and Variables #ADDDSTTRANSITION Built-In Function (SuperGroup Only) ° For D-series RVUs, manipulate the DST either interactively using the ADDDSTTRANSITION TACL command or programmatically using the ADDDSTTRANSITION Guardian procedure. ° For G04.00 and earlier G-series RVUs, manipulate the DST either interactively using the ADDDSTTRANSITION TACL command or the SCF ALTER command for the Kernel Subsystem, or programmatically using the ADDDSTTRANSITION Guardian procedure. ° For G05.
Built-In Functions and Variables #ALTERPRIORITY Built-In Function #ALTERPRIORITY Built-In Function Use #ALTERPRIORITY to change the priority of a process or process pair. This function invokes the ALTERPRIORITY operating system procedure. #ALTERPRIORITY [ [\node-name.]{$process-name | cpu,pin} ] pri \node-name is the system where the process resides. $process-name is the name of the process or process pair. cpu,pin is the CPU number and process number for the process.
Built-In Functions and Variables #APPEND Built-In Function #APPEND Built-In Function Use #APPEND to add a line of text to the end of a variable level. #APPEND to-variable-level [ text ] to-variable-level is the name of an existing variable level to which text is to be appended. text is the text to be added. If you omit text, a blank line is added to the end of the variable level. Result #APPEND returns nothing.
Built-In Functions and Variables #APPENDV Built-In Function #APPENDV Built-In Function Use #APPENDV to append a string to the contents of a variable level, to append a copy of the contents of one variable level to the end of another variable level, or to send data to a file or process opened by #REQUESTER. #APPENDV to-variable-level { from-variable-level | string } to-variable-level is the name of an existing variable level whose definition is to be modified.
Built-In Functions and Variables #ARGUMENT Built-In Function #ARGUMENT Built-In Function Use #ARGUMENT to parse the arguments passed to a routine. #ARGUMENT returns the position number (in the list of alternatives to #ARGUMENT) of the alternative that matches the type of the routine argument being examined. You can specify up to eight alternatives to #ARGUMENT.
Built-In Functions and Variables #ARGUMENT Built-In Function TACL is using PLAIN format, TACL does not recognize square brackets as metacharacters. The identity of the alternative being tested can have an effect on the result of the VALUE option. For example, if there is a variable FN and a file named FN, the VALUE option would return different results depending on which type of argument is expected. alternative can be any of these: ASSIGN [ / SYNTAX / ] matches an existing logical-unit name.
Built-In Functions and Variables #ARGUMENT Built-In Function CLOSEPAREN matches a closing parenthesis. COMMA matches a comma. DEFINENAME matches a valid DEFINE name as described in Section 5, Statements and Programs. The name must be terminated by a standard TACL separator. DEFINETEMPLATE matches a valid DEFINE template as described in Section 5, Statements and Programs. The name must be terminated by a standard TACL separator. DEVICE [ / SYNTAX / ] matches the name of an existing device.
Built-In Functions and Variables #ARGUMENT Built-In Function SYNTAX specifies that any file name or DEFINE name is acceptable as long as it is formatted correctly. The file need not exist. If you do not include SYNTAX and you specify a file name, the file name returned by VALUE is fully qualified, using your current defaults for any missing fields. GMOMJOBID matches a valid job ancestor job ID, expressed as one of these: $process-name. num cpu,pin, num such as $XYZ.3 or 2,12,100.
Built-In Functions and Variables #ARGUMENT Built-In Function use OTHERWISE, it must be positioned as the last option in the list of alternatives. PARAM [ / SYNTAX / ] matches the name of an existing parameter. The SYNTAX option specifies that any parameter name is acceptable as long as it is formatted correctly. PARAMVALUE matches a text sequence of 1 to 255 characters terminated by a comma, space, or end-of-line.
Built-In Functions and Variables #ARGUMENT Built-In Function STRING matches the name of a variable level, text enclosed in quotation marks, or a concatenation of such entities. The concatenation operator is '+'. With this type of alternative, the TEXT option returns an exact copy of the string as it was entered; the VALUE option returns the resulting value of the string after it has been evaluated (enclosing quotation marks removed and all specified invocation and concatenation performed).
Built-In Functions and Variables #ARGUMENT Built-In Function If the transaction ID is local, you can omit the node name. USER [ / { SYNTAX | USERNAME } / ] matches an existing user name or user ID. The SYNTAX option states that the user name or user ID need not exist but need only be formatted correctly (#USERNAME or #USERID can determine whether it is defined). The USERNAME option specifies that the argument must be a user name only; a user ID is unacceptable. VARIABLE [ / var-option [ , var-option ] ...
#ARGUMENT Built-In Function Built-In Functions and Variables If you omit both QUALIFIED and UNQUALIFIED, a variable name is acceptable with or without a level number. WORD [ / SPACE / ] matches all text up to the next comma, slash, semicolon, space, left or right parenthesis, or end-of-line. If you include the SPACE option, space and end-ofline are the only delimiters. Result #ARGUMENT returns the position number of the alternative that matches the type of the routine argument being examined.
#ARGUMENT Built-In Function Built-In Functions and Variables Table 9-4. Some Effects of Expectation on VALUE Result Alternative Argument Text Value String fn fn FILENAME Variable fn fn :MYDIR:FN.1 Filename fn fn \SYS.$VOL.SUBVOL.FN Other special VALUE results are documented in the descriptions of the individual alternatives. In the majority of cases, however, TEXT and VALUE results are the same.
Built-In Functions and Variables #ARGUMENT Built-In Function Assume also that the variable TERMNAME contains the name of the home terminal, which currently is $MINE, and that RTN is invoked as follows: RTN "My terminal is " '+' termname '+' " at this time." The resulting output is: TEXT: "My terminal is " '+' termname '+' " at this time." VALUE: My terminal is $MINE at this time. For additional examples, see the TACL Programming Guide.
Built-In Functions and Variables #ASSIGN Built-In Variable #ASSIGN Built-In Variable #ASSIGN contains all the defined attributes of all currently defined unit names. #ASSIGN [ / option [ , option ] ... / logical-unit ] option specifies one of these types of information: ACCESS requests the type of access for the logical unit; it returns I/O, INPUT, OUTPUT, or nothing. BLOCK requests the block size of the logical unit; it returns the block size or nothing.
Built-In Functions and Variables #ASSIGN Built-In Variable specifies the logical-unit name about which you want information. For more information about logical units, see the ASSIGN Command on page 8-21. Result #ASSIGN returns as its result a space-separated list of the requested information about the specified logical unit. If you do not specify any options, #ASSIGN returns a space-separated list of all currently defined logical units.
Built-In Functions and Variables #ASSIGN Built-In Variable ACCESS { I/O | INPUT | OUTPUT } specifies the type of access for the logical unit. BLOCK num specifies the block size of the logical unit. CODE num specifies the file code for the logical unit. EXCLUSION { EXCLUSIVE | PROTECTED | SHARED } specifies the type of exclusion assigned to the logical unit. EXISTENCE specifies that a logical unit can be defined without including any other information.
Built-In Functions and Variables #BACKUPCPU Built-In Function #BACKUPCPU Built-In Function Use #BACKUPCPU to start a backup process for the current TACL process or delete an existing backup process. #BACKUPCPU [ cpu ] cpu specifies the number, in the range 0 to 15, of the CPU to be used for the backup. If you omit it, TACL runs without a backup. Result #BACKUPCPU returns nothing. Considerations • #BACKUPCPU with no CPU specification has no effect if the current TACL process has no backup.
Built-In Functions and Variables #BEGINTRANSACTION Built-In Function #BEGINTRANSACTION Built-In Function Use #BEGINTRANSACTION to start a new transaction. This function invokes the BEGINTRANSACTION operating system procedure. When you use this function, the TMF subsystem creates a new transaction identifier that becomes the current transaction identifier for the process issuing BEGINTRANSACTION.
Built-In Functions and Variables #BREAKMODE Built-In Variable #BREAKMODE Built-In Variable Use #BREAKMODE to disable, enable, or temporarily postpone most of the effect of the BREAK key. #BREAKMODE Result #BREAKMODE returns the current break mode setting: DISABLE, ENABLE, or POSTPONE. Considerations • Use #PUSH #BREAKMODE (or PUSH #BREAKMODE) to save the current break mode setting. • Use #SET #BREAKMODE (or SET VARIABLE #BREAKMODE) to establish a new break mode setting.
Built-In Functions and Variables #BREAKPOINT Built-In Function #BREAKPOINT Built-In Function Use #BREAKPOINT to set or delete a _DEBUGGER breakpoint for a specific variable level. #BREAKPOINT variable-level state variable-level is the name of an existing variable level. state is either a nonzero value, which sets a breakpoint for the variable level, or zero, which deletes an existing breakpoint.
Built-In Functions and Variables #BUILTINS Built-In Function #BUILTINS Built-In Function Use #BUILTINS to obtain the names of the TACL built-in functions or built-in variables. #BUILTINS [ / { FUNCTIONS | VARIABLES } / ] FUNCTIONS displays the built-in functions. VARIABLES displays the built-in variables. If you fail to specify either option, FUNCTIONS is assumed. Result #BUILTINS returns a space-separated list of the names of the specified built-in functions or variables.
Built-In Functions and Variables #CASE Built-In Function #CASE Built-In Function Use #CASE to return one of a set of alternative text sequences. You provide a set of labeled options using an enclosure. When TACL evaluates the #CASE statement, it searches the enclosure for a label that matches some specified text, and returns the text sequence that follows the label. #CASE text enclosure text is the text to be matched to a label in the enclosure; it cannot contain any spaces.
#CASE Built-In Function Built-In Functions and Variables • You cannot use square brackets in a label-num; no evaluation takes place between the vertical bars. • If neither a matching label-num nor OTHERWISE is present, an error occurs. Examples 1. This macro accepts an argument. If the argument is 0, the macro writes Zero; if the argument is 1, the macro writes One, and so on.
Built-In Functions and Variables #CHANGEUSER Built-In Function #CHANGEUSER Built-In Function Use #CHANGEUSER to log on under a different user ID, keeping the current user’s values. Note. The LOGON command behavior depends on the Safeguard environment. If Safeguard is not running on your system or if the USER_AUTHENTICATE procedure is not in the system library, the alias option is not available #CHANGEUSER [ / CHANGEDEFAULTS / ] group-name.
Built-In Functions and Variables #CHANGEUSER Built-In Function Safeguard facility if Safeguard is running. Otherwise, the VERIFYUSER system procedure is called by TACL. • If the user ID and password are syntactically correct (but not necessarily valid), TACL sends a pre-LOGON message to $CMON (if that user-supplied monitoring process exists) for additional validation before calling VERIFYUSER. In addition, TACL sends LOGON messages to $CMON during the logon process.
Built-In Functions and Variables #CHANGEUSER Built-In Function disabled, #CHANGEUSER fails and returns a zero. To display the value of NOCHANGEUSER, use #GETCONFIGURATION. • The TACL configuration BLINDLOGON option and the Safeguard BLINDLOGON flag do not affect #CHANGEUSER. • If the TACL configuration option REMOTECMONREQUIRED is not set to 0, all operation requiring approval by remote $CMON are denied if that remote $CMON is unavailable or is running too slowly.
Built-In Functions and Variables #CHARACTERRULES Built-In Variable #CHARACTERRULES Built-In Variable Use #CHARACTERRULES to obtain or set the name of the file that is currently being used to define the character-processing rules. #CHARACTERRULES Result #CHARACTERRULES returns the fully qualified name of the file containing the character-processing rules currently in effect. This name is CPRULES0, CPRULES1, or the name of a user-supplied file that contains character rules.
Built-In Functions and Variables #CHARACTERRULES Built-In Variable • If an error occurs while acquiring the new rules, the character rules already in effect remain unchanged. • If a #SET #CHARACTERRULES is never executed, TACL uses default rules.
Built-In Functions and Variables #CHARADDR Built-In Function #CHARADDR Built-In Function Use #CHARADDR to convert a line address to a character address. #CHARADDR variable-level line-addr variable-level is an existing variable level to be operated upon. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-addr is an integer or a variable level that contains an integer. line-addr specifies the line number of the line to be converted.
Built-In Functions and Variables #CHARBREAK Built-In Function #CHARBREAK Built-In Function Use #CHARBREAK to insert an end-of-line into a variable level at a specified character position. #CHARBREAK variable-level char-addr variable-level is the name of an existing variable level into which the end-of-line is to be inserted. It must not be in a shared segment and must not be a DIRECTORY, a STRUCT, or a STRUCT item. char-addr is the character position at which the end-of-line is to be inserted.
Built-In Functions and Variables #CHARBREAK Built-In Function LMNOPQRST UVWXYZ HP NonStop TACL Reference Manual—429513-018 9-48
Built-In Functions and Variables #CHARCOUNT Built-In Function #CHARCOUNT Built-In Function Use #CHARCOUNT to obtain the number of characters in a variable level. #CHARCOUNT variable-level variable-level is the name of an existing variable level whose characters are to be counted. It must not be a DIRECTORY, a STRUCT, or a STRUCT item.
Built-In Functions and Variables #CHARCOUNT Built-In Function returns 28; there are 26 letters and 2 internal line breaks. #CHARCOUNT does not count the last end-of-line character.
Built-In Functions and Variables #CHARDEL Built-In Function #CHARDEL Built-In Function Use #CHARDEL to delete characters from a variable level, starting at a character address. #CHARDEL variable-level char-addr-1 [ [ FOR char-count ] | [ TO char-addr-2 ] ] variable-level is an existing variable level from which the characters are to be deleted. It must not be in a shared segment and must not be a DIRECTORY, a STRUCT, or a STRUCT item.
Built-In Functions and Variables • #CHARDEL Built-In Function Each logical line contains an end-of-line character that counts as one byte. For variables that contain TACL statements, each metacharacter uses the number of visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte.
Built-In Functions and Variables #CHARFIND Built-In Function #CHARFIND Built-In Function Use #CHARFIND to find text in a variable level, searching forward from a specified character address. #CHARFIND [ / EXACT / ] variable-level char-addr text EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level within which TACL will search for text.
Built-In Functions and Variables #CHARFIND Built-In Function visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte. Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ 1. The invocation: #CHARFIND var 1 IJK returns 10; the first occurrence of IJK starting at or after 1 is at character address 10. 2.
Built-In Functions and Variables #CHARFINDR Built-In Function #CHARFINDR Built-In Function Use #CHARFINDR to find text in a variable level, searching backward from a character address. #CHARFINDR [ / EXACT / ] variable-level char-addr text EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level within which TACL will search for text.
Built-In Functions and Variables • #CHARFINDR Built-In Function Each logical line contains an end-of-line character that counts as one byte. For variables that contain TACL statements, each metacharacter uses the number of visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte. Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ 1.
Built-In Functions and Variables #CHARFINDRV Built-In Function #CHARFINDRV Built-In Function Use #CHARFINDRV to find a string constant in a variable level, searching backward from a specified character address. #CHARFINDRV [ / EXACT / ] variable-level char-addr string EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level within which TACL will search for string.
Built-In Functions and Variables • #CHARFINDRV Built-In Function Each logical line contains an end-of-line character that counts as one byte. For variables that contain TACL statements, each metacharacter uses the number of visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte.
Built-In Functions and Variables #CHARFINDV Built-In Function #CHARFINDV Built-In Function Use #CHARFINDV to find a string constant in a variable level, searching forward from a specified character address. #CHARFINDV [ / EXACT / ] string-1 char-addr string-2 EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. string-1 is a string constant or an existing variable level in which TACL will search for string-2.
Built-In Functions and Variables #CHARFINDV Built-In Function visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte. Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ and that var2 is a variable level containing: IJK 1.
Built-In Functions and Variables #CHARGET Built-In Function #CHARGET Built-In Function Use #CHARGET to obtain a copy of a set of contiguous characters in a variable level. #CHARGET variable-level char-addr-1 [ [ FOR char-count ] | [ TO char-addr-2 ] ] variable-level is an existing variable level from which characters are to be copied. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. char-addr-1 is an integer greater than zero or a variable level that contains an integer greater than zero.
Built-In Functions and Variables • #CHARGET Built-In Function Each logical line contains an end-of-line character that counts as one byte. For variables that contain TACL statements, each metacharacter uses the number of visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte. Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ 1.
Built-In Functions and Variables #CHARGETV Built-In Function #CHARGETV Built-In Function Use #CHARGETV to copy a set of contiguous characters from one variable level to another. #CHARGETV var-1 var-2 char-addr-1 [ [ FOR char-count ] | [ TO char-addr-2 ] ] var-1 is an existing variable level from which characters are to be copied. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. var-2 is an existing variable level that is to receive the copy.
Built-In Functions and Variables • • #CHARGETV Built-In Function Any part of the specified copy that lies beyond the end of var-1 is ignored. Each logical line contains an end-of-line character that counts as one byte. For variables that contain TACL statements, each metacharacter uses the number of visible characters plus one, including unprintable characters that are subject to change from one TACL RVU to another. Nonmetacharacters use one byte.
Built-In Functions and Variables #CHARINS Built-In Function #CHARINS Built-In Function Use #CHARINS to insert text into a variable level at a specified character address. #CHARINS string char-addr text string is a string constant or the name of an existing variable level into which text is to be inserted. It must not be in a shared segment or be a DIRECTORY, a STRUCT, or a STRUCT item. char-addr is an integer greater than zero or a variable level that contains an integer greater than zero.
Built-In Functions and Variables 1. The invocation: #CHARINS var 13 NEW TEXT causes var to contain: ABCDEFG HIJKNEW TEXTLMNOPQRST UVWXYZ 2. The invocation: [#CHARINS var 13 NEW TEXT] causes var to contain: ABCDEFG HIJKNEW TEXTLMNOPQRST UVWXYZ 3.
Built-In Functions and Variables #CHARINSV Built-In Function #CHARINSV Built-In Function Use #CHARINSV to insert a string into a variable level at a specified character address. #CHARINSV variable-level char-addr string variable-level is a string constant or the name of an existing variable level into which a string will be inserted. It must not be in a shared segment or be a DIRECTORY, a STRUCT, or a STRUCT item.
Built-In Functions and Variables #CHARINSV Built-In Function Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ and that var2 is a variable level containing: NEW TEXT 1. The invocation: #CHARINSV var 13 var2 causes var to contain: ABCDEFG HIJKNEW TEXTLMNOPQRST UVWXYZ 2. The invocation: #CHARINSV var 13 "NEW TEXT" causes var to contain: ABCDEFG HIJKNEW TEXTLMNOPQRST UVWXYZ 3.
Built-In Functions and Variables #COLDLOADTACL Built-In Function #COLDLOADTACL Built-In Function #COLDLOADTACL indicates whether a TACL process is the cold-load TACL process. #COLDLOADTACL Result #COLDLOADTACL returns -1 if the TACL process from which it was invoked is the first TACL process started during the cold-load process, and the TACL process has not logged off since it was started. Otherwise, #COLDLOADTACL returns zero.
Built-In Functions and Variables #COMPAREV Built-In Function #COMPAREV Built-In Function Use #COMPAREV to compare one string with another. #COMPAREV string-1 string-2 string-1 and string-2 are the names of variable levels of a type other than DIRECTORY, text enclosed in quotation marks, or concatenations of such entities. The concatenation operator is '+' (the apostrophes are required).
Built-In Functions and Variables #COMPUTE Built-In Function #COMPUTE Built-In Function Use #COMPUTE to obtain the value of an arithmetic expression. #COMPUTE expression expression is an expression using integer values and variable levels, arithmetic operators, and logical operators, as defined in Section 3, Expressions. Result • #COMPUTE returns the result of expression; that value can be assigned to a variable level.
Built-In Functions and Variables #COMPUTEJULIANDAYNO Built-In Function #COMPUTEJULIANDAYNO Built-In Function Use #COMPUTEJULIANDAYNO to convert a calendar date on or after January 1, 0001, to a Julian day number. A Julian day number is an integral number of days elapsed since January 1, 4713 B.C. #COMPUTEJULIANDAYNO year month day year is a four-digit number, from 1975 through 9999, representing the year. month is a number in the range 1 to 12 representing the month.
Built-In Functions and Variables #COMPUTETIMESTAMP Built-In Function #COMPUTETIMESTAMP Built-In Function Use #COMPUTETIMESTAMP to convert a calendar date to a four-word timestamp. #COMPUTETIMESTAMP year month day hour min sec milli micro year is a four-digit number, from 1975 through 9999, representing the year. month is a number in the range 1 to 12 indicating the month. day is a number in the range 1 to 31 indicating the day. hour is a number in the range 0 to 23 indicating the hour.
#COMPUTETRANSID Built-In Function Built-In Functions and Variables #COMPUTETRANSID Built-In Function Use #COMPUTETRANSID to convert the separate numeric values for the components of a transaction ID into a single numeric transaction ID. #COMPUTETRANSID system cpu sequence crash-count system is the system number of the transaction ID. cpu is the CPU number of the transaction ID. sequence is the sequence number of the transaction ID. crash-count is the crash count of the transaction ID.
Built-In Functions and Variables #CONTIME Built-In Function #CONTIME Built-In Function Use #CONTIME to break down a three-word timestamp into a seven-number set of date and time components. #CONTIME timestamp timestamp is a decimal number obtained from #TIMESTAMP or from #FILEINFO / MODIFICATION /. Result #CONTIME returns seven numbers representing various components of date and time (year, month, day, hour, minute, second, hundredths of a second), as shown in the following examples. Examples 1.
Built-In Functions and Variables #CONVERTPHANDLE Built-In Function #CONVERTPHANDLE Built-In Function Use #CONVERTPHANDLE to convert a process file identifier to a process handle or a process handle to a process file identifier. #CONVERTPHANDLE { / PROCESSID / integer-string } | { / INTEGERS / process-identifier } integer-string is a process handle represented by ten integers, each separated by a period. process-identifier is a process name or CPU,PIN.
#CONVERTPHANDLE Built-In Function Built-In Functions and Variables 2. This function call converts a process name to its corresponding process handle: 11> #CONVERTPHANDLE / INTEGERS / $S 512.31.2.18.0.0.11.57728.0.243 3. This example uses #CONVERTPHANDLE to convert a process handle field in STRUCT s to a process identifier: [#CONVERTPHANDLE / PROCESSID / [s:proc]] where proc is a process-handle field in the STRUCT named s.
Built-In Functions and Variables #CONVERTPROCESSTIME Built-In Function #CONVERTPROCESSTIME Built-In Function Use #CONVERTPROCESSTIME to convert the time value obtained by the PROCESSTIME option of #PROCESSINFO. #CONVERTPROCESSTIME process-time process-time is a numeric expression representing a CPU time. Result #CONVERTPROCESSTIME returns a space-separated list of the equivalent number of hours, minutes, seconds, milliseconds, and microseconds in the process-time argument.
#CONVERTTIMESTAMP Built-In Function Built-In Functions and Variables #CONVERTTIMESTAMP Built-In Function Use #CONVERTTIMESTAMP to convert a Greenwich mean time (GMT) timestamp to or from a local time-based timestamp on any accessible node in a network. The resulting timestamp is still in four-word format (as returned by #JULIANTIMESTAMP), but its value is adjusted for the time differential between local time and GMT.
Built-In Functions and Variables #CONVERTTIMESTAMP Built-In Function Example This example obtains the current Greenwich mean time, converts the timestamp to local civil time (LCT), and displays the GMT and LCT in component form: ?SECTION convtime ROUTINE #FRAME #PUSH gmttime, loctime, err #SET gmttime [#JULIANTIMESTAMP] #SETMANY err loctime , [#CONVERTTIMESTAMP gmttime 0] SINK [IF [err] |THEN| #OUTPUT Error occurred: [err] |ELSE| #OUTPUT GMT = [#INTERPRETTIMESTAMP gmttime] #OUTPUT LCT = [#INTERPRETTIMESTA
Built-In Functions and Variables #CREATEFILE Built-In Function #CREATEFILE Built-In Function Use #CREATEFILE to create an unstructured file. #CREATEFILE [ / option [ , option ] / ] file-name option can be: EXTENT num the number of data pages allocated for the primary and all secondary extents. • For format 1 files, specify num as an integer in the range from 1 through 65535. • For format 2 files, specify num as an integer in the range from 1 through 512000000. The default value is 2.
Built-In Functions and Variables #CREATEFILE Built-In Function If a logical volume is specified in the file name for file creation, the physical volume on which the file is created is chosen by the system. The physicalvolume parameter overrides this selection. The PHYSICALVOLUME option should be used only if no physical volume is specified in file-name. Otherwise, a file-system error is returned.
Built-In Functions and Variables #CREATEPROCESSNAME Built-In Function #CREATEPROCESSNAME Built-In Function Use #CREATEPROCESSNAME to create a unique process name that is not in use on the local system. This function invokes the CREATEPROCESSNAME operating system procedure. #CREATEPROCESSNAME Result #CREATEPROCESSNAME returns a unique, unused process name in one of the forms $Xnnn, $Ynnn, or $Zxxx, where n is any numeric character and x is any alphanumeric character.
Built-In Functions and Variables #CREATEREMOTENAME Built-In Function #CREATEREMOTENAME Built-In Function Use #CREATEREMOTENAME to create a unique process name not in use on the specified system. This function invokes the CREATEREMOTENAME operating system procedure. #CREATEREMOTENAME \node-name \node-name is the name of an available system to be checked for processes in use.
Built-In Functions and Variables #DEBUGPROCESS Built-In Function #DEBUGPROCESS Built-In Function Use #DEBUGPROCESS to invoke the default debugger, DEBUG or INSPECT, for a specified process. #DEBUGPROCESS invokes the DEBUGPROCESS operating system procedure. #DEBUGPROCESS [ / NOW / ] [\node-name.] {$process-name | cpu,pin} [ , TERM [\node-name.]$terminal-name ] NOW specifies that debugging is to begin immediately. This option is available to supergroup users only.
Built-In Functions and Variables #DEBUGPROCESS Built-In Function • If you are the super ID, you can debug any process. Only the super ID can debug privileged processes. • The process to be debugged does not enter the debug state until it executes its next instruction in the user code space; the process cannot enter the debug state while executing system code. If you enter the NOW option, however, the process enters the debug state immediately. To use this option, you must have a group ID of 255.
Built-In Functions and Variables #DEF Built-In Function #DEF Built-In Function Use #DEF to define a variable. #DEF variable { { ALIAS | DELTA | MACRO | ROUTINE | TEXT} enclosure} DIRECTORY [ segment-spec ] STRUCT structure-body } variable is the name of the variable. If the variable exists, TACL pushes it, creating a new top level. If the variable does not exist, TACL creates it. ALIAS specifies that variable is a command alias. DELTA specifies that variable is to contain #DELTA commands.
Built-In Functions and Variables #DEF Built-In Function PRIVATE specifies that the creator of the segment file has read and write access to the file and that no other process may open it. SHARED specifies that the segment file is a read-only file and that other processes may open it for read access. file-name is the name of a TACL segment file. If file-name does not exist, TACL creates it and initializes it as an empty TACL segment. STRUCT structure-body specifies that variable represents a structure.
Built-In Functions and Variables #DEF Built-In Function standard functionality from your TACL environment, do not use #DEF on the directories supplied as part of the TACL software product (such as UTILS). • You cannot attach more than 50 segment files. Examples 1. This example defines a variable, RTN, as a ROUTINE that accepts no arguments and displays a “thank you” message: [#DEF rtn ROUTINE |BODY| SINK [#ARGUMENT END] #OUTPUT Thank you! ] 2.
Built-In Functions and Variables #DEFAULTS Built-In Variable #DEFAULTS Built-In Variable Use #DEFAULTS to set or obtain the saved defaults (set by the DEFAULT program), the current defaults (set by the VOLUME and SYSTEM commands), or both. #DEFAULTS [ / option [ , option ] / ] option is either of these: CURRENT specifies your current defaults. SAVED specifies your logon defaults. Result #DEFAULTS returns the file-name defaults you request.
Built-In Functions and Variables #DEFAULTS Built-In Variable Example Assuming #INFORMAT is set to TACL, this example displays both your current and saved defaults: 12> #OUTPUT [ #DEFAULTS /SAVED, CURRENT/ ] $BUNK.HOUSE $OPEN.
Built-In Functions and Variables #DEFINEADD Built-In Function #DEFINEADD Built-In Function Use #DEFINEADD to add a DEFINE to the TACL context, or to replace an existing DEFINE, using the attributes in the working set. #DEFINEADD invokes the DEFINEADD operating system procedure. #DEFINEADD define-name [ flag ] define-name is the name of the DEFINE to be added. flag is a flag that specifies what to do if a DEFINE with the same name already exists.
Built-In Functions and Variables #DEFINEDELETE Built-In Function #DEFINEDELETE Built-In Function Use #DEFINEDELETE to delete a DEFINE from the TACL context. This function invokes the DEFINEDELETE operating system procedure. #DEFINEDELETE define-name define-name is the name of the DEFINE to be deleted. Result #DEFINEDELETE returns a numeric error code indicating the outcome of the DEFINEDELETE procedure. Zero indicates success. See Appendix B, Error Messages for a list of DEFINE-oriented error codes.
Built-In Functions and Variables #DEFINEDELETEALL Built-In Function #DEFINEDELETEALL Built-In Function Use #DEFINEDELETEALL to delete all DEFINEs except =_DEFAULTS from the TACL context (=_DEFAULTS cannot be deleted). This function invokes the DEFINEDELETEALL operating system procedure. #DEFINEDELETEALL Result #DEFINEDELETEALL returns a numeric error code indicating the outcome of the DEFINEDELETEALL procedure; zero indicates success. See Appendix B, Error Messages for DEFINE-oriented error codes.
Built-In Functions and Variables #DEFINEINFO Built-In Function #DEFINEINFO Built-In Function Use #DEFINEINFO to set or obtain information about a specified DEFINE. The function invokes the DEFINEINFO operating system procedure. #DEFINEINFO define-name define-name is the name of the DEFINE for which information is desired. Result #DEFINEINFO returns a numeric error code indicating the outcome of the DEFINEINFO procedure; zero indicates success.
Built-In Functions and Variables #DEFINEMODE Built-In Variable #DEFINEMODE Built-In Variable Use #DEFINEMODE to obtain the current setting of DEFMODE (described with the SET DEFMODE command), which controls the use and propagation of DEFINEs. #DEFINEMODE Result #DEFINEMODE returns the current DEFMODE setting: OFF or ON. Considerations • • When you first log on, #DEFINEMODE is initialized to ON. #DEFINEMODE is set to ON when TACL is started and whenever a LOGON is done from the logged-off state.
Built-In Functions and Variables #DEFINENAMES Built-In Function #DEFINENAMES Built-In Function Use #DEFINENAMES to find the names of DEFINEs that match a specified DEFINE template. #DEFINENAMES define-template define-template is a template indicating the DEFINE names to search for.
Built-In Functions and Variables #DEFINENEXTNAME Built-In Function #DEFINENEXTNAME Built-In Function Use #DEFINENEXTNAME to obtain the name of the DEFINE that follows the specified DEFINE in the sequence established by the operating system. The function invokes the DEFINENEXTNAME operating system procedure. #DEFINENEXTNAME [ define-name ] define-name specifies the name from which to begin searching for the next DEFINE name. If you omit it, the function returns the first DEFINE name.
Built-In Functions and Variables #DEFINEREADATTR Built-In Function #DEFINEREADATTR Built-In Function Use #DEFINEREADATTR to obtain the current value of a specified attribute in the TACL context or in the working set. This function invokes the DEFINEREADATTR operating system procedure. #DEFINEREADATTR { define-name | _ } { attribute-name | cursor-mode } define-name is the name of the DEFINE in the TACL context from which an attribute is to be read.
Built-In Functions and Variables #DEFINEREADATTR Built-In Function • A number indicating the type of the attribute: 0 if it is optional, 1 if it is defaulted, or 2 if it is required. • A number indicating the condition of the attribute: 1 if it was inconsistent the last time attributes were validated, 0 if it was consistent. • • The name of the attribute whose value is being returned. The (possibly empty) value of the selected attribute.
Built-In Functions and Variables #DEFINERESTORE Built-In Function #DEFINERESTORE Built-In Function Use #DEFINERESTORE to create or replace an active DEFINE, or replace the working set, with the contents of a DEFINE previously saved with #DEFINESAVE. #DEFINERESTORE [ / option [ , option ] / ] buffer option is either of these: REPLACE specifies that if a DEFINE with the same name as the saved DEFINE exists, the saved DEFINE is to replace the existing DEFINE.
Built-In Functions and Variables #DEFINERESTORE Built-In Function However, the saved DEFINE is restored to the working set even if it is incomplete, inconsistent, or invalid. • If you save the =_DEFAULTS DEFINE, you must use the REPLACE option when restoring it. Because the =_DEFAULTS DEFINE always exists, it cannot be added.
Built-In Functions and Variables #DEFINERESTOREWORK Built-In Function #DEFINERESTOREWORK Built-In Function Use #DEFINERESTOREWORK to restore the DEFINE working set from the background set. This function invokes the DEFINERESTOREWORK operating system procedure. #DEFINERESTOREWORK Result #DEFINERESTOREWORK returns a numeric error code indicating the outcome of the DEFINERESTOREWORK procedure; zero indicates success. See Appendix B, Error Messages for DEFINE-oriented error codes.
#DEFINESAVE Built-In Function Built-In Functions and Variables #DEFINESAVE Built-In Function Use #DEFINESAVE to save a copy of an active DEFINE, or the working set, for later restoration by #DEFINERESTORE. #DEFINESAVE [ / WORK / ] define-name buffer WORK specifies that the working set is to be saved with the specified DEFINE name. If you omit this option, the DEFINE with the specified name is saved. define-name is the name of the DEFINE to be saved.
#DEFINESAVE Built-In Function Built-In Functions and Variables Considerations • The internal form of the DEFINE is placed in the buffer if it is large enough to hold it. • If the buffer is too small, an error occurs; you can use the length field of the result to determine how large the buffer should have been.
Built-In Functions and Variables #DEFINESAVEWORK Built-In Function #DEFINESAVEWORK Built-In Function Use #DEFINESAVEWORK to save the DEFINE working set in the background set. This function invokes the DEFINESAVEWORK operating system procedure. #DEFINESAVEWORK Result #DEFINESAVEWORK returns a numeric error code indicating the outcome of the DEFINESAVEWORK procedure; zero indicates success. See Appendix B, Error Messages for a list of DEFINE-oriented error codes.
Built-In Functions and Variables #DEFINESETATTR Built-In Function #DEFINESETATTR Built-In Function Use #DEFINESETATTR to modify the value of an attribute in the working set. #DEFINESETATTR can also be used to reset the value of an attribute to its default value, if one exists, or to delete the attribute from the working set. This function invokes the DEFINESETATTR operating system procedure. #DEFINESETATTR attribute-name [ attribute-value ] attribute-name is the name of the attribute to be set.
Built-In Functions and Variables #DEFINESETLIKE Built-In Function #DEFINESETLIKE Built-In Function Use #DEFINESETLIKE to initialize the working set with the attributes of an existing DEFINE. This function invokes the DEFINESETLIKE operating system procedure. #DEFINESETLIKE define-name define-name is the name of the DEFINE whose attributes are to be copied to the working set. Result #DEFINESETLIKE returns a numeric error code indicating the outcome of the DEFINESETLIKE procedure; zero indicates success.
Built-In Functions and Variables #DEFINEVALIDATEWORK Built-In Function #DEFINEVALIDATEWORK Built-In Function Use #DEFINEVALIDATEWORK to check the DEFINE working set for consistency. This function invokes the DEFINEVALIDATEWORK operating system procedure. #DEFINEVALIDATEWORK Result #DEFINEVALIDATEWORK returns a numeric error code indicating the outcome of the DEFINEVALIDATEWORK procedure, followed by a space and a check number. If the error code is 0, the working set is consistent.
Built-In Functions and Variables #DELAY Built-In Function #DELAY Built-In Function Use #DELAY to cause TACL to delay for a specified number of centiseconds. #DELAY centiseconds centiseconds is the number of centiseconds for TACL to delay. Result #DELAY returns nothing. Consideration • You cannot end the #DELAY built-in function using the BREAK key if you specify #BREAKMODE DISABLE or #BREAKMODE POSTPONE.
Built-In Functions and Variables #DELTA Built-In Function #DELTA Built-In Function #DELTA, the TACL character editor, allows you to perform complex operations on text. Although it is mainly for editing text from within macros and routines, you can use #DELTA interactively as well. Using #DELTA interactively allows you to observe how #DELTA works and lets you debug existing #DELTA macros. You can also use #DELTA to read text from a file, modify the text and write the modified text to another file.
Built-In Functions and Variables #DELTA Built-In Function About #DELTA Commands Most #DELTA commands are one or two characters long; #DELTA allows you to enter as many commands as you want in a command string. The RETURN character can be a part of a command or a separator between commands. Commands can be separated by many spaces or no spaces. Because most of the #DELTA commands are only one character long, spaces are important to writing legible command strings.
Built-In Functions and Variables #DELTA Built-In Function Comments Comments help to produce readable #DELTA code. A #DELTA comment is an exclamation point (!) followed, optionally, by explanatory text to the end of the line. You can also use the standard TACL “{ }” and “==” comments within #DELTA. (Using TACL comments could be safer because #DELTA ignores all text within comments; you can also continue them over additional lines by using ampersands.
Built-In Functions and Variables #DELTA Built-In Function #DELTA 15> EOF! 11 #DELTA 16> v #DELTA 16> EOF! Test string(.) When #DELTA is first invoked, the pointer points to the end of the buffer. The X and Y Registers As mentioned, you enter the operand values for a #DELTA command before entering the command. When you enter the values, #DELTA stores them in two internal registers named X and Y. When you first enter a value, it is stored in the X register.
Built-In Functions and Variables #DELTA Built-In Function the range between the current pointer position and the beginning of the current line. • If you specify both X and Y register values, the range is the characters between the absolute locations y and x. For example, 4,8T means type the characters between the fourth character and eighth character in the buffer (this can include end-of-line characters). X Register Arithmetic You can do mathematical operations on the contents of the X register.
Built-In Functions and Variables #DELTA Built-In Function #DELTA Commands This subsection describes the commands that you can use in #DELTA. Table 9-5 is a summary of all #DELTA commands. Table 9-5. Summary of #DELTA Commands (page 1 of 2) Command Description $ Clears X and Y registers , Moves X into Y .
#DELTA Built-In Function Built-In Functions and Variables Table 9-5.
#DELTA Built-In Function Built-In Functions and Variables Table 9-6.
#DELTA Built-In Function Built-In Functions and Variables Table 9-6.
#DELTA Built-In Function Built-In Functions and Variables Table 9-7. Variable Control Commands (page 2 of 2) Command Description Effect On Buffer Effect on X, Y, and Pointer (P) y,xUvar$ Unloads x into variable level - X=y xXvar$ Extracts lines to variable level Lines from P to x EOLs put into variable level - y,xXvar$ Extracts chars to variable level Characters from y to x put into variable level - ^\ Exits from macro - - Caution.
#DELTA Built-In Function Built-In Functions and Variables command execution. Table 9-9 summarizes the syntax and effects of these commands. Table 9-9.
Built-In Functions and Variables #DELTA Built-In Function If the position specified by the X register is outside the text in the buffer, an error occurs. However, if you have placed a value in the Y register, #DELTA avoids the error and loads the Y register value into the X register instead. The B Command The B command loads the value 0 into the X register, thus indicating the beginning of the buffer.
Built-In Functions and Variables #DELTA Built-In Function #DELTA 67> EOF! agh! The EI Command The EI command opens a file for input. To read a file, you must open the file and specify that the file is open for input. You cannot open the same file for both input and output, and you can have only one file open for input and one file open for output at the same time. If you try to open a nonexistent file for input, an error occurs.
Built-In Functions and Variables #DELTA Built-In Function The FC Command The FC command changes the case of text within a specified range. You can specify the range of text either with an X register value (X lines of text, starting at the current pointer position), or with X and Y register values (from character Y to character X). If you use the @ flag with the FC command, the text in the range is changed to uppercase; if you do not use the @ flag, the text is changed to lowercase.
#DELTA Built-In Function Built-In Functions and Variables The FL Command The FL command loads the X register with the length of the string last inserted by I or found by S. This is especially useful for doing text replacement where you do not want to (or cannot) count the length of the search string. For example, you might use the following in a TACL macro because the length of the first argument of the macro varies from call to call: #SET /TYPE DELTA/ cmds ... J <@:S/%1%/; -FL D> ...
Built-In Functions and Variables #DELTA Built-In Function The G Command The G command copies text from a variable level and inserts it in the buffer, moving the pointer to the right of the text. The G command must be followed by a variable level name; that name must be terminated by a dollar sign. If you precede the G command with the : flag, #DELTA extracts (and deletes) the first line from the variable level and puts it in the buffer.
Built-In Functions and Variables #DELTA Built-In Function delimiters around the string; the character immediately to the right of the I command is the new delimiter. The delimiter is changed only for the current I command. For example: #DELTA 45> @I/new$/ v #DELTA 45> EOF! a !!!!!new$(.) test #DELTA 46> I string$ v #DELTA 46> EOF! a !!!!!new$ string(.) test #DELTA 47> #DELTA uses the ASCII code 0 to mean end-of-line; thus, 0I (or I) breaks a line.
Built-In Functions and Variables #DELTA Built-In Function encounters the ^\command or the end of the commands in the variable level. When the macro exits, the buffer and current pointer value remain where the macro left them. The only way to pass arguments to #DELTA macros is to load the arguments into variable levels before calling the macro, then, from within the macro, get the contents of the variables. The P Command The P command writes a range of text to the output file.
Built-In Functions and Variables #DELTA Built-In Function If the search string is not found, #DELTA issues an error message and, if the #DELTA session is not interactive, #DELTA exits. The pointer does not move. You can use the : flag to enable your #DELTA code to handle search errors-if the string is found, the X register is set to -1; if not, it is set to 0. You can also use S with FL to do text replacement.
Built-In Functions and Variables #DELTA Built-In Function command could then save the former Y register value in another variable level. For example: 123,456 Uxval$ Uyval$ puts 456 into XVAL, 123 into YVAL, and clears the X and Y registers. The U command is the complementary function of the Q command. The V Command The V (view) command is most commonly used as an aid in debugging #DELTA macros and, in general, finding out where you are in the buffer.
Built-In Functions and Variables #DELTA Built-In Function file. If you use the Y command on a closed file, it loads the value zero into the X register. #DELTA does all file I/O in PLAIN mode. The Z Command The Z command loads the X register with the size of the currently used portion of the buffer (in characters). You can use the Z command as a pointer to the end of the buffer. For example, the commands Z K delete the characters from the current position to the end of the buffer.
Built-In Functions and Variables #DELTA Built-In Function The \ Command The backslash command converts a value in the X register to a number in text and vice versa. If there is no value in the X register and the text to the right of the pointer is a number, #DELTA converts the text to a numeric value and loads it into the X register. For example, if the text is 123ABC, the \ command loads 123 into the X register. If the text is nonnumeric or is empty, an error occurs.
Built-In Functions and Variables #DELTA Built-In Function Conditional constructs can be nested. Iteration (< and >Commands) Iterations (groups of #DELTA commands to be performed repeatedly) are delimited by angle brackets. If there is a value in the X register, #DELTA performs the iteration that number of times. If there is no value in the X register, #DELTA repeats the iteration until you explicitly end it from within the loop.
Built-In Functions and Variables #DEVICEINFO Built-In Function #DEVICEINFO Built-In Function Use #DEVICEINFO to obtain information about a device. #DEVICEINFO / option [ , option ] ... / { device-name | file-name } option identifies the specific information you are requesting. It must be one of these: AUDITED requests the value of the AUDITED flag of the specified device or file. If the AUDITED flag is set for a device, files audited by the TMF subsystem can reside on the device.
Built-In Functions and Variables #EMPTY Built-In Function #EMPTY Built-In Function Use #EMPTY to determine if some specified text is empty. #EMPTY [ text ] text is the text to be examined. Result #EMPTY returns -1 if text is empty; otherwise, it returns 0. Considerations • • TACL considers text to be empty if it contains nothing but spaces or end-of-lines. Use the #EMPTYV built-in function to determine whether a variable level or quoted text is empty.
Built-In Functions and Variables #EMPTYV Built-In Function #EMPTYV Built-In Function Use #EMPTYV to determine whether a variable level or quoted text is empty. #EMPTYV [ / BLANK / ] string BLANK specifies that a string containing only spaces or end-of-lines is to be considered empty. string is the name of an existing variable level, text enclosed in quotation marks, or a concatenation of such entities. The concatenation operator is '+' (the apostrophes are required).
Built-In Functions and Variables #EMSADDSUBJECT Built-In Function #EMSADDSUBJECT Built-In Function Use #EMSADDSUBJECT to add a subject token to the event message buffer. This function places the token that you provide, preceded by a subject-mark token, in the buffer. #EMSADDSUBJECT [ / SSID ssid / ] buffer-var token-id [ token-value ] SSID ssid is a subsystem ID that qualifies the token code; if omitted or zero (0.0.
Built-In Functions and Variables Code Condition -9 Invalid token code or map -10 Invalid subsystem ID -11 Operation not supported -12 Insufficient stack space #EMSADDSUBJECT Built-In Function Considerations • Every event message has at least one subject, which you specify to the #EMSINIT procedure. Use #EMSADDSUBJECT to specify additional subjects.
#EMSADDSUBJECTV Built-In Function Built-In Functions and Variables #EMSADDSUBJECTV Built-In Function Use #EMSADDSUBJECTV to add a subject token to the event message buffer. This function places binary token values taken from a variable level, preceded by a subjectmark token, in the buffer. #EMSADDSUBJECTV [ / SSID ssid / ] buffer-var token-id source-var SSID ssid is a subsystem ID that qualifies the token code; if omitted or zero (0.0.
#EMSADDSUBJECTV Built-In Function Built-In Functions and Variables Code Condition -7 Internal error -8 Token not found -9 Invalid token code or map -10 Invalid subsystem ID -11 Operation not supported -12 Insufficient stack space Considerations • Every event message has at least one subject, which you specify to the #EMSINIT(V) procedure. Use #EMSADDSUBJECTV to specify additional subjects.
Built-In Functions and Variables #EMSGET Built-In Function #EMSGET Built-In Function Use #EMSGET to retrieve binary token values from an SPI buffer, convert them to external representation, and make that external representation accessible in the result of the function. #EMSGET invokes the EMSGET operating system procedure. You cannot use #EMSGET to extract values of extensible structured tokens using a token map or using a token code of type ZSPI^TDT^STRUCT. Instead, use #EMSGETV.
Built-In Functions and Variables #EMSGET Built-In Function buffer-var is the name of the message buffer from which information is to be taken; it must be a writable STRUCT that has been initialized by #SSINIT. get-op is one of these: token-code directs #EMSGET to return the token value or values associated with tokencode. If token-code is a token that marks the beginning of a list, #EMSGET selects the list so that subsequent calls can retrieve tokens within the list.
Built-In Functions and Variables #EMSGET Built-In Function ZSPI^TKN^NEXTCODE directs #EMSGET to return the next token code that is different from the current token code, followed by the subsystem ID. The subsystem ID returned in the result always has a version field of zero (null). The index parameter has no effect on this operation, but if you supply it, it must be zero. ZSPI^TKN^NEXTTOKEN directs #EMSGET to return the next token code, followed by the subsystem ID.
Built-In Functions and Variables #EMSGET Built-In Function The meaning of the status code: Code Description 0 No error -1 Invalid buffer format -2 Invalid parameter value -3 Missing parameter -4 Invalid parameter address -5 Buffer full -6 Invalid checksum -7 Internal error -8 Token not found -9 Invalid token code or map -10 Invalid subsystem ID -11 Operation not supported -12 Insufficient stack space If the status code is 0 (no error), it is followed by a space and a space-sepa
Built-In Functions and Variables #EMSGET Built-In Function • When the current position is within a particular list, all #EMSGET calls pertain only to tokens within that list (except that header fields are always accessible). You can exit from the list by calling #EMSGET to get the ZSPI^TKN^ENDLIST token. • When token-code is ZSPI^TKN^ENDLIST, the index and count parameters have no effect. However, if you supply them, index must be 0 or 1; count is always returned as 1.
Built-In Functions and Variables #EMSGETV Built-In Function #EMSGETV Built-In Function Use #EMSGETV to obtain binary token values from an SPI buffer and put them into a STRUCT. You can use #EMSGETV with any type of token (in fact, you must use #EMSGETV with extensible structured tokens and tokens of type ZSPI^TYP^STRUCT). #EMSGETV invokes the EMSGET procedure. #EMSGETV [ / option [ , option ] ...
Built-In Functions and Variables #EMSGETV Built-In Function result-var is the name of the writable STRUCT into which #EMSGETV is to store the data returned. The original contents of the STRUCT are lost. If the status code in the function result is zero (no error), the result stored in result-var is: • • If you specified token-id, the result is the value of the token. • If you specified ZSPI^TKN^LEN l-token-id, the result is an INT giving the length of the specified token.
Built-In Functions and Variables #EMSGETV Built-In Function If no error occurred, and get-op is token-id, the status code is followed by a space and the number of token values returned. Considerations • • Tokens extracted by #EMSGETV are not deleted or removed from the buffer. • When token-id is ZSPI^TKN^ENDLIST, the index and count parameters have no effect; however, if you supply them, index must be 0 or 1.
Built-In Functions and Variables #EMSGETV Built-In Function 1. Call #EMSGET to get the subject token: #SETMANY spi^err _ subject^token [#EMSGET /INDEX 1/ & event^buf zems^subject^token 2.
Built-In Functions and Variables #EMSINIT Built-In Function #EMSINIT Built-In Function Use #EMSINIT to initialize a STRUCT as an event message buffer, preparing it for use with the other #EMSxxx and #SSxxx built-in functions. This operation gives the buffer an appropriate header and adds event information to the buffer.
Built-In Functions and Variables #EMSINIT Built-In Function Result #EMSINIT returns a numeric status code indicating the outcome of the initialization.
Built-In Functions and Variables #EMSINITV Built-In Function #EMSINITV Built-In Function Use #EMSINITV to initialize a STRUCT as an event message buffer, preparing it for use with the other #EMSxxx and #SSxxx built-in functions. This operation gives the buffer an appropriate header and adds event information, taken from a variable level, to the buffer.
Built-In Functions and Variables #EMSINITV Built-In Function Result #EMSINITV returns a numeric status code indicating the outcome of the initialization.
Built-In Functions and Variables #EMSTEXT Built-In Function #EMSTEXT Built-In Function Use #EMSTEXT to obtain information from an event buffer and make it available in the function result as printable text derived from the event. #EMSTEXT [ / option [ , option ] ... / ] buffer-var option is one of these: INDENT num-chars specifies the number of characters to indent the second and subsequent lines of text generated by the EMSTEXT procedure. INDENT 0 means no indentation.
Built-In Functions and Variables #EMSTEXT Built-In Function Considerations • You cannot access the lengths result from the EMSTEXT procedure with #EMSTEXT; you must use #EMSTEXTV instead. • The INT(32) result of EMSTEXT is not included in the result of #EMSTEXT; you must use #EMSTEXTV to access it.
#EMSTEXTV Built-In Function Built-In Functions and Variables #EMSTEXTV Built-In Function Use #EMSTEXTV to obtain data from an event buffer and put the printable text derived from the event into a STRUCT. #EMSTEXTV [ / option [ , option ] ... / ] buffer-var formatted-var [ lengths-var ] option is one of these: INDENT num-chars INITTEMPLATE struct LINES num-lines OPRLOG num WIDTH num-chars These have the same definitions as those in the #EMSTEXT built-in function.
#EMSTEXTV Built-In Function Built-In Functions and Variables Result Description 1 code ALLOCATESEGMENT error code 2 +code Template file open failed 2 -code Template file opened, but has improper structure 3 code Template file read error 40 buffer-var not a valid SPI buffer 5 code File read error (INITTEMPLATE related) 60 Malformed template 7 code MOVEX error code If error 0 22 or 0 29 occurs, no text appears in the STRUCT.
Built-In Functions and Variables #ENDTRANSACTION Built-In Function #ENDTRANSACTION Built-In Function Use #ENDTRANSACTION to commit the database changes associated with a transaction identifier. #ENDTRANSACTION invokes the ENDTRANSACTION operating system procedure. When this procedure is called by the process (or its backup) that issued #BEGINTRANSACTION, the TMF subsystem tries to commit the transaction.
Built-In Functions and Variables #EOF Built-In Function #EOF Built-In Function Use #EOF to set a flag so that a process receives one end-of-file after it reads all the data in a variable level. That variable level is one that is used either as the IN variable of a #SERVER or as the DYNAMIC IN variable (see the #NEWPROCESS Built-In Function on page 9-266) of an implicit server. If the variable level is not being used for either of these purposes, #EOF does nothing.
Built-In Functions and Variables #ERRORNUMBERS Built-In Variable #ERRORNUMBERS Built-In Variable Use #ERRORNUMBERS to get information about the most recent error detected by your TACL. #ERRORNUMBERS Result #ERRORNUMBERS returns a space-separated list of four integer numbers that describe the most recent error. If the first number in the list is less than 1024, it is the number of a file-system error or sequential I/O error. If the number is 1024 or larger, it is a TACL error number.
Built-In Functions and Variables #ERRORNUMBERS Built-In Variable Example If you try to create a process that already exists, you receive this error when you output the error numbers: 37> #OUTPUT [#ERRORNUMBERS] 1149 1 48 0 The first number is a TACL #NEWPROCESS error (1149). The second number is a PROCESS_CREATE_ error number (1), which usually indicates that a file system error occurred. The third number is a file-system error number (48), which indicates that a security violation occurred.
Built-In Functions and Variables #ERRORTEXT Built-In Function #ERRORTEXT Built-In Function Use #ERRORTEXT with exception handlers to intercept any error text that might have been written to OUT if there had been no exception handler. #ERRORTEXT / option / option is one of these: CAPTURE variable-level indicates that the specified variable level is to be cleared and the current error text, if any, moved into it. CLEAR specifies that the current error text is to be discarded.
Built-In Functions and Variables #EXCEPTION Built-In Function #EXCEPTION Built-In Function Use #EXCEPTION, when exception handling is in effect, to determine why a routine was invoked. #EXCEPTION Result #EXCEPTION returns _CALL, if the routine issuing #EXCEPTION was invoked normally, or returns the name of the exception if the routine was invoked in response to an exception that it had filtered. (See the TACL Programming Guide for a discussion of exception handling.
Built-In Functions and Variables #EXIT Built-In Variable #EXIT Built-In Variable Use #EXIT to determine the current state of the exit flag. #EXIT Result #EXIT returns 0 if the EXIT flag is off and -1 if it is on. If the EXIT flag is on, it causes TACL to exit as soon as its buffer becomes empty. Considerations • • When you first log on, #EXIT is initialized to zero. • Use #POP #EXIT (or POP #EXIT) to restore the exit flag from the last copy pushed.
Built-In Functions and Variables #EXTRACT Built-In Function #EXTRACT Built-In Function Use #EXTRACT to obtain the first line of a variable level. #EXTRACT variable-level variable-level is the name or level of an existing variable level whose first line is to be extracted. Result #EXTRACT returns the first line of the specified variable level and deletes the line from the variable level.
Built-In Functions and Variables #EXTRACTV Built-In Function #EXTRACTV Built-In Function Use #EXTRACTV to move the first line of a variable level to another variable level. You can also use #EXTRACTV to set the binary data of a STRUCT directly, by extracting the first line from a variable level of another type and placing it in the STRUCT. No type checking is performed. (This use is primarily for accepting structured data from the variables associated with requesters and servers.
Built-In Functions and Variables #FILEGETLOCKINFO Built-In Function #FILEGETLOCKINFO Built-In Function Use #FILEGETLOCKINFO to obtain information about record and file locks. #FILEGETLOCKINFO [ / option / ] fvname control lockdesc participants option can be one of the following options or can be omitted. If omitted, #FILEGETLOCKINFO returns information for all locks. PROCESSID processid specifies the name or PID (if not named) of an existing process.
Built-In Functions and Variables #FILEGETLOCKINFO Built-In Function The control STRUCT must be initialized prior to a series of calls to #FILEGETLOCKINFO.
#FILEGETLOCKINFO Built-In Function Built-In Functions and Variables participants is a STRUCT that is to receive information about processes or transactions that hold or wait for the lock; it must be defined as follows: [#DEF participants STRUCT BEGIN STRUCT locker(0:mp-1); == BEGIN UINT flags; == == == == == == == FILLER 2; == PHANDLE process; == == TRANSID transid == REDEFINES process; == END; END; ] mp = max participants <0> set for process clear for transaction <1:3> 0=waiting, 1=granted <4> internal
Built-In Functions and Variables #FILEGETLOCKINFO Built-In Function Table 9-10. #FILEGETLOCKINFO Status Codes Code Meaning -1 The control STRUCT is the wrong size. -2 The lockdesc STRUCT is the wrong size. -3 The participants STRUCT is the wrong size. (This STRUCT can vary in size, but it must always be a multiple of the size that would be required for one participant.
Built-In Functions and Variables #FILEINFO Built-In Function #FILEINFO Built-In Function Use #FILEINFO to obtain detailed, specific information about a file. #FILEINFO / option [ , option ] ... / file-name [ file-name ... ] option is an information request. It can be any of these: AUDITED returns -1 if the file exists and is audited by the TMF subsystem; otherwise, it returns 0.
Built-In Functions and Variables #FILEINFO Built-In Function DEVICETYPE returns the numeric device type word (0, if the file does not exist); see the Guardian Procedure Calls Reference Manual. EOF returns the numeric value of the end-of-file pointer, which represents the size of the file in bytes (0, if the file does not exist). EXISTENCE returns -1 if the file exists; if not, it returns 0. EXTENTSALLOCATED returns the number of file extents currently allocated (0, if the file does not exist).
Built-In Functions and Variables #FILEINFO Built-In Function INCOMPLETESQLDDL returns -1 if the file exists and an SQL DDL operation is currently in progress. Otherwise, it returns 0. INDEXCOMPRESSION returns -1 if the file exists, is key-sequenced, and uses index compression; otherwise, it returns 0. LASTOPEN_GMT returns the time and date when the file was last opened, expressed as a fourword timestamp.
Built-In Functions and Variables #FILEINFO Built-In Function ODDUNSTR returns -1 if the file exists, is unstructured, and was created with the ODDUNSTR parameter in effect; otherwise, it returns 0. OPENNOW returns -1 if the file exists and is currently open; otherwise, it returns 0. OWNER returns the owner’s user ID (0,0 if the file does not exist). PHYSICALFILENAME returns the physical file name that is associated with the physical file where the data resides if the specified file is a logical file.
#FILEINFO Built-In Function Built-In Functions and Variables SECURITY returns the security established for the file: rwep for a Guardian file **** for a Safeguard file #### for an OSS file *SQL for SQL/MX objects blank for a nonexistent file SUBVOL returns the subvolume-name portion of the file name (missing fields in filename are supplied by the current defaults); the file need not exist. If the file is a temporary file, SUBVOL returns the file-name portion (#nnnn).
Built-In Functions and Variables #FILEINFO Built-In Function Considerations • If you specify more than one request option, the items of information are listed, separated by spaces, in the same order as the requests. • Because FILE and SYSTEM can return nothing, you should specify them last in the list of options to avoid confusion. When assigning results with #SETMANY, for example, you avoid loss of synchronization between the items returned and the variable levels that receive them.
Built-In Functions and Variables #FILENAMES Built-In Function #FILENAMES Built-In Function Use #FILENAMES to obtain all file names that satisfy a specified file-name template. #FILENAMES [ / option [ , option ] ... / ] [ file-name-template ] option specifies the criteria the requested file names must meet; specify one of these options: MAXIMUM [ num ] specifies the maximum number of file names to be returned on this call. If num is omitted or is less than 1, all matching file names are returned.
Built-In Functions and Variables #FILENAMES Built-In Function Consideration File names within a volume are returned in alphabetical order, but volumes are processed in logical-device number order. Examples This example illustrates the output of the #FILENAMES built-in function: 17> #OUTPUT [#FILENAMES $BOOKS.TACL.SEC*] $BOOKS.TACL.SEC01 $BOOKS.TACL.SEC02 $BOOKS.TACL.
Built-In Functions and Variables #FILTER Built-In Function #FILTER Built-In Function Use #FILTER in a routine to specify the exceptions the routine can handle. An exception is an unusual event that causes TACL to interrupt the normal flow of invocations and transfer to special code, known as an exception handler. The event can be BREAK, a TACL error, or a user-defined exception. #FILTER [ exception [ exception ] ...
Built-In Functions and Variables #FILTER Built-In Function • Only the most recent #FILTER in a routine has any effect. If a routine that contains a filter list calls another routine that also contains a filter list, the list in the called routine becomes active. When control is returned from that routine, the filter list in the calling routine resumes active status. If a routine contains more than one #FILTER function call, the latest list supersedes all previous lists.
Built-In Functions and Variables #FRAME Built-In Function #FRAME Built-In Function Use #FRAME to establish a reference point for pushed variables. A subsequent occurrence of #UNFRAME pops all variable levels pushed since the last #FRAME. #FRAME Result #FRAME returns nothing. Considerations • All variables pushed after a #FRAME are automatically popped when a matching #UNFRAME is executed. This allows you to control local variables without having to explicitly pop them.
Built-In Functions and Variables #GETCONFIGURATION Built-In Function #GETCONFIGURATION Built-In Function Use #GETCONFIGURATION to obtain the settings of special TACL flags that can change the behavior of TACL in certain situations. Note. These flags can be changed only by users who are authorized to alter the Command Interpreter Monitor (CMON). For additional information, see Command Interpreter Monitor Interface (CMON) on page 6-9. #GETCONFIGURATION / option [ , option ] ...
Built-In Functions and Variables #GETCONFIGURATION Built-In Function CONFIGRUN if PROCESSLAUNCH, then the TACL RUN[D] command was configured to call the system procedure PROCESS_LAUNCH_ to start the process. In this case, the additional RUN[D] command options, MAXMAINSTACKSIZE, MAXNATIVEHEAPSIZE, and GUARANTEEDSWAPSPACE, are available. if PROCESSCREATE, then the TACL RUN[D] command was configured to call the system procedure PROCESS_CREATE_ to start the process.
Built-In Functions and Variables #GETCONFIGURATION Built-In Function requesting the configuration parameters (the flag settings) in effect for the current user. This option is meaningful only if the $CMON process has been coded to return the appropriate information. Otherwise the request is ignored. Use of this option allows $CMON to control (and change) the flag settings for each logon session. These flag settings are then returned to the TACL process. This option is initially set to 0.
Built-In Functions and Variables #GETPROCESSSTATE Built-In Function #GETPROCESSSTATE Built-In Function Use #GETPROCESSSTATE to obtain process state information for the current TACL process. #GETPROCESSSTATE [ / option [ , option ] ... / ] option can be zero or more of these: LOGGEDON requests the logged-on state of the TACL process.
Built-In Functions and Variables #GETPROCESSSTATE Built-In Function created the TACL process did not authenticate the user prior to creating the TACL process, so the TACL process performs user authentication after prompting for logon information. The default value is 0 for a regular TACL process or a TACL process started by a TSN-TACL process. The default value is 1 for a TSN-TACL process.
Built-In Functions and Variables #GETPROCESSSTATE Built-In Function If you do not specify any options, #GETPROCESSSTATE returns a space-separated list with a one or zero for each process state option, specified from left to right as LOGGEDON, TSNLOGON, TSNLOGOFF, INHERITEDLOGON, STOPONLOGOFF, PROPAGATELOGON, and PROPAGATESTOPONLOGOFF. If the #GETPROCESSSTATE built-in function cannot obtain process state information, the TACL process displays an operating system error and abends.
Built-In Functions and Variables #GETSCAN Built-In Function #GETSCAN Built-In Function Use #GETSCAN to obtain the number of characters that #ARGUMENT has processed. #GETSCAN Result #GETSCAN returns the number of characters that #ARGUMENT has passed over, not including the routine name and the first character after the name. Consideration To determine whether there are more arguments in an argument set, use the #MORE built-in function.
Built-In Functions and Variables #HELPKEY Built-In Variable #HELPKEY Built-In Variable Use #HELPKEY to retrieve the name of the TACL help key. The help key displays syntax information during an interactive TACL session. You can type part of a statement, including the full name of a command or built-in function, and then press the help key. TACL lists what types of elements are expected next. #HELPKEY Result #HELPKEY returns the name of the current help key or, if there is no help key, returns nothing.
Built-In Functions and Variables #HIGHPIN Built-In Variable #HIGHPIN Built-In Variable Use the #HIGHPIN built-in variable to establish the default PIN range for processes started by the current TACL. #HIGHPIN Considerations • The default value for #HIGHPIN depends on the forced-low attribute of the TACL process. To ensure a default value for #HIGHPIN, set it to the desired value in the TACLLOCL or TACLCSTM file.
Built-In Functions and Variables #HISTORY Built-In Function #HISTORY Built-In Function Use #HISTORY to display and manipulate the commands saved in the history buffer. #HISTORY [ / option [ , option ] ... / ] option is an option that specifies the action to perform on the commands in the history buffer; it can be any of these: CLEARLAST deletes the most recent command line from the history buffer.
Built-In Functions and Variables #HOME Built-In Variable #HOME Built-In Variable Use #HOME to set or obtain the variable defined as your home directory. #HOME Result #HOME returns the full path-name of the home directory. Considerations • • When you first log on, #HOME is initialized to : (the root directory). • Use #POP #HOME (or POP #HOME) to restore your home directory to its previous identity, the last copy pushed.
Built-In Functions and Variables #IF Built-In Function #IF Built-In Function Use #IF to obtain one set of text (typically TACL statements), contained within the #IF construct, if a given condition is met. #IF [ NOT ] numeric-expression [ enclosure ] NOT specifies that #IF should negate numeric-expression after evaluating it; that is, the condition is met if numeric-expression is NOT true.
Built-In Functions and Variables #IF Built-In Function Examples 1. The macro, furd, outputs each of its arguments on a separate line: [#DEF furd MACRO |BODY| == Output current argument #OUTPUT %1% == Test for more arguments [#IF NOT [#EMPTY %2 TO *%] |THEN| furd %2 TO *% == Call self without 1st arg ] ] 2. This example illustrates the use of a numeric expression: [#IF 3 | THEN | . . . 3. This example illustrates the use of a variable name containing a decimal number: #SET var 3 [#IF var | THEN | . . . 4.
Built-In Functions and Variables #IN Built-In Variable #IN Built-In Variable Use #IN to specify or obtain the name of the file currently being used by TACL as its IN file. #IN Result #IN returns the name of the file currently being used for input by TACL. Considerations • At TACL startup time, #IN contains the name of the file currently being used as the TACL IN file. This file is called the primary IN file.
Built-In Functions and Variables #IN Built-In Variable • Be careful to coordinate functions that enable the communication (such as #IN or #OUT) with the counterpart mechanisms in that process (such as IN or OUT • referring to the TACL process name). Combining different mechanisms can lead to conflicts in interprocess message handling. For more information, see the TACL Programming Guide.
Built-In Functions and Variables #INFORMAT Built-In Variable #INFORMAT Built-In Variable Use #INFORMAT to set or obtain the current input format for the TACL IN file. #INFORMAT Result #INFORMAT returns the current #INPUT formatting mode-PLAIN, QUOTED, or TACL. Considerations • #INFORMAT applies only to input read from the IN file, not to any other input data. The default format for macro or routine files and function libraries is TACL format; to change this setting, use a ?FORMAT directive.
Built-In Functions and Variables #INFORMAT Built-In Variable PLAIN specifies that TACL should not translate characters read from IN, but should consider everything to be ordinary text; for example, braces and double equal signs are read as such and are not interpreted as comments in PLAIN mode.
#INFORMAT Built-In Variable Built-In Functions and Variables TACL passes the brackets as text to TEDIT. Preceding any TACL metacharacter (including the tilde character itself) with a tilde causes TACL to consider it as simple text. Table 9-11 lists the difference in text storage between TACL and QUOTED settings after the variables are initialized as follows (#OUTFORMAT is set to PLAIN): #PUSH var b #SET b $ Table 9-11.
Built-In Functions and Variables #INITTERM Built-In Function #INITTERM Built-In Function Use #INITTERM to reset your home terminal to its configured settings. #INITTERM Result #INITTERM returns nothing. Considerations • You typically use this command when an application program leaves your terminal in an abnormal state. • The #INITTERM built-in function calls the SETMODE operating system procedure, function 28.
Built-In Functions and Variables #INLINEECHO Built-In Variable #INLINEECHO Built-In Variable Use #INLINEECHO to determine whether TACL copies to its own OUT file the lines it passes to the IN file of an inline process. #INLINEECHO Result #INLINEECHO returns 0 if echoing is disabled, -1 if it is enabled. Considerations • • When you first log on, #INLINEECHO is initialized to zero. • Use #POP #INLINEECHO (or POP #INLINEECHO) to restore the echo flag from the last copy pushed.
Built-In Functions and Variables #INLINEEOF Built-In Function #INLINEEOF Built-In Function Use #INLINEEOF to send an end-of-file character to a process under control of the INLINE facility. #INLINEEOF Result #INLINEEOF returns nothing. Considerations • TACL waits until the inline process prompts for input then sends an EOF indication to that process. • Use of #INLINEEOF when no inline process exists causes an error.
Built-In Functions and Variables #INLINEOUT Built-In Variable #INLINEOUT Built-In Variable Use #INLINEOUT to control whether TACL copies to its own OUT file lines that inline processes write to their OUT files (when neither the OUT nor the OUTV option has been specified). #INLINEOUT Result #INLINEOUT returns 0 if inline process output copying is disabled, -1 if it is enabled. Considerations • • When you first log on, #INLINEOUT is initialized to -1.
Built-In Functions and Variables #INLINEPREFIX Built-In Variable #INLINEPREFIX Built-In Variable Use #INLINEPREFIX to establish the prefix that identifies lines to be passed to inline processes. Lines that start with the defined prefix are not processed by TACL. #INLINEPREFIX Result #INLINEPREFIX returns the character or characters that make up the current inline prefix, if any. Considerations • • When using prefixed lines: ° The prefix must be followed by a space unless it appears alone on a line.
Built-In Functions and Variables #INLINEPROCESS Built-In Variable #INLINEPROCESS Built-In Variable Use #INLINEPROCESS to obtain the process ID of the current inline process. #INLINEPROCESS Result #INLINEPROCESS returns the process ID of the current inline process, if one exists; if not, #INLINEPROCESS returns nothing. Considerations • Use #PUSH #INLINEPROCESS (or PUSH #INLINEPROCESS) to save the process ID of the current inline process.
Built-In Functions and Variables #INLINEPROCESS Built-In Variable When you pop #INLINEPROCESS (or unframe it) and its corresponding inline process is still in existence, you can no longer communicate with that process; • TACL responds to all its I/O requests with error 66. The process is still counted against the 100-process limit mentioned above, however, until it terminates.
Built-In Functions and Variables #INLINETO Built-In Variable #INLINETO Built-In Variable Use #INLINETO to determine whether TACL copies to a variable level the lines that inline processes write to their OUT files (when neither the OUT nor the OUTV options have been specified). #INLINETO Result #INLINETO returns the fully qualified name of the variable level to which inline process output is appended, if such a variable has been defined; otherwise, #INLINETO returns nothing.
Built-In Functions and Variables #INPUT Built-In Function #INPUT Built-In Function Use #INPUT to read information from the TACL IN file. #INPUT [ / option [ , option ] ... / ] [ prompt ] option is an option that qualifies the read operation. It can be any of these: CURRENT reads input from the current IN file (if #IN was pushed), rather than from the primary IN file. FUNCTIONKEY variable-level sets variable-level to the name of the function key used to terminate reading.
Built-In Functions and Variables #INPUT Built-In Function If you omit the UNTIL option, pressing a function key or the RETURN key terminates reading. prompt is one or more characters to be written to the IN file as a prompt. Consideration TACL saves the primary IN file, set at startup time, as the default setting of the #IN built-in variable. If you set #IN to another file, TACL stores the second file as the current IN file. You can use the #INPUT built-in function to read from either file.
Built-In Functions and Variables #INPUT Built-In Function 34> OUTVAR text this is a test 35> HISTORY 4 32> 33> 34> 35> this is a test OUTVAR key OUTVAR text HISTORY 4 If you omit the HISTORY option in the #INPUT function call, "this is a test" does not appear in the history listing.
Built-In Functions and Variables #INPUTEOF Built-In Variable #INPUTEOF Built-In Variable Use #INPUTEOF to obtain the current state of the end-of-file flag. #INPUTEOF Result #INPUTEOF returns -1 if TACL reads an end-of-file; otherwise, it returns 0. Considerations • • When you first log on, #INPUTEOF is initialized to zero. • Use #PUSH #INPUTEOF (or PUSH #INPUTEOF) to save a copy of the current setting of the INPUTEOF flag.
Built-In Functions and Variables #INPUTV Built-In Function #INPUTV Built-In Function Use #INPUTV to read information from the TACL primary or current IN file (typically, the home terminal) into a variable level. You can also use #INPUTV to prompt directly with the binary data of a STRUCT or to set the binary data of a STRUCT directly from the IN file. No type-checking is done on the input data. #INPUTV [ / option [ , option ] ...
Built-In Functions and Variables #INPUTV Built-In Function The former construct is faster and is not subject to errors incurred in type-checking the input data. • If the data from IN is longer than the data area of the STRUCT, the excess bytes are discarded without any notification. • If the data from IN is shorter than the data area of the STRUCT, TACL sets the entire STRUCT to its default values and then moves the supplied data into the beginning of the data bytes of the STRUCT.
Built-In Functions and Variables #INSPECT Built-In Variable #INSPECT Built-In Variable Use #INSPECT to set or obtain the current state of the inspect flag. #INSPECT Result #INSPECT returns the current state of the inspect flag: OFF, ON, or SAVEABEND. Considerations • • When you first log on, #INSPECT is initialized to OFF. • Use #POP #INSPECT (or POP #INSPECT) to restore the inspect flag from the copy last pushed. • Use #SET #INSPECT (or SET #INSPECT) to set the state of the inspect flag.
Built-In Functions and Variables #INSPECT Built-In Variable The rules about which debugger gets invoked are approximately the same as for the RUND command. That is, if the INSPECT attribute is set ON anywhere (in the object file during compilation, or on the TACL command line using the SET command), you will get a debugger in the Inspect family (either Inspect or VI), unless of course neither of these debuggers is available, and then you get the default debugger, eInspect.
Built-In Functions and Variables #INTERACTIVE Built-In Function #INTERACTIVE Built-In Function Use #INTERACTIVE to determine whether your TACL is interactive. TACL is considered to be interactive if its IN and OUT files are the same. #INTERACTIVE [ / CURRENT / ] Result If you include the CURRENT option, #INTERACTIVE returns -1 if the current IN file is the same as the current OUT file (the contents of #IN are the same as the contents of #OUT); otherwise, it returns 0.
Built-In Functions and Variables #INTERPRETJULIANDAYNO Built-In Function #INTERPRETJULIANDAYNO Built-In Function Use #INTERPRETJULIANDAYNO to convert a Julian day number to its corresponding calendar date. A Julian day number is an integer representing the number of days from the arbitrary date January 1, 4713 B.C. to the present day.
Built-In Functions and Variables #INTERPRETTIMESTAMP Built-In Function #INTERPRETTIMESTAMP Built-In Function Use #INTERPRETTIMESTAMP to convert a four-word timestamp to its date and time components. #INTERPRETTIMESTAMP four-word-timestamp four-word-timestamp is the timestamp to be converted. Result #INTERPRETTIMESTAMP returns a space-separated list of nine numbers, consisting of the Julian day number, year, month, day, hour, minute, second, millisecond, and microsecond.
Built-In Functions and Variables #INTERPRETTRANSID Built-In Function #INTERPRETTRANSID Built-In Function Use #INTERPRETTRANSID to convert a numeric transaction ID into separate numeric values for the various components of a transaction ID. #INTERPRETTRANSID transid transid is a numeric transaction ID.
Built-In Functions and Variables #JULIANTIMESTAMP Built-In Function #JULIANTIMESTAMP Built-In Function Use #JULIANTIMESTAMP to obtain a selected four-word timestamp. #JULIANTIMESTAMP [ type [ tuid-request ] ] type specifies the particular timestamp desired: 0 current GMT 1 GMT when the system was loaded 2 GMT when SYSGEN was run If you omit type, 0 is assumed. tuid-request if not zero, specifies that the time update ID is to be included in the result. The default is zero.
Built-In Functions and Variables #KEEP Built-In Function #KEEP Built-In Function Use #KEEP to remove all but the top n definition levels of one or more variables. #KEEP num variable num is the number of levels to keep. variable is the name of an existing variable. Result #KEEP returns as its result the number of levels deleted. Consideration #KEEP 0 removes the variable.
Built-In Functions and Variables #KEYS Built-In Function #KEYS Built-In Function Use #KEYS to determine which function keys are currently defined. #KEYS Result #KEYS returns a space-separated list containing the names of all defined function keys.
Built-In Functions and Variables #LINEADDR Built-In Function #LINEADDR Built-In Function Use #LINEADDR to convert a character address to a line address. #LINEADDR variable-level char-addr variable-level is an existing variable level to be operated upon. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. char-addr is an integer or a variable level that contains an integer. char-addr specifies the character address of the character to be converted.
Built-In Functions and Variables #LINEBREAK Built-In Function #LINEBREAK Built-In Function Use #LINEBREAK to insert an end-of-line into a variable level at a specified point in a specified line. #LINEBREAK variable-level line-addr char-offset variable-level is the name of an existing variable level into which the end-of-line is to be inserted. It must not be in a shared segment and must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-addr is an integer or a variable level that contains an integer.
Built-In Functions and Variables #LINEBREAK Built-In Function The invocation: #LINEBREAK var 2 5 causes var to contain: ABCDEFG HIJK LMNOPQRST UVWXYZ HP NonStop TACL Reference Manual—429513-018 9-225
Built-In Functions and Variables #LINECOUNT Built-In unction #LINECOUNT Built-In unction Use #LINECOUNT to obtain the number of lines in a variable level. #LINECOUNT variable-level variable-level is the name of an existing variable level whose lines are to be counted. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. Result #LINECOUNT returns the number of lines in the variable level.
Built-In Functions and Variables #LINEDEL Built-In Function #LINEDEL Built-In Function Use #LINEDEL to delete lines from a variable level, starting at a specified line. #LINEDEL variable-level line-addr-1 [ [ FOR line-count ] | TO line-addr-2 ] ] variable-level is an existing variable level from which lines are to be deleted. It must not be in a shared segment, and must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-addr-1 is an integer or a variable level that contains an integer.
Built-In Functions and Variables #LINEDEL Built-In Function Assume that var is a variable level containing: THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG TWICE A DAY EXCEPT TUESDAYS. 1. Either of the invocations: #LINEDEL var 2 TO 4 or #LINEDEL var 2 FOR 3 causes var to contain: THE QUICK BROWN EXCEPT TUESDAYS. 2.
Built-In Functions and Variables #LINEFIND Built-In Function #LINEFIND Built-In Function Use #LINEFIND to find text in a variable level, searching forward from a specified line number. #LINEFIND [ / EXACT / ] variable-level line-addr text EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level within which TACL will search for text.
Built-In Functions and Variables #LINEFIND Built-In Function Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ 1. The invocation: #LINEFIND var 1 IJK returns 2; the first occurrence of IJK starting in or after line 1 is in line number 2. 2. The invocation: #LINEFIND var 2 IJK returns 2; the first occurrence of IJK is in the specified starting line, line 2. 3. The invocation: #LINEFIND var 3 IJK returns 0; there are no occurrences of IJK starting in or after line 3. 4.
Built-In Functions and Variables #LINEFINDR Built-In Function #LINEFINDR Built-In Function Use #LINEFINDR to find text in a variable level, searching backward from a specified line number. #LINEFINDR [ / EXACT / ] variable-level line-addr text EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level within which TACL will search for text.
Built-In Functions and Variables #LINEFINDR Built-In Function Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ 1. The invocation: #LINEFINDR var 3 IJK returns 2; the nearest occurrence of IJK beginning in or before line 3 is in line 2. 2. The invocation: [#LINEFINDR var 2 T UV] returns 2; though the text T(end-of-line)UV carries over to line 3, it begins in line 2. 3. The invocation: #LINEFINDR var 4 FOO returns 0; there are no occurrences of FOO anywhere in var.
Built-In Functions and Variables #LINEFINDRV Built-In Function #LINEFINDRV Built-In Function Use #LINEFINDRV to find a string in a variable level, searching backward from a specified line. #LINEFINDRV [ / EXACT / ] variable-level line-addr string EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level within which TACL will search for string.
Built-In Functions and Variables #LINEFINDRV Built-In Function result before using it in a subsequent call. This procedure avoids finding the same string again. • • Each line break contains an internal end-of-line character that counts as one byte. For variables that contain TACL statements, each square bracket ([,]), vertical bar (|), or tilde-space combination (~_) uses two bytes, including unprintable characters that are subject to change from one TACL RVU to another. Other characters use one byte.
Built-In Functions and Variables #LINEFINDV Built-In Function #LINEFINDV Built-In Function Use #LINEFINDV to find a string in a variable level, searching forward from a specified line. #LINEFINDV [ / EXACT / ] variable-level line-addr string EXACT specifies that the search is to be case-sensitive; if you omit it, the search makes no distinction between uppercase and lowercase letters. variable-level is an existing variable level in which TACL will search for string.
Built-In Functions and Variables #LINEFINDV Built-In Function Examples Assume that var is a variable level containing: ABCDEFG HIJKLMNOPQRST UVWXYZ and that var2 is a variable level containing: IJK 1. Either of the invocations: #LINEFINDV var 1 "IJK" or #LINEFINDV var 1 var2 returns 2; the first occurrence of IJK starting in or after line 1 is in line 2. 2.
Built-In Functions and Variables #LINEGET Built-In Function #LINEGET Built-In Function Use #LINEGET to obtain a copy of a set of consecutive lines in a variable level. #LINEGET string line-addr-1 { { FOR line-count } | { TO line-addr-2 } } string is an existing variable level or quoted text from which lines are to be copied. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-addr-1 is an integer or a variable level that contains an integer.
Built-In Functions and Variables #LINEGET Built-In Function Examples Assume that var is a variable level containing: THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG TWICE A DAY EXCEPT TUESDAYS. 1. The invocation: #LINEGET var 2 returns: FOX JUMPED OVER 2.
Built-In Functions and Variables #LINEGETV Built-In Function #LINEGETV Built-In Function Use #LINEGETV to copy a set of consecutive lines from one variable level to another. #LINEGETV string variable-level line-addr-1 [ [ FOR line-count ] | [ TO line-addr-2 ] ] string is an existing variable level or quoted text from which characters are to be copied. It must not be a DIRECTORY, a STRUCT, or a STRUCT item. variable-level is an existing variable level that is to receive the copy.
Built-In Functions and Variables #LINEGETV Built-In Function Examples Assume that var is a variable level containing: THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG TWICE A DAY EXCEPT TUESDAYS.
Built-In Functions and Variables #LINEINS Built-In Function #LINEINS Built-In Function Use #LINEINS to insert text into a variable level at a specified line number. #LINEINS variable-level line-addr text variable-level is an existing variable level into which text will be inserted. It must not be in a shared segment, and must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-addr is an integer or a variable level that contains an integer.
Built-In Functions and Variables NEW TEXT UVWXYZ 2. The invocation: [#LINEINS var 3 NEW TEXT] causes var to contain: ABCDEFG HIJKLMNOPQRST NEW TEXT UVWXYZ 3.
Built-In Functions and Variables #LINEINSV Built-In Function #LINEINSV Built-In Function Use #LINEINSV to insert a string into a variable level at a specified line number. #LINEINSV variable-level line-addr string variable-level is an existing variable level into which string will be inserted. It must not be in a shared segment and must not be a DIRECTORY, a STRUCT, or a STRUCT item. line-addr is an integer or a variable level that contains an integer.
Built-In Functions and Variables causes var to contain: ABCDEFG HIJKLMNOPQRST NEW TEXT UVWXYZ 2.
Built-In Functions and Variables #LINEJOIN Built-In Function #LINEJOIN Built-In Function Use #LINEJOIN to delete the end-of-line at the end of a specified line, thereby joining the following line to it. #LINEJOIN variable-level line-addr variable-level is an existing variable level in which joining is to take place. line-addr is an integer or a variable level that contains an integer. line-add specifies the line number from which the end-of-line is to be deleted.
Built-In Functions and Variables #LOAD Built-In Function #LOAD Built-In Function Use #LOAD to load variables from a TACL library file into memory. A library file consists of one or more ?SECTION directives of the form: ?SECTION name type Each directive is followed by one or more lines of text that are to be associated with the variable level specified by name. The nature of the text is largely dependent on the type of the section, which can be ALIAS, DELTA, MACRO, ROUTINE, STRUCT, or TEXT.
Built-In Functions and Variables #LOAD Built-In Function • To include lines beginning with question marks, (for example, you might be loading DDL commands into a variable level for later use as the IN variable for a DDL run), double the question mark (??). The first question mark and any spaces adjacent to it are discarded and the remainder of the line is treated as text.
Built-In Functions and Variables #LOAD Built-In Function Examples Following are some examples of ?SECTION directives in library files that can be processed by #LOAD: ?SECTION versnum TEXT == Version of this library 14OCT91 ?SECTION setmacro MACRO == Creates a macro (%1%) defined by text (%2 to *%) [#DEF %1% MACRO |BODY|%2 to *%] ?SECTION setvar ALIAS == Defines a variable SETMACRO ?SECTION nocommas MACRO == Turns comma-separated list into space-separated list [#DELTA /COMMANDS nocommas_d/ %*%] ?SECTION no
Built-In Functions and Variables #LOCKINFO Built-In Function #LOCKINFO Built-In Function Use #LOCKINFO to obtain information about record locks. #LOCKINFO lock-spec tag buffer lock-spec consists of a numeral followed by one or more descriptive fields, and specifies the type of lock information wanted; lock-spec can be any of these: 0 device-name searches the specified device for all locks. 1 file-name searches the specified file for all locks. 2 device-name [\node-name.
Built-In Functions and Variables #LOCKINFO Built-In Function Consideration For D-series programs, use the #FILEGETLOCKINFO built-in function. Example This routine accepts a volume name and reports all locks for that volume. ?SECTION looklock ROUTINE #FRAME == Define buffer into which #LOCKINFO puts lock information.
Built-In Functions and Variables #SET #SET #SET #SET #SET #LOCKINFO Built-In Function keylen [buffer:lib:keylen] fname [vol].[buffer:lib:svol^file(0:7)] fname [fname].[buffer:lib:svol^file(8:15)] numlab [buffer:lib:numlab] laboff [buffer:lib:laboff] == Display them.
Built-In Functions and Variables #LOCKINFO Built-In Function #PUSH count start stop #SET tag 0 == Get name of volume to be searched for locks. SINK [#ARGUMENT /VALUE vol/ DEVICE] == Loop through all locks on volume. [#LOOP |DO| == Get lock info. #SETMANY err tag, [#LOCKINFO 0 [vol] [tag] buffer] == Check if locks found. [#IF (( err = 0) OR (err = 45 )) |THEN| == Display lib info for this resource. DISPLAY_LIB == Display all labinfo entries obtained on this call & to #LOCKINFO.
Built-In Functions and Variables #LOGOFF Built-In Function #LOGOFF Built-In Function Use #LOGOFF to log off the current TACL. #LOGOFF [ / option [ , option ] ... / ] option is any of these: CLEAR clears the terminal screen after you log off (for use when TACL is not configured to clear the screen automatically). NOCLEAR prevents TACL from clearing the terminal screen after you log off (for use when TACL is configured to clear the screen automatically-the usual case).
Built-In Functions and Variables #LOGOFF Built-In Function • If you use the #LOGOFF function while working through a modem, the modem disconnects (unless the ancestor of the TACL process is running in another system). • If the ancestor of your current TACL process is a process running in another system and you enter the LOGOFF command, the current TACL process is deleted and control returns to the ancestor process.
Built-In Functions and Variables #LOOKUPPROCESS Built-In Function #LOOKUPPROCESS Built-In Function Use #LOOKUPPROCESS to request information about a named process or process pair from the destination control table (DCT). #LOOKUPPROCESS / option [ , option ] ... / specifier option is a request option. It can be any of these: ANCESTOR returns the process name, or the CPU number and process identification number, of the process creator.
Built-In Functions and Variables #LOOKUPPROCESS Built-In Function \node-name is the system where the process is running. $process-name is the name of the process. cpu,pin is the CPU,PIN of the entry. entry-number [ \node-name ] is an entry number in the DCT for the specified system. If you omit\nodename, the current default is used. Result #LOOKUPPROCESS returns a space-separated list of the selected information about the DCT entry.
Built-In Functions and Variables #LOOP Built-In Function #LOOP Built-In Function Use #LOOP to execute one or more statements iteratively within a function. #LOOP enclosure enclosure is an enclosure that can contain either of two sets of two labels: WHILE and DO, or DO and UNTIL.
Built-In Functions and Variables #MATCH Built-In Function #MATCH Built-In Function Use #MATCH to determine whether a particular text string satisfies the rules for a template. #MATCH template [ text ] template is a character sequence that may include these template characters: * matches zero or more characters ? matches a single character text is a character sequence to be compared to template. Result #MATCH returns -1 if the text satisfies the rules for the template; otherwise, it returns 0.
Built-In Functions and Variables #MOM Built-In Function #MOM Built-In Function Use #MOM to obtain the process name, or CPU number and process identification number, of the creator, or backup, of your TACL process. #MOM invokes the MOM operating system procedure. #MOM Result • • If TACL is a named process and the backup does not exist, the result is blank. • If TACL is an unnamed single process, the result is the TACL ancestor.
Built-In Functions and Variables #MORE Built-In Function #MORE Built-In Function Use #MORE in a routine to find out whether an entire argument set has been processed. #MORE Result #MORE returns -1 if there are more arguments, 0 if there are none remaining. Considerations • To parse the arguments passed to a routine, use the #ARGUMENT built-in function. • To examine the unprocessed part of an argument set, use the #REST built-in function.
Built-In Functions and Variables #MYGMOM Built-In Function #MYGMOM Built-In Function Use #MYGMOM to obtain the identity of the job ancestor of your TACL process, if your TACL process is part of a batch job. #MYGMOM Result #MYGMOM returns the process name, or the CPU number and process identification number, of the TACL process job ancestor, if there is one; otherwise, it returns nothing.
Built-In Functions and Variables #MYPID Built-In Function #MYPID Built-In Function Use #MYPID to obtain your current CPU number and process identification number (PIN). The number is not qualified with a node name. #MYPID invokes the MYPID operating system procedure. #MYPID Result #MYPID returns the CPU number and PIN of your TACL process. If it is a process pair, #MYPID returns the CPU,PIN of the primary process.
Built-In Functions and Variables #MYSYSTEM Built-In Function #MYSYSTEM Built-In Function Use #MYSYSTEM to obtain the name of the system executing the current TACL. #MYSYSTEM invokes the MYSYSTEMNUMBER operating system procedure and converts the resulting number to the node name. #MYSYSTEM Result #MYSYSTEM returns the node name. Consideration #MYSYSTEM is not affected by #SYSTEM.
Built-In Functions and Variables #MYTERM Built-In Variable #MYTERM Built-In Variable Use #MYTERM to obtain the name of your current TACL home terminal. The TACL home terminal is typically the terminal designated by applications to receive critical system messages (such as abend notifications). A home terminal can be a physical terminal name or a process name. #MYTERM Result #MYTERM returns your current TACL home terminal name.
Built-In Functions and Variables #MYTERM Built-In Variable Examples 1. This example shows how to display the contents of #MYTERM: 10> #MYTERM #MYTERM expanded to: $TG0.$G04 2. This example pushes, sets, and pops the value of #MYTERM: 11> #PUSH MYTERM 12> #MYTERM #MYTERM expanded to: $TG0.$G04 13> #SET #MYTERM $ZTNT.#PTY46 14> #MYTERM #MYTERM expanded to: $ZTNT.#PTY46 15> #POP #MYTERM 16> #MYTERM #MYTERM expanded to: $TG0.
Built-In Functions and Variables #NEWPROCESS Built-In Function #NEWPROCESS Built-In Function Use #NEWPROCESS to start a process (this also establishes the name and CPU,PIN of the default process; see #PROCESS Built-In Function on page 9-292). #NEWPROCESS is similar to the RUN command described in Section 8. #NEWPROCESS program-file [ / option [, option ]... / ] [ param-set ] program-file is the name of the file containing the object program to be run.
Built-In Functions and Variables • #NEWPROCESS Built-In Function If TACL waits for completion of the created process, #NEWPROCESS returns a termination status, a space, and the process identifier of the created process. The termination status is one of these: STOP The process ended normally. ABEND The process ended abnormally (as the result of an error trap, for example). CPU The process was deleted because of a CPU failure. NET The process was deleted because of a network failure.
Built-In Functions and Variables #NEWPROCESS Built-In Function • To obtain additional information about error results, use the #ERRORNUMBERS built-in variable. • #ERRORNUMBERS returns different values for C-series and D-series #NEWPROCESS calls. For more information, see #ERRORNUMBERS Built-In Variable on page 9-160. • The #NEWPROCESS built-in function also supports file type 800, the native object code file for TNS/E systems. • Redirection abilities of the OSH command utility can be used.
Built-In Functions and Variables #NEXTFILENAME Built-In Function #NEXTFILENAME Built-In Function Use #NEXTFILENAME to obtain the file whose name follows the specified file alphabetically on a given volume. #NEXTFILENAME invokes the NEXTFILENAME operating system procedure. #NEXTFILENAME [ file-name ] file-name is the file name after which to begin the search for the next file name. Partial file names are expanded using the current defaults. Result #NEXTFILENAME returns the name of the located file.
Built-In Functions and Variables #OPENINFO Built-In Function #OPENINFO Built-In Function Use #OPENINFO to obtain information about file openers. #OPENINFO / option [ , option ] / { file-name | device-name } tag option is an information request. It can be any of these: ACCESSID returns the user number of the opener.
Built-In Functions and Variables #OPENINFO Built-In Function SYNCDEPTH returns the sync depth with which the file or device was opened. file-name or device-name identifies the file or device for which information is desired. Each call to #OPENINFO returns information about a single opening of the file or device. tag is a number identifying the particular opening for which information is wanted.
Built-In Functions and Variables #OPENINFO Built-In Function Example This routine accepts a file or device name and “processes” (simulation only) all the openings of that file or device.
Built-In Functions and Variables #OUT Built-In Variable #OUT Built-In Variable Use #OUT to set or obtain the name of the file currently being used by TACL as its OUT file. #OUT Result #OUT returns the name of the current TACL OUT file. Considerations When you first log on to an interactive TACL, #OUT is initialized to the name of your home terminal. You cannot permanently change the primary TACL OUT file; that is the primary OUT file always remains the same.
Built-In Functions and Variables #OUT Built-In Variable Any error while pushing OUT causes #OUT to be popped at once. Any other error or break occurring while #OUT is pushed causes all but the bottom level of #OUT to be popped before the error message is printed. • • Use #POP #OUT (or POP #OUT) to restore the last OUT file name pushed. Use #SET #OUT (or SET VARIABLE #OUT) to set the name of the file to be used by TACL for OUT.
Built-In Functions and Variables #OUTFORMAT Built-In Variable #OUTFORMAT Built-In Variable Use #OUTFORMAT to set or obtain the current formatting mode for the TACL OUT file. #OUTFORMAT Result #OUTFORMAT returns the current #OUTPUT formatting mode: PLAIN, PRETTY, or TACL. Considerations • • When you first log on, #OUTFORMAT is initialized to PLAIN.
Built-In Functions and Variables #OUTFORMAT Built-In Variable this feature to manage output spacing or to include a trailing space in a prompt, as follows: #FRAME #PUSH #OUTFORMAT #SET #OUTFORMAT PRETTY #INPUT Prompt:~_ ... #UNFRAME TACL causes TACL to display the internal representations of square brackets ([ and ]) and the vertical line (|) as those characters. It shows actual metacharacters preceded by tildes (~).
Built-In Functions and Variables #OUTPUT Built-In Function #OUTPUT Built-In Function Use #OUTPUT to write data to the TACL OUT file. #OUTPUT [ / option [ , option ] ... / ] [ text ] option qualifies the write operation. It can be any of these: COLUMN num begins writing data at column num. If there is already text in the buffer extending beyond the specified column, the buffer contents are output and a new line is started, beginning at that column.
#OUTPUT Built-In Function Built-In Functions and Variables WORDS causes text to be treated as a space-separated list of output items, applying the FILL, JUSTIFY, and WIDTH options to each item. Without WORDS, text is treated as a single output item. text is the output item. If you omit text, #OUTPUT writes a blank line. Result #OUTPUT returns nothing.
Built-In Functions and Variables #OUTPUT Built-In Function This is the third line This is the last line The fourth #OUTPUT call leaves room for the third line; otherwise, it would appear on the same line as the last line.
Built-In Functions and Variables #OUTPUTV Built-In Function #OUTPUTV Built-In Function Use #OUTPUTV to write the contents of a string to the OUT file of TACL (typically, the terminal). #OUTPUTV [ / option [ , option ] ... / ] string option qualifies the write operation. It can be any of the following unless string is a variable level of type STRUCT, in which case no options are allowed. COLUMN num begins writing data at column num.
Built-In Functions and Variables #OUTPUTV Built-In Function WORDS specifies that each line of string is to be treated as a space-separated list and that the FILL, JUSTIFY, and WIDTH options are to be applied to the individual members of the list. Without WORDS, string is treated as a single output item. string is the data to be output. It is the name of an existing variable level, text enclosed in quotation marks, or a concatenation of such entities.
Built-In Functions and Variables #OUTPUTV Built-In Function Example This example shows the use of a concatenated string containing both a variable name and quoted text as an argument to #OUTPUTV. #PUSH termname #SET termname [#MYTERM] #OUTPUTV "My terminal is " '+' termname '+' " at this time." Assuming the home terminal name is $GREEN at the time the #SET function is executed, the following is written to the OUT file: My terminal is $GREEN at this time.
Built-In Functions and Variables #PARAM Built-In Variable #PARAM Built-In Variable Use #PARAM to set or obtain the value of a specified parameter or to obtain a list of all the parameters you have currently in effect. For a discussion about the use of PARAMs, see the TACL Programming Guide. #PARAM [ param-name ] param-name is the name of the parameter whose value is to be determined.
Built-In Functions and Variables #PARAM Built-In Variable param-value is the value assigned to param-name. It has a maximum length of 255 characters and must be no longer than one logical line. Specify param-value as either character-sequence or "character-sequence". If you do not use quotation marks, you cannot include any commas or spaces as part of the parameter value. If you do use quotation marks, all characters between the quotation marks are included as part of the parameter value.
Built-In Functions and Variables #PAUSE Built-In Function #PAUSE Built-In Function Use #PAUSE to give control of your terminal to processes other than the current TACL. #PAUSE [ [\node-name.]{$process-name | cpu,pin } ] \node-name is the name of the system on which the process resides. $process-name is the name of the process or process pair for whose termination TACL is to wait. cpu,pin is the CPU number and process identification number of the process.
Built-In Functions and Variables • #PAUSE Built-In Function A process specification in #PAUSE establishes the identity of the default process; see the #PROCESS Built-In Function on page 9-292 for information on the default process.
Built-In Functions and Variables #PMSEARCHLIST Built-In Variable #PMSEARCHLIST Built-In Variable Use #PMSEARCHLIST to set or obtain the current contents of the search list used for finding program and macro files. #PMSEARCHLIST Result #PMSEARCHLIST returns the current contents of the search list used for finding programs and macro files. Considerations • • • #PMSEARCHLIST has a maximum size of 500 characters.
Built-In Functions and Variables #PMSEARCHLIST Built-In Variable In this case, TACL searches for $NEW.JONES.TEST. • You can #SET #PMSEARCHLIST [#DEFAULTS] (with brackets around #DEFAULTS), which uses whatever your current subvolume is at the time you set the search list; for example: 39> 40> 41> 42> VOLUME $guest.alice #SET #PMSEARCHLIST [#DEFAULTS] VOLUME $new.jones test In this case, TACL searches for $GUEST.ALICE.
Built-In Functions and Variables #PMSG Built-In Variable #PMSG Built-In Variable Use #PMSG to set or obtain the current state of the PMSG flag. If the PMSG flag is on, TACL outputs a message giving the process name, the CPU number, and process identification number of each process you start, and another message each time a process you started stops. #PMSG Result #PMSG returns the current state of the PMSG flag: 0 if it is off, -1 if it is on.
Built-In Functions and Variables #POP Built-In Function #POP Built-In Function Use #POP to delete the top level of one or more variables. #POP variable [ [,] variable ] ... variable is the name of an existing variable or the name of a built-in variable. Result #POP returns nothing. Considerations • If the top level is the only level, #POP deletes the variable (except for built-in variables.
Built-In Functions and Variables #PREFIX Built-In Variable #PREFIX Built-In Variable Use #PREFIX to set or obtain the current contents of the prompt prefix string. #PREFIX Result #PREFIX returns the current contents of the prompt prefix string. Considerations • • When you first log on, #PREFIX is initialized to a null value. • Use #POP #PREFIX (or POP #PREFIX) to restore the prefix string from the last copy pushed.
Built-In Functions and Variables #PROCESS Built-In Function #PROCESS Built-In Function Use #PROCESS to obtain the process name, or the CPU number and process identification number of the last process created by TACL or for which TACL last paused. This is the default process used by #ABEND, #ACTIVATEPROCESS, #ALTERPRIORITY, #PAUSE, #STOP, and #SUSPENDPROCESS.
Built-In Functions and Variables #PROCESSEXISTS Built-In Function #PROCESSEXISTS Built-In Function Use #PROCESSEXISTS to find out whether a given process exists. #PROCESSEXISTS [\node-name.]{$process-name | cpu,pin } \node-name is the name of the system on which the process resides. $process-name is the name of the process or process pair. cpu,pin is the CPU number and process identification number of the process.
Built-In Functions and Variables #PROCESSFILESECURITY Built-In Variable #PROCESSFILESECURITY Built-In Variable Use #PROCESSFILESECURITY to obtain the current file-creation security for the current TACL process. #PROCESSFILESECURITY Result #PROCESSFILESECURITY returns the current file-creation security, enclosed in quotes, for this TACL process. Considerations • When you first log on, #PROCESSFILESECURITY is initialized to your saved default security.
Built-In Functions and Variables • • #PROCESSFILESECURITY Built-In Variable Each security attribute (R, W, E, or P) can be any of these characters: O (Owner) Only the owner can access the file; the owner must be logged on to the local system. G (Group) Anyone in the owner’s group can access the file; the user must be logged on to the local system. A (Anyone) Any user can access the file; the user must be logged on to the local system.
Built-In Functions and Variables #PROCESSINFO Built-In Function #PROCESSINFO Built-In Function Use #PROCESSINFO to request information about a process. #PROCESSINFO / option [ , { option | search-option } ] ... / [ [ \node-name.] { $process-name | cpu,pin } ] option is a request option. It can be any of these: CAID returns the creator accessor ID as (group-num,user-num). CONTEXTCHANGES is the number of changes made to the DEFINE process context since process creation. The number returned is modulo 65536.
Built-In Functions and Variables #PROCESSINFO Built-In Function GUARANTEEDSWAPSPACE returns the amount of swap space reserved for use by the process in bytes. It returns nothing if the target system is running an operating system RVU earlier than D40. An error message can be returned, indicating the option is invalid. HOMETERM returns the name of the home terminal.
Built-In Functions and Variables #PROCESSINFO Built-In Function MAXMAINSTACKSIZE returns the maximum size, in bytes, to which the main stack can grow. It returns nothing if the target system is running an operating system RVU earlier than D40. An error message can be returned, indicating the option is invalid. MAXNATIVEHEAPSIZE returns the maximum size, in bytes, to which the native heap area can grow. It returns nothing if the target system is running an operating system RVU earlier than D40.
Built-In Functions and Variables #PROCESSINFO Built-In Function OSSPID returns an OSS process ID if the process is an OSS process. An OSS process ID is an integer value. If the process is not an OSS process, this option returns nothing. For software RVUs preceding the D30 RVU, this option returns nothing. PAID returns the process accessor ID as (group-num,user-num). PFR (an abbreviation for privileged-fault-ready) returns a three-digit number.
Built-In Functions and Variables #PROCESSINFO Built-In Function PROCESSSTATE returns a line of twelve space-separated values: eleven flags and a numeric value.
Built-In Functions and Variables #PROCESSINFO Built-In Function PROCESSTIME returns the central processing unit time in microseconds that the process has consumed (as opposed to elapsed run time). If the process is remote and is running on a NonStop 1+ system, it returns 0. PROCESSTYPE returns an unsigned integer value that indicates the process type. If the process is a Guardian process it returns 0. If the process is an OSS process, it returns 1.
Built-In Functions and Variables Value Meaning 2 No such process could be found. 5 The system could not be accessed. 99 The parameters were inconsistent. #PROCESSINFO Built-In Function SRLFILES returns a list of shared run-time library (SRL) file names used by the process. A maximum of 32 SRLs can be attached to a process. If the process has no associated SRLs, this option returns nothing. If the operating system RVU precedes the D40 RVU, this option returns nothing.
Built-In Functions and Variables #PROCESSINFO Built-In Function selected for storing the file. For pre-D40 software RVUs, this option returns nothing. For more information on the swap facility, see the Kernel-Managed Swap Facility (KMSF) Manual. SYSTEM returns the name of the system. UPB returns a single character (U, P, or B) that indicates whether the process is unnamed or, if named, is the primary or backup of the process pair.
#PROCESSINFO Built-In Function Built-In Functions and Variables search-option is a search option for use with one or more of the preceding options, as follows: SEARCH criterion specifies a criterion that the process must match; if you specify multiple SEARCH options, the process must match all the criteria. criterion can be any of these: CAID [ user ] specifies that the creator accessor ID must match the specified user.
Built-In Functions and Variables #PROCESSINFO Built-In Function PRI [ num ] specifies that the priority must be less than or equal to the specified num. If you omit the priority specification, #PROCESSINFO searches for a process with a priority less than that of the TACL process. PROCESSID [[\node-name.]{$process-name | cpu,pin } ] specifies that the process identification must match the specified $process-name or cpu,pin (if you omit both, the process identification must match the TACL process ID).
Built-In Functions and Variables • #PROCESSINFO Built-In Function The process ID that follows the slashes determines where TACL searches for a process: ° TACL uses a starting CPU,PIN if specified; otherwise, TACL uses the CPU and PIN of its own primary process. TACL starts searching at that CPU and PIN, then searches higher PINs in the same CPU. If no matching process is found, TACL searches higher-numbered CPUs for a matching process.
Built-In Functions and Variables #PROCESSINFO Built-In Function • If you do not specify a system in the SEARCH PROGRAMFILE option, TACL does not assume that you are referring to the current default system; instead, it assumes that the program file resides on the search system. • The recommended way to get information about a given process is as follows: #PROCESSINFO /RESULT, ... ,SEARCH PROCESSID [p]/ 0,0 (assuming the variable P contains the process ID).
Built-In Functions and Variables • #PROCESSINFO Built-In Function When retrieving multiple items of information from one call to #PROCESSINFO, some options may return nothing, depending on the software RVU. Use the #SETMANY built-in function carefully. List the potentially empty options last to avoid loss of synchronization between real values and the relative position of these values in the query structure in which they are returned.
Built-In Functions and Variables #PROCESSLAUNCH Built-In Function #PROCESSLAUNCH Built-In Function Use #PROCESSLAUNCH to start a process. If compared to #NEWPROCESS, #PROCESSLAUNCH enables the use of three additional configuration options for the process being started: • • MAXMAINSTACKSIZE, allowing the user to specify the maximum main stack size • GUARANTEEDSWAPSPACE, allowing the user to specify the amount of space that the process reserves with the Kernel-Managed Swap Facility for swapping.
Built-In Functions and Variables #PROCESSLAUNCH Built-In Function param-set is a program parameter or a series of parameters sent to the new process in the startup message. Leading and trailing spaces are deleted. Result See the #NEWPROCESS Built-In Function on page 9-266. Considerations • • See the #NEWPROCESS Built-In Function on page 9-266.
Built-In Functions and Variables #PROCESSORSTATUS Built-In Function #PROCESSORSTATUS Built-In Function Use #PROCESSORSTATUS to determine the status of all CPUs on a given system. #PROCESSORSTATUS [ \node-name ] \node-name is the name of the system for which you want the processor status. If you omit it, the local system is assumed. Result #PROCESSORSTATUS returns a space-separated list of 17 numbers. The first number indicates the highest processor number present in the system, plus one.
Built-In Functions and Variables #PROCESSORTYPE Built-In Function #PROCESSORTYPE Built-In Function Use #PROCESSORTYPE to find out the processor type of a specified CPU or of the processor in which a given process is running. PROCESSORTYPE [ / BOTH | NAME / ] { [\node-name.]$process-name } | { cpu‚pin } | { cpu-num } BOTH specifies that #PROCESSORTYPE returns both a number and the name of the processor, in text. NAME specifies that #PROCESSORTYPE returns the name of the processor, in text.
Built-In Functions and Variables • #PROCESSORTYPE Built-In Function If an error occurs, the #PROCESSORTYPE built-in function returns a numeric error code as follows: Code Meaning -1 One or more of these: You specified BOTH and the CPU does not exist. You did not specify an option and the CPU does not exist. The system cannot be reached. The process does not exist. -2 The system does not support the #PROCESSORTYPE built-in function.
Built-In Functions and Variables #PROMPT Built-In Variable #PROMPT Built-In Variable Use #PROMPT to set or obtain the current state of the prompt flag. #PROMPT Result #PROMPT returns -1 if the prompt flag is on, 0 if it is off. Considerations • • When you first log on, #PROMPT is initialized to zero. • Use #POP #PROMPT (or POP #PROMPT) to restore the prompt flag from the last copy pushed. • Use #SET #PROMPT (or SET VARIABLE #PROMPT) to set the prompt flag off or on.
Built-In Functions and Variables #PURGE Built-In Function #PURGE Built-In Function Use #PURGE to remove a file from a disk. #PURGE file-name file-name is the name of the file to be removed. Result #PURGE returns zero if it removes the file successfully; otherwise, it returns the filesystem error indicating the reason for the failure.
Built-In Functions and Variables #PUSH Built-In Function #PUSH Built-In Function Use #PUSH to create a new top-level definition for one or more variables or built-in variables. #PUSH variable [ [,] variable ] ... variable is a valid variable name or a built-in variable name. Result #PUSH returns nothing. Considerations • The PUSH command is an alias for the #PUSH built-in function and can be used interchangeably with it. • • For variables, #PUSH creates an empty top level of type TEXT.
Built-In Functions and Variables #RAISE Built-In Function #RAISE Built-In Function Use #RAISE in a routine to explicitly cause an exception. The exception must be filtered by some active routine. #RAISE exception exception can be any of these: _BREAK indicates that the BREAK key has been pressed. _ERROR indicates that an error has occurred. user_exception is any text, 1 to 31 alphanumeric characters in length, of which the first must be alphabetic. Result #RAISE returns nothing.
Built-In Functions and Variables #RENAME Built-In Function #RENAME Built-In Function Use #RENAME to change the name of an existing disk file. #RENAME old-file-name new-file-name old-file-name is the name of the disk file to be renamed. new-file-name is the new name for the file. Result #RENAME returns zero if it renames the file successfully otherwise, it returns the filesystem error that indicates the reason for the failure.
Built-In Functions and Variables #REPLY Built-In Function #REPLY Built-In Function Use #REPLY to add text to the reply if the TACL process IN file is $RECEIVE. #REPLY [ text ] text is the text to be added to the reply. Result #REPLY returns nothing. Considerations • The #REPLY function is used when TACL functions as a server. For additional information, see the #SERVER Built-In Function on page 9-341 built-in function.
Built-In Functions and Variables #REPLYPREFIX Built-In Variable #REPLYPREFIX Built-In Variable Use #REPLYPREFIX to examine the current value of the reply prefix, which can be an integer or empty. The #REPLYPREFIX function adds a prefix to a reply when TACL functions as a server. For additional information about TACL as a server and an example showing the use of #REPLYPREFIX, see the TACL Programming Guide. #REPLYPREFIX Result #REPLYPREFIX returns the current value of the reply prefix.
Built-In Functions and Variables #REPLYV Built-In Function #REPLYV Built-In Function Use #REPLYV to add a copy of the text in a string to the reply if the TACL IN file is $RECEIVE. You can also use #REPLYV to append the binary data of a STRUCT to the reply when TACL is operating as a server. #REPLYV string string is the name of an existing variable level, which can be of type STRUCT, or text enclosed in quotation marks, or a concatenation of such entities.
Built-In Functions and Variables #REQUESTER Built-In Function #REQUESTER Built-In Function Use #REQUESTER to open and close processes, devices, and structured and unstructured files and to read and write those files.
Built-In Functions and Variables #REQUESTER Built-In Function CLOSE variable-level closes the file and deletes the requester associated with variable-level. If it is a write requester, use #WAIT on write-var to ensure that all data in the write variable has been written to the file before you delete the requester. variable-level is any one of the variable levels used when #REQUESTER was invoked to open a file.
Built-In Functions and Variables #REQUESTER Built-In Function WRITE file-name error-var write-var creates a write requester and opens file-name for output. For each line added to write-var with #APPEND(V), the requester writes a record containing that line to file-name. If you include the WAIT option, TACL begins executing subsequent code, but if it encounters #APPEND(V) or #EXTRACT(V) that refers to a requester variable, it waits until the I/O operation is finished.
#REQUESTER Built-In Function Built-In Functions and Variables This action triggers a read operation. If you are reading from a file, TACL ignores the contents of prompt-var. If you are reading from a process or device, TACL sends the contents of prompt-var to the process or device as part of a WRITEREAD operation. • If you specify a WRITE requester for a nonexistent disk file, TACL creates an editformat file; if you specify a READ requester for a nonexistent file, a file-system error occurs.
Built-In Functions and Variables #REQUESTER Built-In Function • If the data to be written to an unstructured non-edit file is smaller than the maximum record length, the remaining bytes of the record are padded with trailing blanks to fill out the logical record. • When communicating with a process, be careful to coordinate functions that enable the communication (such as #REQUESTER) with the counterpart mechanisms in that process (such as IN or OUT referring to the TACL process name).
Built-In Functions and Variables #RESET Built-In Function #RESET Built-In Function Use #RESET to reset the argument pointer, frame number, reply value, and result text. #RESET option [ option ] ... option is a reset request. It can be any of these: ARGUMENTS sets the argument pointer (see #ARGUMENT Built-In Function on page 9-21) to the beginning of the routine argument list. This option is applicable only within a routine.
Built-In Functions and Variables #REST Built-In Function #REST Built-In Function Use #REST to examine the unprocessed portion of the argument set of the current routine. #REST does not process the remainder of the argument. #REST Result #REST returns the remainder of the arguments of the current routine. Considerations • • • An internal end-of-line is a binary zero and is not converted to a space.
Built-In Functions and Variables #RESULT Built-In Function #RESULT Built-In Function Use #RESULT to supply the text that is to replace the original invocation of a routine. #RESULT [ text ] text specifies the text that replaces the original invocation of the routine in which this function appears. Result #RESULT returns nothing. Considerations • • • • If your routine contains no calls to #RESULT, the routine returns nothing.
Built-In Functions and Variables #RETURN Built-In Function #RETURN Built-In Function Use #RETURN to exit immediately from a routine. #RETURN Result #RETURN returns nothing. Considerations • TACL immediately exits from the current routine as though there were no more code after #RETURN. • #RETURN does not reset #FRAMEs.
Built-In Functions and Variables #ROUTEPMSG Built-In Variable #ROUTEPMSG Built-In Variable The built-in variable #ROUTEPMSG provides the capability to suppress system and process messages. Use #ROUTEPMSG to set or obtain the current state of the #ROUTEPMSG built-in variable. #ROUTEPMSG { ALL | STANDARD | ( message-type [ message-type ] ... ) } ALL suppresses all messages selected by the #PMSG built-in variable setting from being output. STANDARD no suppression occurs.
#ROUTEPMSG Built-In Variable Built-In Functions and Variables • The output of certain message classes is determined by the #PMSG built-in variable setting. The #ROUTEPMSG built-in variable allows specified message classes to be suppressed from being output. • • When you first log on, #ROUTEPMSG is initialized to STANDARD. • Use #POP #ROUTEPMSG (or POP #ROUTEPMSG) to restore the #ROUTEPMSG built-in variable from the copy last pushed.
#ROUTEPMSG Built-In Variable Built-In Functions and Variables • #ROUTEPMSG System Normal Process Abnormal Process SYSTEM ABNORMAL No Yes No NORMAL ABNORMAL Yes No No STANDARD Yes Yes Yes This table defines how the #ROUTEPMSG setting affects message output if #PMSG is off: #ROUTEPMSG System Normal Process Abnormal Process ALL No N.A. No SYSTEM No N.A. Yes NORMAL Yes N.A. Yes ABNORMAL Yes N.A. No SYSTEM NORMAL No N.A. Yes SYSTEM ABNORMAL No N.A.
Built-In Functions and Variables #ROUTINENAME Built-In Function #ROUTINENAME Built-In Function Use #ROUTINENAME to allow a routine to obtain its own name; the routine can then use this information to invoke itself. #ROUTINENAME Result #ROUTINENAME returns the fully qualified name of the variable level holding the currently active routine.
Built-In Functions and Variables #SEGMENT Built-In Function #SEGMENT Built-In Function Use #SEGMENT to determine the name of the file TACL is using as its default segment file to hold its variables. #SEGMENT [ / USED / ] USED requests an estimate of the number of bytes currently used in your segment. Result Without the USED option, #SEGMENT returns the segment file name. If you include the USED option, #SEGMENT returns an estimate of the number of bytes currently used in your segment.
Built-In Functions and Variables #SEGMENTCONVERT Built-In Function #SEGMENTCONVERT Built-In Function #SEGMENTCONVERT converts a segment file from a C00/C10 format version to a C20 or later version, or the reverse. Segment files created under newer RVUs of TACL have a different format from those created under earlier RVUs of TACL because of character changes necessitated by the addition of the international character set with the C20 RVU.
Built-In Functions and Variables #SEGMENTCONVERT Built-In Function ° Whenever a RVU of TACL after C10 tries to attach a C00/C10 segment file, it automatically creates a temporary segment file in format version C20 or later, copies the older file to it, and attaches the temporary file instead. This typically happens every time you log on. Converting the older file to the newer format eliminates this action, as well as the disk space requirements of the temporary file.
Built-In Functions and Variables #SEGMENTINFO Built-In Function #SEGMENTINFO Built-In Function Use #SEGMENTINFO to obtain information about any of the segments being used by your TACL process. #SEGMENTINFO / option [ , option ] / [ segment-id ] option is an information request. It can be any of these: ACCESS returns the access mode of the segment, SHARED or PRIVATE. DIRECTORY returns the directory in which the segment file appears. FILENAME returns the name of the current segment file.
Built-In Functions and Variables • • #SEGMENTINFO Built-In Function For execution To point to other segments USED returns the number of bytes in use in the segment. segment-id is the segment ID at which to begin searching. If you omit it, segment zero is assumed. Result #SEGMENTINFO returns a space-separated list of the specified information in the order it was requested. Consideration To obtain the name of your default segment file, use the #SEGMENT built-in function.
Built-In Functions and Variables #SEGMENTVERSION Built-In Function #SEGMENTVERSION Built-In Function #SEGMENTVERSION returns the format (C00/C10 or C20 or later) of a segment file. #SEGMENTVERSION file-name file-name is the name of an existing TACL segment file.
Built-In Functions and Variables #SERVER Built-In Function #SERVER Built-In Function The #SERVER built-in function allows you to use your TACL process to interact with one or more other processes. This mechanism is an alternative to the use of INV and OUTV or the use of INLINE commands. Processes open your TACL process as if it were a file. Your TACL process can then read requests and respond to them. You can control processes, such as utilities, and interpret their responses.
Built-In Functions and Variables #SERVER Built-In Function KILL specifies that the indicated server is to be deleted. You must specify a servername for this option. If a server is deleted, any processes that still have the server open receive file-system error 66 (device downed) on subsequent I/O operations to the named server. name is the access name of your TACL process. This argument is optional unless you specify the KILL option.
Built-In Functions and Variables #SERVER Built-In Function #SERVER, initialize the IN variable for #SERVER to contain enough DEBUG or INSPECT commands to ensure that the program gets past the point where it reads its startup messages. • When communicating with a process, be careful to avoid race conditions. Coordinate functions that enable communication (such as #SERVER) with counterpart mechanisms in that process.
#SERVER Built-In Function Built-In Functions and Variables Table 9-12 lists commands that a TACL process using #REQUESTER and a TACL process using #SERVER can use to communicate with each other. The decision to use one-way or two-way communication depends entirely upon how the server responds to requests. Table 9-12.
Built-In Functions and Variables #SET Built-In Function #SET Built-In Function Use #SET to change the contents of a variable level or built-in variable. #SET { [/ option [‚ option ]/] variable-level [ text ] } | { built-in-variable [ built-in-text ] } option is either of these: IN file-name specifies that the named file is to be read into the variable level. If this option is present, text is not allowed. TYPE type-name specifies the type of the variable level being set.
Built-In Functions and Variables #SET Built-In Function MACRO specifies that text is a TACL macro. ROUTINE specifies that text is a TACL routine. TEXT specifies that text is simply text; that is, it has no special meaning to TACL. variable-level is the name of the existing variable level to be set. text is the text to be put into the specified variable level. built-in-variable is the name of a built-in variable. built-in-text is the new value for the built-in variable. Result #SET returns nothing.
Built-In Functions and Variables #SET Built-In Function • To distribute the members of a space-separated list into several individual variable levels, use the #SETMANY built-in function. • You cannot attach more than 50 segment files. Examples 1. This example sets a built-in variable: 32> #SET #WIDTH 132 2. The next example sets a user-defined variable level: 33> #SET vara This is it 3.
Built-In Functions and Variables #SETBYTES Built-In Function #SETBYTES Built-In Function #SETBYTES moves data between STRUCTs. Use #SETBYTES to fill one STRUCT or STRUCT item with as many copies of the data from another STRUCT or STRUCT item as can fit, without regard to the data types of the fields involved. #SETBYTES destination source destination is the STRUCT or STRUCT item to receive the copy or copies. source is the STRUCT or STRUCT item from which the data is to be copied.
Built-In Functions and Variables #SETCONFIGURATION Built-In Function #SETCONFIGURATION Built-In Function #SETCONFIGURATION sets the TACL flags that can change the behavior of TACL for the specified TACL image or that can configure the currently running TACL process. Note. These flags can be changed only by users who are authorized to alter the Command Interpreter Monitor (CMON). For additional information, see Command Interpreter Monitor Interface (CMON) on page 6-9.
Built-In Functions and Variables #SETCONFIGURATION Built-In Function CONFIGRUN [ PROCESSCREATE | PROCESSLAUNCH ] PROCESSLAUNCH a TACL RUN[D] command is configured to call the system procedure PROCESS_LAUNCH_ to start a process. In this case, these additional RUN[D] command options, MAXMAINSTACKSIZE, MAXNATIVEHEAPSIZE, and GUARANTEEDSWAPSPACE, are available. PROCESSCREATE a TACL RUN[D] command is configured to call the system procedure PROCESS_CREATE_ to start a process.
Built-In Functions and Variables #SETCONFIGURATION Built-In Function REQUESTCMONUSERCONFIG [ OFF | ON ] if set to ON, then, after every LOGON command or #CHANGEUSER built-in function is executed, the TACL process sends a request to the $CMON process for the configuration parameters in effect for this current TACL user.
#SETCONFIGURATION Built-In Function Built-In Functions and Variables Result #SETCONFIGURATION returns zero if it configures the TACL image or itself successfully; otherwise, it returns these values: -2 SETCONFIGURATION error The specified image is not a TACL image. -1 Insufficient capability error The user does not have user ID 255, 255 . >0 File system error Number returned indicates the reason for the failure.
Built-In Functions and Variables #SETCONFIGURATION Built-In Function Considerations • If TACL cannot open or read the tacl-image-file or if it is not a TACL image, an error message results. • A TACL image must be supplied for the #SETCONFIGURATION built-in function to configure the TACL. If the TACL image name is omitted, TACL will configure itself and the new configuration values are used for later operations that require these configuration values.
Built-In Functions and Variables #SETCONFIGURATION Built-In Function If your installation uses $CMON processes and you want to take advantage of the STOPONFEMODEMERR behavior, your $CMON program must be changed to specifically include the new configuration parameter. Example ?TACL MACRO #FRAME #PUSH configuration^error ==Make a duplicate TACL from the current TACL FUP DUP $SYSTEM.SYSTEM.TACL, NEWTACL ==Secure the current TACL so no other users can access it. FUP SECURE $SYSTEM.SYSTEM.
Built-In Functions and Variables #SETMANY Built-In Function #SETMANY Built-In Function Use #SETMANY to distribute the members of a space-separated list into individual variable levels. #SETMANY variable-name-list , [ text ] variable-name-list is a space-separated list of one or more existing variable levels or underscores. text is a space-separated list of items (if the entire function call is enclosed in square brackets, end-of-line characters are treated as spaces).
Built-In Functions and Variables #SETMANY Built-In Function 2. This example shows how to find the numeric portion of the current operating system RVU: #SETMANY _ number , [#TOSVERSION] #TOSVERSION returns a letter, a space, and a number; the underscore causes the letter in the #TOSVERSION result to be discarded.
Built-In Functions and Variables #SETPROCESSSTATE Built-In Function #SETPROCESSSTATE Built-In Function Use #SETPROCESSSTATE to alter the value of a process state flag in the Process Control Block (PCB) of your logged-on TACL process. The process state flags can only be set by the process owner. #SETPROCESSSTATE / option / { 0 | 1 } option is one of these: LOGGEDON specifies the logged-on state of the TACL process.
Built-In Functions and Variables #SETPROCESSSTATE Built-In Function value of 0 for the current TACL process indicates that the INHERITEDLOGON state of the local child TACL process will be 0. The new process will start in the logged-off state. The default value is 0. Remote descendent TACL processes always start in a logged-off state. You can clear the PROPAGATELOGON state flag in the current TACL process, which causes local descendent TACL processes to start in a loggedoff state and prompt for logon.
#SETPROCESSSTATE Built-In Function Built-In Functions and Variables Table 9-13.
Built-In Functions and Variables #SETSCAN Built-In Function #SETSCAN Built-In Function Use #SETSCAN to specify the position at which the next #ARGUMENT function is to resume processing arguments. #SETSCAN num num specifies the argument position. Position zero is the first character after the routine name. Result #SETSCAN returns nothing. Considerations • To obtain the number of characters that #ARGUMENT has processed, use the #GETSCAN built-in function.
Built-In Functions and Variables #SETSYSTEMCLOCK Built-In Function (SuperGroup Only) #SETSYSTEMCLOCK Built-In Function (Super-Group Only) Use #SETSYSTEMCLOCK to change the setting of the system clock. To use this function, you must have a group ID of 255. #SETSYSTEMCLOCK julian-gmt mode [ tuid ] julian-gmt is the current Julian timestamp.
Built-In Functions and Variables #SETSYSTEMCLOCK Built-In Function (SuperGroup Only) SYSTEMCLOCK_SET_ description in the Guardian Procedure Calls Reference Manual. If not, the error result is -1. Considerations • The #SETSYSTEMCLOCK built-in function calls the SETSYSTEMCLOCK system procedure. • If you use #SETSYSTEMCLOCK to set the system clock forward or backward two minutes or less, the system adjusts the clock in small increments rather than setting it to the new time.
Built-In Functions and Variables #SETV Built-In Function Use #SETV Built-In Function Use #SETV to copy a string to an existing variable level. #SETV dest-variable-level source-variable dest-variable-level is the variable level that is to receive the copy; it must already exist. Its original contents are lost. source-variable is the name of an existing variable that contains the string to be copied. sourcestring remains unchanged.
Built-In Functions and Variables #SETV Built-In Function Use Assuming that the home terminal is named $HAPPY at the time the #SET function is invoked, var then contains: My terminal is $HAPPY at this time.
Built-In Functions and Variables #SHIFTDEFAULT Built-In Variable #SHIFTDEFAULT Built-In Variable Use #SHIFTDEFAULT to set or obtain the current default shift direction for #SHIFTSTRING. #SHIFTDEFAULT Result #SHIFTDEFAULT returns DOWN, NOOP, or UP. Considerations • • When you first log on, #SHIFTDEFAULT is initialized to UP. • Use #POP #SHIFTDEFAULT (or POP #SHIFTDEFAULT) to restore the default shift setting from the last copy pushed.
#SHIFTSTRING Built-In Function Built-In Functions and Variables #SHIFTSTRING Built-In Function Use #SHIFTSTRING to change text from uppercase to lowercase and from lowercase to uppercase. #SHIFTSTRING [ / option / ] [ text ] option specifies how the text should be shifted. If you omit the option, the shift direction defaults to the current value of the #SHIFTDEFAULT built-in variable. option is one of these: DOWN specifies that the text is to be shifted to lowercase.
Built-In Functions and Variables #SHIFTSTRING Built-In Function Example This example illustrates the use of #SHIFTSTRING to shift the case of a variable level: 62> #PUSH vara 63> #SET vara this is a test 64> #OUTPUT [#SHIFTSTRING /UP/ [vara]] THIS IS A TEST HP NonStop TACL Reference Manual—429513-018 9-367
Built-In Functions and Variables #SORT Built-In Function #SORT Built-In Function Use #SORT to sort a space-separated list of text. #SORT [ / option / ] [ text ] option specifies the order in which the indicated text is to be sorted. If you omit option, ascending order is the default. If, however, there is any chance that the text may begin with a slash (/), you must include an option so that the slash in the text is not interpreted as the beginning of the option.
Built-In Functions and Variables #SORT Built-In Function 2. This example illustrates the way in which equal-valued uppercase and lowercase characters are sorted. 67> #OUTPUT [#SORT /ASCENDING/ a B b A] a A B b 3. These examples show the influence of character-processing rules.
Built-In Functions and Variables #SPIFORMATCLOSE Built-In Function #SPIFORMATCLOSE Built-In Function Use #SPIFORMATCLOSE to close an open EMS formatter template file. #SPIFORMATCLOSE Result #SPIFORMATCLOSE returns nothing. Consideration TACL opens the formatter template file associated with =_EMS_TEMPLATES automatically whenever you invoke a built-in function that uses a formatter file (such as #EMSTEXT or #EMSINIT).
Built-In Functions and Variables #SSGET Built-In Function #SSGET Built-In Function Use #SSGET to retrieve binary token values from an SPI buffer, convert them to external representation, and make that external representation accessible in the function result. You cannot use #SSGET to extract values of extensible structured tokens using a token map or using a token code of type ZSPI^TDT^STRUCT. Use #SSGETV instead. #SSGET [ / option [ , option ] ...
Built-In Functions and Variables #SSGET Built-In Function get-op is one of these: token-code directs #SSGET to return the token value or values associated with tokencode. If token-code is a token that marks the beginning of a list, #SSGET selects the list so that subsequent calls can retrieve tokens within the list. If token-code is ZSPI^TKN^ENDLIST, #SSGET pops out of the list.
Built-In Functions and Variables #SSGET Built-In Function The index parameter has no effect on this operation, but if you supply it, it must be zero. ZSPI^TKN^NEXTTOKEN directs #SSGET to return the very next token code, followed by the subsystem ID. The subsystem ID returned always has a version field of zero (null).
Built-In Functions and Variables #SSGET Built-In Function are returned in two parts-the byte length followed by the actual value-separated by a space • If you specify ZSPI^TKN^COUNT c-token-id, the total number of occurrences of the specified token, starting at the occurrence specified by index If you specify ZSPI^TKN^LEN l-token-id, the length of the token specified by the token code or token map l-token-id • If you specify ZSPI^TKN^NEXTCODE, the next token code that is different from the current tok
#SSGET Built-In Function Built-In Functions and Variables Header Tokens and Special Operation for #SSGET and #SSGETV Table 9-14 lists the header tokens used to obtain the values of various fields of the SPI message header. The index parameter you specify with these token codes must be 0 or 1. Table 9-14.
Built-In Functions and Variables #SSGETV Built-In Function #SSGETV Built-In Function Use #SSGETV to obtain binary token values from an SPI buffer and put them into a STRUCT. You can use #SSGETV with any type of token (you must use #SSGETV with tokens of type ZSPI^TYP^STRUCT and extensible structured tokens). #SSGETV [ / option [ , option ] ...
Built-In Functions and Variables #SSGETV Built-In Function result-var is the name of the writable STRUCT into which #SSGETV is to store the data returned. The original contents of the STRUCT are lost. If the status code in the function result is zero (no error), the result stored in result-var is as follows: • • If you specified token-id, the result is the value of the token. • If you specified ZSPI^TKN^LEN l-token-id, the result is an INT giving the length of the specified token.
Built-In Functions and Variables #SSGETV Built-In Function Considerations • • Tokens extracted by #SSGETV are not deleted or removed from the buffer. • When token-id is ZSPI^TKN^ENDLIST, the index and count parameters have no effect. However, if you supply them, index must be 0 or 1; count is always returned as 1. • When using #SSGETV with a token map for the token-id parameter, the map can specify a structure version that is longer or shorter than the structure contained in the buffer.
Built-In Functions and Variables #SSGETV Built-In Function UINT z^version; END; END; ?SECTION nexttoken_return STRUCT BEGIN STRUCT tkn ; LIKE zspi^ddl^tokencode; STRUCT ssid; LIKE decompose_ssid; END; ?SECTION nextcode_return STRUCT BEGIN STRUCT tkn ; LIKE zspi^ddl^tokencode; INT contiguous_occurrences; STRUCT ssid; LIKE decompose_ssid; END; 2.
Built-In Functions and Variables #SSINIT Built-In Function #SSINIT Built-In Function Use #SSINIT to initialize a STRUCT as an SPI message buffer, preparing it for use with the other #SSxxx built-in functions. #SSINIT gives the buffer an appropriate header and, optionally, adds parameter information. Use #SSINIT only to initialize a buffer for a command or a response; do not use it to initialize an event-message buffer. #SSINIT [ / TYPE 0 / ] buffer-var ssid command [ / type-0-option [ , type-0-option ] ..
#SSINIT Built-In Function Built-In Functions and Variables many response records as can fit in the buffer, each enclosed in a list. If you omit this option, it defaults to zero. OBJECT num is the object type. If you omit this option, it defaults to ZSPI^VAL^NULL^OBJECT^TYPE (zero). SERVERVERSION num is the server version number, normally provided only by subsystems or by other programs or functions that act as servers.
Built-In Functions and Variables #SSMOVE Built-In Function #SSMOVE Built-In Function Use #SSMOVE to copy tokens from one message buffer to another. #SSMOVE performs a sequence of #SSGETV and #SSPUTV operations. #SSMOVE [ / option [ , option ] ... / ] source-var dest-var token-id option can be any of these: COUNT count specifies the maximum number of token values to move, unless token-id is a list token; in that case, count specifies the maximum number of lists to move.
#SSMOVE Built-In Function Built-In Functions and Variables source-var is the name of the source message buffer variable level, from which the specified token or tokens are to be copied. source-var must be a writable STRUCT that has been initialized with #SSINIT. dest-var is the name of the destination message buffer variable level, to which the specified token or tokens are to be copied. dest-var must be a writable STRUCT that has been initialized with #SSINIT.
Built-In Functions and Variables #SSMOVE Built-In Function Considerations • • #SSMOVE does not alter any tokens copied from the source buffer. After a successful copy, #SSMOVE changes the source buffer position for a subsequent #SSGET(V) to the position of the last token moved. • When #SSMOVE copies a token identified by a token map, it truncates or pads the value according to the map specifications, and adjusts the ZSPI^TKN^MAX^FIELD^VERSION header field of the destination buffer appropriately.
Built-In Functions and Variables #SSNULL Built-In Function #SSNULL Built-In Function Use #SSNULL to initialize an extensible structured token before setting values within the structure. Note. A macro or routine must use #SSNULL before you place values in the fields of an extensible structured token, even if all currently defined fields are to be set explicitly. Using #SSNULL allows the routine to continue to work with future software RVUs.
Built-In Functions and Variables #SSPUT Built-In Function #SSPUT Built-In Function Use #SSPUT to convert token values from external representation to binary form and put them into an SPI buffer previously initialized by #SSINIT. You cannot use #SSPUT to insert values of extensible structured tokens using a token map or using a token code of type ZSPI^TDT^STRUCT. Use #SSPUTV instead. #SSPUT [ / option [ , option ] ... / ] buffer-var token-code [ token-value [ token-value ] ...
Built-In Functions and Variables #SSPUT Built-In Function token-value is the token value in external representation. Its data representation is determined by the token-type field of token-code.
#SSPUT Built-In Function Built-In Functions and Variables • Adding a token to the buffer with #SSPUT does not affect the current position for subsequent calls to #SSGET or #SSGETV. Header Tokens and Special Operations for #SSPUT and #SSPUTV Header tokens for #SSPUT and #SSPUTV include tokens to enable or disable checksum protection, specify the maximum-response value, restore the current position to an earlier value, and specify the server RVU.
Built-In Functions and Variables #SSPUT Built-In Function ZSPI^TKN^CLEARERR. Use this token code to clear the last-error information to zero. When using this token code, you must omit token-value and the COUNT option. You could use this operation before issuing a series of #SSGET(V) or #SSPUT(V) calls that are followed by a check of the last error. You need this operation only if you use #SSPUT or #SSPUTV to check the header token ZSPI^TKN^LASTERR. ZSPI^TKN^DATA^FLUSH.
Built-In Functions and Variables #SSPUT Built-In Function • It clears the last-error information to null values (equivalent to the action of ZSPI^TKN^CLEARERR). • It resets the current position to the beginning of the buffer (equivalent to the action of ZSPI^TKN^INITIAL^POSITION with ZSPI^VAL^INITIAL^BUFFER). If token-value is less than the actual number of bytes used in the buffer, as given in the header token ZSPI^TKN^USEDLEN, this operation returns an SPI error -5 (buffer full).
Built-In Functions and Variables #SSPUTV Built-In Function #SSPUTV Built-In Function Use #SSPUTV to move binary token values from a variable level into an SPI message buffer. You can use #SSPUTV with any type of token, but you must use #SSPUTV with tokens of type ZSPI^TYP^STRUCT and extensible structured tokens). #SSPUTV [ / option [ , option ]... / ] buffer-var token-id source-var option is either of these: COUNT count is the token count, an integer in the range 1 through 65535.
Built-In Functions and Variables #SSPUTV Built-In Function Result #SSPUTV returns a numeric status code indicating the outcome of the SSPUT procedure, as follows: Code Condition 0 No error -1 Invalid buffer format -2 Invalid parameter value -3 Missing parameter -4 Invalid parameter address -5 Buffer full -6 Invalid checksum -7 Internal error -8 Token not found -9 Invalid token code or map -10 Invalid subsystem ID -11 Operation not supported -12 Insufficient stack space Consider
Built-In Functions and Variables #SSPUTV Built-In Function • If you specify the COUNT option, #SSPUTV expects the value of source-var to be an array of count values of the type of token-value. Variable-length token values must be word-aligned. • Adding a token to the buffer with #SSPUTV does not affect the current position for subsequent calls to #SSGET or #SSGETV.
Built-In Functions and Variables #STOP Built-In Function #STOP Built-In Function Use #STOP to request termination of a process that you started. #STOP passes the name or CPU,PIN of the process to the STOP operating system procedure. #STOP can also pass process deletion message fields that you specify. #STOP [ / option [ , option ] ... / ] [ [\node-name.
Built-In Functions and Variables #STOP Built-In Function text is text, 1 to 80 characters, for the process deletion message. Leading and trailing spaces are suppressed. Result If you do not specify the ERROR option, the #STOP built-in function returns 0 if the STOP system procedure cannot make a successful request to stop the process. If the request is submitted successfully, #STOP returns -1.
Built-In Functions and Variables #SUSPENDPROCESS Built-In Function #SUSPENDPROCESS Built-In Function Use #SUSPENDPROCESS to suspend a process that you started. It invokes the SUSPENDPROCESS operating system procedure. #SUSPENDPROCESS [ [\node-name.]{$process-name | cpu,pin} ] \node-name is the name of the system where the process resides. $process-name is the name of the process. cpu,pin indicates the CPU number and process number for the process you want to suspend.
Built-In Functions and Variables #SWITCH Built-In Function #SWITCH Built-In Function Use #SWITCH to make your TACL backup process become the primary process and initialize itself as though you had just logged on to it. The former primary process becomes the backup. #SWITCH Considerations • Your TACL must have a backup process. To create a backup process, include a backup specification in the #NEWPROCESS call or RUN command, or use the BACKUPCPU command.
Built-In Functions and Variables #SYSTEM Built-In Function #SYSTEM Built-In Function Use #SYSTEM to change your current default node name. This function is meaningful only on systems that are in a network. #SYSTEM [ \node-name ] \node-name specifies the name of the new current default system. Result #SYSTEM returns nothing. Considerations • If you omit \node-name, your saved default system becomes your current default system.
Built-In Functions and Variables #SYSTEMNAME Built-In Function #SYSTEMNAME Built-In Function Use #SYSTEMNAME to obtain the name of a system, given its network node number. #SYSTEMNAME system-number system-number is the number of the system whose name is to be found. The system number is an integer in the range 0 to 254. Result #SYSTEMNAME returns the name of the system if the system can be reached, -2 if all paths to the system are down, or -1 if the system is not defined.
Built-In Functions and Variables #SYSTEMNUMBER Built-In Function #SYSTEMNUMBER Built-In Function Use #SYSTEMNUMBER to obtain the network node number of a system, given its name. #SYSTEMNUMBER \node-name \node-name is the name of the system whose number is to be found. Result #SYSTEMNUMBER returns the number of the system if the system can be reached, -2 if all paths to the system are down, or -1 if the system is not defined.
Built-In Functions and Variables #TACLOPERATION Built-In Function #TACLOPERATION Built-In Function Use #TACLOPERATION to determine whether TACL is reading commands from IN or $RECEIVE. #TACLOPERATION Result #TACLOPERATION returns REQUESTER or SERVER depending on whether TACL is receiving its command stream from IN (REQUESTER) or $RECEIVE (SERVER).
Built-In Functions and Variables #TACLSECURITY Built-In Variable #TACLSECURITY Built-In Variable Use #TACLSECURITY to read the current TACL security, which indicates who can open this TACL process. #TACLSECURITY Result #TACLSECURITY returns a pair of characters, enclosed in quotes, that represent the current TACL security. The first character represents the criterion that determines whether to allow a process to open the TACL process’s $RECEIVE for writing.
Built-In Functions and Variables #TACLSECURITY Built-In Variable The syntax of #SET #TACLSECURITY is: #SET #TACLSECURITY "security" "security" is a two-character security definition as described previously. You must include the quotation marks.
Built-In Functions and Variables #TACLVERSION Built-In Function #TACLVERSION Built-In Function Use #TACLVERSION to determine which RVU of TACL you are using. #TACLVERSION [ / REVISION / ] Result With the REVISION option, #TACLVERSION returns only the RVU-level portion of the version identifier, followed by a revision level identifier, in the form: Xnn nnnn where Xnn is the RVU identifier (C20, for example) and nnnn is a four-digit number identifying the revision level within that RVU.
Built-In Functions and Variables #TACLVERSION Built-In Function END; ] == Put TACL version into the structure #SET tv [#TACLVERSION] == Obtain the fields #SET %1% [tv:fld(0:4)] == T9205 Product number #SET %2% [tb:fld(5:7)] == Xnn Version == Ignore 8:10 == " - " (formatting) #SET %3% [tv:fld(11:19)] == ddMMMyyyy Date == Clean up and exit #UNFRAME ] To use this macro, define variables to hold the components of the TACL product number and invoke the macro to assign those components: 12> #PUSH product versio
Built-In Functions and Variables #TIMESTAMP Built-In Function #TIMESTAMP Built-In Function Use #TIMESTAMP to obtain a three-word timestamp from the CPU interval clock in the TACL CPU. The three-word timestamp is also known as a local timestamp and represents the number of centiseconds (.01 second) since 00:00 December 31, 1974. #TIMESTAMP Result #TIMESTAMP returns the result of the TIMESTAMP operating system procedure.
Built-In Functions and Variables #TOSVERSION Built-In Function #TOSVERSION Built-In Function Use #TOSVERSION to obtain an identifying letter and number that indicates which RVU of the operating system is running. #TOSVERSION [ \node-name ] \node-name is the name of an available system containing the operating system whose RVU is to be found. Result #TOSVERSION returns the result of the TOSVERSION operating system procedure, in the form character-space-number.
Built-In Functions and Variables #TRACE Built-In Variable #TRACE Built-In Variable Use #TRACE to set or obtain the current state of the trace flag. #TRACE Result #TRACE returns -1 (true) if the flag is on, 0 (false) if the flag is off. Considerations • • When you first log on, #TRACE is initialized to zero. • Do not use #TRACE and _DEBUGGER to trace #DELTA commands. Instead, execute #DELTA commands interactively to step through their operation.
Built-In Functions and Variables #UNFRAME Built-In Function #UNFRAME Built-In Function Use #UNFRAME to pop all variable levels pushed since the last #FRAME. #UNFRAME Result #UNFRAME returns nothing. Note. ATTACHSEG operates by pushing and defining a directory variable that refers to the specified segment file; DETACHSEG operates by popping that directory variable.
Built-In Functions and Variables #USELIST Built-In Variable #USELIST Built-In Variable Use #USELIST to manage the list of directory variables that you commonly use. If TACL cannot find a specified variable in your home directory, it searches the directories named in the use list. #USELIST Result #USELIST returns a space-separated list of full path names of the directories in your use list. Considerations • When you first log on, #USELIST is initialized to : :UTILS.1 :UTILS.1:TACL.
Built-In Functions and Variables #USERID Built-In Function #USERID Built-In Function Use #USERID to obtain the user ID (group-num, user-num) of a user, given the user name or alias, or to determine whether a specified user is defined on the system. #USERID user user is either a user name, a user ID, or an alias. Result #USERID returns the user ID of the specified user if that user is defined; otherwise, it returns nothing.
Built-In Functions and Variables #USERNAME Built-In Function #USERNAME Built-In Function Use #USERNAME to obtain the user name of a user, given the user ID (group-num, user-num) or alias, or to determine whether a specified user is defined on the system. #USERNAME user user is either a user name, a user ID, or an alias. Result #USERNAME returns the user name of the specified user if that user is defined on the system; otherwise, it returns nothing.
Built-In Functions and Variables #VARIABLEINFO Built-In Function #VARIABLEINFO Built-In Function Use #VARIABLEINFO to obtain information about a variable level. #VARIABLEINFO / option [ , option ] ... / variable-level option specifies the type of information requested; it can be any of these: DEPTH returns the total number of levels for the specified variable. DIRECTORY returns the full name of the directory that contains the specified variable.
Built-In Functions and Variables #VARIABLEINFO Built-In Function OFFSET returns the number of bytes between the beginning of the structure and the first byte of data of the specified variable level (if the specified variable level is a STRUCT item). PROCESS returns the process identification associated with the specified variable level by means of an implicit server. • • • For an unnamed process, a process ID (that is, cpu,pin) is returned. For a named process, the process name is returned.
#VARIABLEINFO Built-In Function Built-In Functions and Variables Table 9-16 lists the result for each of these options depending on the type of argument given to #VARIABLEINFO. Table 9-16.
Built-In Functions and Variables • #VARIABLEINFO Built-In Function If you are using #SETMANY to assign a number of results from #VARIABLEINFO to several variable levels, put those options that can return empty results at the end of the options to prevent losing the correlation between the two lists.
Built-In Functions and Variables #VARIABLES Built-In Function #VARIABLES Built-In Function Use #VARIABLES to obtain the names of all variables in your home directory or the fully qualified names of certain selected variable levels. #VARIABLES [ / { BREAKPOINT | IO } / ] BREAKPOINT specifies that only those variable levels for which debugging breakpoints have been set are to be listed. IO specifies that only the “I/O variables” (variable levels used by processes, requesters, and servers) are to be listed.
Built-In Functions and Variables #VARIABLESV Built-In Function #VARIABLESV Built-In Function Use #VARIABLESV to obtain the names of some or all of the variables in your home directory and to put them into a variable level, each name on a separate line. The selection criteria are the same as for #VARIABLES. #VARIABLESV [ / { BREAKPOINT | IO } / ] variable-level BREAKPOINT specifies that only those variable levels for which debugging breakpoints have been set are to be listed.
Built-In Functions and Variables #WAIT Built-In Function #WAIT Built-In Function Use #WAIT to specify the variable level(s) for which you require TACL to wait. TACL does not execute the next instruction until the variable is ready. The conditions that define ready depend on the purpose for which the variable level is used and are listed under “Considerations.” #WAIT variable-level [ variable-level ] ... variable-level is the name of a variable level for which the routine must wait.
Built-In Functions and Variables ] #WAIT Built-In Function |error^var| == Handle error^var ready condition here |read^var| == Handle read^var ready condition here |prompt^var| == Handle prompt^var ready condition here • When waiting for a prompt variable, be sure to clear the variable before initiating the read and #WAIT operations. Otherwise, the variable might be ready despite the outcome of your operation. For an example, see the TACL Programming Guide.
Built-In Functions and Variables #WAKEUP Built-In Variable #WAKEUP Built-In Variable Use #WAKEUP to set or obtain the current state of the WAKEUP flag. If the WAKEUP flag is on, #PAUSE (or PAUSE) ends when any process you started stops, instead of when the last process you started stops. #WAKEUP Result #WAKEUP returns the current state of the WAKEUP flag: -1 if the flag is on, 0 if it is off. Considerations • • When you first log on, #WAKEUP is initialized to zero.
Built-In Functions and Variables #WIDTH Built-In Variable #WIDTH Built-In Variable Use #WIDTH to set or obtain the current setting of the width register, which indicates the maximum width of lines TACL writes to its OUT file. #WIDTH Result #WIDTH returns the current setting of the width register. Considerations • • When you first log on, #WIDTH is initialized to 80. • Use #POP #WIDTH (or POP #WIDTH) to restore the width register from the last copy pushed.
Built-In Functions and Variables #XFILEINFO Built-In Function #XFILEINFO Built-In Function #XFILEINFO is the built-in function that implements the FILEINFO command. Its syntax and use are exactly the same as those of the FILEINFO command. #XFILENAMES Built-In Function #XFILENAMES is the built-in function that implements the FILENAMES command. Its syntax and use are exactly the same as those of the FILENAMES command.
A Syntax Summary The syntax diagrams summarized in this appendix are divided into five categories: • The command interpreter set of commands and functions, supplied with TACL in the directory :UTILS:TACL • The built-in functions and variables that constitute the TACL programming language • 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 •
:UTILS:TACL Commands and Functions Syntax Summary :UTILS:TACL Commands and Functions The following summarizes the syntax of the TACL command interpreter commands and functions: ACTIVATE [ [\node-name.]{$process-name | cpu,pin } ] ADD DEFINE { define-name |( define-name [, define-name ]...) } [, LIKE define-name ] [, attribute-spec ] ...} ADDDSTTRANSITION start-date-time , stop-date-time , offset ADDUSER [ / run-option [ , run-option ] ... / ] group-name.
:UTILS:TACL Commands and Functions Syntax Summary CREATE file-name [ , extent-size ] CREATESEG file-name DEBUG [ [\node-name.]{$process-name | cpu,pin } ] [ , TERM [\node-name.]$terminal-name ] _DEBUGGER current-trace-value reason-for-entry DEFAULT [ / run-option [ , run-option ] ... / ] default-names [,"default-security"] ,"default-security" DELETE DEFINE define-name-list DELUSER [ / run-option [ , run-option ] ... / ] group-name.
:UTILS:TACL Commands and Functions Syntax Summary LIGHTS [ / run-option [, run-option ] .../ ] [ ON | OFF | SMOOTH [ num ] ] [ , sys-option | , ALL ] ... [, BEAT ] LOAD [ / KEEP num / ] file-name [ file-name ] ... LOGOFF [ / option [, option ] ... / ] LOGON { group-name.user-name | group-id,user-id | alias } [ [ ,password ] | [ , old-password, new-password ] | [ , old-password, new-password, new-password ]] [ ; parameter [, parameter ] ...
:UTILS:TACL Commands and Functions Syntax Summary G-Series RECEIVEDUMP RECEIVEDUMP / OUT dump-file / cpu , fabric [ , param [ , param ] ] RELOAD [ / run-option [, run-option ] ... / ] [ [ cpu-set [; cpu-set ]... ] REMOTEPASSWORD [ \node-name [ , password ] ] RENAME old-file-name [,] new-file-name RESET DEFINE { { attribute-name [, attribute-name ]... } | * } [ RUN[D] ] program-file [ / run-option [ , run-option ]...
:UTILS:TACL Commands and Functions Syntax Summary TIME USE [ directory-name [ [,] directory-name ] ... ] USERS [ / run-option [ , run-option ] ... / ] [ range ] VARIABLES [ directory-name ] VARINFO [ variable [ [,] variable ] ... ] VARTOFILE variable-level file-name VCHANGE [ / option [ , option ] ... / ] variable-level string-1 string-2 [ range ] VCOPY [ / option [ , option ] ... / ] source-var range dest-var dest-line VDELETE [ / option [ , option ] / ...
Built-In Functions and Variables Syntax Summary Built-In Functions and Variables The following summarizes the syntax of the built-in functions and variables used for programming in TACL: #ABEND [ / option [ , option ] ... / ] [ [\node-name.]{$process-name | cpu,pin } [ text ] ] #ABORTTRANSACTION #ACTIVATEPROCESS [ [\node-name.]{$process-name | cpu,pin} ] #ADDDSTTRANSITION low-gmt high-gmt offset #ALTERPRIORITY [ [\node-name.
Built-In Functions and Variables Syntax Summary #CHARGET variable-level char-addr-1 [ FOR char-count | TO char-addr-2 ] #CHARGETV var-1 var-2 char-addr-1 [ FOR char-count | TO char-addr-2 ] #CHARINS string char-addr text #CHARINSV variable-level char-addr string #COLDLOADTACL #COMPAREV string-1 string-2 #COMPUTE expression #COMPUTEJULIANDAYNO year month day #COMPUTETIMESTAMP year month day hour min sec milli micro #COMPUTETRANSID system cpu sequence crash-count #CONTIME timestamp #CONVERTPHANDLE { / PROCE
Built-In Functions and Variables Syntax Summary #DEFINERESTORE [ / option [ , option ] ... / ] buffer #DEFINERESTOREWORK #DEFINESAVE [ / WORK / ] define-name buffer #DEFINESAVEWORK #DEFINESETATTR attribute-name [ attribute-value ] #DEFINESETLIKE define-name #DEFINEVALIDATEWORK #DELAY csecs #DELTA [ / COMMANDS variable-level / ] [ text ] #DEVICEINFO / option [ , option ] ...
Built-In Functions and Variables Syntax Summary #FILEGETLOCKINFO [ / option / ] fvname control lockdesc participants #FILEINFO / option [ , option ] ... / file-name #FILENAMES [ / option [ , option ] ... / ] [ file-name-template ] #FILTER [ exception [ exception ] ... ] #FRAME #GETCONFIGURATION / option [ , option ] ... / #GETPROCESSSTATE [ / option [ , option ] ... / ] #GETSCAN #HELPKEY #HIGHPIN #HISTORY [ / option [ , option ] ...
Built-In Functions and Variables Syntax Summary #KEEP num variable #KEYS #LINEADDR variable-level char-addr #LINEBREAK variable-level line-addr char-offset #LINECOUNT variable-level #LINEDEL variable-level line-addr-1 [ FOR line-count | TO line-addr-2 ] #LINEFIND [ / EXACT / ] variable-level line-addr text #LINEFINDR [ / EXACT / ] variable-level line-addr text #LINEFINDRV [ / EXACT / ] variable-level line-addr string #LINEFINDV [ / EXACT / ] variable-level line-addr string #LINEGET string line-addr-1 [ FO
Built-In Functions and Variables Syntax Summary #OUT #OUTFORMAT #OUTPUT [ / option [ , option ] ... / ] [ text ] #OUTPUTV [ / option [ , option ] ... / ] string #PARAM [ param-name ] #PAUSE [ [\node-name.]{$process-name | cpu,pin } ] #PMSEARCHLIST #PMSG #POP variable [ [,] variable ] ... #PREFIX #PROCESS #PROCESSEXISTS [\node-name.]{$process-name | cpu,pin } #PROCESSFILESECURITY #PROCESSINFO / option [ , option ] ... / [ [\node-name.
Built-In Functions and Variables Syntax Summary #SEGMENTCONVERT / FORMAT { a | b } / old-file-name new-file-name #SEGMENTINFO / option [ , option ] / [ segment-id ] #SEGMENTVERSION file-name #SERVER / option [ , option ] ... / [ server-name ] #SET { [ / option [, option ]/] variable-level [ text ] } | { built-in-variable [ built-in-text ] } #SETBYTES destination source #SETCONFIGURATION / option [, option ] ...
STRUCT Declarations Syntax Summary #SYSTEMNUMBER \node-name #TACLOPERATION #TACLSECURITY #TACLVERSION / REVISION / #TIMESTAMP #TOSVERSION [ \node-name ] #TRACE #UNFRAME #USELIST #USERID user #USERNAME user #VARIABLEINFO / option [ , option ] ... / variable-level #VARIABLES [ / { BREAKPOINT | IO } / ] #VARIABLESV [ / { BREAKPOINT | IO } / ] variable-level #WAIT variable-level [ variable-level ] ...
#SET Summary Syntax Summary #SET Summary The following summarizes the syntax of the #SET function when it is used to assign values to built-in variables. SET VARIABLE commands used for the same purpose have the same syntax. #SET #ASSIGN [ [ / option [ , option ] ...
#DELTA Command Summary Syntax Summary #SET #TACLSECURITY "security" #SET #TRACE num #SET #USELIST [ directory-name [ directory-name ] ... ] #SET #WAKEUP num #SET #WIDTH num #DELTA Command Summary Table A-1 summarizes the syntax of the #DELTA character processor commands. Table A-1.
#DELTA Command Summary Syntax Summary Table A-1.
#DELTA Command Summary Syntax Summary Table A-1.
B Error Messages TACL can generate several types of errors. Table 5-1 on page 5-21 lists the types of TACL errors and a sample display, description, and typical action for each type of error. The first subsection describes: • TACL Error Messages - the text and meaning of each TACL error message and warning.
TACL Error Messages Error Messages *ERROR* All block buffers in use Cause. Certain built-in functions that perform I/O, including (#)PUSH #IN, (#)PUSH #OUT, and #REQUESTER, require block buffers. There are only four available. More than four block buffers would have been needed to carry out the action you requested. Effect. The requested operation is ignored. Recovery. Perform a (#)POP #IN or #OUT or #REQUESTER /CLOSE/ operation as necessary.
TACL Error Messages Error Messages Effect. The requested operation is ignored. Recovery. Specify a different CPU, or wait until the desired processor is back in operation. *ERROR* Backup CPU may not be same as primary CPU Cause. In a (#)BACKUPCPU request, you specified that the TACL backup is to be run in the same CPU as its primary. Effect. The requested operation is ignored. Recovery. Specify a different processor as the backup CPU. *ERROR* Backup process already exists Cause.
TACL Error Messages Error Messages *ERROR* Badly formed variable name Cause. You formatted a variable name incorrectly. Effect. The requested operation is ignored. Recovery. Change the variable name to the correct format. *ERROR* BODY label not found Cause. #DEF did not contain the required |BODY| label. Effect. The requested operation is ignored. Recovery. Add the required |BODY| label to the #DEF function. #DEF requires |BODY| if the type specified is MACRO, ROUTINE, TEXT, ALIAS, or DELTA.
TACL Error Messages Error Messages *ERROR* Cannot retrieve I/O process info from a C-series node Cause. You attempted a PPD process, * operation for an I/O process on a C-series node. Effect. TACL displays the error. Recovery. Remove all attempts to retrieve I/O process information from C-series nodes.
TACL Error Messages Error Messages *ERROR* Conflicting floating point type in object files Cause. You used a floating-point format in your program that conflicts with the floating-point format in your user library object file. Effect. The operating system does not allow the creation of the process. Recovery. Resolve the conflict. *ERROR* CONVERTPROCESSTIME argument too large (>3.7 years) Cause. A call to the CONVERTPROCESSTIME operating system procedure included a request to convert more than 3.7 years.
TACL Error Messages Error Messages Recovery. Use #ERRORNUMBERS to see the subcode (nnn) that indicates the specific cause of the error: Subcode Meaning 0 Unable to convert a DEFINE name to network form. 1 Indicates that flags.<10> = 1 and flags.<11:12> <> 0 and you are trying to create a process on a remote system that is a NonStop 1+, or any other NonStop system operating under operating system RVU B20 or earlier; the use of DEFINEs is not allowed. 2 Internal context propagation error.
TACL Error Messages Error Messages Effect. The requested operation is ignored. Recovery. Delete the duplicate exception in your #FILTER. *ERROR* Duplicate keyword Cause. You specified the same keyword twice in a place where duplicate keywords are not allowed. Effect. The requested operation is ignored. Recovery. Consult the syntax description for the feature you were trying to use. Delete the unneeded keyword and reissue the request. *ERROR* Enclosure not allowed in #DEF of DIR or STRUCT Cause.
TACL Error Messages Error Messages Effect. The operation fails. Recovery. Correct the spelling to “#DEFAULTS”. *ERROR* Expecting a number or an arithmetic expression Cause. For a RUN command, the PFS value is out of range. Effect. The RUN command fails. Recovery. Specify a correct value, from 64 through 512. *ERROR* Expecting |DO| Cause. You called #LOOP with |WHILE| but did not include |DO|. Effect. The requested operation is ignored. Recovery. Rewrite the loop to include |DO| after |WHILE|.
TACL Error Messages Error Messages *ERROR* Extended data segment initialization error Cause. A file-system error occurred while you were setting up the extended data segment of a program you are trying to run. Effect. The extended data segment is not initialized. Recovery. Check that you have specified a valid volume *ERROR* Extended data segment swap file error Cause. A file-system error occurred while you were setting up the swap file of a program you are trying to run.
TACL Error Messages Error Messages *ERROR* File in use [ , File: file-name ] Cause. The specified file is already open, and shared access is not permitted. If you get this error with a process name error when creating a new process, another process is running under that name. Effect. The file is not opened for you. Recovery. Find out why the file is open, then close it if possible, or wait until the other user is finished with the file. You might be trying to open the file twice.
TACL Error Messages Error Messages Recovery. Check that you have the right file. *ERROR* File number has not been opened [ , File: file-name ] Cause. A file-system call used a file number that was not assigned to an open file. Effect. The requested operation is ignored. Recovery. Report the problem to your service provider. *ERROR* File or record already exists [ , File: file-name ] Cause. When creating or renaming a file, the name specified was already in use on the specified subvolume. Effect.
TACL Error Messages Error Messages Recovery. See the Guardian Procedure Errors and Messages Manual for corrective action for the error number indicated by nnn. *ERROR* GUARDIAN SETMYTERM failed Cause. TACL could not change its home terminal when you tried to set #MYTERM. Effect. The requested operation is ignored. Recovery. Use a terminal name acceptable to the operating system. *ERROR* Header INITSEGS not consistent with size Cause. The file was not produced by BINDER, or BINDER malfunctioned. Effect.
TACL Error Messages Error Messages *ERROR* Illegal filename specification [ , File: file-name ] Cause. A file name was specified that was not in the correct file system form. Effect. The requested operation is ignored. Recovery. See the appropriate command or function description in this manual for information about the correct file-name format. *ERROR* Illegal internal character representation Cause. Internally, TACL represents certain special characters as two bytes, the first having the value 255.
TACL Error Messages Error Messages *ERROR* Illegal process device subtype Cause. #NEWPROCESS attempted to run an object file with an illegal device subtype. The device subtype is an attribute stored in each object file. The process created from an object file is assigned the device subtype stored in that object file. Only named processes can have nonzero device subtypes.
TACL Error Messages Error Messages *ERROR* In OBEY file file-name: error-information Cause. TACL detected an error while processing an OBEY file. Effect. Depends on the error; TACL attempts to continue processing the file. Recovery. Review the error information that accompanies this error and correct the problem. If the error is a process creation error, see Process Creation Error Messages on page B-50. *ERROR* Invalid alias format Cause.
TACL Error Messages Error Messages *ERROR* I/O error writing to terminal Cause. An I/O error occurred at the home terminal. Undefined externals exist in the object file that #NEWPROCESS is attempting to run, so the procedure cannot open, or write to, the home terminal to display the undefined-externals message. Effect. No process is created. Recovery. The file-system error code can be found by the use of #ERRORNUMBERS.
TACL Error Messages Error Messages Effect. The requested operation is ignored. Recovery. Use the LIST command in BIND to determine the MAIN procedure present. The LIST command also specifies whether the MAIN attribute is set. Either remove the MAIN procedure or set the MAIN attribute to OFF by using the ALTER command in BINDER. *ERROR* Library conflict Cause. When trying to run a program, you specified a library file that was not the same as the library file used by another copy of the program.
TACL Error Messages Error Messages *ERROR* Missing close bracket Cause. You omitted a closing bracket. Effect. The requested operation is ignored. Recovery. Supply the missing bracket and reissue the request. *ERROR* Missing close quote; must be on same line as open quote Cause. You either forgot the closing quotation mark of a string or attempted to include an end-of-line delimiter in a string. Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages *ERROR* Neither case label nor OTHERWISE found Cause. The case label could not be found, and there was no OTHERWISE included in the CASE statement. Effect. The requested operation is ignored. Recovery. Check that you specified the case label correctly, or add an OTHERWISE. *ERROR* NEWPROCESS Error: nnn, nnn Cause. When you attempted to create a new process, an error occurred for which TACL has no explanatory text. Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages *ERROR* No level number or STRUCT qualification allowed Cause. You supplied a level number, or a reference to a STRUCT item or substructure, where TACL accepts only an unqualified variable name. Effect. The requested operation is ignored. Recovery. Check the variable reference to ensure that it refers to the correct entity, in the proper form. *ERROR* No main procedure Cause.
TACL Error Messages Error Messages Effect. The requested operation is ignored. Recovery. Try running the program on a different CPU, or wait until a PCB entry becomes free. *ERROR* No routine has been called Cause. You attempted to invoke one of certain built-in functions, such as #RESULT, that can be called only from within a routine, but the function call is not in a routine. Effect. The requested operation is ignored. Recovery. Include the invocation of the built-in function in a routine.
TACL Error Messages Error Messages Recovery. Check that you have correctly specified the variable type or I/O mode. *ERROR* Not correct file structure Cause. The file specified has an incorrect structure. Effect. The requested operation is ignored. Recovery. Check that you specified the correct file. If not, retry the operation with the correct file; otherwise, corrective action depends on the application. *ERROR* Not file code 100 Cause. The file specified has a code other than 100. Effect.
TACL Error Messages Error Messages *ERROR* One or more errors occurred while loading library file Cause. There was a problem with a TACL library file that you tried to load. Effect. The requested operation is ignored. Recovery. Check your library file and correct the errors. *ERROR* Option conflicts with another option Cause. You specified an option that conflicts with another option; for example, specifying IN and INV in the same RUN command or #NEWPROCESS call. Effect.
TACL Error Messages Error Messages *ERROR* PROCESS_GETINFO_ error = , error^detail = Cause. TACL received error unexpectedly from operating system procedure PROCESS_GETINFO_. Effect. For each of these errors, #ERRORNUMBERS is set: First number 1150, 1151, 1152, or 1153 Second Number Third number Fourth number 0 Recovery. Refer to the Guardian Procedure Errors and Messages Manual for a description of PROCESS_GETINFO_ errors.
TACL Error Messages Error Messages *ERROR* Program file error: text Cause. When you attempted to run a program, the program file could not be used for the reason indicated in text. Effect. The requested operation is ignored. Recovery. Check that you specified the correct program file. *ERROR* Range must be last Cause. You can specify a range only as the last item in a structure reference. Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages Recovery. Use a FILLER byte to ensure proper alignment of a STRUCT item and another item that redefines it. *ERROR* Reference out of defined bounds Cause. You attempted to refer to a structure element outside its defined range. You can get this error if you define the range of an element so that it does not contain 0,and you then refer to that element without giving a specific offset. Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages Effect. The requested operation is ignored. Recovery. Check that the RVU of BINDER in use is of the same or earlier RVU as the operating system in use. If the RVU of BINDER in use is from a later RVU than that of the operating system, it may include features that are not supported.Rebind the object file, using a RVU of BINDER that is of the same RVU as the operating system in use. For additional information, see the Binder Manual.
TACL Error Messages Error Messages *ERROR* Segment file code must be 440 Cause. You attempted to attach a segment file whose file code is not 440, the only valid file code for TACL segment files. Effect. The requested operation is ignored. Recovery. Check whether you are referring to the correct file. *ERROR* Segment is inconsistent because its last DETACHSEG failed to complete Cause. You attempted to attach a segment whose contents are inconsistent.
TACL Error Messages Error Messages *ERROR* Stack overflow Cause. TACL experienced a processor stack overflow, possibly because of a very large structure or I/O buffer. Effect. The requested operation is ignored. Recovery. Reexamine your coding to find ways in which structures or I/O buffers can be made smaller. *ERROR* STRUCT is not long enough to be nulled by given token map Cause.
TACL Error Messages Error Messages Effect. The LOGON operation is ignored. Recovery. None. (You can, however, log on to the remote system under an allowable ID, start a TACL process locally on that system, and then log on as the super ID.) *ERROR* Syntax error in lower bound Cause. You attempted to define the lower end of a range in a structure and failed to supply a number, or the number was not terminated by a colon or closing parenthesis. Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages Recovery. Decrease the size of macros or routines where possible, avoid excessive nesting of macros or routines, and structure recursive macros so that they invoke themselves in their last statements, so that each instance of the macro vanishes from the text buffer before the next one begins. Use loops to perform operations on large amounts of data a little at a time. Use options, such as LOADED in the LOAD command, or other similar means, to direct results to variables.
TACL Error Messages Error Messages • The TACL IN file is read into the text buffer until any square brackets have been balanced. • File or variable macros, when invoked, are read entirely into the text buffer; dummy arguments are substituted as they are read in. • • All other variable types, when invoked, are read entirely into the text buffer. During execution, the space available in the text buffer diminishes as routines and macros are nested.
TACL Error Messages Error Messages *ERROR* Token map contains a specification unknown to TACL Cause. You supplied a token map with a format that TACL does not understand. The token map is probably invalid, corrupted, or includes some new feature unknown to this RVU of TACL. Effect. The requested operation is ignored. Recovery. Examine the token map and repair as the situation indicates. *ERROR* Token map would overflow its STRUCT Cause.
TACL Error Messages Error Messages *ERROR* Too many PARAMs Cause. You specified more PARAMs than are allowed. Effect. The requested operation is ignored. Recovery. Your PARAM assignments must not exceed 1024 bytes of internal storage *ERROR* Too many simultaneous exceptions Cause. Too many exceptions have been filtered. Effect. The requested operation is ignored. Recovery. You are allowed a cumulative total of 32 different exceptions. *ERROR* Too many successive aliases or alias loop Cause.
TACL Error Messages Error Messages *ERROR* TRAP 1 in TACL: Instruction failure Cause. An attempt was made to execute a code word that is not an instruction, or an illegal extended address reference was made. Effect. Indeterminate. Depending on context, the trap handler either recovers or abends the TACL process. Recovery. None. Notify your service provider. *ERROR* TRAP 2 in TACL: Arithmetic overflow Cause.
TACL Error Messages Error Messages *ERROR* TRAP 11 in TACL: Memory manager disk read error Cause. An unrecoverable read error occurred while attempting to bring in a page from virtual memory. Effect. Indeterminate. Depending on context, the trap handler either recovers or abends the TACL process. Recovery. None. Notify your service provider. TRAP 12 in TACL: No memory available or swap volume full Cause.
TACL Error Messages Error Messages Recovery. Use #LOGOFF, then log on again. *ERROR* Unable to allocate map Cause. When attempting to run a program, there was not enough space in the MAPPOOL of the processor. Effect. The requested operation is ignored. Recovery. Run the program on another CPU, or wait until there is room on the chosen CPU. *ERROR* Unable to allocate space in segment: seg-file-name (HINT: You probably should #LOGOFF/SEGRELEASE/) Cause.
TACL Error Messages Error Messages *ERROR* Unable to express default volume in network form Cause. The default volume is not in the correct format for network usage. Effect. The requested operation is ignored. Recovery. For network access, device names, including names of disk volumes, can have no more than six characters (not including $). *ERROR* Unable to express a filename in network form Cause. The specified file name is not in the correct format for network usage. Effect.
TACL Error Messages Error Messages *ERROR* Unable to perform edit Cause. #DELTA was unable to perform the requested edit. Effect. The requested operation is ignored. Recovery. A prior message indicates the specific problem. *ERROR* Unknown delta command Cause. The command you entered is not a valid #DELTA command. Effect. The requested operation is ignored. Recovery. A prior message indicates the specific problem. *ERROR* Unknown function key Cause.
TACL Error Messages Error Messages Cause. The CPRULES file version is no longer supported by this RVU of TACL. Effect. The requested operation is ignored. Recovery. See your service provider to obtain a new copy of the CPRULES file in question. *ERROR* Variable does not exist Cause. You referred to a nonexistent variable. (This problem also occurs if you embed a dollar sign in a text argument that is terminated by a dollar sign.) Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages *ERROR* VT Internal error VTLAUNCH: at code location nnn Cause. There is an internal problem within the VTLAUNCH procedure at code location nnn. Effect. VTLAUNCH did not create the window or start the process. Recovery. Report this error and code location to your service provider. *ERROR* VT TELNET SCP window add failure TELNET: code Cause. TELNET returned an SCP ADD error. Effect. VTLAUNCH was unable to add a new TELNET window.
TACL Error Messages Error Messages Recovery. Refer to the Guardian Procedure Errors and Messages Manual for recovery and file system error information. *ERROR* VT Unable to communicate with emulator GUARDIAN: file system error Cause. VTLAUNCH was unable to communicate with the emulator whose file number was specified. Effect. The virtual terminal window was not created. Recovery. Refer to the Guardian Procedure Errors and Messages Manual for recovery and file system error information.
TACL Error Messages Error Messages *ERROR* VT Unable to start the newly added TELNET window TELNET: code Cause. A window process was successfully added but could not be started. Effect. The window was not created and the process was not started. Recovery. Refer to TELNET documentation for recovery details and information about the TELNET error code. *ERROR* Was not pushed Cause. You attempted to set a variable that had not been pushed. Effect. The requested operation is ignored. Recovery.
TACL Error Messages Error Messages *ERROR* You have no INLINE process Cause. You began an input line with the current INLINE prefix, or you issued an INLEOF command or #INLINEEOF invocation while no inline process exists. Effect. The requested operation is ignored. Recovery. Start a process with the INLINE option before attempting to use the INLINE feature. *ERROR* ? line not allowed here Cause. A line beginning with ? appeared in a place where such a line is not allowed. Effect.
DEFINE Error Messages Error Messages DEFINE Error Messages The following messages relate specifically to DEFINEs. Each (except the first, which is a TACL message) is associated with a numeric error code returned by the DEFINEoriented procedure invoked. If one of these operating system procedures returns an error number that TACL does not recognize, TACL simply displays: DEFINE error num See the Guardian Procedure Errors and Messages Manual for additional details about these messages.
DEFINE Error Messages Error Messages Recovery. Correct the working set, then retry the operation. See Table 8-7 on page 8-185 for consistency rules. DEFINE already exists " name" Cause. You attempted to add a DEFINE name that already exists. Effect. The operation is ignored. Recovery. Correct or change the DEFINE name, then reissue the request. DEFINE cannot be deleted " name" Cause. You attempted to delete a DEFINE that cannot be deleted: for example, the =_DEFAULTS DEFINE. Effect.
DEFINE Error Messages Error Messages DEFINE error 2073 Cause. You attempted to replace the =_DEFAULTS DEFINE with a DEFINE having the same name but a class other than DEFAULTS. Effect. The operation is ignored. Recovery. Specify the DEFINE with a DEFAULTS class, then retry the operation. DEFINE name not allowed under current defmode setting Cause. The DEFMODE setting for the process does not allow the addition of a DEFINE type. Effect. The operation is ignored. Recovery.
DEFINE Error Messages Error Messages Effect. The operation is ignored. Recovery. Correct the value, then reissue the request. Required attribute - Cannot be reset Cause. You attempted to reset a required DEFINE attribute. Effect. The operation is ignored. Recovery. None; you cannot reset a required DEFINE attribute. Required parameter is not supplied Cause. You failed to supply a required parameter. Effect. The operation is ignored. Recovery. Add the missing parameter, then reissue the request.
Process Creation Error Messages Error Messages Process Creation Error Messages If you receive a message indicating that the program file or library file has an illegal format (*ERROR* NEWPROCESS error 006, nnn), TACL follows that message with an error that describes why the file is unacceptable.
RCVDUMP Error Messages Error Messages Table B-1. #ERRORNUMBERS Results (page 2 of 2) Number Error 11 File-system error occurred on library file 12 Program file and library file specified are the same file 13 Extended data segment initialization error 14 Extended segment swap file error 15 Illegal home terminal If the second number is 3, 5, 8, 11, 13, 14, or 15, the third number contains a filesystem error number identifying the specific error condition.
RCVDUMP Error Messages for H-Series Only Error Messages Recovery. Redo the command with only one of these options. DUMP_INSUFFICIENT_PRIVILEGE Cause. Receive dump was not started by super user id. Your current id cannot perform this operation. Effect. RCVDUMP does not continue processing. Recovery. Log in as the super user. DUMP_NOT_LOCAL Cause. You cannot dump a remote system. Effect. RCVDUMP does not continue processing. Recovery. Run RCVDUMP on the remote system. DUMP_SLICE_NOT_STOPPED Cause.
RCVDUMP Error Messages for H-Series Only Error Messages Cause. Priming the CPU for an HSS dump failed. Effect. RCVDUMP does not continue processing. Recovery. Contact your HP service provider. DUMP_NO_MEMORY Cause. Couldn’t allocate memory for internal data buffers. Effect. RCVDUMP does not continue processing. Recovery. Contact your HP service provider. DUMP_COMM_FAILURE Cause. RCVDUMP couldn’t talk to the downed CPU. Effect. RCVDUMP does not continue processing. Recovery.
RCVDUMP Error Messages for H-Series, G-Series and D-Series Error Messages Cause. Online dump start failed. Effect. RCVDUMP does not continue processing. Recovery. Contact your HP service provider. DUMP_ONLINE_PROCESS_ABEND Cause. Online dump process abended. Effect. RCVDUMP does not continue processing. Recovery. Contact your HP service provider. DUMP_DUPLICATE_INVOCATION Cause. Already one instance of receive dump is running on this logical CPU. Effect. RCVDUMP does not continue processing.
RCVDUMP Error Messages for H-Series, G-Series and D-Series Error Messages Cause. You attempted to dump a processor that had not been through the reset-load sequence. Effect. No processor is dumped. Recovery. Do the reset-load and then retry the command. CPU nn IS RUNNING, CANNOT BE DUMPED. Cause. You attempted to dump a processor that is running. Effect. No processor is dumped. Recovery. Specify the number of a processor that is not running. CPU nn MAY HAVE BEEN PARTIALLY DUMPED TO file-name.
RCVDUMP Error Messages for H-Series, G-Series and D-Series Error Messages Effect. No processor is dumped. Recovery. Reenter the command specifying PRIME or NOPRIME. INVALID bus id, THE ALLOWED VALUES ARE [ X Y ]. Cause. You specified an invalid bus. Effect. No processor is dumped. Recovery. Specify a valid bus. IS NOT A DISK FILE. Cause. You attempted to dump a processor to a nondisk file. Effect. No processor is dumped. Recovery. Retry the operation specifying a disk file file-name IS NOT EMPTY. Cause.
RCVDUMP Error Messages for H-Series, G-Series and D-Series Error Messages Cause. You specified an invalid file name. Effect. No processor is dumped. Recovery. Specify a valid file name. MISSING bus id. Cause. You did not specify the bus through which to dump the processor. Effect. No processor is dumped. Recovery. Specify a bus MISSING dump-file-name. Cause. You did not specify a dump file name. Effect. No processor is dumped. Recovery. Specify a file in the command. MISSING cpu NUMBER. Cause.
RELOAD Error Messages Error Messages UNABLE TO PURGE file-name, ERROR nnnn. Cause. The specified file could not be purged because file-system error nnnn occurred Effect. No processor is dumped. Recovery. Correct the cause of the file-system error and reenter the command. UNABLE TO WRITE TO file-name, ERROR nnnn. Cause. The specified file could not be written to because file-system error nnnn occurred. Effect. No processor is dumped. Recovery.
RELOAD Error Messages for H-Series Only Error Messages usually prevent RELOAD from going any farther. A third class of messages are warnings, which don’t indicate the failure of RELOAD of any CPU, but indicate something amiss in the system. Alternate OS FileSet name should be specified as : $VOLUME.SYSnn.OSDIR or $VOLUME or SYSnn.OSDIR or OSDIR Cause. RELOAD is trying to open the alternate file specified on the command line. Effect. This is a command-line error.
Error Messages RELOAD Error Messages for H-Series Only Cause. RELOAD is trying to FILENAME_EDIT_ the alternate filename specified on the command line. Effect. This is a command-line error. RELOAD will not continue processing that CPU specification. Recovery. Make sure the alternate osdir file, its volume and its subvolume are properly specified in the command line. Unable to FILENAME_DECOMPOSE_ Cause. RELOAD is trying to FILENAME_DECOMPOSE_ the alternate filename specified on the command line.
Omitslice Information and Error Messages Error Messages Recovery. Make sure the alternate osdir file, its volume and its subvolume are properly specified in the command line. If they are, see if the file is open, unreadable or of the wrong type. Unable to open , file-system error: # Cause. RELOAD is trying to open one of the OS Fileset files and gets an error. The possible reasons include an internal error in RELOAD itself or a corrupted OS Fileset. Effect.
Error Messages RELOAD Error Messages for H-Series, G-Series and D-Series XXXXXX: alternate osimage file error code nnn. Cause. There was an error (nnn) with the alternate system-image file. Effect. What you typed (XXXXXX) is returned in uppercase along with the error. Recovery. Specify a different file or make the desired file accessible. XXXXXX: alternate osimage file is incompatible. Cause. The alternate system-image file was not compatible. Effect.
RELOAD Error Messages for H-Series, G-Series and D-Series Error Messages Cause. An attempt was made to reload the indicated CPU, but the CPU was not configured at system generation time. Effect. CPU nn is not reloaded. Recovery. Correct the CPU number and reissue the command. CPU nn reload FAILED: bad cpu number [, step # nn]. Cause. A bad CPU number was indicated.
RELOAD Error Messages for H-Series, G-Series and D-Series Error Messages CPU nn reload FAILED: bad file type [, step # nn]. Cause. A bad system-image file was indicated.
RELOAD Error Messages for H-Series, G-Series and D-Series Error Messages CPU nn reload FAILED: File system error # nnn [, step # nn]. Cause. There was a file-system error, probably with the system-image file, on the attempted reload.
RELOAD Error Messages for H-Series, G-Series and D-Series Error Messages CPU nn reload FAILED: simultaneous RELOAD attempted [, step # nn]. Cause. An attempt was made to do more than one reload at the same time.
RELOAD Error Messages for H-Series, G-Series and D-Series Error Messages XXXXXX: invalid bus. Cause. An invalid bus was indicated. Effect. The RELOAD command aborts. What you typed (XXXXXX) is returned in uppercase along with the error. Recovery. Correct and reissue the command. XXXXXX: invalid cpu. Cause. An invalid CPU was indicated. Effect. What you typed (XXXXXX) is returned in uppercase along with the error. Recovery. Correct and reissue the command. Invalid cpu list. Cause.
RELOAD Error Messages for H-Series, G-Series and D-Series Error Messages Effect. What you typed (XXXXXX) is returned in uppercase along with the error. Recovery. Correct and reissue the command. No configured and down cpus were selected. Cause. No configured and nonrunning CPUs were specified in the RELOAD command. Effect. No CPUs are reloaded. Recovery. Reissue the command, including the configured and nonrunning CPU. Operand error. Cause. The operand was unacceptable. Effect. The RELOAD command aborts.
EMS Messages Error Messages Recovery. Specify a different CPU or none. EMS Messages These Event Management Service (EMS) messages can be generated by a TACL process. 001 TACL DEVICE I/O ERROR: file-system-error, device-name file-system-error the I/O error. device-name the device name. Cause. An I/O error occurred when a TACL process attempted to communicate with a device. The message is generated only for the first occurrence of the error.
Error Numbers Error Messages Recovery. Depends on the error. Error Numbers Some TACL functions (#ERRORNUMBERS in particular) return an error number as part of their result. Table B-1 on page B-50 lists the TACL error numbers and their meanings. More complete descriptions of the errors can be found earlier in this section. Numbers lower than 1024 are issued by the file system or the sequential I/O facility (SIO) and are described elsewhere.
Error Numbers Error Messages Table B-2. Error Numbers Associated With TACL Messages (page 2 of 5) Error Number Error Text 1048 Syntax error (any “Expecting ...
Error Numbers Error Messages Table B-2.
Error Numbers Error Messages Table B-2. Error Numbers Associated With TACL Messages (page 4 of 5) Error Number Error Text 1124 Token map would overflow its STRUCT 1125 Token map contains a specification unknown to TACL 1126 STRUCT is not long enough to be nulled by given token map 1127 Any DEFINE-oriented error 1128 Missing close quote; must be on same line as open quote 1129 You have no INLINE process 1130 SUPER.
Error Numbers Error Messages Table B-2. Error Numbers Associated With TACL Messages (page 5 of 5) Error Number Error Text 1159 TACL internal buffer too small 1160 This built-in variable cannot be pushed or popped 1161 Enclosure not allowed in this context 1162 Could not open window 1163 Expecting |THEN| or |ELSE| 1164 Label may not appear more than once 1165 Refer to #SETCONFIGURATION Built-In Function on page 9-349 for a complete description of this error.
C Mapping TACL Built-In Functions to Guardian Procedures Many TACL built-in functions access Guardian procedures to provide functionality. Table C-1 lists the TACL built-in functions and specifies whether each TACL built-in function accesses a Guardian procedure, and if so, which procedure or procedures. Table C-1.
Mapping TACL Built-In Functions to Guardian Procedures Table C-1. TACL Built-In Functions and Guardian Procedures (page 2 of 7) TACL Built-In Guardian Procedure #COLDLOADTACL None #COMPAREV None #COMPUTE None #COMPUTEJULIANDAYNO COMPUTEJULIANDAYNO #COMPUTETIMESTAMP COMPUTETIMESTAMP #COMPUTETRANSID COMPUTETRANSID API #CONTIME The time is computed with conversion logic.
Mapping TACL Built-In Functions to Guardian Procedures Table C-1.
Mapping TACL Built-In Functions to Guardian Procedures Table C-1.
Mapping TACL Built-In Functions to Guardian Procedures Table C-1.
Mapping TACL Built-In Functions to Guardian Procedures Table C-1.
Mapping TACL Built-In Functions to Guardian Procedures Table C-1. TACL Built-In Functions and Guardian Procedures (page 7 of 7) TACL Built-In Guardian Procedure #VARIABLES No GPC Used. #VARIABLESV No GPC Used. #WAIT No GPC Used. #XFILEINFO FILE_GETINFOLISTBYNAME_, OLDFILENAME_TO_FILENAME_ , FILENAME_DECOMPOSE_ #XFILENAMES No GPC Used. #XFILES No GPC Used.
Glossary access mode. A file attribute that determines what operations you can perform on the file, like reading and writing. alias. An alternative name for a given function. ancestor. The process that is notified when a named process or process pair is deleted. The ancestor is usually the process that created the named process or process pair. argument. A parameter that you specify when you invoke a macro or routine. array data item.
command-interpreter monitor ($CMON). Glossary command-interpreter monitor ($CMON). A server process that monitors requests made to the TACL process and affects the way TACL responds. completion code. A value used to return information about a process to its ancestor process when the process is deleted. This value is returned in the process deletion message, system message -101. condition code. A status returned by some file-system procedure calls to indicate whether the call was successful.
device subtype. Glossary device subtype. A value that further qualifies a device type. For example, a device type of 4 indicates a magnetic tape drive; if the same device has a device subtype of 2, then the magnetic tape drive has a 3206 controller. disk volume. Also called a disk or a volume; a magnetic storage medium. Disk names consist of a dollar sign ($) followed by one to seven alphanumeric characters (network) or one to eight alphanumeric characters (local), the first of which must be alphabetic.
file lock. Glossary file lock. A mechanism that restricts access to a file by all processes except the lock owner. file. As used here, a file refers to an organized collection of data stored on a disk. In general, a file can be a disk file, a process, or a device. file name. A unique name for a file. This name is used to open a file and thereby provides a connection between the opening process and the file. File names consist of one to eight alphanumeric characters, the first of which must be alphabetic.
home terminal. Glossary home terminal. The terminal whose name is returned by a call to the MYTERM procedure, or the name returned in the hometerm parameter of the PROCESS_GETINFO_ procedure. The home terminal is often the terminal from which the process or process’s ancestor was started. interprocess communication (IPC). The exchange of messages between processes in a system or network. interrupt.
macro. Glossary macro. 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. message system. A set of operating system procedures and data structures that handles the mechanics of exchanging messages between processes. metacharacter.
one-way communication. Glossary one-way communication. A form of interprocess communication where the sender of a message (the requester) does not expect any data in the reply from the receiver of the message (the server). Contrast with two-way communication. operator. Perform mathematical or logical operations on values. page. 1,024 words of contiguous data. page mode.
process access ID (PAID). Glossary process access ID (PAID). A user ID used to determine whether a process can make requests to the system; for example, to open a file, stop another process, and so on. The process access ID is usually the same as the creator access ID, but it can be different; the owner of the corresponding object file can set the object file security such that it runs with a process access ID equal to the user ID of the file owner, rather than the creator of the process.
redefinition. Glossary redefinition. A STRUCT declaration that gives a new definition, such as a different data type or a different alignment, to an existing STRUCT or STRUCT item. All definitions are valid concurrently, allowing a STRUCT or STRUCT item to be used in a variety of ways. reply. A response to a requester process by a server process. Contrast with request. request. A message formatted and sent to a server by a requester.
startup sequence. Glossary startup sequence. A convention for sending and receiving certain messages while starting a new process. By convention, the new process receives an Open message, followed by a startup message, an assign message for each ASSIGN in effect, a param message if there are any PARAMs in effect, and then a Close message string. A type of argument that some commands and functions accept in place of a variable.
timekeeping. Glossary timekeeping. A function performed by the operating system that involves initializing and maintaining the correct time in a processor module. timestamp. An item containing a representation of the time. A timestamp can be applied to an object at a critical point, such as the last modification time of a file. transaction identifier. A four-word identifier that uniquely identifies a transaction within the Transaction Management Facility (TMF) subsystem. TMF.
virtual memory. Glossary virtual memory. A range of addresses that processes use to reference real storage, where real storage consists of physical memory and disk storage. volume. A disk drive or a pair of disk drives that forms a mirrored disk. waited I/O. An operation with an I/O device where the process waits until the operation finishes. Contrast with nowait I/O. waiting process. A process that cannot execute until an event occurs, a resource becomes available, or an interval of time passes.
Index A Access a variable 4-5 ACTIVATE command 8-8 ADD DEFINE command 8-9 Add new users 8-14 ADDDSTTRANSITION command 8-12 ADDUSER program 8-14 ALARMOFF program 8-16 ALIAS 4-6 Alias variable 4-6 Allocate a variable 4-3 ALTER DEFINE command 8-17 Alter process priority 8-20 Alter status of bus 8-32 Alter status of ServerNet fabric 8-32 ALTPRI command 8-20 Ampersand 2-6 Arithmetic operators 3-1 Array data item 4-18 ASSIGN command 8-21 Assign logical file name 8-21 ATTACHSEG command 8-26 B Background TACL proc
B Index #DEFINEADD 9-92 #DEFINEDELETE 9-93 #DEFINEDELETEALL 9-94 #DEFINEINFO 9-95 #DEFINENAMES 9-97 #DEFINENEXTNAME 9-98 #DEFINEREADATTR 9-99 #DEFINERESTORE 9-101 #DEFINERESTOREWORK 9-103 #DEFINESAVE 9-104 #DEFINESAVEWORK 9-106 #DEFINESETATTR 9-107 #DEFINESETLIKE 9-108 #DEFINEVALIDATEWORK 9-109 #DELAY 9-110 #DELTA 9-111 #DEVICEINFO 9-134 #EMPTY 9-135 #EMPTYV 9-136 #EMSADDSUBJECT 9-137 #EMSADDSUBJECTV 9-139 #EMSGET 9-141 #EMSGETV 9-146 #EMSINIT 9-150 #EMSINITV 9-152 #EMSTEXT 9-154 #EMSTEXTV 9-156 #ENDTRANS
B Index #NEWPROCESS 9-266 #NEXTFILENAME 9-269 #OPENINFO 9-270 #OUTPUT 9-277 #OUTPUTV 9-280 #PAUSE 9-285 #PROCESS 9-292 #PROCESSEXISTS 9-293 #PROCESSINFO 9-296 #PROCESSLAUNCH 9-309 #PROCESSORSTATUS 9-311 #PROCESSORTYPE 9-312 #PUSH 9-316 #RAISE 9-317 #RENAME 9-318 #REPLY 9-319 #REPLYV 9-321 #REQUESTER 9-322 #RESET 9-327 #REST 9-328 #RESULT 9-329 #RETURN 9-330 #ROUTINENAME 9-334 #SEGMENT 9-335 #SEGMENTCONVERT 9-336 #SEGMENTINFO 9-338 #SEGMENTVERSION 9-340 #SERVER 9-341 #SET 9-345 #SETBYTES 9-348 #SETCONFIGUR
C Index #EXIT 9-164 #HELPKEY 9-189 #HIGHPIN 9-190 #HOME 9-192 #IN 9-195 #INFORMAT 9-197 #INLINEECHO 9-201 #INLINEOUT 9-203 #INLINEPREFIX 9-204 #INLINEPROCESS 9-205 #INLINETO 9-207 #INPUTEOF 9-211 #INSPECT 9-214 #MYTERM 9-264 #OUT 9-273 #OUTFORMAT 9-275 #PARAM 9-283 #PMSEARCHLIST 9-287 #PMSG 9-289 #POP 9-290 #PREFIX 9-291 #PROCESSFILESECURITY 9-294 #PROMPT 9-314 #REPLYPREFIX 9-320 #ROUTEPMSG 9-331 #SHIFTDEFAULT 9-365 #TACLSECURITY 9-402 #TRACE 9-408 #USELIST 9-410 #WAKEUP 9-421 #WIDTH 9-422 Bus 8-32 BUSCMD
C Index FC 8-63 FILEINFO 8-67 FILENAMES 8-71 FILES 8-73 FILETOVAR 8-74 HELP 8-75 HISTORY 8-76 HOME 8-77 INFO DEFINE 8-78 INITTERM 8-80 INLECHO 8-81 INLEOF 8-82 INLOUT 8-83 INLPREFIX 8-84 INLTO 8-85 JOIN 8-89 KEEP 8-90 KEYS 8-91 LOAD 8-94 LOGOFF 8-97 LOGON 8-99 OBEY 8-109 OUTVAR 8-110 PARAM 8-113 PAUSE 8-116 PMSEARCH 8-118 PMSG 8-120 POP 8-122 PPD 8-126 PURGE 8-129 PUSH 8-131 Question mark (?) 8-268 RECEIVEDUMP 8-139 REMOTEPASSWORD 8-151 RENAME 8-153 RESET DEFINE 8-154 RUN 8-156 SEGINFO 8-168 SET DEFINE 8-
D Index COMMENT command 8-36 Comments 2-10 Compare strings 8-37 Completion code 5-16 Compress disk dump 8-42 COMPUTE command 8-38 Control process creation and deletion messages 8-120 Convert numeric date-time to text date 8-40 numeric date-time to text datetime 8-39 numeric date-time to text time 8-41 Copy file data to variable 8-74 Copy tape dump 8-42 Copy variable 8-43 COPYDUMP program 8-42 COPYVAR command 8-43 CPRULES0 2-1 CPRULES0 file 6-2 CPRULES1 2-1 CPRULES1 file 6-2 CREATE command 8-44 Create DEFI
E Index Delete DEFINE 8-56 DELETE DEFINE command 8-56 Delete disk file 8-129 Delete PARAM 8-33 Delete users 8-57 Delete variable level 8-90, 8-122 DELTA variable 4-30 DELUSER program 8-57 DETACHSEG command 8-58 DEVICE data type 4-15 Directives ?BLANK 5-6 ?FORMAT 5-6 ?SECTION 5-8 ?TACL 5-9 Directories 6-10 Personal 6-11 TACL 6-11 DIRECTORY accessing variables 4-29 declaring variables 4-29 TACL product :UTILS 4-30 :UTILS_GLOBALS 4-30 variables 4-28 Directory specification 8-77 Disable default debugger 8-193
H Index device name argument 5-4 filename argument 5-3 general syntax 5-1 process identifier argument 5-4 Function key definitions 8-91 Functions _COMPAREV 8-37 _CONTIME_TO_TEXT 8-39 _CONTIME_TO_TEXT_DATE 8-40 _CONTIME_TO_TEXT_TIME 8-41 _DEBUGGER 8-51 _LONGEST 8-107 _MONTH3 8-108 H HELP command 8-75 HIGHPIN range setting 8-192 HISTORY command 8-76 HOME command 8-77 I Identify a data type 4-17 INFO DEFINE command 8-78 Initialize terminal 8-80 Initiate debugging 8-48 INITTERM command 8-80 INLECHO command
P Index relational 3-1 string 3-1 types 3-1 OUTVAR command 8-110 P PARAM command 8-113 Parameter creation 8-113 PASSWORD program 8-115 PAUSE command 8-116 PHANDLE data type 4-16 PINs and TACL processes 6-3 PMSEARCH command 8-118 PMSG command 8-120 POP command 8-122 Popping variables 4-3 PPD command 8-126 Process completion code 5-16 Process completion-code display 5-20 Process creation and deletion messages 8-120 Process priority 8-20 Process (suspended) restarting 8-8 Process-pair directory 8-126 Progra
T Index Separator character 2-5 ServerNet fabric 8-32 Set breakpoint 8-30 Set date 8-197 Set defaults 8-53 Set DEFINE attribute value 8-173 SET DEFINE command 8-173 SET DEFMODE command 8-191 SET HIGHPIN command 8-192 Set HIGHPIN range 8-192 SET INSPECT command 8-193 SET SWAP command 8-196 Set TACL prompt value 8-194 Set time 8-197 SET VARIABLE command 8-199 SET _DO_NOT_PROMPT_TACL_STOP command 8-195 SETPROMPT command 8-194 SETTIME command 8-197 SHOW command 8-201 SHOW DEFINE command 8-203 SINK command 8-2
U Index TACL environment parameters display 8-60 TACL file 6-1 TACL library files 8-94 TACL output display 8-35 TACL process and PINs 6-2 initialization 6-3 logging on 6-3 new process PINs 6-6 securing 6-8 starting 6-2 starting a new process from 6-5 TACL program 8-227 TACL segment file create 8-46 information about 8-168 loading 8-26 relinquishing 8-58 TACL variables naming conflicts 6-12 overview 4-1 TACLBASE file 6-2 TACLCOLD file 6-2 TACLCSTM file 6-1 TACLINIT file 6-1 TACLLOCL file 6-1 TACLSEGF file
W Index level of 4-3 levels 4-3 MACRO 4-7 names 4-2 naming conflicts 6-12 overview 4-1 popping 4-3 pushing 4-3 ROUTINE 4-9 routine 4-9 specifying a level 4-4 STRUCT 4-12 TEXT 4-6 text 4-6 variable stack 4-3 _EXECUTE 6-13 VARIABLES command 8-237 VARINFO command 8-238 VARTOFILE command 8-240 VCHANGE command 8-241 VCOPY command 8-244 VDELETE command 8-247 VFIND command 8-249 VINSERT command 8-252 VLIST command 8-254 VMOVE command 8-256 VOLUME command 8-259 VTREE command 8-261 W WAKEUP command 8-262 WHO comm
Special Characters Index #COMPUTEJULIANDAYNO built-in function 9-72 #COMPUTETIMESTAMP built-in function 9-73 #COMPUTETRANSID built-in function 9-74 #CONTIME built-in function 9-75 #CONVERTPHANDLE built-in function 9-76 #CONVERTPROCESSTIME built-in function 9-78 #CONVERTTIMESTAMP built-in function 9-79 #CREATEFILE built-in function 9-81 #CREATEPROCESSNAME built-in function 9-83 #CREATEREMOTENAME built-in function 9-84 #DEBUGPROCESS built-in function 9-85 #DEF built-in function 9-87 #DEFAULTS built-in varia
Special Characters Index #INLINEPREFIX built-in variable 9-204 #INLINEPROCESS built-in variable 9-205 #INLINETO built-in variable 9-207 #INPUT built-in function 9-208 #INPUTEOF built-in variable 9-211 #INPUTV built-in function 9-212 #INSPECT built-in variable 9-214 #INTERACTIVE built-in function 9-216 #INTERPRETJULIANDAYNO built-in function 9-217 #INTERPRETTIMESTAMP built-in function 9-218 #INTERPRETTRANSID built-in function 9-219 #JULIANTIMESTAMP 9-217 #JULIANTIMESTAMP built-in function 9-220 #KEEP built
Special Characters Index #POP #PROCESSFILESECURITY 9-294 #POP #PROMPT 9-314 #POP #REPLYPREFIX 9-320 #POP #ROUTEPMSG 9-332 #POP #SHIFTDEFAULT 9-365 #POP #TACLSECURITY 9-402 #POP #TRACE 9-408 #POP #USELIST 9-410 #POP #WAKEUP 9-421 #POP #WIDTH 9-422 #PREFIX built-in variable 9-291 #PROCESS built-in function 9-292 #PROCESSEXISTS built-in function 9-293 #PROCESSFILESECURITY built-in variable 9-294 #PROCESSINFO built-in function 9-296 #PROCESSLAUNCH built-in function 9-309 #PROCESSORSTATUS built-in function 9-3
Special Characters Index #SET #DEFINEMODE 9-96 #SET #ERRORNUMBERS 9-160 #SET #EXIT 9-164 #SET #HELPKEY 9-189 #SET #HIGHPIN 9-190 #SET #HOME 9-192 #SET #IN 9-196 #SET #INFORMAT 9-197 #SET #INLINEECHO 9-201 #SET #INLINEOUT 9-203 #SET #INLINEPREFIX 9-204 #SET #INLINETO 9-207 #SET #INPUTEOF 9-211 #SET #INSPECT 9-214 #SET #MYTERM 9-264 #SET #OUT 9-274 #SET #OUTFORMAT 9-275 #SET #PARAM 9-283 #SET #PMSEARCHLIST 9-287 #SET #PMSG 9-289 #SET #PREFIX 9-291 #SET #PROCESSFILESECURITY 9-294 #SET #PROMPT 9-314 #SET #REP
Special Characters Index & 2-6 :UTILS 4-30 :UTILS_GLOBALS 4-30 == 2-10 ? 2-6 ? command 8-268 ?BLANK 5-6 ?FORMAT 5-6 ?SECTION 5-8 ?TACL 5-9 _COMPAREV function 8-37 _CONTIME_TO_TEXT function 8-39 _CONTIME_TO_TEXT_DATE function 8-40 _CONTIME_TO_TEXT_TIME function 8-41 _DEBUGGER function 8-51 _EXECUTE variable 6-13 _LONGEST function 8-107 _MONTH3 function 8-108 ~ 2-5 ~_ 2-5 HP NonStop TACL Reference Manual—429513-018 Index-17
