System Software Library Guardian Application Conversion Guide Abstract This guide describes how to convert a TAL, COBOL85, or Pascal application or a TACL program to use the extended features of the Tandem NonStop Kernel. It is intended for application programmers. Part Number 096047 Edition Second Published Product Version Release ID Supported Releases September 1993 Guardian D20 D20.00 This manual supports D20.00 and all subsequent releases until otherwise indicated in a new edition.
Document History Edition Part Number Product Version Earliest Supported Release Published First Second 069808 096047 Guardian 90 D10 Guardian D20 N/A D20.00 January 1993 September 1993 New editions incorporate any updates issued since the previous edition. A plus sign (+) after a release ID indicates that this manual describes function added to the base release, either by an interim product modification (IPM) or by a new product version on a .99 site update tape (SUT).
New and Changed Information The following changes have been made to the Guardian Application Conversion Guide for this edition: The name of this guide has been changed from the Guardian 90 Operating System Application Conversion Guide to the Guardian Application Conversion Guide. Section 8, “Converting Other Parts of an Application,” has been updated to include information on converting applications to use the ADDRESS_DELIMIT_ and SEGMENT_USE_ procedures. Section 9, “Converting to TNS/R Systems,” is new.
New and Changed Information iv 096047 Tandem Computers Incorporated
Contents About This Guide xvii Notation Conventions Section 1 xxiii Introduction Why a New Operating System? What Are the Differences? 1-1 1-2 More Concurrent Processes per CPU 1-3 Conversion Strategy 1-4 Converting Single-Process Applications 1-5 Converting Multiple-Process Applications 1-5 An Approach to Converting an Application 1-6 Conversion Options 1-7 Running a Process at a High PIN 1-8 Allowing a High-PIN Creator 1-8 Opening a High-PIN Process 1-8 Allowing a High-PIN Opener 1-8 Creating
Contents Section 2 Conversion Concepts (continued) New Object-File Attributes 2-18 The HIGHPIN Attribute 2-18 The HIGHREQUESTERS Attribute The RUNNAMED Attribute 2-19 2-19 Conversion Considerations and the Common Run-Time Environment (CRE) 2-19 Section 3 Converting TAL Applications Converting Basic Elements of a TAL Program 3-2 Using the EXTDECS Declarations 3-2 Using the ZSYSTAL Declarations 3-3 Declaring and Using Programming Variables 3-4 Running the TAL Compiler 3-8 Using the Binder With Converted
Contents Section 3 Converting TAL Applications (continued) Allowing a High-PIN Creator 3-38 Full Conversion or HIGHREQUESTERS? 3-38 Getting Your Creator’s Process Identifier 3-40 Converting a Startup Sequence That Does Not Use INITIALIZER Setting the HIGHREQUESTERS Attribute to Allow a High-PIN Creator 3-45 3-41 Being Opened by and Communicating With a High-PIN Requester 3-46 Converting a Server 3-46 Setting the HIGHREQUESTERS Attribute to Allow High-PIN Openers 3-54 Section 4 Converting COBOL85 Appli
Contents Section 5 Converting C Applications Recompiling Your C Program 5-2 D-Series and C-Series Object Modules 5-2 D-Series CEXTDECS Declarations 5-3 D-Series ZSYSC Declarations 5-3 Changing Memory-Model File References 5-4 Opening Temporary Files 5-4 Replacing min and max Macros 5-4 Including the Macro NULL Definition 5-4 Changing Macro Definitions 5-4 Using Type long in Bit-field Declarations 5-5 Using the New Definition for errno 5-5 Result of the sizeof Operator 5-5 Type of size_t 5-5 fflush Functio
Contents Section 5 Converting C Applications (continued) Opening and Communicating With a High-PIN Server 5-16 Setting the RUNNAMED Object-File Attribute 5-17 Communicating With a High-PIN Server 5-18 Opening a High-PIN Server 5-18 Opening a High-PIN Server for a Backup Requester Process 5-20 Sending a Request to a High-PIN Server 5-21 Closing a High-PIN Server 5-21 Closing a High-PIN Server for a Backup Requester Process 5-21 Monitoring a High-PIN Server 5-22 Opening $RECEIVE 5-22 Reading System Messages
Contents Section 6 Converting Pascal Applications (continued) Converting a Pascal Program to Run at a High PIN 6-9 Setting the HIGHPIN Object-File Attribute 6-9 Using a Library File 6-10 Declaring CPU and PIN Variables 6-10 Converting MYPID Procedure Calls 6-10 Creating a High-PIN Process 6-12 Opening and Communicating With a High-PIN Server 6-14 Setting the RUNNAMED Object-File Attribute 6-15 Communicating With a High-PIN Server 6-16 Monitoring a High-PIN Server 6-20 Being Opened by and Communicating W
Contents Section 8 Converting Other Parts of an Application (continued) Using Sequential I/O (SIO) Procedures 8-17 Using the GPLDEFS File 8-17 Allocating FCBs Using the INITIALIZER 8-18 Allocating FCBs Using Declarations 8-19 Initializing the Common FCB Using SET^FILE 8-19 Initializing a New FCB Using SET^FILE 8-19 Specifying an Opener for $RECEIVE Using the SET^FILE Procedure 8-20 Specifying System Messages Using the SET^FILE Procedure 8-20 Determining an Opener Using the CHECK^FILE Procedure 8-21 Openin
Contents Section 9 Converting to TNS/R Systems (continued) General-Case Variances 9- 3 Trap Handlers That Use the Register Stack 9- 3 Trap Handlers That Use the Program Counter 9- 3 Privileged Instructions 9- 4 Nonprivileged References to System Global Data 9- 4 Stack Wrapping 9- 5 Odd-Byte References 9- 6 Data Swap File Size 9- 7 Passing the Addresses of P-Relative Objects 9- 7 Shift Instructions With Dynamic Shift Counts 9- 7 Appendix A Guardian Procedures Appendix B System Messages Appendix C Sys
Contents Appendix D Considerations for Migrating Any Application (continued) D-Series Systems Must Be Named D-4 File Names Always Include a System Name D-4 Device Names Should Not Exceed 7 Characters D-4 DEFINEREADATTR and DEFINEINFO Return a System Name Temporary File Names Have 7 Digits D-4 D-5 System-Message Protocol for Process Pairs Includes CPU Down Message Pool Space Address Adjustment D-5 TERMPROCESS Replaced by ATP6100 D-6 Device and Subdevice Names for ATP6100 Protocol Differences D-6 Nowai
Contents Figure 4-3. Converting a COBOL85 Program to Create and Manage a HighPIN Process 4-13 Figure 4-4. Converting a COBOL85 Requester to Communicate With a High-PIN Server 4-16 Figure 4-5. Converting a COBOL85 Server to Communicate With a HighPIN Requester 4-22 Figure 5-1. Converting Basic Elements of a C Program Figure 5-2. Converting a C Program to Run at a High PIN Figure 5-3. Converting a C Program to Create a High-PIN Process Figure 5-4.
Contents Table 2-3. C-Series and D-Series Programmatic Representation of Process File Names 2-13 Table 2-4. C-Series Process IDs and D-Series Process Handles Table 2-5. D-Series File-System Errors Table 3-1. FILE_GETRECEIVEINFO_ message^info Parameter Format 3-50 Table 4-1. COBOL85 Utility Routines Table 4-2. Message-Type Keywords Table 5-1. FILE_GETRECEIVEINFO_ message_info Parameter Format 5-29 Table 6-1. FILE_GETRECEIVEINFO_ message_info Parameter Format 6-27 Table 8-1.
Contents xvi 096047 Tandem Computers Incorporated
About This Guide This guide describes how to convert a TAL, COBOL85, C, or Pascal application or a Tandem Advanced Command Language (TACL) program to use the extended features of the D-series operating system. Audience This guide is intended for an application programmer who is converting an application.
About This Guide Section 2 provides details of some concepts associated with conversion. It expands on the differences between C-series and D-series systems and provides a comparison of C-series syntax with D-series syntax. Section 3 describes how to convert a TAL application. This section also applies to a COBOL85, C, or Pascal application that calls Guardian procedures. Section 4 describes how to convert a COBOL85 application. Section 5 describes how to convert a C application.
About This Guide The Event Management Service (EMS) Manual describes EMS, which allows an application to collect, process, distribute, and generate event messages. The Tandem NonStop Kernel Event Management Programming Manual describes Tandem NonStop Kernel event messages.
About This Guide Figure 1.
About This Guide Optional Manuals The C-series Guardian Programmer’s Guide describes how to use the C-series Guardian programmatic interface. The TAL Programmer’s Guide provides TAL programming information for the less experienced programmer who will need to read this guide before using the Transaction Application Language (TAL) Reference Manual. The Common Run-Time Environment (CRE) Programmer’s Guide describes the Common Run-Time Environment for TAL, COBOL85, C, and Pascal applications.
About This Guide xxii 096047 Tandem Computers Incorporated
Notation Conventions General Syntax Notation UPPERCASE LETTERS The following list summarizes the notation conventions for syntax presentation in this manual. Uppercase letters indicate keywords and reserved words; enter these items exactly as shown. Items not enclosed in brackets are required. For example: MAXATTACH lowercase italic letters Lowercase italic letters indicate variable items that you supply. Items not enclosed in brackets are required.
Notation Conventions General Syntax Notation Ellipsis ... An ellipsis immediately following a pair of brackets or braces indicates that you can repeat the enclosed sequence of syntax items any number of times. For example: M address-1 [ , new-value ]... [ - ] {0|1|2|3|4|5|6|7|8|9}... An ellipsis immediately following a single syntax item indicates that you can repeat that syntax item any number of times. For example: "s-char...
Notation Conventions Notation for Management Programming Interfaces !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).
1 Introduction Most TAL, COBOL85, C, or Pascal applications or Tandem Advanced Command Language (TACL) programs written for the C-series operating system can run under the D-series operating system without modification. However, to take advantage of the higher limits of the D-series operating system, an application might need to be converted as described in this manual. Also, most applications written to run on TNS systems can run on TNS/R systems without modification.
Introduction What Are the Differences? I/O devices and named processes from 4,096 to 65,535 per system I/O subdevices per device from 256 to a theoretical limit of 65,535 depending on the subsystem Opens per subdevice from 16 to a theoretical limit of 65,535, again depending on the subsystem Opens per disk volume from 4,096 to 32,767 Again, these values are the architectural limits. The actual limits depend on the available resources of the system.
Introduction More Concurrent Processes per CPU Other changes To support its extended features, the D-series operating system also provides new file-system error numbers, file-system error lists, and object-file attributes. Section 2, “Conversion Concepts,” describes these differences in detail. Note There are two programmable interfaces to a D-series system: The C-series-compatible interface. You cannot make use of the extended system limits using this interface.
Introduction Conversion Strategy Figure 1-1. D-Series Operating System Environment Operating System Tandem Subsystems User Applications High-PIN Processes: PINs ≥ 256 PIN 255 is reserved.
Introduction Conversion Strategy Converting Single-Process Applications Interprocess communication and process management might need a moderate to large amount of conversion effort. Single-process applications need the least effort to convert because they communicate with few, if any, other processes. They also do not keep track of what processes open them. They do not create other processes because if they did, they would not be single-process applications.
Introduction An Approach to Converting an Application Server Processes That Care About Their Creator’s Identity Some processes check the identity of the process that creates them. Such a process might, for example, compare that process identifier with the sender of the Startup message to make sure that the sender is also the creator. Some changes might be necessary if the creator runs at a high PIN; the server needs to be able to obtain the identity of a high-PIN creator and a high-PIN opener.
Introduction Conversion Options Figure 1-2. Sample Application to Be Converted Requester Process TACL $REQ Server Process $SRV 10> RUN reqfile /NAME $REQ,.../ Sections 3 through 7 describe the conversion of TAL, COBOL85, C, Pascal, and TACL applications, respectively. Section 8, “Converting Other Parts of an Application,” describes converting parts of an application that can apply to any of these languages.
Introduction Conversion Options Running a Process at a High PIN The following table identifies the parts of this guide that tell you how to convert an application to be capable of running at a high PIN. For programs written in... See the subsection entitled... In Section...
Introduction Conversion Options Creating and Managing a High-PIN Process The following tables identify the subsections of this guide that you should refer to for help in creating and managing high-PIN processes. Separate tables are included for TAL, COBOL85, C, and Pascal. These operations do not apply to TACL programs. For TAL Programs Step... 1 2 3 4 5 6 7 You might need to convert your application to... As described in Section... Subsection entitled...
Introduction Conversion Options For C Programs Step... 1 2 3 4 You might need to convert your application to... As described in Section... Subsection entitled...
Introduction Conversion Options Converting Other Parts of an Application If you convert your application programs to use the D-series enhancements, you might have to convert other parts of the application: Terminal I/O operations; specifically those that have an interface with TACL or process the BREAK key Sequential I/O operations Direct transfers during I/O operations Memory management for extended data segments, if your process shares an extended data segment with one or more processes There are two ad
2 Conversion Concepts This section describes the major concepts involved in converting an application to make use of the D-series enhancements.
Conversion Concepts New Guardian Procedures Naming Conventions A D-series procedure name has an underscore (_) after each part, including the last part. This convention allows you to give your own procedures names that do not conflict with Tandem procedure names provided that you do not end your procedure names with an underscore. A D-series procedure name follows one of these format conventions: [module_]object_action_[CHKPT_] module_ is the module or subsystem that owns the object.
Conversion Concepts New Guardian Procedures String Parameters The D-series procedures use a variable-length string for: All kinds of file names, including disk file names, device file names, and D-series process file names. A D-series process file name parameter represents either a named or unnamed process or a named process pair. Node names. Process-descriptor parameters, which are a specific form of D-series process file name returned by Guardian procedures. Declaring String Parameters.
Conversion Concepts New Guardian Procedures Specifying the String Parameter Length. You specify the length of a string parameter depending on whether the string is being used as an input-only, output-only, or input/output parameter as described below and as shown in the hypothetical procedure calls: Input only The string parameter is followed by a colon (:) and an integer input parameter that specifies the actual length in bytes of the string.
Conversion Concepts New Guardian Procedures To set a process handle parameter to a null value, set each word to -1. An example of a TAL null process handle is: process^handle ':=' [ZSYS^VAL^PHANDLE^WLEN * [-1]]; However, when you check a process handle output parameter, you need check only the first word for a -1. If the first word of a process handle output parameter is -1, the parameter contains a -1 in each word and is a null process handle.
Conversion Concepts New File-Name Format the first parameter that the system detected as causing an error (provided the procedure returns the error-detail parameter). If more than one parameter causes an error, error-detail does not necessarily point to the lowest-numbered parameter. When determining the ordinal number, the string parameter and its length (for example, file^name:file^name^length) are treated as a single parameter.
Conversion Concepts New File-Name Format C-Series and D-Series Disk File Name Differences A D-series disk file name is similar to an external-format disk file name used on C-series systems except for the following differences: Subvolume defaulting is not allowed. A D-series permanent disk file name does not allow subvolume defaulting. For example, this disk file name is invalid on Dseries systems: $DISKVOL.MYFILE ! Volume name and file ID Temporary file names are longer.
Conversion Concepts New File-Name Format Table 2-1 shows a comparison of the programmatic representation of C-series and D-series disk file names. Table 2-1. C-Series and D-Series Programmatic Representation of Disk File Names Form C-Series Programmatic Representation D-Series Programmatic Representation Permanent disk file (without a specified node name)1 file-name [0:3] file-name [4:7] file-name [8:11] = Volume name = Subvolume name = File ID [[volume.]subvolume.
Conversion Concepts New File-Name Format A converted process on a D-series system can identify remote device names with eight characters (seven characters after the dollar sign) on other D-series systems in a network. A process on a C-series system can identify remote device names with a maximum of six letters or digits after the dollar sign on other systems. However, a process on a D-series system cannot identify a remote C-series volume name that has seven characters after the dollar sign.
Conversion Concepts New Process Identifiers New Process A process identifier identifies a process in a system or network. The D-series Identifiers operating system uses these process identifiers: Process names Process file names Process descriptors Process handles These identifiers are described in the following paragraphs. For compatibility with C-series systems, the D-series operating system also supports C-series process names, process file names, and process IDs.
Conversion Concepts New Process Identifiers Process File Names for Named Processes A D-series process file name can identify a named process. Valid examples are: \LONDON.$ZAB2:4300411433 ! Process name with node and seq num $ZSVR ! Process name only \LA.$APP2.#A001.Z1 ! Process name, node, and qualifiers The format of a D-series process file name for a named process is: [node-name.]process-name[:sequence-number][.q1[.q2]] node-name is a variable-length string specifying the node (system) name.
Conversion Concepts New Process Identifiers same sequence number. When the original primary process restarts, it too has the same sequence number. Only if both processes in the process pair stop is the process pair restarted with a new sequence number. q1 and q2 are optional file-name qualifiers. Each qualifier can have up to eight characters. The first character of q1 must be a pound sign (#). This syntax is identical to the syntax of C-series file-name qualifiers.
Conversion Concepts New Process Identifiers CPU number and PIN but with a different sequence number. An attempt to access process $:1:650:1234567890 fails, because the process no longer exists. Table 2-3 shows a comparison of the programmatic representation of C-series and D-series process file names. Table 2-3.
Conversion Concepts New Process Identifiers Process Descriptors A process descriptor is a special case of a D-series process file name. It replaces the process ID or CRTPID for returning the identity of a process from a procedure call (such as PROCESS_CREATE_). It always contains a node name and a sequence number as well as either a process name or a dollar sign and CPU/PIN designation. A process descriptor never contains a qualifier.
Conversion Concepts New Process Identifiers For example, an unnamed process terminates while running in a specific CPU. The system then creates another unnamed process in the same CPU with the same PIN. The verifier number distinguishes the new process from the old process, even though both processes have the same CPU number and PIN. A process pair index allows the system to determine the name of a named process pair (and therefore to locate the members of a named process pair).
Conversion Concepts New System Messages Null Process Handle A null process handle contains a -1 in each of its ten words. It is used for the following purposes: An application can specify a null process handle (for example, by using the PROECSSHANDLE_NULLIT_ procedure) as an input parameter in a D-series procedure such as PROCESS_GETINFO_ in order to get information about itself.
Conversion Concepts New File-System Error Numbers Improved I/O The D-series operating system improves the performance of most I/O operations by Performance transferring data directly between an application’s I/O buffers and the I/O device. A C-series I/O operation (that is, an I/O operation that uses C-series procedures) uses an intermediate buffer in the application’s process file segment (PFS) for data transfers.
Conversion Concepts New Object-File Attributes New Object-File The D-series operating system provides the following new object-file attributes: Attributes HIGHPIN Use this attribute to tell the system that the program can be run at a high PIN. HIGHREQUESTERS and RUNNAMED Use these attributes to allow communication between converted and unconverted applications . These attributes can remove the need to convert certain processes.
Conversion Concepts Conversion Considerations and the Common Run-Time Environment (CRE) The HIGHREQUESTERS Attribute The HIGHREQUESTERS attribute allows an unconverted server process to support high-PIN requesters if the server meets certain requirements; that is, if the server does not examine its openers. This attribute gives you the option of not converting the server process, but you must be sure that the server process allows you to do this.
Conversion Concepts Conversion Considerations and the Common Run-Time Environment (CRE) For programs that contain C, COBOL85, FORTRAN, and Pascal routines but do not contain TAL routines, no changes are required to run in the CRE. There are no changes in execution, except perhaps the text and format of run-time diagnostic messages in C and Pascal, which come from the CRE error-reporting routines.
3 Converting TAL Applications A TAL program can run at a low PIN under the D-series operating system without any changes. However, for a TAL program to use the extended features of the D-series operating system, specific parts of it must be converted.
Converting TAL Applications Converting Basic Elements of a TAL Program Converting Basic This subsection describes conversion that applies to all TAL programs you need to Elements of a TAL convert to run under the D-series operating system, irrespective of what the program Program does. Later subsections describe how to convert specific actions that your program might take.
Converting TAL Applications Converting Basic Elements of a TAL Program Convert your SOURCE directive to specify declarations from the D-series EXTDECS0 file. Use the procedure names for any D-series enhanced procedures your program calls: ?SOURCE $SYSTEM.SYSTEM.EXTDECS0 (FILE_OPEN_, ? READX, ? WRITEX, ? FILE_CLOSE_) Specify only the D-series EXTDECS file (EXTDECS0). The C-series compatible declarations are also available in this file.
Converting TAL Applications Converting Basic Elements of a TAL Program Declaring and Using Programming Variables When converting your program to use the D-series enhanced interface, there are several variables that you might need to add or modify.
Converting TAL Applications Converting Basic Elements of a TAL Program Using Guardian File Names Guardian file names include disk file names, device names (such as a printer or terminal name), and process file names. You might need to convert the parts of your program that declare and use file-name variables as described in the following paragraphs. The C-series-compatible interface uses file names that have an internal format, have a fixed length of 12 words, and are fully qualified.
Converting TAL Applications Converting Basic Elements of a TAL Program Device Names. Your existing program might declare a variable for a Guardian device name.
Converting TAL Applications Converting Basic Elements of a TAL Program Declaring Process Identifiers Your existing program might declare a four-word process-ID variable to identify a process: INT process^id[0:3]; Convert the process-ID variable declaration to a process-handle variable for processcontrol operations or to a process-descriptor variable for returning information from a Guardian procedure. Use a process-ID variable for compatibility with unconverted C-series procedures.
Converting TAL Applications Converting Basic Elements of a TAL Program Running the TAL Compiler When you start the TAL compiler using the TACL RUN command, TACL calls the PROCESS_CREATE_ procedure to create the TAL compiler process and the resulting BINSERV and SYMSERV processes at low PINs.
Converting TAL Applications Converting a TAL Program to Run at a High PIN Converting a TAL This subsection describes how to convert a TAL program to run at a high PIN under Program to Run at a the D-series operating system. Figure 3-2 shows a typical application. The box shows High PIN which processes this part of the conversion applies to. Converting a TAL program to run at a high PIN applies to both of these processes. Figure 3-2.
Converting TAL Applications Converting a TAL Program to Run at a High PIN Setting the HIGHPIN Object-File Attribute The HIGHPIN object-file attribute informs the system that the object file can run at a high PIN. You set the HIGHPIN object-file attribute either during compilation using a compiler directive or after compilation using the Binder program.
Converting TAL Applications Converting a TAL Program to Run at a High PIN Calling the MYPID Procedure If a high-PIN process calls MYPID, a trap condition occurs; MYPID cannot return 16 bits to an 8-bit field. Your existing program might call the MYPID procedure to obtain its CPU and PIN values: INT cpu^and^pin; ! CPU and PIN values. ... cpu^and^pin := MYPID; ! Return the CPU and PIN values.
Converting TAL Applications Converting a TAL Program to Run at a High PIN Using MYPID in a SETMODE (Function 11) Procedure Call Your existing program might also attempt to establish break ownership using a call to the MYPID procedure in a SETMODE (function 11) procedure call as shown in the following example: LITERAL set^break^owner = 11; ... CALL SETMODE (terminal^number, set^break^owner, MYPID, ! Call MYPID to set parameter-1.
Converting TAL Applications Creating and Managing a High-PIN Process Creating and This subsection describes how to convert a program to create and manage a new Managing a process using the D-series programmatic interface. The process you create must High-PIN Process already be converted to run at a high PIN as described under “Converting a TAL Program to Run at a High PIN” earlier in this section. Figure 3-3 shows the processes involved in converting this part of an application.
Converting TAL Applications Creating and Managing a High-PIN Process Creating a High-PIN Process To convert a program to create a high-PIN process, follow the steps in this subsection. The ZSYSTAL file contains LITERAL declarations that you can use with the PROCESS_CREATE_ procedure.
Converting TAL Applications Creating and Managing a High-PIN Process 5. Set create^options.<10> to 1 if you want the process to run at a high PIN irrespective of process ancestry. Set create^options.<10> to zero (the default value) if you want process ancestry to influence whether the process runs at a high PIN or a low PIN. In the following example, PROCESS_CREATE_ creates a high-PIN process in a waited manner, assuming the inherited force-low flag is not set.
Converting TAL Applications Creating and Managing a High-PIN Process 5. Set create^options.<10> to 1 if you want the process to run at a high PIN irrespective of process ancestry. Set create^options.<10> to zero (the default value) if you want process ancestry to influence whether the process runs at a high PIN or a low PIN. In this example, PROCESS_CREATE_ creates a high-PIN process in a nowait manner, assuming the inherited force-low flag is not set.
Converting TAL Applications Creating and Managing a High-PIN Process Specifying a Process Name Using PROCESS_CREATE_ Your existing program might call the CREATEPROCESSNAME or CREATEREMOTENAME procedure to obtain a process name to use in the NEWPROCESS[NOWAIT] procedure call: CALL CREATEPROCESSNAME (process^name); CALL NEWPROCESS (filenames, priority, memory^pages, processor, process^id, error, process^name); Convert your program to generate a process name in one of the following ways: Use the PROCESS_CREA
Converting TAL Applications Creating and Managing a High-PIN Process System-Generated Name Without Using PROCESSNAME_CREATE_ To have the system generate a name for a new process, follow these steps: 1. Set the name^option parameter to the LITERAL ZSYS^VAL^PCREATEOPT^NAMEDBYSYS. 2. Omit the name parameter, or set the name^length parameter to zero. 3. Set any other PROCESS_CREATE_ parameters as needed and call the procedure. 4.
Converting TAL Applications Creating and Managing a High-PIN Process User-Specified Name Alternatively, you can specify a name for the new process when calling PROCESS_CREATE_ by following these steps: 1. Set the name^option parameter to the LITERAL ZSYS^VAL^PCREATEOPT^NAMEINCALL. 2. Set the name parameter to the process name. This name must be a variable-length file-name string. 3. Set the name^length parameter to the length in bytes of the process name. 4.
Converting TAL Applications Creating and Managing a High-PIN Process System-Generated Name Using PROCESSNAME_CREATE_ Alternatively, you can let the PROCESSNAME_CREATE_ procedure create a process name which you later pass to the PROCESS_CREATE_ procedure. The following steps show how: 1. Call the PROCESSNAME_CREATE_ procedure to obtain a system-generated name and its length. 2. Set the name^option parameter of the PROCESS_CREATE_ procedure to the LITERAL ZSYS^VAL^PCREATEOPT^NAMEINCALL. 3.
Converting TAL Applications Creating and Managing a High-PIN Process Using the Process Name From PROCESS_CREATE_ After calling PROCESS_CREATE_ , you might want to save the process name (if one exists) from either the process^desc output parameter or system message -102 for later use in your program.
Converting TAL Applications Creating and Managing a High-PIN Process Use the process descriptor directly in the FILE_OPEN_ procedure call to open the process: error := PROCESS_CREATE_(program^file:pf^length, ! library^file:lf^length ! swap^file:sf^length ! ext^swapfile:esf^length ! priority ! cpu^number process^handle, error^detail, ! name^option:length process^desc:max^length, process^desc^length); ! ! ! ! ! , , , , , ! , ...
Converting TAL Applications Creating and Managing a High-PIN Process According to C-series rules, the process-deletion message is delivered to whatever process has the same name as the process that created the terminating process. For a description of these features, refer to the Guardian Procedure Calls Reference Manual. Creating a Low-PIN Process Your program might need to create a new process that must run at a low PIN.
Converting TAL Applications Creating and Managing a High-PIN Process Activating a Process Your existing program might call the ACTIVATEPROCESS procedure to return a process or process pair from the suspended state to the active state: CALL ACTIVATEPROCESS (process^id); Convert the ACTIVATEPROCESS call into a call to the PROCESS_ACTIVATE_ procedure. PROCESS_ACTIVATE_ requires a process handle rather than a process ID as an input parameter to specify the process or process pair to activate.
Converting TAL Applications Creating and Managing a High-PIN Process In the following example, PROCESS_SUSPEND_ first suspends a process identified by the process^handle parameter and then suspends both processes of a process pair where one process of the pair is identified by process^handle: error := PROCESS_SUSPEND_(process^handle); ... ! Suspend both processes of the process pair. specifier := suspend^pair; ! Set to 1. error := PROCESS_SUSPEND_(process^handle, specifier); ! Value = 1.
Converting TAL Applications Creating and Managing a High-PIN Process Stopping or Abending a Process Your existing program might call the STOP or ABEND procedure to delete a process or process pair and to send a system message to the creator process indicating that the deletion was caused by a normal (STOP) or abnormal (ABEND) condition: CALL ABEND (process^id, ! Process to abend. ! stop^backup ! , error); ... CALL STOP; ! Stop the calling process.
Converting TAL Applications Creating and Managing a High-PIN Process These examples show PROCESS_STOP_ used to stop several processes: error := PROCESS_STOP_; ! Stop the calling process. ... ! Stop the process identified by process^handle. error := PROCESS_STOP_(process^handle); ... ! Stop the brother process for the calling process. specifier := stop^brother; ! Set to 2. error := PROCESS_STOP_(! process^handle specifier); ! , ! Value = 2. ... ! Stop both processes of a process pair.
Converting TAL Applications Creating and Managing a High-PIN Process PROCESS_GETINFO_ returns a limited set of information about a specific process identified by its process handle. It also allows a process to retrieve its own process handle. PROCESS_GETINFOLIST_ returns detailed information about a specific process or about all processes within a CPU that meet a list of search criteria. This procedure also allows you to identify a process using the CPU and PIN if the process handle is not available.
Converting TAL Applications Creating and Managing a High-PIN Process home^term^attribute := ZSYS^VAL^PINF^HOMETERM; error := PROCESS_SETSTRINGINFO_ (! process^handle ! , ! specifier ! , home^term^attribute, new^home^term:new^home^term^length, old^home^term:max^length, old^home^term^length); In the following example, PROCESS_SETINFO_ sets the process file security to the value of parameter new^security for both members of a named process pair if one of the members of the pair is identified by parameter proc
Converting TAL Applications Opening and Communicating With a High-PIN Server Opening and Your existing program might be a requester that communicates with a server. For Communicating With a example, you might open a server, send it a request, and then process its reply. You High-PIN Server might also open a server for a backup requester if your program is running as a process pair.
Converting TAL Applications Opening and Communicating With a High-PIN Server An example of this directive as a compiler option is: 10> TAL /IN talsrc, ... / talobj; HIGHPIN, RUNNAMED You need to specify the RUNNAMED directive only once during a compilation. The TAL compiler ignores redundant RUNNAMED directives. If you do not set the RUNNAMED attribute when you compile your program, you can set it after compilation using Binder.
Converting TAL Applications Opening and Communicating With a High-PIN Server Opening a High-PIN Server Your requester might open the server using the OPEN procedure: INT .server^name[0:11] := ["$SRV", 10 * [" "]]; ... CALL OPEN (server^name, server^file^number, nowait^depth, sync^depth); Convert your requester to open the high-PIN server using the FILE_OPEN_ procedure.
Converting TAL Applications Opening and Communicating With a High-PIN Server If you started the server using the PROCESS_CREATE_ procedure, you can use the PROCESS_CREATE_ process-descriptor output parameter directly in the FILE_OPEN_ procedure call (shown below as the server^name parameter). Refer to “Creating and Managing a High-PIN Process” earlier in this section for details.
Converting TAL Applications Opening and Communicating With a High-PIN Server Convert your requester to open the high-PIN server for its backup process using the FILE_OPEN_CHKPT_ procedure. To identify the high-PIN server, FILE_OPEN_CHKPT_ requires the file number returned by the FILE_OPEN_ procedure call in the primary process.
Converting TAL Applications Opening and Communicating With a High-PIN Server Monitoring a High-PIN Server If your program monitors a high-PIN server, you must convert the following operations: Opening and closing $RECEIVE Reading process-deletion and status-change messages Using the CHILD_LOST_ procedure The following paragraphs describe how to convert these operations. These steps also can apply to any creator process that monitors a process that it has created.
Converting TAL Applications Opening and Communicating With a High-PIN Server Reading System Messages From $RECEIVE Your requester might read system messages from $RECEIVE using the READ[X] or READUPDATE[X] procedure: STRING .message^buffer[0:199]; ! Message buffer (200 bytes). ... read^count := 200; CALL READX (receive^file^number, message^buffer, read^count, bytes^read); The lengths shown for each system message are subject to change.
Converting TAL Applications Opening and Communicating With a High-PIN Server Reading Status-Change System Messages. Your requester might monitor a server process by reading these status-change system messages from $RECEIVE: -2 -8 CPU down: local CPU failure after process called MONITORCPUS Change in status of network node Continue to read system message -2.
Converting TAL Applications Allowing a High-PIN Creator Allowing a High-PIN This subsection describes two approaches to allowing your process to be created by a Creator high-PIN process: Convert your program to use the D-series enhanced interface when obtaining the process identifier of the creator process or when receiving the startup sequence of messages if your process does not use the INITIALIZER procedure. Set the HIGHREQUESTERS object file attribute on your program file.
Converting TAL Applications Allowing a High-PIN Creator If You Do a Full Conversion To use the D-series enhanced interface to allow your program to enable a high-PIN creator, you need to convert your program to run at a high PIN as described in “Converting a TAL Program to Run at a High PIN,” earlier in this section.
Converting TAL Applications Allowing a High-PIN Creator Getting Your Creator’s Process Identifier Your existing application might get the process ID of its creator directly using either of: The MOM procedure The LOOKUPPROCESSNAME procedure In either case, you must convert your program to use the corresponding D-series procedure call as described in the following paragraphs.
Converting TAL Applications Allowing a High-PIN Creator Convert your program to use the D-series PROCESS_GETPAIRINFO_ procedure to return the process handle instead.
Converting TAL Applications Allowing a High-PIN Creator Convert your program to open $RECEIVE for processing the startup sequence using the FILE_OPEN_ procedure: 1. Use a file-name string for the $RECEIVE file name instead of the internal file-name format. Specify the length as a separate integer value. 2. Make sure that the FILE_OPEN_ options.<15> bit is zero (the default value). If this bit is not zero, system messages such as -103 (Process open) and -104 (Process close) are not sent to $RECEIVE. 3.
Converting TAL Applications Allowing a High-PIN Creator Reading and Processing Process Open and Process Close System Messages When processing the startup sequence, your program might read the C-series -30 (Process open) and -31 (Process close) system messages from $RECEIVE. To allow a high-PIN creator process, convert your server to read the D-series -103 (Process open) and -104 (Process close) system messages.
Converting TAL Applications Allowing a High-PIN Creator Getting Information About the Process Open Message in the Startup Sequence The RECEIVEINFO and LASTRECEIVE procedures obtain information about the last message read from $RECEIVE.
Converting TAL Applications Allowing a High-PIN Creator Setting the HIGHREQUESTERS Attribute to Allow a HighPIN Creator You can set the HIGHREQUESTERS object-file attribute in your source file, or you can set it after you have finished converting your source code, either during compilation using a compiler directive or after compilation using the Binder program. The following paragraphs describe all of these alternatives.
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Being Opened by and This subsection describes how to convert a TAL server to communicate with a highCommunicating With a PIN requester. Whether you need to convert the server process depends in part on High-PIN Requester whether the server tracks its openers.
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Defining an Opener Table If your server tracks its openers, it might define an opener table that uses a process ID to identify an opener (primary process opener and backup process opener): STRUCT .
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Opening $RECEIVE Your server might open $RECEIVE using the OPEN procedure with the OPEN flags.<1> bit set to 1 (flags = %40000). This allows you to receive system messages such as -30 (Process open) and -31 (Process close): INT .receive^name[0:11] := ["$RECEIVE", 8 * [" "]]; LITERAL read^open^close^msgs = %40000 ; ...
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Reading System Messages From $RECEIVE Your existing server might read system messages from $RECEIVE using the READ[X] or READUPDATE[X] procedure using code similar to the following: STRING .message^buffer[0:199]; ! Message buffer (200 bytes). ... read^count := 200; CALL READX (receive^file^number, message^buffer, read^count, bytes^read); The lengths shown for each system message are subject to change.
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester FILE_GETRECEIVEINFO_ returns information in the 17-word message^info parameter, which has the format shown in Table 3-1. The ZSYSTAL file contains a structure that you can use for the message^info format. Table 3-1. FILE_GETRECEIVEINFO_ message^info Parameter Format Word Description 0 I/O type for the message: 0 = A system message was sent. 1 = The sender called WRITE[X]. 2 = The sender called READ[X].
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester System Message -103 (Process Open). Check the process open sysmsg[7].<15> bit (or ZSYS^DDL^SMSG^OPEN.Z^FLAGS if you use the ZSYSTAL file), which indicates whether the opener is a primary or backup process: Primary open (sysmsg[7].<15> bit = 0): Add an entry in your opener table for the process. Backup open (sysmsg[7].<15> bit = 1): Process a backup open as follows: 1.
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Replying to System Message -103 (Process Open). The D-series system supports returning a label value in the reply to a system message -103 (Process open). Typically, an openertable index gets sent in this way. This label then appears in the open^label field of future FILE_GETRECEIVEINFO_ procedure calls that provide information about messages received from the same requester.
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Using the OPENER_LOST_ Procedure to Maintain an Opener Table After receiving a status-change message, your server might call one or more routines to maintain its opener table. You might want to use the OPENER_LOST_ procedure to maintain your opener table. OPENER_LOST_ determines whether a status-change message affects your opener table and updates the appropriate table entry if an opener was lost.
Converting TAL Applications Being Opened by and Communicating With a High-PIN Requester Setting the HIGHREQUESTERS Attribute to Allow High-PIN Openers The HIGHREQUESTERS object-file attribute allows a process to support requests from high-PIN requesters. You can set the HIGHREQUESTERS attribute by including a compiler directive in your source file, or you can set it after you have finished converting your source code either, with a compiler option or after compilation using the Binder program.
4 Converting COBOL85 Applications A COBOL85 program can run at a low PIN under the D-series operating system without any changes. However, for a program to use the extended features of the D-series operating system, specific parts of it must be converted.
Converting COBOL85 Applications Converting Basic Elements of a COBOL85 Program Converting Basic Elements of a COBOL85 Program This subsection describes conversion that applies to all COBOL85 programs you need to convert to run under the D-series operating system, irrespective of what the program does. Later subsections describe how to convert specific functions of your programs, such as communicating with a high-PIN process.
Converting COBOL85 Applications Converting Basic Elements of a COBOL85 Program The ZSYSCOB file is divided into sections, which allows you to copy only the sections your program actually needs. For example, these statements copy only the process creation and system-message constant declarations: COPY PROCESS-CONSTANT OF "$SYSTEM.ZSYSDEFS.ZSYSCOB". COPY SYSTEM-MESSAGES-CONSTANT OF "$SYSTEM.ZSYSDEFS.ZSYSCOB".
Converting COBOL85 Applications Converting Basic Elements of a COBOL85 Program Declaring and Checking File-System Error Numbers A Guardian procedure can return a file-system error number in the GIVING phrase of an ENTER statement to report an error or special condition. Similarly, the COBOLFILEINFO utility routine is capable of returning a file-system error code. You might need to convert the parts of your program that declare and process file-system errors.
Converting COBOL85 Applications Converting Basic Elements of a COBOL85 Program However, a converted COBOL85 program cannot use a remote D-series file name with an eight-character volume name: In a USING or GIVING phrase in a SORT or MERGE statement For a file using fast I/O For spooler job file names Because of this extra character in the volume name, the largest D-series fully qualified disk file name is 35 characters.
Converting COBOL85 Applications Converting Basic Elements of a COBOL85 Program The ZSYSCOB file also contains declarations that you can use for declaring D-series process file name data items. Declaring Process Identifiers Your existing program might declare a process-ID data item to identify a process (for example, to represent an opener in an opener table): * Process-ID declaration. 01 PROCESS-ID. 05 PROCESS-NAME 05 CPU-PIN PIC X(6). PIC S9(5) COMPUTATIONAL.
Converting COBOL85 Applications Converting Basic Elements of a COBOL85 Program For example: * Subvolume defaulting is NOT allowed in a program running * under the D-series operating system. INPUT-OUTPUT SECTION. FILE-CONTROL. SELECT MASTER-FILE ASSIGN TO "$DATA.FY90.MASTER".
Converting COBOL85 Applications Converting a COBOL85 Program to Run at a High PIN Using the Binder With Converted Object Files You cannot bind modules that have been compiled with the D-series compiler with modules that have been compiled with a C-series compiler. If you compile any module with the D-series compiler, you must also recompile any other modules that you bind it with.
Converting COBOL85 Applications Converting a COBOL85 Program to Run at a High PIN Selecting the Common Run-Time Environment (CRE) To convert your COBOL85 program to run at a high PIN, you must select the Common Run-Time Environment (CRE) using the ENV compiler directive. To select the CRE, specify the COMMON or LIBRARY option for the ENV compiler directive. Place this directive before any source code lines in your program: ?ENV COMMON The COMMON or LIBRARY option selects the CRE for the object file.
Converting COBOL85 Applications Converting a COBOL85 Program to Run at a High PIN Setting the HIGHPIN Object-File Attribute The HIGHPIN object-file attribute directs the system to run a program at a high PIN if one is available. If a high PIN is not available, the program runs at a low PIN if one is available. You set the HIGHPIN object-file attribute either during compilation using a compiler directive or after compilation using the Binder program.
Converting COBOL85 Applications Converting a COBOL85 Program to Run at a High PIN Declaring CPU and PIN Data Items As already stated under “Declaring and Using Guardian Data Items,” earlier in this section, your existing program might declare either a two-digit data item for the CPU value and a three-digit data item for the PIN value, or a three-digit data item for just a PIN value: WORKING-STORAGE SECTION. 01 CPU-PIN-DEFINITIONS. 05 CPU PIC S9(2) COMPUTATIONAL. 05 PIN PIC S9(3) COMPUTATIONAL.
Converting COBOL85 Applications Converting a COBOL85 Program to Run at a High PIN Converting MYPID Procedure Calls Your existing program might call the MYPID Guardian procedure using the ENTER statement to obtain its CPU and PIN values: WORKING-STORAGE SECTION. 01 CPU-PIN PIC S9(5) COMPUTATIONAL. ... PROCEDURE DIVISION. ... ENTER TAL "MYPID" GIVING CPU-PIN If a high-PIN process calls MYPID, a trap condition occurs. Convert MYPID procedure calls into PROCESSHANDLE_DECOMPOSE_ procedure calls.
Converting COBOL85 Applications Creating and Managing a High-PIN Process Creating and This subsection describes how to convert a program that creates and manages a new Managing a High-PIN process. The converted program uses the D-series enhanced interface. The process Process you create must already be converted to run at a high PIN as described under “Converting a COBOL85 Program to Run at a High PIN” earlier in this section. Figure 4-3 shows the processes involved in converting a typical application.
Converting COBOL85 Applications Creating and Managing a High-PIN Process Creating a High-PIN Process If you have already converted your program to run at a high PIN as described earlier in this section under “Converting a COBOL85 Program to Run at a High PIN,” then your program will automatically create any new processes at a high PIN, assuming: The process you are creating is designed to run at a high PIN (that is, it has its HIGHPIN object-file attribute set).
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server Opening and This subsection describes how to convert a COBOL85 requester to communicate with Communicating With a and monitor a high-PIN server. For the requester, you have the following options: High-PIN Server The requester remains unconverted, but the server has the RUNNAMED objectfile attribute set.
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server An example of this directive as a compiler option is: 10> COBOL85 / ... / cobobj; ENV COMMON; HIGHPIN; RUNNAMED You need only specify the RUNNAMED directive once during a compilation. However, you can specify it any number of times and the compiler will not generate an error. If you do not set the RUNNAMED attribute when you compile your program, you can set it after compilation using Binder.
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server Opening and Communicating With a High-PIN Server To use the D-series enhanced interface for opening and communicating with a highPIN server, you simply need to recompile your COBOL85 program using the CRE. See “Selecting the Common Run-Time Environment (CRE)” earlier in this section for details on how to compile with the CRE.
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server The REPORT Clause. The REPORT clause in the RECEIVE-CONTROL paragraph specifies the specific system messages that your program reads from $RECEIVE. You might need to convert this clause to specify the D-series messages you want to read from $RECEIVE. Table 4-2 shows the REPORT clause message-type keywords and the corresponding C-series and D-series system messages that each keyword allows a program to read from $RECEIVE.
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server Table 4-2.
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server Reading Process-Deletion System Messages.
Converting COBOL85 Applications Opening and Communicating With a High-PIN Server The MESSAGE SOURCE Clause. If your existing program receives system messages, the MESSAGE SOURCE clause in the RECEIVE-CONTROL paragraph identifies the process that sent the message. The C-series MESSAGE SOURCE clause uses a process ID to identify the sender process: * C-series receive-control table. RECEIVE-CONTROL. TABLE OCCURS 1 TIMES SYNCDEPTH LIMIT IS 1 MESSAGE SOURCE IS MESSAGE-SENDER. ... 01 MESSAGE-SENDER.
Converting COBOL85 Applications Being Opened by and Communicating With a High-PIN Requester Being Opened by and This subsection describes how to convert a COBOL85 server to communicate with a Communicating With a high-PIN requester. Whether you need to convert the server process depends in part High-PIN Requester on whether the server tracks its openers.
Converting COBOL85 Applications Being Opened by and Communicating With a High-PIN Requester Converting the RECEIVE-CONTROL Paragraph The RECEIVE-CONTROL paragraph allows a program to read system messages by defining the receive-control and reply tables.
Converting COBOL85 Applications Being Opened by and Communicating With a High-PIN Requester Reading Status-Change System Messages.
Converting COBOL85 Applications Being Opened by and Communicating With a High-PIN Requester The MESSAGE SOURCE Clause. If your existing program receives system messages, the MESSAGE SOURCE clause in the RECEIVE-CONTROL paragraph identifies the process that sent the message. The C-series MESSAGE SOURCE clause uses a process ID to identify the sender process: * C-series receive-control table. RECEIVE-CONTROL. TABLE OCCURS 1 TIMES SYNCDEPTH LIMIT IS 1 MESSAGE SOURCE IS MESSAGE-SENDER. ... 01 MESSAGE-SENDER.
Converting COBOL85 Applications Being Opened by and Communicating With a High-PIN Requester Defining an Opener Table If your program is a server that tracks its openers, you might define an opener table using a process ID to identify an opener: * C-series opener table. 01 OPENER-TABLE. 03 OPENERS OCCURS 15 TIMES. 05 CURRENT-COUNT PIC 999 COMPUTATIONAL. 05 PRIMARY-OPENER. 07 PROCESS-NAME PIC X(6). 07 CPU-PIN PIC S9(5). 05 BACKUP-OPENER. 07 PROCESS-NAME PIC X(6). 07 CPU-PIN PIC S9(5).
Converting COBOL85 Applications Being Opened by and Communicating With a High-PIN Requester Setting the HIGHREQUESTERS Attribute to Allow High-PIN Openers The HIGHREQUESTERS object-file attribute allows a process to support requests from high-PIN requesters. Use this attribute only for a COBOL85 main program.
5 Converting C Applications A C program can run at a low PIN on a D-series operating system without any changes. However, for a C program to use the extended features of the D-series operating system, specific parts of it must be converted.
Converting C Applications Recompiling Your C Program Recompiling Your C Some elements of a C-series C program must be changed if you recompile the program Program on a D-series system.
Converting C Applications Recompiling Your C Program D-Series CEXTDECS Declarations The $SYSTEM.SYSTEM.CEXTDECS file contains external declarations for Guardian procedures. Some C-series Guardian procedures have been replaced by new D-series procedures. The D-series CEXTDECS file contains declarations for both the C-series version and D-series version of these procedures. Convert your #include compiler directive to specify D-series declarations instead of C-series declarations.
Converting C Applications Recompiling Your C Program Changing Memory-Model File References Opening Temporary Files If your program uses a SEARCH compiler pragma to specify a memory-model file (to search when resolving external references), you must change the name of the memory-model file as follows: C-Series pragma Format (Superseded) D-Series pragma Format #pragma SEARCH smallc #pragma SEARCH largec #pragma SEARCH widec #pragma SEARCH csmall #pragma SEARCH clarge #pragma SEARCH cwide Temporary file
Converting C Applications Recompiling Your C Program Using Type long in Bit-field Declarations Programs should only use the type int in bit-field declarations. ANSI C only supports type int for bit field declarations. However, the D-series compiler continues to support bit field declarations of type short for large-memory model and type long for widedata model.
Converting C Applications Program Elements Affected by D-Series System Enhancements sscanf Function Changing Keywords Replacing Obsolete TAL Function Declarations The sscanf function returns a value that is the number of items scanned and converted. On C-series systems, the sscanf function returns a -1 if no conversion takes place. On D-series systems, the sscanf function returns a 0 if no conversion takes place. You must change your programs if they rely on sscanf returning a -1.
Converting C Applications Program Elements Affected by D-Series System Enhancements Declaring CPU and PIN Variables Declare all PIN values, including backup-process PIN values, as short variables. Declare all CPU values as a separate short variables. For example: Declaring and Checking File-System Error Numbers C-Series Declarations (Superseded) D-Series Declarations short cpu_pin; char pin; short cpu, pin; A D-series file-system error number can be a maximum of 16 bits.
Converting C Applications Program Elements Affected by D-Series System Enhancements Therefore, you might need to declare your network file-name variables large enough to include this extra character and the terminating null character. To ensure that your declaration is long enough, use the ZSYS_VAL_LEN_FILENAME constant from the ZSYSC file and add one for the null character. For example: char employee[ZSYS_VAL_LEN_FILENAME + 1] = "\\newyork.$payroll.july1990.
Converting C Applications Program Elements Affected by D-Series System Enhancements Declaring Process Identifiers Your existing program might declare a process-ID variable to identify a process (for example, an opener in an opener table): short process_id[4]; Convert the process-ID variable declaration to a process-handle variable for processcontrol operations or to a process-descriptor variable for returning information from a Guardian procedure.
Converting C Applications Making the C Compiler Run as a High PIN Process For examples of Guardian procedure calls, refer to Section 3, “Converting TAL Applications.” If you are converting a C program, you must convert the TAL procedure calls shown in Section 3 to C. The Common Run-Time Environment (CRE) Programmer’s Guide provides information about converting TAL procedure calls to C.
Converting C Applications Converting a C Program to Run at a High PIN Converting a This subsection describes how to convert your C program to run at a high PIN under C Program to Run the D-series operating system. Figure 5-2 shows a typical application. The box shows at a High PIN which processes this part of the conversion applies to. Converting a C program to run at a high PIN applies to both of these processes. Figure 5-2.
Converting C Applications Converting a C Program to Run at a High PIN Setting the HIGHPIN Object-File Attribute The HIGHPIN object-file attribute directs the system to run a program at a high PIN if one is available. If a high PIN is not available, the program runs at a low PIN if one is available. You set the HIGHPIN object-file attribute either during compilation using a compiler pragma or after compilation using the Binder program.
Converting C Applications Converting a C Program to Run at a High PIN Converting MYPID Procedure Calls Your existing program might call the MYPID procedure to obtain its CPU and PIN values: short cpu_pin; ... cpu_pin = MYPID(); If a high-PIN process calls MYPID, a trap condition occurs. You must convert all MYPID calls into calls to the PROCESSHANDLE_DECOMPOSE_ procedure. The PROCESSHANDLE_DECOMPOSE_ procedure requires a process handle as an input parameter.
Converting C Applications Creating a High-PIN Process Creating a High-PIN You can create a high-PIN process programmatically or interactively. This subsection Process describes how to programmatically create a high-PIN process. For information on how to interactively create a high-PIN process using TACL, see Section 7, “Converting TACL Programs.” Figure 5-3 shows the processes involved in converting a typical application.
Converting C Applications Creating a High-PIN Process NEWPROCESS (program_file, priority, memory_pages, cpu, process_id, &err_return, process_name, home_terminal, /* flags */ 0, /* job_id */ , error_info); On a D-series system, the NEWPROCESS[NOWAIT] procedure can create only a low-PIN process. The D-series operating system provides the PROCESS_CREATE_ procedure to create a new low-PIN or high-PIN process in a waited or nowait manner. The following procedure creates a new process in a waited manner.
Converting C Applications Opening and Communicating With a High-PIN Server Opening and Your existing program might be a requester that communicates with a server. For Communicating With a example, you might open a server, send it a request, and then process its reply. You High-PIN Server might also open a server for a backup requester if your program is running as a process pair.
Converting C Applications Opening and Communicating With a High-PIN Server Setting the RUNNAMED Object-File Attribute The RUNNAMED object-file attribute causes a process to run as a named process even if you do not provide a name for it. Thus, a process can run at a high PIN under the D-series operating system and be opened by an unconverted process using the Guardian OPEN procedure.
Converting C Applications Opening and Communicating With a High-PIN Server Communicating With a High-PIN Server A requester can open and communicate with a high-PIN named server by opening the server using the OPEN procedure.
Converting C Applications Opening and Communicating With a High-PIN Server Note If the file-name input parameter is incomplete (that is, not fully qualified), FILE_OPEN_ uses the current settings, including the system name, in the =_DEFAULTS DEFINE for the unspecified parts. FILE_OPEN_ also accepts a DEFINE name that represents a valid file name in this format. FILE_OPEN_ accepts an integer options parameter to specify certain file characteristics.
Converting C Applications Opening and Communicating With a High-PIN Server Opening a High-PIN Server for a Backup Requester Process If your requester is running as a process pair, it might open the server for its backup process using the CHECKOPEN procedure: c_code = CHECKOPEN (server_name, server_file_number, nowait_depth, sync_depth, /* seq_block_buffer */ , /* buffer_length */ , back_error); Figure 5-5 shows a requester process pair and a server process. Figure 5-5.
Converting C Applications Opening and Communicating With a High-PIN Server Sending a Request to a High-PIN Server Your requester might send a request to a high-PIN server using the WRITE[X] or WRITEREAD[X] procedure: c_code = WRITEREADX (server_file_number, sbuffer, write_count, read_count, count_read); Your WRITE[X] or WRITEREAD[X] procedure call should not require any changes to send a request to a high-PIN server.
Converting C Applications Opening and Communicating With a High-PIN Server Monitoring a High-PIN Server If your program monitors a high-PIN server, you must convert the following operations: Opening and closing $RECEIVE Reading process-deletion and status-change messages Using the CHILD_LOST_ procedure The following paragraphs describe how to convert these operations. These steps also can apply to any creator process that monitors a process that it has created.
Converting C Applications Opening and Communicating With a High-PIN Server Reading System Messages From $RECEIVE Your requester might read system messages from $RECEIVE using the READ[X] or READUPDATE[X] procedure: char message_buffer[200]; /* Message buffer (200 bytes) */ ... read_count = 200; c_code = READX (receive_file_number, message_buffer, read_count, bytes_read); The lengths shown for each system message are subject to change.
Converting C Applications Opening and Communicating With a High-PIN Server Reading Status-Change System Messages. Your requester might monitor a server process by reading these status-change system messages from $RECEIVE: -2 -8 CPU down: local CPU failure after process called MONITORCPUS Change in status of network node Continue to read system message -2.
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Being Opened by and This subsection describes how to convert a server process written in C to communicate Communicating With a with a high-PIN requester. Whether you need to convert the server process depends High-PIN Requester in part on whether the server tracks its openers.
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Defining an Opener Table If your server tracks its openers, it might define an opener table that uses a process ID to identify an opener (primary process opener and backup process opener): struct opener_table { short current_count; struct openers[max_openers] { short primary_process_id[4]; short primary_file_number; short backup_process_id[4]; short backup_file_number; }; }; Convert your opener table to identify an opener
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Opening $RECEIVE Your server might open $RECEIVE using the OPEN procedure with bit 1 of the flags parameter set to 1 (flags = 040000). This allows you to receive system messages such as -30 (Process open) and -31 (Process close): short receive_name[12] = "$RECEIVE "; short read_open_close_msgs = 040000 ; ...
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Reading System Messages From $RECEIVE Your server might read system messages from $RECEIVE using the READ[X] or READUPDATE[X] procedure: char message_buffer[200]; /* Message buffer (200 bytes) */ ... read_count = 200; c_code = READX (receive_file_number, message_buffer, read_count, bytes_read); The lengths shown for each system message are subject to change.
Converting C Applications Being Opened by and Communicating With a High-PIN Requester FILE_GETRECEIVEINFO_ returns information in the 17-word message_info parameter, which has the format shown in Table 5-1. The ZSYSC file contains a structure that you can use for the message_info format. Table 5-1. FILE_GETRECEIVEINFO_ message_info Parameter Format Word Description 0 I/O type for the message: 0 = A system message was sent. 1 = The sender called WRITE[X]. 2 = The sender called READ[X].
Converting C Applications Being Opened by and Communicating With a High-PIN Requester System Message -103 (Process Open). Check bit 15 of sysmsg[7] of the process open message (or zsys_ddl_smsg_open.z_flags if you use the ZSYSC file), which indicates whether the opener is a primary or backup process: Primary open (sysmsg[7] bit 15 is 0): Add an entry in your opener table for the process. Backup open (sysmsg[7] bit 15 is 1): Process a backup open as follows: 1.
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Replying to System Message -103 (Process Open). The D-series system supports returning a label value in the reply to a system message -103 (Process open). Typically, an openertable index gets sent in this way. This label then appears in the open_label field of future FILE_GETRECEIVEINFO_ procedure calls that provide information about messages received from the same requester.
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Using the OPENER_LOST_ Procedure to Maintain an Opener Table After receiving a status-change message, your server might call one or more routines to maintain its opener table. You might want to use the OPENER_LOST_ procedure to maintain your opener table. OPENER_LOST_ determines whether a status-change message affects your opener table and updates the appropriate table entry if an opener was lost.
Converting C Applications Being Opened by and Communicating With a High-PIN Requester Setting the HIGHREQUESTERS Attribute to Allow High-PIN Openers The HIGHREQUESTERS object-file attribute allows a process to support requests from high-PIN requesters. Use the HIGHREQUESTERS object-file attribute only for a source program that contains the main function.
6 Converting Pascal Applications A Pascal program can run at a low PIN under the D-series operating system without any changes. However, for a Pascal program to use the extended features of the D-series operating system, specific parts of it must be converted.
Converting Pascal Applications Converting Basic Elements of a Pascal Program Converting Basic This subsection describes conversion that applies to all Pascal programs you need to Elements of a Pascal convert to run under the D-series operating system, irrespective of what the program Program does. Later subsections describe how to convert specific functions of your programs such as communicating with a high-PIN process.
Converting Pascal Applications Converting Basic Elements of a Pascal Program Importing the PEXTDECS and PASEXT Declarations The PEXTDECS file contains declarations for Guardian procedures. The PASEXT file contains declarations for Tandem routines. Your existing program should use the SOURCE or CSOURCE compiler directive to import the declarations you need from these files. For example, these SOURCE directives import C-series procedures and routines: IMPORT BEGIN ?SOURCE $SYSTEM.SYSTEM.
Converting Pascal Applications Converting Basic Elements of a Pascal Program Importing the ZSYSPAS Declarations Tandem provides source declarations for Guardian procedures and system messages in the ZSYSPAS file. This file is typically found on the $SYSTEM.ZSYSDEFS subvolume. Contact your system manager to find the location of this file on your system. To use these declarations, import them using the SOURCE or CSOURCE compiler directive.
Converting Pascal Applications Converting Basic Elements of a Pascal Program Declaring and Using Programming Variables For your existing program to run at a high PIN, you might need to add or modify declarations for the following variables: CPU and PIN variables File-system error numbers Guardian file names, including disk file names, device names, and process file names Process identifiers, including process IDs, process handles, and process descriptors Declaring CPU and PIN Variables Your existing progr
Converting Pascal Applications Converting Basic Elements of a Pascal Program Using Guardian File Names Guardian file names include disk file names, device names (such as a printer or terminal name), and process file names. You might need to convert the parts of your program that declare and use file-name variables. Disk File Names. Your existing program might declare a Guardian disk-file-name variable.
Converting Pascal Applications Converting Basic Elements of a Pascal Program Process File Names. Your existing program might declare a variable for a C-series process file name. The D-series enhanced interface uses D-series process files names instead of C-series process file names. Use C-series process file names for compatibility with unconverted C-series procedures. D-series process file names are variable-length string data items with their lengths specified as separate data items.
Converting Pascal Applications Converting Basic Elements of a Pascal Program Converting Guardian Procedure Calls Guardian procedures that you might need to convert are procedures that accept or return: A PIN parameter for a high-PIN process A process-ID parameter D-series procedures use a process handle (which includes the CPU and PIN values) rather than a process ID to identify a process.
Converting Pascal Applications Converting a Pascal Program to Run at a High PIN Converting a This subsection describes how to convert your Pascal program to run at a high PIN Pascal Program to under the D-series operating system. Figure 6-2 shows a typical application. The box Run at a High PIN shows which processes this part of the conversion applies to. Converting a Pascal program to run at a high PIN applies to both of these processes. Figure 6-2.
Converting Pascal Applications Converting a Pascal Program to Run at a High PIN You need to specify the HIGHPIN directive only once during a compilation. However, you can specify it any number of times and the compiler will not generate an error. If you do not set the HIGHPIN attribute when you compile your program, you can set it after compilation using Binder.
Converting Pascal Applications Converting a Pascal Program to Run at a High PIN The PROCESSHANDLE_DECOMPOSE_ procedure requires a process handle as an input parameter. If you do not know the process handle of your process, first call the PROCESSHANDLE_GETMINE_ procedure. Then pass the result to PROCESSHANDLE_DECOMPOSE_ , which returns the CPU and PIN values as separate integer values. For example: VAR my_phandle : ARRAY[1..
Converting Pascal Applications Creating a High-PIN Process Creating a You can create a high-PIN process programmatically or interactively. This subsection High-PIN Process describes how to programmatically create a high-PIN process. For information on how to interactively create a high-PIN process using TACL, see Section 7, “Converting TACL Programs.” Figure 6-3 shows the processes involved in converting a typical application.
Converting Pascal Applications Creating a High-PIN Process status := NEWPROCESS (program_file, priority, memory_pages, cpu, process_id, err_return, process_name, home_terminal, { flags } 0, { job_id } , error_info); On a D-series system, the NEWPROCESS[NOWAIT] procedure can create only a lowPIN process. The D-series operating system provides the PROCESS_CREATE_ procedure to create a new low-PIN or high-PIN process in a waited or nowait manner.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Opening and Your existing program might be a requester that communicates with a server. For Communicating With a example, you might open a server, send it a request, and then process its reply. You High-PIN Server might also open a server for a backup requester if your program is running as a process pair.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Setting the RUNNAMED Object-File Attribute The RUNNAMED object-file attribute causes a process to run as a named process even if you do not provide a name for it. Thus, a process can run at a high PIN under the D-series operating system and still be opened by an unconverted process using the Guardian OPEN procedure.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Communicating With a High-PIN Server A requester can open and communicate with a high-PIN named server by opening the server using the Guardian OPEN procedure.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Note If the file-name input parameter is incomplete (that is, not fully qualified), FILE_OPEN_ uses the current settings, including the system name, in the =_DEFAULTS DEFINE for the unspecified parts. FILE_OPEN_ also accepts a DEFINE name that represents a valid file name in this format. FILE_OPEN_ accepts an integer options parameter to specify certain file characteristics.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Opening a High-PIN Server for a Backup Requester Process If your requester is running as a process pair, it might open the server for its backup process using the CHECKOPEN procedure: status := CHECKOPEN (server_name, server_file_number, nowait_depth, sync_depth, { seq_block_buffer } , { buffer_length } , back_error); Figure 6-5 shows a requester process pair and a server process. Figure 6-5.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Sending a Request to a High-PIN Server Your requester might send a request to a high-PIN server using the Guardian WRITE[X] or WRITEREAD[X] procedure: status := WRITEREADX (server_file_number, sbuffer, write_count, read_count, count_read); Your Guardian WRITE[X] or WRITEREAD[X] procedure call should not require any changes to send a request to a high-PIN server.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Monitoring a High-PIN Server If your program monitors a high-PIN server, you must convert the following operations: Opening and closing $RECEIVE Reading process-deletion and status-change messages Using the CHILD_LOST_ procedure The following paragraphs describe how to convert these operations. These steps also can apply to any creator process that monitors a process that it has created.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Reading System Messages From $RECEIVE Your requester might read system messages from $RECEIVE using the Guardian READ[X] or READUPDATE[X] procedure: { Message buffer (200 bytes) } VAR message_buffer : ARRAY[1..200] OF CHAR; ... read_count := 200; status := READX (receive_file_number, message_buffer, read_count, bytes_read); The lengths shown for each system message are subject to change.
Converting Pascal Applications Opening and Communicating With a High-PIN Server Reading Status-Change System Messages. Your requester might monitor a server process by reading these status-change system messages from $RECEIVE: -2 -8 CPU down: local CPU failure after process called MONITORCPUS Change in status of network node Continue to read system message -2.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Being Opened by and This subsection describes how to convert a Pascal server to communicate with a highCommunicating With a PIN requester. Whether you need to convert the server process depends in part on High-PIN Requester whether the server tracks its openers.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Defining an Opener Table If your server tracks its openers, it might define an opener table that uses a process ID to identify an opener (primary process opener and backup process opener): TYPE opener = RECORD primary_process_id: primary_file_number: backup_process_id: backup-file_number: END; ARRAY [1..4] OF INTEGER; INTEGER; ARRAY [1..
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Opening $RECEIVE Your server might open $RECEIVE using the OPEN procedure with bit 1 of the flags parameter set to 1 (flags = 8#40000). This allows you to receive system messages such as -30 (Process open) and -31 (Process close): VAR receive_name: ARRAY[1..12] OF INTEGER; CONST read_open_close_msgs = 8#40000; ...
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Reading System Messages From $RECEIVE Your server might read system messages from $RECEIVE using the Guardian READ[X] or READUPDATE[X] procedure: { Message buffer (200 bytes) } VAR message_buffer: ARRAY [1..200] OF CHAR; ... read_count := 200; status := READX (receive_file_number, message_buffer, read_count, bytes_read); The lengths shown for each system message are subject to change.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester FILE_GETRECEIVEINFO_ returns information in the 17-word message_info parameter, which has the format shown in Table 6-1. The ZSYSPAS file contains a structure that you can use for the message_info format. Table 6-1. FILE_GETRECEIVEINFO_ message_info Parameter Format Word Description 0 I/O type for the message: 0 = A system message was sent. 1 = The sender called Guardian WRITE[X] procedure.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester System Message -103 (Process Open). Check bit 15 of sysmsg[7] of the process-open message (or ZSYS_DDL_SMSG_OPEN.Z_FLAGS if you use the ZSYSPAS file), which indicates whether the opener is a primary or backup process: Primary open (sysmsg[7] bit 15 is 0): Add an entry in your opener table for the process. Backup open (sysmsg[7] bit 15 is 1): Process a backup open as follows: 1.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Replying to System Message -103 (Process Open). The D-series system supports returning a label value in the reply to a system message -103 (Process open). Typically, an openertable index gets sent in this way. This label then appears in the open_label field of future FILE_GETRECEIVEINFO_ procedure calls that provide information about messages received from the same requester.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Using the OPENER_LOST_ Procedure to Maintain an Opener Table After receiving a status-change message, your server might call one or more routines to maintain its opener table. You might want to use the OPENER_LOST_ procedure to maintain your opener table. OPENER_LOST_ determines whether a status-change message affects your opener table and updates the appropriate table entry if an opener was lost.
Converting Pascal Applications Being Opened by and Communicating With a High-PIN Requester Setting the HIGHREQUESTERS Attribute to Allow High-PIN Openers The HIGHREQUESTERS object-file attribute allows a process to support requests from high-PIN requesters. Use this attribute only for a Pascal main program.
7 Converting TACL Programs Whether you use TACL commands and functions interactively or write TACL programs, you might need to make some changes to take advantage of the D-series enhanced interface. This section describes how to convert your TACL programs.
Converting TACL Programs Declaring and Using TACL Variables Declaring and Using This subsection describes how to change TACL declarations for: TACL Variables File-system error numbers CPU and PIN variables Process identifiers This subsection also provides information on how to: Avoid subvolume defaulting Convert between process handles and process file names Declaring File-System Error Numbers File-system error numbers under the C-series operating system are all in the range 0 through 255.
Converting TACL Programs Declaring and Using TACL Variables To allow for high-PIN processes, convert your program to use INT data types for both CPU and PIN values. For example: [#DEF cpu^and^pin STRUCT BEGIN INT cpu; INT pin; END; ] Declaring Process Identifiers The C-series interface uses 4-word process IDs to identify processes. The D-series enhanced interface instead uses 20-byte process handles or process descriptor strings, depending on what the identifier is used for.
Converting TACL Programs Declaring and Using TACL Variables For details of converting DSM applications, see Section 8, “Converting Other Parts of an Application.” Avoiding Subvolume Defaulting Your existing program might use subvolume defaulting to represent a Guardian disk file name in the form volume.file-id. For example: $MYVOL.MYFILE If you are using the D-series programmatic interface, you must explicitly specify the subvolume.
Converting TACL Programs Creating and Managing a High-PIN Process Creating and This subsection describes: Managing a High-PIN How to use TACL to run processes at a high PIN Process How to receive completion code information using the D-series enhanced interface Creating a High-PIN Process This subsection describes how you can use TACL to run a process at a high PIN or at a low PIN.
Converting TACL Programs Creating and Managing a High-PIN Process Setting High PIN for a New Process You might create a new process (for example, your requester) using the TACL RUN command or #NEWPROCESS built-in function: 9> SET HIGHPIN ON 10> RUN requestr / CPU 3, NAME $REQ, NOWAIT / In the above example, TACL creates the $REC process at a high PIN because the #HIGHPIN built-in variable is set ON.
Converting TACL Programs Creating and Managing a High-PIN Process Convert your program to reference the :_COMPLETION^PROCDEATH variable instead of :_COMPLETION to make use of the process deletion message information.
Converting TACL Programs Using TACL Built-in Functions Using TACL Built-in This subsection describes variances between the effect of TACL built-in functions on a Functions C-series system and the effect of the same built-in functions on a D-series system.
Converting TACL Programs Obtaining Lock Information Obtaining Lock Your existing program might use the #LOCKINFO built-in function to obtain Information information about record locks and file locks. For example: #LOCKINFO lock^spec tag buffer Convert your program to use the #FILEGETLOCKINFO built-in function to get information about a lock (either held or pending). Each time you use #FILEGETLOCKINFO, it returns information about one lock.
Converting TACL Programs Obtaining Lock Information [#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 use <5:15> reserved reserved process holding or waiting for the lock transaction holding or waiting for the lock ] #SET control 0 #FILEGETLOCKINFO myfile control
8 Converting Other Parts of an Application This section describes how to convert the parts of a TAL, COBOL85, C, Pascal, or TACL application that are not described in Sections 3 through 7.
Converting Other Parts of an Application Managing Your Disk Files Managing Your This subsection describes how to convert an application that calls Guardian file-system Disk Files procedures to: Manipulate and edit disk file names Manage disk files and volumes Converting an application to use D-series file-system procedures is usually optional.
Converting Other Parts of an Application Managing Your Disk Files Expanding Partially Qualified File Names Your existing program might call the FNAMEEXPAND or FNAME32EXPAND procedure to expand a partially qualified external file name to a 12-word internalformat file name: length := FNAMEEXPAND (external^filename, internal^filename, default^vol^subvol); Convert your program to call the FILENAME_SCAN_ and FILENAME_RESOLVE_ procedures.
Converting Other Parts of an Application Managing Your Disk Files Extracting Parts of a File Name Your existing program might extract parts from an internal-format file name. For example, you might extract the volume name from a file name. Convert your program to call the FILENAME_DECOMPOSE_ procedure, which returns one or more parts of a file-name string. You specify the parts that are to be returned with the level input parameter.
Converting Other Parts of an Application Managing Your Disk Files Each FILENAME_COMPARE_ file-name parameter must be followed by a colon and an integer value, which specifies the length in bytes of the file name. In this example, FILENAME_COMPARE_ compares two file names. The error value is then checked for the results: ! Compare the two file names and check the results. error := FILENAME_COMPARE_(file^name1:file^name1^length, file^name2:file^name2^length); CASE (error) OF BEGIN -1 -> ...
Converting Other Parts of an Application Managing Your Disk Files Upshifting ASCII Strings Your existing program might call the SHIFTSTRING procedure to upshift all alphabetic characters in an ASCII string: CALL SHIFTSTRING (file^name^string, string^length, shift^param); ! Value = 0 (upshift). You might want to convert your program to call the STRING_UPSHIFT_ procedure. This procedure uses both an input and output parameter for the string, which allows you to preserve the unshifted version of the string.
Converting Other Parts of an Application Managing Your Disk Files Maintaining Disk Files and Volumes The D-series operating system provides new file-system procedures to maintain disk files and volumes, including: Creating, renaming, and purging disk files Refreshing a disk volume Getting information about disk files and volumes These topics are described in the following paragraphs.
Converting Other Parts of an Application Managing Your Disk Files Renaming a Disk File Your existing program might call the RENAME procedure to rename an open disk file: CALL RENAME (file^number, new^name); Convert your program to call the FILE_RENAME_ procedure to rename an open disk file. If the file is temporary, FILE_RENAME_ causes the file to become permanent. You must have purge access to the file; otherwise, a security violation (file-system error 48) occurs.
Converting Other Parts of an Application Managing Your Disk Files Refreshing a Disk Volume Your existing program might call the REFRESH procedure to refresh a disk volume: CALL REFRESH (volume^name); Convert your program to call the DISK_REFRESH_ procedure. DISK_REFRESH_ writes control information from the file control blocks (FCBs) to the disk volume. It should be used only before the disk volume is brought down (for example, immediately before a cold load).
Converting Other Parts of an Application Managing Your Disk Files In the example below, FILE_GETINFO_ returns the last file-system error for a terminal I/O operation. Then, FILE_GETINFOLISTBYNAME_ uses the file name to return information about a disk file. ! Return the last file-system error. error := FILE_GETINFO_(terminal^file^number, last^terminal^file^error); ... ! Return information for the file indicated by file^name.
Converting Other Parts of an Application Managing Your Disk Files FILE_GETLOCKINFO_ returns information about the lock in the lock^description buffer in this format: word[0] word[1] Lock type (0 = file, 1 = record) Flags: .<0> Lock is generic .
Converting Other Parts of an Application Managing Your Disk Files Getting Open Information About a Disk File Your existing program might call the OPENINFO procedure to get information about the opens for a disk file or device: error := OPENINFO (search^name, previous^tag, primary^process^id, backup^process^id, access^mode, exclusion^mode, sync^depth, file^name, paid, valid^info^mask); Convert your program to call the FILE_GETOPENINFO_ procedure.
Converting Other Parts of an Application Using Terminal I/O Operations Using Terminal I/O Operations If your existing program uses terminal I/O, it might include: A command-interpreter interface BREAK key handling These topics are described in the following subsections. Converting a CommandInterpreter Interface A command-interpreter interface might involve accepting and displaying items such as a CPU value and PIN value or a file name.
Converting Other Parts of an Application Using Terminal I/O Operations Displaying File-System Error Numbers Your existing program might display or print three-digit file-system error numbers. A D-series file-system error number is an integer variable, which allows a maximum of five digits. Convert your program to display or print five-digit error numbers (or six digits if you display the numbers in octal).
Converting Other Parts of an Application Using Terminal I/O Operations Displaying Information About a Process Your existing program might display or print information about a process using a process ID to identify the process. In D-series procedures, the process handle replaces the process ID. However, a process handle is not suitable to display or print.
Converting Other Parts of an Application Using Terminal I/O Operations Converting BREAK Key Handling BREAK key handling might involve taking ownership of the BREAK key and sending and receiving system message -20 (Break). Taking BREAK Key Ownership If your existing program calls the SETMODE 11 procedure to take BREAK key ownership, do not use the MYPID procedure to set parameter-1. for SETMODE 11. Instead, set parameter-1 to any positive value.
Converting Other Parts of an Application Using Sequential I/O (SIO) Procedures Using Sequential I/O An existing program that calls Sequential Input/Output (SIO) procedures can run (SIO) Procedures under the D-series operating system without any changes.
Converting Other Parts of an Application Using Sequential I/O (SIO) Procedures Allocating FCBs Using the INITIALIZER The D-series INITIALIZER procedure supports creator processes that are running at a high PIN. If your existing program calls the INITIALIZER only to read its STARTUP, ASSIGN, or PARAM messages and not to set up its required FCBs, you do not need to make any changes. However, if your program calls the INITIALIZER to allocate its required FCBs, convert the program as follows.
Converting Other Parts of an Application Using Sequential I/O (SIO) Procedures Allocating FCBs Using Declarations Your existing program might allocate the common FCB and $RECEIVE FCB using the FCBSIZE LITERAL declaration (60 words). This example shows the allocation of the common FCB, $RECEIVE FCB, and a file FCB for an input file: INT .common^fcb [ 0:FCBSIZE - 1 ], ! Common FCB. .receive^file [ 0:FCBSIZE - 1 ], ! $RECEIVE FCB. .input^file [ 0:FCBSIZE - 1 ]; ! File FCB.
Converting Other Parts of an Application Using Sequential I/O (SIO) Procedures Specifying an Opener for $RECEIVE Using the SET^FILE Procedure Your existing program might specify an allowable opener for $RECEIVE (and therefore a process that is allowed to send you messages) using the SET^FILE procedure and the SET^OPENERSPID parameter: error := SET^FILE (receive^file, SET^OPENERSPID, @mom^pid); Convert your program to use the SET^OPENERSPHANDLE parameter in the SET^FILE call.
Converting Other Parts of an Application Using Sequential I/O (SIO) Procedures Table 8-2. SET^SYSTEMMESSAGESMANY Parameter Bit Determining an Opener Using the CHECK^FILE Procedure D-Series System Message C-Series System Message sys-msg-mask-words [0]: .<5> -101 (Process deletion) .<6> Unused .<8> Unused; see sys-msg-mask-words [3].<4:7> .<9> -112 (Job process creation) -5 (Process deletion: Stop) -6 (Process deletion: Abend -8 (MONITORNET) Unused sys-msg-mask-words [1]: .<4> -105 (Break on device) .
Converting Other Parts of an Application Using Sequential I/O (SIO) Procedures Opening $RECEIVE to Read System Messages Your existing program might open $RECEIVE using the OPEN^FILE procedure to read system messages: error := OPEN^FILE (common^fcb, receive^file, ! block^buffer ! block^buffer^size NOWAIT, nowait^io^mask); ! ! ! ! , , flags flags^mask The OPEN^FILE flags parameter defines a list of LITERAL declarations that can be used with the flags^mask parameter to set file-transfer characteristics.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Converting Distributed This subsection describes how to convert Distributed Systems Management (DSM) Systems Management applications that: (DSM) Applications Use the Event Management Service (EMS) to receive and interpret event messages from a Tandem subsystem Use EMS to generate and report event messages Use the Subsystem Programmatic Interface (SPI) to communicate with a Tandem subsystem Note Except f
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Defining the Event-Message Buffer Your DSM application might define a buffer to receive the event message. The D-series event-message header contains the new variable-length process-descriptor token, ZEMS-TKN-PROC-DESC, which makes the D-series header approximately 24 bytes larger than a C-series header.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Handling Superseded C-Series Tokens Your DSM application might try to extract one or more C-series tokens that are superseded by D-series tokens. Table 8-4 shows the C-series tokens that are superseded by D-series tokens. You might need to modify the parts of your application (including any filters and templates) that refer to these superseded C-series tokens. Table 8-4.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Handling Cross-Version Tokens A D-series event-message header might contain a C-series header token (for example, ZEMS-TKN-CRTPID), if the token can hold the required information. If the C-series token cannot hold the required information, the subsystem omits the token from the header. In this case, if your application tries to extract the token, it will receive the missing token error (ZSPI-ERR-MISTKN).
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Replacing a Process-ID Token Your DSM application might extract a process-ID token from the event-message buffer (for example, a token with token type ZSPI-TYP-CRTPID). A Tandem subsystem usually substitutes a process-descriptor token for a process-ID token that represents a high-PIN process.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Using EMS Filters If your DSM application uses filters to select specific event messages, EMS provides the D-series FILENAMECOMPARE, DECOMPOSE, and DECOMPOSEERROR functions to use in your filters. FILENAMECOMPARE compares two variable-length file-name strings. It returns TRUE if the file names are identical; otherwise, it returns FALSE.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Generating Event Messages This subsection describes how to convert a DSM application (or a user-written subsystem) that uses EMS to generate and report event messages. Calling the EMSINIT Procedure When your unconverted application calls the C-series EMSINIT procedure to build the event-message header, EMSINIT places the process-ID token, ZEMS-TKN-CRTPID, in the event-message header.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Specifying a File-System Error Your DSM application might include an 8-bit token for a file-system error in an event message. For example, you might define an error token using token type ZSPI-TYP-BYTE. Define file-system error-number tokens as integers using a token type such as ZSPI-TYP-UINT.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Specifying Device Numbers and Names Your DSM application might put a logical device number in an integer token such as ZEMS-TKN-LDEV or in a token with token type ZSPI-TYP-INT or ZSPI-TYP-UINT. A D-series logical device number requires 32 bits. Place a logical device number in the ZEMS-TKN-LDEVNUMBER token or define another 32-bit token using a token type such as ZSPI-TYP-INT2.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Converting DSM Applications That Use SPI This subsection describes how to convert a DSM application that uses the Subsystem Programmatic Interface (SPI) to communicate with a Tandem subsystem. You need to refer to the management programming manual for the specific subsystem.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Processing File-System Error Lists Your DSM application might process file-system error lists from a subsystem. A subsystem returns a file-system error list when a file-system error occurs during a procedure call from the subsystem. The subsystem nests the file-system error list within a subsystem error list.
Converting Other Parts of an Application Converting Distributed Systems Management (DSM) Applications Table 8-6.
Converting Other Parts of an Application Improving I/O Performance Using Direct I/O Transfers Improving I/O The D-series operating system can improve the performance of I/O operations by Performance Using transferring data directly between a program's I/O buffers and the I/O device without Direct I/O Transfers first allocating an intermediate buffer in the program's process file segment (PFS).
Converting Other Parts of an Application Improving I/O Performance Using Direct I/O Transfers When You Must Use PFS Buffers Your existing program might execute one or more of the following types of nowait I/O operations. In each case, you must avoid using direct I/O transfers.
Converting Other Parts of an Application Converting Memory-Management Procedure Calls Converting Memory-Management Procedure Calls Note Allocating an Extended Data Segment The D-series operating system provides new memory-management procedures to allocate, make accessible, deallocate, and get information about extended data segments. It also provides a new procedure for checking the address limits of either your process’s data segment or an extended data segment.
Converting Other Parts of an Application Converting Memory-Management Procedure Calls error := SEGMENT_USE_ (segment^id, old^segment^id, ! base^address ! , error^detail); Deallocating an Extended Data Segment Your existing program might call the DEALLOCATESEGMENT procedure to deallocate an extended data segment: CALL DEALLOCATESEGMENT (segment^id); Convert your program to call the SEGMENT_DEALLOCATE_ procedure. The flags integer parameter specifies whether dirty pages are written to the swap file.
Converting Other Parts of an Application Converting Memory-Management Procedure Calls To return the same information about an extended data segment that is currently allocated by the backup process of a process pair, call the SEGMENT_GETBACKUPINFO_ procedure from the primary process. Extended Segment Size On both TNS and TNS/R systems, the maximum size of an extended segment is 127.5 megabytes as of the C30.06 release.
Converting Other Parts of an Application Converting Memory-Management Procedure Calls INT LOCAL^VARIABLE; INT(32) LOW^ADDR; STRING .EXT HIGH^ADDR; INT ERROR, ERROR^DETAIL; . . .
Converting Other Parts of an Application Handling the Message System Interface Handling the Message System Interface Prior to the D-series versions of the operating system, the RESERVELCBS procedure allowed you to reserve link control blocks (LCBs) for sending and receiving messages. It also performed certain secondary functions concerning the limits on the number of extended memory link control blocks (XLBs).
9 Converting to TNS/R Systems Most TNS programs written for the C30 and D-series versions of the operating system can run on a TNS/R system without modification. Variances between TNS and TNS/R systems, however, might require modification in some programs, particularly in privileged TAL programs. One variance (see “Odd-Byte References,” later in this subsection) applies to C programs as well.
Converting to TNS/R Systems General Considerations Addresses (%h) Page 1 00080000 – 00080FFF 2 00081000 – 00081FFF 3 00082000 – 00082FFF 00083000 – 000837FF 4 00083800 – 00083FFF 901 Overflow Results Multiplication and division overflow results are undefined on all Tandem systems. Furthermore, overflow results of integer multiplication and division instructions (except LMPY) are incompatible between the TNS and TNS/R systems.
Converting to TNS/R Systems General-Case Variances General-Case The following variances apply to all object files (whether accelerated or not) that you Variances are running on a TNS/R system: Trap handlers that use the register stack Trap handlers that use the program counter Privileged instructions Nonprivileged references to system global data Stack wrapping Odd-byte references Data swap file size Passing the address of P-relative objects Shift instructions with dynamic shift counts Trap Handlers That U
Converting to TNS/R Systems General-Case Variances For example, the results of the following operations are undefined: INT trap_p = 'L' - 2; trap_p := trap_p '+' 1; trap_p := trap_p '-' 1; !Location of the P register !Undefined !Undefined Change your programs to comply with the preceding restrictions. Find trap handlers by looking for calls to the system procedure ARMTRAP with parameters (address of label, address of data area).
Converting to TNS/R Systems General-Case Variances Stack Wrapping If a nonprivileged program tries to allocate variables past the end of the user data segment, results might differ depending on the system: On TNS processors, the allocation wraps back to the user data segment. On TNS/R processors, the allocation is unpredictable; it might wrap or trap. Remove any constructs that result in stack wrapping. Change addressing operations so that they stay within the user data segment.
Converting to TNS/R Systems General-Case Variances Odd-Byte References TNS/R systems do not support the same odd-byte references to doublewords (4-byte units) or quadruplewords (8-byte units) as TNS systems do. Odd-byte references are made when the least significant bit (bit 31) of an extended pointer is set. TNS systems ignore bit 31 of an extended pointer and fetch or store data starting from the byte prior to the addressed one to ensure that the address is on a word boundary.
Converting to TNS/R Systems General-Case Variances Data Swap File Size On all TNS/R systems, the amount of memory allotted to a process for user data is rounded up to the nearest multiple of 4 KB. Additionally, on D20 TNS/R systems, the data swap file for the process requires 16 disk pages (32 KB) beyond this amount.
Converting to TNS/R Systems General-Case Variances For double-word shift operations with dynamic shift counts: TNS systems accept counts within the range of 0 to 255. Shift counts of 32 to 255 are treated as 32. TNS/R systems accept counts within the range of 0 to 32,767. Shift counts greater than 32 are treated as 32. Dynamic shift counts that fall outside of the acceptable ranges give undefined results.
Appendix A Guardian Procedures This appendix lists the D-series Guardian procedures that supersede C-series Guardian procedures. If you are converting an application, find each C-series procedure used in your application in the left-hand column of Table A-1. The corresponding item in the right-hand column shows the D-series procedure used for conversion. A hyphen (-) in the right-hand column means that there is no new Dseries procedure and that you should continue to use the C-series procedure.
Guardian Procedures Table A-1.
Guardian Procedures Table A-1.
Guardian Procedures Table A-1.
Guardian Procedures Table A-1.
Guardian Procedures Table A-1.
Guardian Procedures Table A-1.
Guardian Procedures Table A-1.
Appendix B System Messages Table B-1 lists the C-series and corresponding D-series user-level system messages. For the description and format of these system messages, refer to the Guardian Procedure Errors and Messages Manual. Table B-1.
Appendix C System Compatibility This appendix describes the compatibility between processes on C-series and D-series systems in a network. A typical network has C-series systems with all processes at low PINs and D-series systems with low-PIN unconverted processes, low-PIN converted processes, and high-PIN converted processes. Figure C-1 shows three systems in a typical network. Figure C-1.
System Compatibility Identifying Disks and I/O Devices Identifying Disks and A process uses a file name to identify a disk volume or an I/O device such as a printer I/O Devices or tape drive. An unconverted process can use eight-character file names (one to seven characters after the dollar sign) to identify local disk volumes or I/O devices. However, an unconverted process cannot use an eight-character name to identify remote disk volumes or I/O devices.
System Compatibility Identifying Processes Identifying Processes The D-series operating system uses D-series process file names and process handles to identify processes. For compatibility with C-series operating systems, the D-series operating system also supports C-series process file names and process IDs. The following paragraphs describe the use of C-series and D-series process identifiers. Note that the ability to identify a process does not imply that you can open it and communicate with it.
System Compatibility Identifying Processes Using D-Series Process File Names Using a D-series process file name, a converted process can identify a high-PIN or lowPIN process with a name that has up to five characters after the dollar sign (for example, $ZAB22) on D-series systems in a network.
System Compatibility Ensuring Compatibility: The Inherited Force-Low Characteristic Ensuring Compatibility: The Inherited Force-Low Characteristic Processes that create other processes often need to communicate with their descendent processes. Communication problems can occur when a process running on a C-series system creates a process running on a D-series system that in turn creates additional processes, some of which run at a high PIN. Figure C-5 shows the problem. Figure C-5.
System Compatibility Allowing Opens by High-PIN Requesters Overriding the Inherited Force-Low Characteristic If there is no need for a process to communicate with an ancestor process that runs at a low PIN, then you can override the inherited force-low characteristic and allow the new process to run at a high PIN or low PIN, depending on the force-low flag and on whether the HIGHPIN object-file attribute is set. You use create-options.
System Compatibility Allowing Opens by High-PIN Requesters Using Synthetic Process IDs A synthetic process ID is a process name or timestamp followed by the CPU number and a PIN value of 255. A synthetic process ID allows an unconverted server to support high-PIN openers (for example, in an opener table).
System Compatibility Communicating With a Named High-PIN Process Communicating With a An unconverted process running on a D-series system can communicate with a named Named High-PIN high-PIN process as described in the following paragraphs. However, to communicate Process with an unnamed high-PIN process, the process must be converted. Figure C-7 shows an unconverted process and a named high-PIN process. Figure C-7.
Appendix D Considerations for Migrating Any Application This appendix provides information about processing changes that may require minor conversion of your application even if you do not intend to take advantage of the D-series extensions.
Considerations for Migrating Any Application Potential Application Problems Table D-1.
Considerations for Migrating Any Application Aggregate SDU Length Checking Enhanced INITIALIZER Procedure For D-series systems, the number of FCBs specified in the INITIALIZER procedure Enhanced must match the number of FCBs actually allocated for the RUCB and common FCB. If the numbers do not match, the INITIALIZER issues the message “INITIALIZER: Invalid format or wrong number of FCBs specified” and terminates. For C-series systems, specifying the wrong number of FCBs did not cause a processing error.
Considerations for Migrating Any Application All D-Series Systems Must Be Named D-Series Systems All D-series systems, unlike C-series systems, must be named, even if they are not part Must Be Named of an Expand network. Migrating your C-series application from an unnamed system to a named D-series system might cause problems if: Your application does not expect a file name to contain a system (node) name.
Considerations for Migrating Any Application Pool Space Address Adjustment Temporary File Names Have 7 Digits On D-series systems, the number of concurrent temporary files allowed per volume has been increased. As a consequence, temporary file names now have 7 digits in their name, after the pound sign (#).
Considerations for Migrating Any Application TERMPROCESS Replaced by ATP6100 TERMPROCESS TERMPROCESS, which provided I/O support for asynchronous terminals, is not Replaced by ATP6100 supported on D-series systems. On D-series systems, 6100/3600-class controllers are now the only option for asynchronous terminal support, and these controllers require ATP6100 rather than TERMPROCESS.
Considerations for Migrating Any Application TMF Transactions Not Propagated to Device Simulator Process Automatically Nowait Write Buffer A program using nowait write operations with Guardian procedures might incorrectly Integrity allow the contents of the buffer being written to be altered before completion of the operation (with an AWAITIO[X] procedure call).
Considerations for Migrating Any Application Enhanced Attribute Values Are Returned from DEFINEs Enhanced Attribute Some of the attribute values returned by the DEFINE support procedures Values Returned from DEFINEREADATTR and DEFINEINFO on C-series systems have been enhanced for DEFINEs D-series systems.
Glossary accelerate. To use the Accelerator program to generate an accelerated object file. accelerated object code. The RISC instructions that result from processing a TNS object file with the Accelerator. accelerated object file. The object file that results from processing a TNS object file with the Accelerator.
Glossary advantage of the extended system limits. Applications must be converted to make use of this interface. D-series process file name. A variable-length string that identifies a process by name or CPU, PIN and can also include the node name, sequence number, and one or two qualifiers. D-series system. A system that is running a D-series version of the operating system. device. An addressable I/O device, independent of its physical environment (for example, a terminal or printer).
Glossary file system. A set of operating system procedures and data structures that allows communication between a process and a file (disk file, I/O device, or another process). filter. In the Event Management Service (EMS), a file that contains a list of criteria against which incoming event messages can be compared. Messages are either passed or not passed based on the list of criteria. GMOM. See “godmother (GMOM).” godmother (GMOM).
Glossary another subsystem from performing a command, the calling subsystem reports this error by nesting error lists in its own response. node. A system of one or more processor modules. Typically, a node is linked with other nodes to form a network. node name. The portion of the file name that identifies the system through which the file can be accessed. object file.
Glossary process string. A process identifier that is suitable to display or print. It contains either the process name or the CPU, PIN, optionally preceded by the node name. program. A static set of instruction codes and initialized data (for example, the output of a compiler or the Binder program) that is not executing. A program usually resides in a program file on disk. See also “process.” program file. An executable object file. See “object file.” reduced instruction-set computing (RISC).
Glossary SPI message. A message specially formatted by the Subsystem Programmatic Interface (SPI) procedures for communication between a management application and a subsystem, or between one subsystem and another. An SPI message consists of a collection of tokens. structured token. In the Subsystem Programmatic Interface (SPI), a token whose value is a structure.
Glossary NonStop Cyclone/R, NonStop CLX 2000, and NonStop CLX/R 1200 systems. Contrast with “Tandem NonStop Series (TNS).” TNS. See “Tandem NonStop Series (TNS).” TNS instructions. Stack-oriented, 16-bit machine instructions defined as part of the TNS environment. On TNS systems, TNS instructions are implemented by microcode; on TNS/R systems, TNS instructions are implemented by millicode routines or by translation to an equivalent sequence of RISC instructions. Contrast with “RISC instructions.
Index A Abend (-6) system message in C 5-23 in COBOL85 4-20 in Pascal 6-21 in TACL 7-6 in TAL 3-36 ABEND message-type keyword, COBOL85 4-20 ABEND procedure 3-26 Accelerate GLOSS-1 Accelerated object code GLOSS-1 Accelerated object file GLOSS-1 Accelerator GLOSS-1 ACTIVATEPROCESS procedure 3-24 Address limits checking for data segment 8-39 checking for extended data segment 8-39 Addresses of P-relative objects, TNS and TNS/R variances 9-7 ADDRESS_DELIMIT_ procedure 8-39 Aggregate SDU buffer D-3 ALLOCATESEGME
Index Arithmetic operations, TNS and TNS/R variances 9-2 ARMTRAP procedure, in COBOL85 4-11 ARMTRAP procedure, TNS and TNS/R variances 9-3, 9-4 ASCII strings, upshifting 8-6 Asterisk (*) as a wild-card character 8-5 ATP6100 protocol D-6 AWAITIO[X] procedure 3-33, 3-34, 5-19, 5-20, 6-17, 6-18 B Backup process, opening 3-51, 5-30, 6-28 Base address of an extended data segment 8-38 Batch processing 7-6/7 Binder CHANGE command setting HIGHPIN attribute C programs 5-12 COBOL85 programs 4-10 Pascal programs 6-10
Index Binder program (continued) setting RUNNAMED attribute C programs 5-17 COBOL85 programs 4-16 Pascal programs 6-15 TAL programs 3-31 you cannot mix C-series and D-series modules 3-8, 4-8, 5-2, 6-8 Binder SET command setting HIGHPIN attribute C programs 5-12 Pascal programs 6-10 TAL programs 3-31 setting HIGHREQUESTERS attribute C programs 5-33 COBOL85 programs 4-27 Pascal programs 6-31 TAL programs 3-45, 3-54 setting RUNNAMED attribute C programs 5-17 COBOL85 programs 4-16 Pascal programs 6-15 Binder S
Index BINSERV program (continued) setting HIGHREQUESTERS attribute C programs 5-33 COBOL85 programs 4-27 Pascal programs 6-31 TAL programs 3-45, 3-54 setting RUNNAMED attribute C programs 5-17 COBOL85 programs 4-15 Pascal programs 6-15 TAL programs 3-30 Bounds parameter error 2-5 Break (-20) system message 8-16 BREAK key ownership 8-16 Break-on-device (-105) system message 8-16 BREAKMESSAGE_SEND_ procedure 8-16 Buffer integrity for nowait write D-7 Buffer, event-message 8-24, 8-29 C C language changing key
Index C language (continued) file names in 5-7 file-system errors in 5-7 HIGHPIN object-file attribute 5-12 HIGHREQUESTERS object-file attribute 5-33 in Common Run-Time Environment (CRE) 4-9 including macro NULL definition 5-4 memory-mode files 5-4 monitoring a server 5-22/24 monitoring high-PIN server 5-22/24 opening a server 5-18/21 opening high-PIN server 5-18/21 opening temporary file 5-4 PIN in 5-12 process descriptor in 5-9 process file name in 5-8 process handle in 5-9 process ID in 5-9 replacing mi
Index Channels, I/O 1-1 CHECKALLOCATESEGMENT procedure 8-37 CHECKCLOSE procedure 3-34, 5-21, 6-19 CHECKMONITOR procedure 3-34, 5-20, 6-18 CHECKOPEN procedure 3-33, 5-20, 6-18 CHECK^FILE procedure 8-21 CHILD_LOST_ procedure in C 5-24 in Pascal 6-22 in TAL 3-37 CHKPT_ in procedure names 2-2 CISC GLOSS-1 clarge file 5-4 Close (-104) system message 3-43, 3-50/51, 4-23, 5-29/30, 6-27/28, B-1 Close (-31) system message 3-43, 3-50, 4-23, 5-29, 6-27, B-1 CLOSE message-type keyword, COBOL85 4-23 CLOSE procedure hig
Index COBOL85 (continued) CPU numbers in 4-3, 4-11 CPU-DOWN message-type keyword 4-20, 4-24 creating high-PIN process 4-14 device names in 4-5 disk file names in 4-4/5 ENTER statement 4-4 fast I/O 4-5 FILE clause 4-4 file names in 4-4/6 FILE-CONTROL paragraph 4-4 file-system errors in 4-4 FUNCTION reserved word 4-7 GIVING phrase ENTER TAL statement 4-4 SORT or MERGE statement 4-5 HIGHPIN object-file attribute 4-10 HIGHREQUESTERS object-file attribute 4-27 in Common Run-Time Environment (CRE) 4-9 MERGE stat
Index COBOL85 (continued) PIN in 4-3, 4-11 process descriptors in 4-6 process file names in 4-5/6 process handle in 4-6 process ID in 4-6 PROCESS-DELETION message-type keyword 4-20 program with no ENTER TAL statements 1-5 READ statement 4-17, 4-26 RECEIVE-CONTROL paragraph 4-17, 4-23 REMOTE-CPU-DOWN message-type keyword 4-20, 4-24 REMOTE-CPU-UP message-type keyword 4-20, 4-24 REPORT clause 4-18, 4-23/25 RUN command with 4-7 RUNNAMED object file attribute 4-15/16 running high-PIN process 4-8/12 SELECT claus
Index Condition codes undefined D-3 Configurations, I/O 1-1 CONTROLMESSAGESYSTEM procedure 8-41 Conversion, strategy for 1-4/6 Converted application GLOSS-1 Converting an application an approach to 1-6 in C 5-1/33 in COBOL85 4-1/27 in Pascal 6-1 in TACL 7-1/10 in TAL 3-1/54 options 1-7 COPY statement, COBOL85 4-2 CPU concurrent processes in 1-1, 1-2 efficiency of 1-1 CPU down (-2) system message 4-24 local CPU failure after process called CHECKMONITOR D-5 local CPU failure after process called MONITORCPUS
Index CPU-DOWN message-type keyword, COBOL85 4-20, 4-24 CRE 4-9 CREATE procedure 8-7 CREATEPROCESSNAME procedure 3-17 CREATEREMOTENAME procedure 3-17 Creating a high-PIN process using PROCESS_CREATE_ 3-14/15, 3-16, 5-14, 6-12 Creating disk files 8-7 CREATORACCESSID procedure 3-27, 8-15 CRTPID GLOSS-1 csmall file 5-4 CSOURCE directive in Pascal 6-3 Cyclone system 1-1 D D-series enhanced interface 1-3 D-series process file name GLOSS-2 D-series system GLOSS-2 D-series-enhanced interface GLOSS-1 Data segment
Index Device names (continued) in TAL 3-6 length D-4 length of for terminals D-6 Device numbers, defining an EMS token for 8-31 Device simulator process and TMF transactions D-7 Device type inquiry (-106) system message B-1 Device type inquiry (-40) system message B-1 Device, I/O 1-2, GLOSS-2 DEVICEINFO[2] procedure 8-9 Direct I/O transfers 8-35 Disk file names format of 2-6/8 in C 5-7 in COBOL85 4-4/5 in Pascal 6-6 in TAL 3-5 temporary files 2-7 Disk files creating 8-7 getting information about 8-9 gettin
Index E EMS See Event Management Service (EMS) ENTER statement, COBOL85 4-4, 4-11 ENV compiler directive 4-9 Error return value 2-5 error return value in PROCESS_CREATE_ 3-16 Error-checking routines, file-system error numbers in in C 5-7 in COBOL85 4-4 in Pascal 6-5 in TAL 3-4 error-detail parameter 2-5 in PROCESS_CREATE_ 3-16 Error-return conventions in Guardian procedures 2-5/6 Establishment of communication with node (-111) system message 4-20, 4-24 Event Management Service (EMS) 1-2, 2-17, GLOSS-2 EMSI
Index Extended segments, TNS and TNS/R variances limit checking 9-1 Extended swap file parameter, with PROCESS_CREATE_ 3-14, 3-15, 3-22 F Fast I/O, COBOL85 4-5 FCB See file control block (FCB) File GLOSS-2 FILE clause, COBOL85 4-4 File control block (FCB) GLOSS-2 using with SIO procedures 8-17 File lock information, using TACL to obtain 7-9/10 File names comparing using FILENAME_COMPARE_ 8-4 comparing using FNAMECOMPARE 8-4 DEFINEs D-8 defining an EMS token for 8-29 device 2-8/9 expanding partially qualifi
Index File-system errors accepting, displaying, and printing variables containing 8-14 checking error returned value 2-5 defining an EMS token for 8-30 error-48 8-8 error-560 2-17, C-6 error-561 2-17 error-563 2-17 error-564 2-17 error-565 2-17 error-566 2-17 error-590 2-17 error-593 2-17 error-597 2-17 error-632 2-17 in COBOL85 4-4 in Pascal 6-5 in TACL 7-2 in TAL 3-4 FILEINFO procedure 8-9 FILEINQUIRE procedure 8-9 FILENAMECOMPARE filter function 8-28 FILENAME_COMPARE_ procedure 8-4 FILENAME_DECOMPOSE_ p
Index FILE_GETRECEIVEINFO_ open-label field 6-29 FILE_GETRECEIVEINFO_ procedure 3-39, 3-44, 3-49, 5-28, 6-26 open-label field 3-52, 5-31, 6-29 FILE_OPEN_ procedure direct I/O transfers, opening for 8-35 high-PIN server, opening in C 5-18/19 high-PIN server, opening in Pascal 6-16/17 high-PIN server, opening in TAL 3-32/33 process descriptor, opening in TAL 3-22 $RECEIVE, opening in C 5-22, 5-27 $RECEIVE, opening in Pascal 6-20, 6-25 $RECEIVE, opening in TAL 3-35, 3-42, 3-48 FILE_PURGE_ procedure 8-8 FILE_R
Index GPLDEFS file GLOSS-3 using with SIO procedures 8-17 Guardian procedures See Procedures, Guardian H High PIN GLOSS-3 High-PIN creator allowing High-PIN creator, allowing 1-8, 3-38/45 High-PIN opener, allowing 1-8 in C 5-25/33 in COBOL85 4-22/27 in Pascal 6-23 in TAL 3-46/54 High-PIN process communicating with 1-8 creating 1-8 in C 5-14/15 in COBOL85 4-13/14 in Pascal 6-12/13 in TACL 7-5/6 in TAL 3-14 with PROCESS_CREATE_ 3-14/15, 3-16 with TACL RUN command 7-6 creating in TAL 3-23 creating using TACL
Index High-PIN server (continued) monitoring in C 5-22/24 in COBOL85 4-17 in Pascal 6-20/22 in TAL 3-35/37 opening in C 5-18/20 in COBOL85 4-17 in Pascal 6-16/18 in TAL 3-31/34 HIGHPIN object-file attribute 2-18, 7-6 displaying in C 5-12 in COBOL85 4-10 in Pascal 6-10 in TAL 3-10 setting in C 5-12 in COBOL85 4-10 in Pascal 6-9/10 in TAL 3-10 HIGHPIN TACL RUN option 7-6 HIGHREQUESTERS object-file attribute 2-18/19, 3-39 in C 5-27, 5-33 in COBOL85 4-27 in Pascal 6-25, 6-31 in TAL 3-42, 3-45, 3-48, 3-54 I I/O
Index Input/output channels 1-1 configurations 1-1 devices 1-2 subdevices 1-2 Input/output process (IOP) 1-1, GLOSS-3 Inspect, invoking using Debug 3-25 Interprocess communication GLOSS-3 Invalid operation error 3-52, 5-31, 6-29 IOP 1-1, GLOSS-3 L largec file 5-4 LASTADDR procedure 8-39 LASTADDRX procedure 8-39 LASTRECEIVE procedure 3-39 in C 5-28 in Pascal 6-26 in TAL 3-44, 3-49 synthetic process ID C-7 LCBs 8-41 Length of device names D-4 Library file using with a C high-PIN process 5-12 using with a COB
Index Low PIN GLOSS-3 Low-PIN process creating using TACL #NEWPROCESS built-in function 7-6 creating using TACL RUN command 7-6 definition 1-3 M Memory lock completion (-23) system message B-1 Memory lock failure (-24) system message B-1 Memory pages size, TNS and TNS/R variances 9-1 Memory-management procedure calls 8-37 Memory-model files 5-4 MERGE statement, COBOL85 4-5 MESSAGE SOURCE clause, COBOL85 4-21, 4-25 Message system GLOSS-3 Message system interface 8-41 Messages, system See System messages Mig
Index Mom process 3-26, GLOSS-3 Monitor process pair, converting 1-6, 1-9/10 MONITORCPUS procedure 3-37, 5-24, 6-22 MONITORNET procedure 3-37, 5-24, 6-22 Monolithic program See Single-process applications Multiple-process applications 1-5/6 MYGMOM procedure 3-27, 8-15 MYPID procedure in C 5-13 in COBOL85 4-12 in Pascal 6-10 in TAL 3-11 MYTERM procedure 3-27, 8-15 N Named process C-8, GLOSS-3 Naming conventions for Guardian procedures 2-2 Nested error list GLOSS-4 Network form of process ID C-3 NETWORK mess
Index Nowait process creation using NEWPROCESSNOWAIT 3-15 using PROCESS_CREATE_ 3-15 Nowait PROCESS_CREATE_ completion (-102) system message B-1 in C 5-15 in Pascal 6-13 in TAL 3-16, 3-18 Nowait write buffer integrity D-7 Null process handle using in Guardian procedures 2-16 O Object file GLOSS-4 Object part of procedure names 2-2 Object-file attributes 1-3, 2-18/19, GLOSS-4 Odd-byte references, TNS and TNS/R variances 9-6 OLD option, ENV compiler directive 4-9 OLDFILENAME_TO_FILENAME_ procedure 8-6 OLD^RE
Index Opener table C-6 adding an entry after an open in C 5-30 in Pascal 6-28 in TAL 3-51 defining for OPENER_LOST_ in C 5-26 in Pascal 6-24 in TAL 3-47 deleting an entry after a close in C 5-30 in Pascal 6-28 in TAL 3-51 identifying an opener in in C 5-9 in COBOL85 4-26 in Pascal 6-7 maintaining using OPENER_LOST_ in C 5-32 in Pascal 6-30 in TAL 3-53 OPENER_LOST_ procedure 2-16 in C 5-26, 5-32 in Pascal 6-24, 6-30 in TAL 3-47, 3-53 OPENINFO procedure 8-12, C-7 Opens, number of per disk volume 1-2 per I/O
Index P P register, TNS and TNS/R variances 9-3 P-relative objects, TNS and TNS/R variances 9-7 Page See Memory pages Parameter conventions in Guardian procedures 2-2/5 Parameter error 2-5 Pascal communicating with high-PIN server 6-16/22 communicating with server 6-16/22 compiler 6-8, 6-9, 6-15, 6-31 converting a requester in 6-14, 6-16/22 converting a server 6-23/30 converting an application 6-1 converting to D-series Guardian procedures 6-8 CPU numbers in 6-5, 6-10 creating high-PIN process 6-12/13 devi
Index PEXTDECS file 6-3 PFS See Process file segment (PFS) PHANDLE data type 7-3 PID GLOSS-4 PIN GLOSS-4 See Process identification number (PIN) PIN method, allocating an extended data segment 8-37 Pointers uninitialized, TNS and TNS/R variances 9-6 Pool space assuring adequate amount D-5 Pound sign (#) in a file name 8-5 Primary-process open 3-51, 5-30, 6-28 Printed reports, generated by an application 8-13 PRIORITY procedure 3-27, 3-28, 8-15 Procedures CHECKMONITOR D-5 DEFINEREADATTR D-4 FNAMECOLLAPSE D-
Index Procedures, Guardian (continued) BREAKMESSAGE_SEND_ 8-16 CBCINFO 3-27, 8-15 CHECKALLOCATESEGMENT 8-37 CHECKCLOSE 3-34, 5-21, 6-19 CHECKMONITOR 3-34, 5-20, 6-18 CHECKOPEN 3-33, 5-20, 6-18 CHILD_LOST_ in C 5-24 in Pascal 6-22 in TAL 3-37 CLOSE high-PIN server using C 5-21 high-PIN server using Pascal 6-19 high-PIN server using TAL 3-34 $RECEIVE using C 5-24 $RECEIVE using Pascal 6-22 $RECEIVE using TAL 3-37 CONTROLMESSAGESYSTEM 8-41 CREATE 8-7 CREATEPROCESSNAME 3-17 CREATEREMOTENAME 3-17 CREATORACCESSI
Index Procedures, Guardian (continued) FILE_EDIT_ 3-22 FILE_GETINFOBYNAME_ 8-9 FILE_GETINFOLISTBYNAME_ 8-9 FILE_GETINFOLIST_ 3-33, 3-34, 5-19, 5-20, 6-17, 6-18, 8-9 FILE_GETINFO_ 8-9 FILE_GETLOCKINFO_ 8-10 FILE_GETOPENINFO_ 8-12 FILE_GETRECEIVEINFO_ 3-39, 3-44, 3-49, 5-28, 6-26 FILE_OPEN_ direct I/O transfers, opening for 8-35 high-PIN server, opening in C 5-18/19 high-PIN server, opening in Pascal 6-16/17 high-PIN server, opening in TAL 3-32/33 process descriptor, opening in TAL 3-22 $RECEIVE, opening in
Index Procedures, Guardian (continued) MYPID in C 5-13 in COBOL85 4-12 in Pascal 6-10 in TAL 3-11 MYTERM 3-27, 8-15 NEWPROCESS 3-14 NEWPROCESSNOWAIT 3-15, 5-14, 6-12 OLDFILENAME_TO_FILENAME_ 8-6 OPEN C-8 $RECEIVE, opening in C 5-22, 5-27 $RECEIVE, opening in Pascal 6-20, 6-25 $RECEIVE, opening in TAL 3-35, 3-41, 3-48 OPENER_LOST_ 2-16 in C 5-26 in Pascal 6-24 in TAL 3-47 OPENINFO 8-12 PRIORITY 3-27, 3-28, 8-15 PROCESSFILESECURITY 3-27, 3-28, 8-15 PROCESSHANDLE_DECOMPOSE_ 8-15 and a process-handle token 8-2
Index Procedures, Guardian (continued) PROCESS_ACTIVATE_ 3-24 PROCESS_CREATE_ 2-10, 3-14/15, 3-16 PROCESS_DEBUG_ 3-25 PROCESS_GETINFOLIST_ 3-27, 3-28 PROCESS_GETINFO_ 3-27 getting creators ID 3-40 PROCESS_GETPAIRINFO_ 3-27, 3-40/41 PROCESS_SETINFO_ 3-28/29 PROCESS_SETSTRINGINFO_ 3-28/29 PROCESS_STOP_ 3-26/27 PROCESS_SUSPEND_ 3-24 PROGRAMFILENAME 3-27, 8-15 PURGE 8-8 READUPDATE[X] reading from $RECEIVE in C 5-23, 5-28 reading from $RECEIVE in Pascal 6-21, 6-26 reading from $RECEIVE in TAL 3-36, 3-43, 3-49 R
Index Procedures, Guardian (continued) SETMODE function-11 3-12, 5-13, 6-11, 8-16 function-141 8-35 function-72 1-2, 2-17, 8-35 SETMYTERM 3-28 SHIFTSTRING 8-6 STEPMOM 3-28 STOP 3-26 STRING_UPSHIFT_ 8-6 SUSPENDPROCESS 3-24 USESEGMENT 8-37 WRITEREAD[X] 3-34, 5-21, 6-19, 8-36, C-8 WRITE[X] 8-33, 8-36, C-8 Procedures, sequential I/O (SIO) See Sequential I/O (SIO) procedures Procedures, use of undocumented D-1 Procedures, use of undocumented side effects D-1 Process GLOSS-4 abending 3-26, 4-14 activating 3-24,
Index Process CONTROL (-32) system message B-1 Process CONTROLBUF (-35) system message B-1 Process creation swap file size, TNS and TNS/R variances 9-7 Process deletion (-101) system message distinguishing recipient of 3-22/23 in C 5-23 in COBOL85 4-20 in Pascal 6-21 in TACL 7-6/7 in TAL 3-26, 3-36 Process descriptor GLOSS-4 as PROCESS_CREATE_ output parameter 3-18 converting from a process handle 7-4 converting to a process handle 7-4 defining an EMS token for 8-30 format of 2-14 in C 5-9 in COBOL85 4-6 i
Index Process handle (continued) in TACL 7-3/4 in TAL 3-7 null 2-4 using as a procedure parameter 2-4 Process ID GLOSS-4 in C 5-9 in COBOL85 4-6 in Pascal 6-7 in TACL 7-3/4 in TAL 3-7 network form of C-3 timestamp form of C-3 Process identification number GLOSS-4 source of PIN 255 D-8 Process identification number (PIN) accepting, displaying, and printing variables containing 8-13 defining a variable for in C 5-12 in COBOL85 4-3, 4-11 in Pascal 6-5, 6-10 in TACL 7-2 in TAL 3-4, 3-10 defining an EMS token f
Index Process open (-103) system message B-1 in C 5-29, 5-30 in COBOL85 4-23 in Pascal 6-27, 6-28 in TAL 3-43, 3-50, 3-51 Process open (-30) system message B-1, C-7 in C 5-29 in COBOL85 4-23 in Pascal 6-27 in TAL 3-43, 3-50 Process pair index, in a process handle 2-15 Process pairs,migrating D-5 Process RESETSYNC (-34) system message B-1 Process SETMODE (-33) system message B-1 Process SETPARAM (-37) system message B-1 Process string GLOSS-5 Process time timeout (-26) system message B-1 PROCESS-DELETION me
Index PROCESS_ACTIVATE_ procedure 3-24 PROCESS_CREATE_ procedure called by TACL 7-6 running C compiler 5-10 running COBOL85 compiler 4-7 running Pascal compiler 6-8 running TAL compiler 3-8 creating high-PIN process 3-14/15, 3-16 naming processes 2-10 PROCESS_DEBUG_ procedure 3-25 PROCESS_GETINFOLIST_ procedure 3-27, 3-28 PROCESS_GETINFO_ procedure 3-27 getting creators ID 3-40 PROCESS_GETPAIRINFO_ procedure 3-27, 3-40/41 PROCESS_SETINFO_ procedure 3-28/29 PROCESS_SETSTRINGINFO_ procedure 3-28/29 PROCESS_S
Index READ[X] procedure direct I/O transfers 8-36 reading from $RECEIVE in C 5-23, 5-28 in Pascal 6-21, 6-26 in TAL 3-36, 3-43, 3-49 RECEIVE See $RECEIVE RECEIVE-CONTROL paragraph, COBOL85 4-17, 4-23 RECEIVEINFO procedure 3-39, 3-44, 3-49, 5-28, 6-26, C-7 Reduced instruction-set computing (RISC) GLOSS-5 REFRESH procedure 8-9 Refreshing a disk file or volume 8-9 Register stack, TNS and TNS/R variances 9-3 Remote CPU down (-100) system message in C 5-24, 5-30 in COBOL85 4-20, 4-24 in Pascal 6-22, 6-28 in TAL
Index RUNNAMED object-file attribute 2-18/19 in C 5-17 in COBOL85 4-15/16 in Pascal 6-15 in TAL 3-19, 3-20, 3-30/31 S Safeguard subsystem C-1 SDU buffer D-3 Security file C-1 operating system C-1 process and file C-1 Safeguard subsystem C-1 violation, when purging a file 8-8 violation, when renaming a file 8-8 Segment GLOSS-5 SEGMENTSIZE procedure 8-38 SEGMENT_ALLOCATE_ procedure 8-37 SEGMENT_ALLOCATE_CHKPT_ procedure 8-37 SEGMENT_DEALLOCATE_ procedure 8-38 SEGMENT_DEALLOCATE_CHKPT_ procedure 8-38 SEGMENT_
Index Sequential I/O (SIO) procedures (continued) using common FCB with 8-19 using FCB with 8-17/19 using GPLDEFS file with 8-17 Server GLOSS-5 communicating with in C 5-18/24 in COBOL85 4-17/21 in Pascal 6-16/22 in TAL 3-31/37 converting 1-6/7 in C 5-25/32 in COBOL85 4-22/26 in Pascal 6-23/30 in TAL 3-46/53 no opener table 1-5 with opener table 1-6 monitoring in C 5-22/24 in COBOL85 4-17 in Pascal 6-20/22 in TAL 3-35/37 opening for backup process using CHECKOPEN 3-33, 5-20, 6-18 in C 5-18/20 in COBOL85 4-
Index Shift instructions with dynamic shift counts, TNS and TNS/R variances 9-7 SHIFTSTRING procedure 8-6 SHOW command, TACL 7-6 Simple token GLOSS-5 Single-process applications 1-5 SIO procedures See Sequential I/O (SIO) procedures Size extended segments 8-39 memory pages, TNS and TNS/R variances 9-1 smallc file 5-4 SORT statement, COBOL85 4-5 SOURCE directive in Pascal 6-3 in TAL 3-2 SPECIAL-NAMES paragraph, COBOL85 4-4 SPI See Subsystem Programmatic Interface (SPI) Spooler job file names, in COBOL85 4-5
Index Subsystem Programmatic Interface (SPI) 1-2, 2-17, GLOSS-6 converting an application 8-32 SSGET procedure 8-32 using definition files 8-23 Subvolume defaulting 2-7, 8-14 in C 5-9 in COBOL85 4-6/7 in Pascal 6-7 in TACL 7-4 in TAL 3-7 SUSPENDPROCESS procedure 3-24 Swap file GLOSS-6 for an extended data segment 8-38 Swap file parameter with PROCESS_CREATE_ 3-14, 3-15 Swap file size, TNS and TNS/R variances 9-7 SYMSERV process with C compiler 5-10 with COBOL85 compiler 4-7 with Pascal compiler 6-8 with TA
Index System messages (continued) CPU down (-2) 4-24 local CPU failure after process called CHECKMONITOR D-5 local CPU failure after process called MONITORCPUS, in C 5-24, 5-30 local CPU failure after process called MONITORCPUS, in COBOL85 4-20, 4-24 local CPU failure after process called MONITORCPUS, in Pascal 6-22, 6-28 local CPU failure after process called MONITORCPUS, in TAL 3-37, 3-51 named process deletion 3-36, 4-20, 5-23, 6-21 Device type inquiry (-106) B-1 Device type inquiry (-40) B-1 Establishm
Index System messages (continued) message-104 B-1 in C 5-29, 5-30 in COBOL85 4-23 in Pascal 6-27, 6-28 in TAL 3-43, 3-50, 3-51 message-105 8-16 message-106 B-1 message-107 B-1 message-108 8-9, B-1 message-109 B-1 message-110 in C 5-24, 5-30 in COBOL85 4-20, 4-24 in Pascal 6-22, 6-28 in TAL 3-37, 3-51 message-111 4-20, 4-24 message-113 in C 5-24, 5-30 in COBOL85 4-20, 4-24 in Pascal 6-22, 6-28 in TAL 3-37, 3-51 message-12 in C 5-15 in Pascal 6-13 in TAL 3-16 message-2 4-24 local CPU failure after process ca
Index System messages (continued) message-30 B-1, C-7 in C 5-29 in COBOL85 4-23 in Pascal 6-27 in TAL 3-43, 3-50 message-31 4-23, B-1 in C 5-29 in Pascal 6-27 in TAL 3-43, 3-50 message-32 B-1 message-33 B-1 message-34 B-1 message-35 B-1 message-37 B-1 message-38 B-1 message-40 B-1 message-41 B-1 message-5 in C 5-23 in COBOL85 4-20 in Pascal 6-21 in TACL 7-6/7 in TAL 3-36 message-6 in C 5-23 in COBOL85 4-20 in Pascal 6-21 in TACL 7-6/7 in TAL 3-36 message-8 in C 5-24, 5-30 in COBOL85 4-20, 4-24 in Pascal 6-
Index System messages (continued) Nowait PROCESS_CREATE_ completion (-102) B-1 in C 5-15 in Pascal 6-13 in TAL 3-16, 3-18 Open (-103) B-1 in C 5-29, 5-30 in COBOL85 4-23 in Pascal 6-27, 6-28 in TAL 3-43, 3-50, 3-51 Open (-30) B-1, C-7 in C 5-29 in COBOL85 4-23 in Pascal 6-27 in TAL 3-43, 3-50 Process abnormal deletion, abend (-6) in C 5-23 in COBOL85 4-20 in Pascal 6-21 in TACL 7-6/7 in TAL 3-36 Process close (-104) B-1 in C 5-29, 5-30 in Pascal 6-27, 6-28 in TAL 3-43, 3-50, 3-51 Process close (-31) B-1 in
Index System messages (continued) Process normal deletion, stop (-5) in C 5-23 in COBOL85 4-20 in Pascal 6-21 in TACL 7-6/7 in TAL 3-36 Process open (-103) B-1 in C 5-29, 5-30 in COBOL85 4-23 in Pascal 6-27, 6-28 in TAL 3-43, 3-50, 3-51 Process open (-30) B-1, C-7 in C 5-29 in COBOL85 4-23 in Pascal 6-27 in TAL 3-43, 3-50 Process RESETSYNC (-34) B-1 Process SETMODE (-33) B-1 Process SETPARAM (-37) B-1 Process timeout (-26) B-1 Queued message cancellation (-38) B-1 Remote CPU down (-100) in C 5-24, 5-30 in
Index System messages, handling getting information about 3-49, 5-28, 6-26 opening $RECEIVE to read in C 5-27 in COBOL85 4-17, 4-26 in Pascal 6-25 in TAL 3-41, 3-48 processing open and close messages 3-43, 3-50, 5-29, 6-27 reading status-change messages 3-37, 3-51, 5-24, 5-30, 6-22, 6-28 reading using READ[X] or READUPDATE[X] 3-36, 3-43, 3-49, 5-23, 5-28, 6-21, 6-26 replying using REPLY[X] procedure 3-51, 5-30, 6-28 selecting for COBOL85 4-18, 4-23 specifying message-buffer length in C 5-23, 5-28 in COBOL8
Index TACL (continued) process descriptor in 7-3/4 process file name in 7-3 process handle in 7-3/4 process ID in 7-3/4 RUN command 2-10, 3-10, 4-15, 7-6 for C compiler 5-10 for COBOL85 compiler 4-7 for Pascal compiler 6-8 for TAL compiler 3-8 using with COBOL85 compiler 4-7 using with high-PIN requester 7-6 using with HIGHPIN directive 4-10, 5-12, 6-9 using with HIGHREQUESTERS directive 3-45, 3-54, 4-27, 5-33, 6-31 using with RUNNAMED directive 3-30, 5-17, 6-15 using with TAL compiler 3-8 SET command 7-6
Index TAL (continued) HIGHPIN object-file attribute 3-10 HIGHREQUESTERS object-file attribute 3-45, 3-54 monitoring a server 3-35/37 monitoring high-PIN server 3-35/37 opening a server 3-31/34 opening high-PIN server 3-31/34 PIN in 3-4, 3-10 process descriptor in 3-7 process file name in 3-6 process handle in 3-7 process ID in 3-7 RUN command with 3-8 RUNNAMED object-file attribute 3-30/31 running a high-PIN process 3-9/12 subvolume defaulting in 3-7 using library file from high-PIN process 3-10 Tandem Adv
Index Transaction Application Language (TAL) See TAL Transaction lock information, obtaining using TACL 7-9/10 Trap handlers checking overflow 9-2 using P register 9-3 using register stack 9-3 Trap handling, in COBOL85 4-11 Type part of procedure names 2-2 U Unconverted application GLOSS-7 Unconverted process C-1 Undefined condition codes D-3 Underscore (_) in procedure names 2-2 Undocumented procedures, use of D-1 Undocumented side effects,of documented procedures D-1 Unnamed process C-8, GLOSS-7 Upshifti
Index W Waited process creation using NEWPROCESS 3-14 using PROCESS_CREATE_ 3-14 widec file 5-4 Wild-card characters (* and ?) 8-5 wlarge file 5-4 WRITEREAD[X] procedure 3-34, 5-21, 6-19, 8-36, C-8 WRITE[X] procedure 8-33, 8-36, C-8 X XLBs 8-41 Z ZCOMC file 8-23 ZCOMCOB file 8-23 ZCOMPAS file 8-23 ZCOMTAL file 8-23 ZEMS-TKN- tokens CRTPID 8-29 NODENAME 8-29 NODENUMBER 8-29 PROC-DESC 8-29 ZEMSTAL file 8-23 Zero suppression and DEFINEs D-8 ZFIL-TKN-ERRORDETAIL token 8-33 ZSPI-TDT-PHANDLE token data type 7-3
Index ZSYSDDL file GLOSS-7 including in source code 2-1 using with FILE_GETINFOBYNAME_ 8-7, 8-9, 8-11 ZSYSPAS file 2-1, 6-7, GLOSS-7 including in source code 6-4 printing 6-4 using with system messages 6-21, 6-26 ZSYSTAL file 2-1, 3-7, GLOSS-7 including in source code 3-3 printing 3-3 using with FILE_OPEN_ 3-32, 5-19, 6-17 using with PROCESS_CREATE_ 3-14 using with system messages 3-36, 3-43, 3-49 ZSYS]VAL]LEN]FILENAME LITERAL declaration 2-3 ZSYS]VAL]LEN]PROCESSDESCR LITERAL declaration 2-3 ZSYS]VAL]LEN]S
Index $RECEIVE (continued) reading process open and close messages 3-43, 3-50, 5-29, 6-27 reading system messages 5-28, 6-26 reading system messages using READ[X] or READUPDATE[X] 3-43, 3-49 'SG'-equivalenced variables, TNS and TNS/R variances 9-4 * (asterisk) as a wild-card character 8-5 =_DEFAULTS DEFINE 3-32, 5-19, 6-17 ? (question mark) as a wild-card character 8-5 :_COMPLETION TACL structure 7-6/7 :_COMPLETION[PROCDEATH TACL structure 7-6/7 _ (underscore ) in procedure names 2-2 Index–50 096047 Tand
