[PEN_CHECKING_STYLE(NONE),INHERIT('SYS$LIBRARY:PASCAL$D_FLOAT','SYS$LIBRARY:PASCAL$G_FLOAT')] MODULE lib$routines; { © Copyright 2005 Hewlett-Packard Development Company, L.P. } { } { Confidential computer software. Valid license from HP and/or } { its subsidiaries required for possession, use, or copying. } { } { Consistent with FAR 12.211 and 12.212, Commercial Computer Software, } { Computer Software Documentation, and Technical Data for Commercial } { Items are licensed to the U.S. Government under vendor's standard } { commercial license. } { } { Neither HP nor any of its subsidiaries shall be liable for technical } { or editorial errors or omissions contained herein. The information } { in this document is provided "as is" without warranty of any kind and } { is subject to change without notice. The warranties for HP products } { are set forth in the express limited warranty statements accompanying } { such products. Nothing herein should be construed as constituting an } { additional warranty. } { } [HIDDEN] TYPE (**** Pre-declared data types ****) $BYTE = [BYTE] -128..127; $WORD = [WORD] -32768..32767; $QUAD = [QUAD,UNSAFE] RECORD L0:UNSIGNED; L1:INTEGER; END; $OCTA = [OCTA,UNSAFE] RECORD L0,L1,L2:UNSIGNED; L3:INTEGER; END; $UBYTE = [BYTE] 0..255; $UWORD = [WORD] 0..65535; $UQUAD = [QUAD,UNSAFE] RECORD L0,L1:UNSIGNED; END; $UOCTA = [OCTA,UNSAFE] RECORD L0,L1,L2,L3:UNSIGNED; END; $PACKED_DEC = [BIT(4),UNSAFE] 0..15; $DEFTYP = [UNSAFE] INTEGER; $DEFPTR = [UNSAFE] ^$DEFTYP; $BOOL = [BIT(1),UNSAFE] BOOLEAN; $BIT = [BIT(1),UNSAFE] BOOLEAN; $BIT2 = [BIT(2),UNSAFE] 0..3; $BIT3 = [BIT(3),UNSAFE] 0..7; $BIT4 = [BIT(4),UNSAFE] 0..15; $BIT5 = [BIT(5),UNSAFE] 0..31; $BIT6 = [BIT(6),UNSAFE] 0..63; $BIT7 = [BIT(7),UNSAFE] 0..127; $BIT8 = [BIT(8),UNSAFE] 0..255; $BIT9 = [BIT(9),UNSAFE] 0..511; $BIT10 = [BIT(10),UNSAFE] 0..1023; $BIT11 = [BIT(11),UNSAFE] 0..2047; $BIT12 = [BIT(12),UNSAFE] 0..4095; $BIT13 = [BIT(13),UNSAFE] 0..8191; $BIT14 = [BIT(14),UNSAFE] 0..16383; $BIT15 = [BIT(15),UNSAFE] 0..32767; $BIT16 = [BIT(16),UNSAFE] 0..65535; $BIT17 = [BIT(17),UNSAFE] 0..131071; $BIT18 = [BIT(18),UNSAFE] 0..262143; $BIT19 = [BIT(19),UNSAFE] 0..524287; $BIT20 = [BIT(20),UNSAFE] 0..1048575; $BIT21 = [BIT(21),UNSAFE] 0..2097151; $BIT22 = [BIT(22),UNSAFE] 0..4194303; $BIT23 = [BIT(23),UNSAFE] 0..8388607; $BIT24 = [BIT(24),UNSAFE] 0..16777215; $BIT25 = [BIT(25),UNSAFE] 0..33554431; $BIT26 = [BIT(26),UNSAFE] 0..67108863; $BIT27 = [BIT(27),UNSAFE] 0..134217727; $BIT28 = [BIT(28),UNSAFE] 0..268435455; $BIT29 = [BIT(29),UNSAFE] 0..536870911; $BIT30 = [BIT(30),UNSAFE] 0..1073741823; $BIT31 = [BIT(31),UNSAFE] 0..2147483647; $BIT32 = [BIT(32),UNSAFE] UNSIGNED; (* MODULE PASLIB$ROUTINES ; *) (* [HIDDEN] TYPE (**** Pre-declared data types ***?? *) (* $BYTE = [BYTE] -128..127; *) (* $WORD = [WORD] -32768..32767; *) (* $QUAD = [QUAD,UNSAFE] RECORD *) (* L0:UNSIGNED; L1:INTEGER; END; *) (* $OCTA = [OCTA,UNSAFE] RECORD *) (* L0,L1,L2:UNSIGNED; L3:INTEGER; END; *) (* $UBYTE = [BYTE] 0..255; *) (* $UWORD = [WORD] 0..65535; *) (* $UQUAD = [QUAD,UNSAFE] RECORD *) (* L0,L1:UNSIGNED; END; *) (* $UOCTA = [OCTA,UNSAFE] RECORD *) (* L0,L1,L2,L3:UNSIGNED; END; *) (* $UOCTAQUAD = [OCTA(2),UNSAFE] RECORD *) (* L0,L1,L2,L3,L4,L5,L6,L7:UNSIGNED; END; *) (* $PACKED_DEC = [BIT(4),UNSAFE] 0..15; *) (* $DEFTYP = [UNSAFE] INTEGER; *) (* $DEFPTR = [UNSAFE] ^$DEFTYP; *) (* $BOOL = [BIT(1),UNSAFE] BOOLEAN; *) (* $BIT2 = [BIT(2),UNSAFE] 0..3; *) (* $BIT3 = [BIT(3),UNSAFE] 0..7; *) (* $BIT4 = [BIT(4),UNSAFE] 0..15; *) (* $BIT5 = [BIT(5),UNSAFE] 0..31; *) (* $BIT6 = [BIT(6),UNSAFE] 0..63; *) (* $BIT7 = [BIT(7),UNSAFE] 0..127; *) (* $BIT8 = [BIT(8),UNSAFE] 0..255; *) (* $BIT9 = [BIT(9),UNSAFE] 0..511; *) (* $BIT10 = [BIT(10),UNSAFE] 0..1023; *) (* $BIT11 = [BIT(11),UNSAFE] 0..2047; *) (* $BIT12 = [BIT(12),UNSAFE] 0..4095; *) (* $BIT13 = [BIT(13),UNSAFE] 0..8191; *) (* $BIT14 = [BIT(14),UNSAFE] 0..16383; *) (* $BIT15 = [BIT(15),UNSAFE] 0..32767; *) (* $BIT16 = [BIT(16),UNSAFE] 0..65535; *) (* $BIT17 = [BIT(17),UNSAFE] 0..131071; *) (* $BIT18 = [BIT(18),UNSAFE] 0..262143; *) (* $BIT19 = [BIT(19),UNSAFE] 0..524287; *) (* $BIT20 = [BIT(20),UNSAFE] 0..1048575; *) (* $BIT21 = [BIT(21),UNSAFE] 0..2097151; *) (* $BIT22 = [BIT(22),UNSAFE] 0..4194303; *) (* $BIT23 = [BIT(23),UNSAFE] 0..8388607; *) (* $BIT24 = [BIT(24),UNSAFE] 0..16777215; *) (* $BIT25 = [BIT(25),UNSAFE] 0..33554431; *) (* $BIT26 = [BIT(26),UNSAFE] 0..67108863; *) (* $BIT27 = [BIT(27),UNSAFE] 0..134217727; *) (* $BIT28 = [BIT(28),UNSAFE] 0..268435455; *) (* $BIT29 = [BIT(29),UNSAFE] 0..536870911; *) (* $BIT30 = [BIT(30),UNSAFE] 0..1073741823; *) (* $BIT31 = [BIT(31),UNSAFE] 0..2147483647; *) (* $BIT32 = [BIT(32),UNSAFE] UNSIGNED; *) (*** MODULE lib$routines ***) [HIDDEN] TYPE (**** SDL-Generated type names ****) lib$routines$$typ1 = ^$QUAD; lib$routines$$typ2 = $DEFPTR; lib$routines$$typ3 = $DEFPTR; lib$routines$$typ4 = ^$QUAD; lib$routines$$typ5 = ^$QUAD; lib$routines$$typ6 = ^$QUAD; lib$routines$$typ7 = ^$QUAD; lib$routines$$typ8 = ^$QUAD; lib$routines$$typ9 = ^$QUAD; lib$routines$$typ10 = ^$QUAD; lib$routines$$typ11 = ^$QUAD; lib$routines$$typ12 = ^$QUAD; lib$routines$$typ13 = ^$QUAD; lib$routines$$typ14 = ^$QUAD; lib$routines$$typ15 = ^$QUAD; lib$routines$$typ16 = ^$QUAD; lib$routines$$typ17 = ^$UQUAD; lib$routines$$typ18 = ^$UQUAD; lib$routines$$typ19 = ^$UQUAD; lib$routines$$typ20 = ^$UQUAD; lib$routines$$typ21 = ^$UQUAD; lib$routines$$typ22 = ^$UQUAD; lib$routines$$typ23 = ^$UOCTA; lib$routines$$typ24 = ^$UOCTA; lib$routines$$typ25 = ^$UBYTE; lib$routines$$typ26 = ^$UQUAD; lib$routines$$typ27 = ^$UQUAD; lib$routines$$typ28 = ^$UQUAD; lib$routines$$typ29 = ^$UQUAD; lib$routines$$typ30 = ^$UQUAD; lib$routines$$typ31 = ^$UQUAD; lib$routines$$typ32 = ^$UQUAD; lib$routines$$typ33 = ^$UQUAD; lib$routines$$typ34 = ^$UQUAD; lib$routines$$typ35 = ^$UQUAD; lib$routines$$typ36 = ^$UQUAD; lib$routines$$typ37 = ^$UQUAD; lib$routines$$typ38 = ^$UQUAD; lib$routines$$typ39 = ^$UQUAD; lib$routines$$typ40 = ^$QUAD; lib$routines$$typ41 = ^$QUAD; lib$routines$$typ42 = ^$QUAD; lib$routines$$typ43 = ^$QUAD; lib$routines$$typ44 = ^$QUAD; (**************************************************************************** *) (* * *) (* COPYRIGHT (c) 1992, 1994, 1995, 1996, 1997, 2003 BY * *) (* DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS. * *) (* ALL RIGHTS RESERVED. * *) (* * *) (* THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED * *) (* ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE * *) (* INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER * *) (* COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY * *) (* OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY * *) (* TRANSFERRED. * *) (* * *) (* THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE * *) (* AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT * *) (* CORPORATION. * *) (* * *) (* DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS * *) (* SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. * *) (* * *) (* * *) (**************************************************************************** *) (* LIB$ADAWI *) (* *) (* Add Aligned Word with Interlock *) (* *) (* The Add Aligned Word with Interlock routine allows the user to perform an *) (* interlocked add operation using an aligned word. *) (* *) [ASYNCHRONOUS] FUNCTION lib$adawi ( add : $WORD; VAR sum : [VOLATILE] $WORD; VAR sign : [VOLATILE] $WORD) : INTEGER; EXTERNAL; (* LIB$ADDX *) (* *) (* Add Two Multiple-Precision Binary Numbers *) (* *) (* The Add Two Multiple-Precision Binary Numbers routine adds two signed *) (* two's complement integers of arbitrary length. *) (* *) [ASYNCHRONOUS] FUNCTION lib$addx ( %REF addend_array : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF augend_array : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %REF resultant_array : [VOLATILE,UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE; array_length : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$ADD_TIMES *) (* *) (* Add Two Quadword Times *) (* *) (* The Add Two Quadword Times routine adds two VMS internal time format *) (* times. *) (* *) [ASYNCHRONOUS] FUNCTION lib$add_times ( time1 : $UQUAD; time2 : $UQUAD; VAR resultant_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$ANALYZE_SDESC *) (* *) (* Analyze String Descriptors *) (* *) (* The Analyze String Descriptors routine extracts the length and the *) (* address at which the data starts for a variety of string descriptor *) (* classes. *) (* *) [ASYNCHRONOUS] FUNCTION lib$analyze_sdesc ( input_descriptor : $UQUAD; VAR data_length : [VOLATILE] $UWORD; VAR data_address : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$ANALYZE_SDESC_64 *) (* *) (* Analyze String Descriptors *) (* *) (* The Analyze String Descriptors routine extracts the length and the *) (* address at which the data starts for a variety of string descriptor *) (* classes. *) (* *) [ASYNCHRONOUS] FUNCTION lib$analyze_sdesc_64 ( input_descriptor : $UQUAD; VAR data_length : [VOLATILE] $UQUAD; VAR data_address : [VOLATILE] lib$routines$$typ1; VAR descriptor_type : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$ASCII_TO_UID *) (* *) (* Convert Text To UID *) (* *) (* The Convert Text to UID routine converts a standard representation *) (* of a UID in an ASCII text string to a binary UID. *) (* *) [ASYNCHRONOUS] FUNCTION lib$ascii_to_uid ( input_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR output_uid : [VOLATILE] $UOCTA) : INTEGER; EXTERNAL; (* LIB$ASN_WTH_MBX *) (* *) (* Assign Channel with Mailbox *) (* *) (* The Assign Channel with Mailbox routine assigns a channel to a specified *) (* device and associates a mailbox with the device. It returns both the *) (* device channel and the mailbox channel. *) (* *) [ASYNCHRONOUS] FUNCTION lib$asn_wth_mbx ( device_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; maximum_message_size : INTEGER := %IMMED 0; buffer_quota : INTEGER := %IMMED 0; VAR device_channel : [VOLATILE] $UWORD; VAR mailbox_channel : [VOLATILE] $UWORD) : INTEGER; EXTERNAL; (* LIB$AST_IN_PROG *) (* *) (* AST in Progress *) (* *) (* The AST in Progress routine indicates whether an AST is currently in *) (* progress. *) (* *) [ASYNCHRONOUS] FUNCTION lib$ast_in_prog : BOOLEAN; EXTERNAL; (* LIB$ATTACH *) (* *) (* Attach Terminal to Process *) (* *) (* The Attach Terminal to Process routine requests the calling process's *) (* Command Language Interpreter (CLI) to detach the terminal of the calling *) (* process and to reattach it to a different process. *) (* *) [ASYNCHRONOUS] FUNCTION lib$attach ( process_id : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$BBCCI *) (* *) (* Test and Clear Bit with Interlock *) (* *) (* The Test and Clear Bit with Interlock routine tests and clears a *) (* selected bit under memory interlock. *) (* *) [ASYNCHRONOUS] FUNCTION lib$bbcci ( position : INTEGER; %IMMED bit_zero_address : $DEFPTR) : INTEGER; EXTERNAL; (* LIB$BBSSI *) (* *) (* Test and Set Bit with Interlock *) (* *) (* The Test and Set Bit with Interlock routine tests and sets a *) (* selected bit under memory interlock. *) (* *) [ASYNCHRONOUS] FUNCTION lib$bbssi ( position : INTEGER; %IMMED bit_zero_address : $DEFPTR) : INTEGER; EXTERNAL; (* LIB$BUILD_NODESPEC *) (* *) (* Build a Node-Name Specification *) (* *) (* The Build a Node-Name Specification routine builds a node-name *) (* specification from the primary node name. *) (* *) [ASYNCHRONOUS] FUNCTION lib$build_nodespec ( primary_nodename : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR nodespec : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; acs : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; secondary_nodename : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; VAR nodespec_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CALLG *) (* *) (* Call Routine with General Argument List (longword argument list) *) (* *) (* The Call Routine with General Argument List routine calls a routine with *) (* an argument list specified as an array of longwords, the first of which *) (* is a count of the remaining longwords. LIB$CALLG is a callable version *) (* of the VAX CALLG instruction. *) (* *) [ASYNCHRONOUS] FUNCTION lib$callg ( %REF argument_list : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_procedure) : INTEGER; EXTERNAL; (* LIB$CALLG_64 *) (* *) (* Call Routine with General Argument List (quadword argument list) *) (* *) (* The Call Routine with General Argument List routine calls a routine with *) (* an argument list specified as an array of quadwords, the first of which *) (* is a count of the remaining quadwords. LIB$CALLG_64 is a callable *) (* version of the VAX CALLG instruction. *) (* *) [ASYNCHRONOUS] FUNCTION lib$callg_64 ( %REF argument_list : ARRAY [$l1..$u1:INTEGER] OF $UQUAD; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_procedure) : INTEGER; EXTERNAL; (* LIB$CHAR *) (* *) (* Transform Byte to First Character of String *) (* *) (* The Transform Byte to First Character of String routine transforms a *) (* single 8-bit ASCII character to an ASCII string consisting of a single *) (* character followed by trailing spaces, if needed, to fill out the string. *) (* The range of the input byte is 0 through 255. *) (* *) [ASYNCHRONOUS] FUNCTION lib$char ( VAR one_character_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; ascii_code : $UBYTE) : INTEGER; EXTERNAL; (* LIB$COMPARE_NODENAME *) (* *) (* Compare Two Node Names *) (* *) (* The Compare Node Name routine compares two node names *) (* to see if they resolve to the same full name. *) (* *) [ASYNCHRONOUS] FUNCTION lib$compare_nodename ( nodename1 : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; nodename2 : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR comparison_result : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$COMPARE_UID *) (* *) (* Compare Two UIDs *) (* *) (* The Compare Two UIDs routine compares the contents *) (* of two UIDs for total lexical ordering. *) (* *) [ASYNCHRONOUS] FUNCTION lib$compare_uid ( first_uid : $UOCTA; second_uid : $UOCTA; VAR match_result : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$COMPRESS_NODENAME *) (* *) (* Compress a Node Name to its Short Form *) (* *) (* The Compress a Node Name routine compresses a node name to an *) (* unambiguous short form usable within the naming environment *) (* where the compression is performed. *) (* *) [ASYNCHRONOUS] FUNCTION lib$compress_nodename ( nodename : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR compressed_nodename : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CONVERT_DATE_STRING *) (* *) (* Convert Date String to Quadword *) (* *) (* The Convert Date String to Quadword routine converts an absolute date *) (* string into a VMS internal format date-time quadword. That is, given *) (* an input date/time string of a specified format, *) (* LIB$CONVERT_DATE_STRING converts this string to a VMS internal format *) (* time. *) (* *) [ASYNCHRONOUS] FUNCTION lib$convert_date_string ( date_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR date_time : [VOLATILE] $UQUAD; VAR user_context : [VOLATILE] UNSIGNED := %IMMED 0; flags : UNSIGNED := %IMMED 0; %REF defaults : ARRAY [$l5..$u5:INTEGER] OF $UWORD := %IMMED 0; VAR defaulted_fields : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CRC *) (* *) (* Calculate a Cyclic Redundancy Check (CRC) *) (* *) (* The Calculate a Cyclic Redundancy Check routine calculates the cyclic *) (* redundancy check (CRC) for a data stream. *) (* *) [ASYNCHRONOUS] FUNCTION lib$crc ( %REF crc_table : ARRAY [$l1..$u1:INTEGER] OF INTEGER; initial_crc : INTEGER; stream : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$CRC_TABLE *) (* *) (* Construct a Cyclic Redundancy Check (CRC) Table *) (* *) (* The Construct a Cyclic Redundancy Check Table routine constructs a *) (* 16-longword table that uses a cyclic redundancy check polynomial *) (* specification as a bit mask. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$crc_table ( polynomial_coefficient : UNSIGNED; %REF crc_table : [VOLATILE] ARRAY [$l2..$u2:INTEGER] OF INTEGER); EXTERNAL; (* LIB$CREATE_DIR *) (* *) (* Create a Directory *) (* *) (* The Create a Directory routine creates a directory or subdirectory. *) (* *) [ASYNCHRONOUS] FUNCTION lib$create_dir ( device_directory_spec : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; owner_UIC : UNSIGNED := %IMMED 0; protection_enable : $UWORD := %IMMED 0; protection_value : $UWORD := %IMMED 0; maximum_versions : $UWORD := %IMMED 0; relative_volume_number : $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CREATE_USER_VM_ZONE *) (* *) (* Create User-Defined Storage Zone *) (* *) (* The Create User-Defined Storage Zone routine creates a new user-defined *) (* storage zone. *) (* *) [ASYNCHRONOUS] FUNCTION lib$create_user_vm_zone ( VAR zone_id : [VOLATILE] UNSIGNED; user_argument : UNSIGNED := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_allocation_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_deallocation_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_reset_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_delete_procedure := %IMMED 0; zone_name : [CLASS_S] PACKED ARRAY [$l7..$u7:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CREATE_USER_VM_ZONE_64 *) (* *) (* Create User-Defined Storage Zone *) (* *) (* The Create User-Defined Storage Zone routine creates a new user-defined *) (* storage zone. *) (* *) [ASYNCHRONOUS] FUNCTION lib$create_user_vm_zone_64 ( VAR zone_id : [VOLATILE] $UQUAD; user_argument : $UQUAD := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_allocation_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_deallocation_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_reset_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_delete_procedure := %IMMED 0; zone_name : [CLASS_S] PACKED ARRAY [$l7..$u7:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CREATE_VM_ZONE *) (* *) (* Create a New Zone *) (* *) (* The Create a New Zone routine creates a new storage zone according to *) (* specified arguments. *) (* *) [ASYNCHRONOUS] FUNCTION lib$create_vm_zone ( VAR zone_id : [VOLATILE] UNSIGNED; algorithm : INTEGER := %IMMED 0; algorithm_argument : INTEGER := %IMMED 0; flags : UNSIGNED := %IMMED 0; extend_size : INTEGER := %IMMED 0; initial_size : INTEGER := %IMMED 0; block_size : INTEGER := %IMMED 0; alignment : INTEGER := %IMMED 0; page_limit : INTEGER := %IMMED 0; smallest_block_size : INTEGER := %IMMED 0; zone_name : [CLASS_S] PACKED ARRAY [$l11..$u11:INTEGER] OF CHAR := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE get_page := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE free_page := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CREATE_VM_ZONE_64 *) (* *) (* Create a New Zone *) (* *) (* The Create a New Zone routine creates a new storage zone according to *) (* specified arguments. *) (* *) [ASYNCHRONOUS] FUNCTION lib$create_vm_zone_64 ( VAR zone_id : [VOLATILE] $UQUAD; algorithm : $QUAD := %IMMED 0; algorithm_argument : $QUAD := %IMMED 0; flags : $UQUAD := %IMMED 0; extend_size : $QUAD := %IMMED 0; initial_size : $QUAD := %IMMED 0; block_size : $QUAD := %IMMED 0; alignment : $QUAD := %IMMED 0; page_limit : $QUAD := %IMMED 0; smallest_block_size : $QUAD := %IMMED 0; zone_name : [CLASS_S] PACKED ARRAY [$l11..$u11:INTEGER] OF CHAR := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE get_page := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE free_page := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CRF_INS_KEY *) (* *) (* Insert Key in Cross-Reference Table *) (* *) (* The Insert Key in Cross-Reference Table routine inserts information *) (* about a key into a cross-reference table. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$crf_ins_key ( %REF control_table : ARRAY [$l1..$u1:INTEGER] OF INTEGER; key_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; symbol_value : INTEGER; flags : UNSIGNED); EXTERNAL; (* LIB$CRF_INS_REF *) (* *) (* Insert Reference to a Key in the Cross-Reference Table *) (* *) (* The Insert Reference to a Key in the Cross-Reference Table routine *) (* inserts a reference to a key in a cross-reference symbol table. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$crf_ins_ref ( %REF control_table : ARRAY [$l1..$u1:INTEGER] OF INTEGER; longword_integer_key : INTEGER; reference_string : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; VAR longword_integer_reference : [VOLATILE] INTEGER; ref_definition_indicator : INTEGER); EXTERNAL; (* LIB$CRF_OUTPUT *) (* *) (* Output Cross-Reference Table Information *) (* *) (* The Output Cross-Reference Table Information routine extracts the *) (* information from the cross-reference tables and formats the output pages. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$crf_output ( %REF control_table : ARRAY [$l1..$u1:INTEGER] OF INTEGER; output_line_width : INTEGER; page1 : INTEGER; page2 : INTEGER; mode_indicator : INTEGER; delete_save_indicator : INTEGER); EXTERNAL; (* LIB$CURRENCY *) (* *) (* Get System Currency Symbol *) (* *) (* The Get System Currency Symbol routine returns the system's currency *) (* symbol. *) (* *) [ASYNCHRONOUS] FUNCTION lib$currency ( VAR currency_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CVTF_FROM_INTERNAL_TIME *) (* *) (* Convert Internal Time to External Time (F-Floating Point Value) *) (* *) (* The Convert Internal Time to External Time (F-Floating Point Value) *) (* routine converts a delta internal VMS system time into an external *) (* F-floating time. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvtf_from_internal_time ( operation : UNSIGNED; VAR resultant_time : [VOLATILE] SINGLE; input_time : $UQUAD) : INTEGER; EXTERNAL; (* LIB$CVTF_TO_INTERNAL_TIME *) (* *) (* Convert External Time to Internal Time (F-Floating Point Value) *) (* *) (* The Convert External Time to Internal Time (F-Floating Point Value) *) (* routine converts an external time interval into a VMS internal format *) (* F-floating delta time. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvtf_to_internal_time ( operation : UNSIGNED; input_time : SINGLE; VAR resultant_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$CVT_DTB *) (* *) (* Convert Numeric Text to Binary *) (* *) (* The Convert Numeric Text to Binary routine returns a 32-bit binary *) (* representation of the ASCII text string representation of a decimal *) (* number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_dtb ( %IMMED byte_count : INTEGER; %REF numeric_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR result : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$CVT_DTB_64 *) (* *) (* Convert Numeric Text to Binary *) (* *) (* The Convert Numeric Text to Binary routine returns a 64-bit binary *) (* representation of the ASCII text string representation of a decimal *) (* number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_dtb_64 ( %IMMED byte_count : INTEGER; %REF numeric_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR result : [VOLATILE] $QUAD) : INTEGER; EXTERNAL; (* LIB$CVT_DX_DX *) (* *) (* General Data Type Conversion Routine *) (* *) (* The General Data Type Conversion routine converts a VMS standard atomic *) (* or string datum described by a source descriptor to another VMS standard *) (* atomic or string datum described by a destination descriptor. This *) (* conversion is supported over a subset of the VMS standard data types. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_dx_dx ( %REF source_item : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF destination_item : [VOLATILE,UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; VAR word_integer_dest_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CVT_FROM_INTERNAL_TIME *) (* *) (* Convert Internal Time to External Time *) (* *) (* The Convert Internal Time to External Time routine converts an internal *) (* VMS system time (either absolute or delta) into an external time. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_from_internal_time ( operation : UNSIGNED; VAR resultant_time : [VOLATILE] UNSIGNED; input_time : $UQUAD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$CVT_HTB *) (* *) (* Convert Numeric Text to Binary *) (* *) (* The Convert Numeric Text to Binary routine returns a 32-bit binary *) (* representation of the ASCII text string representation of a hexadecimal *) (* number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_htb ( %IMMED byte_count : INTEGER; %REF numeric_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR result : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$CVT_HTB_64 *) (* *) (* Convert Numeric Text to Binary *) (* *) (* The Convert Numeric Text to Binary routine returns a 64-bit binary *) (* representation of the ASCII text string representation of a hexadecimal *) (* number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_htb_64 ( %IMMED byte_count : INTEGER; %REF numeric_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR result : [VOLATILE] $QUAD) : INTEGER; EXTERNAL; (* LIB$CVT_OTB *) (* *) (* Convert Numeric Text to Binary *) (* *) (* The Convert Numeric Text to Binary routine returns a 32-bit binary *) (* representation of the ASCII text string representation of an octal *) (* number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_otb ( %IMMED byte_count : INTEGER; %REF numeric_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR result : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$CVT_OTB_64 *) (* *) (* Convert Numeric Text to Binary *) (* *) (* The Convert Numeric Text to Binary routine returns a 64-bit binary *) (* representation of the ASCII text string representation of an octal *) (* number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_otb_64 ( %IMMED byte_count : INTEGER; %REF numeric_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR result : [VOLATILE] $QUAD) : INTEGER; EXTERNAL; (* LIB$CVT_TO_INTERNAL_TIME *) (* *) (* Convert External Time to Internal Time *) (* *) (* The Convert External Time to Internal Time routine converts an *) (* external time interval into a VMS internal format delta time. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_to_internal_time ( operation : UNSIGNED; input_time : INTEGER; VAR resultant_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$CVT_VECTIM *) (* *) (* Convert Seven-Word Vector to Internal Time *) (* *) (* The Convert Seven-Word Vector to Internal Time routine converts a *) (* seven-word vector into a VMS internal format delta or absolute time. *) (* *) [ASYNCHRONOUS] FUNCTION lib$cvt_vectim ( %REF input_time : ARRAY [$l1..$u1:INTEGER] OF $UWORD; VAR resultant_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$DATE_TIME *) (* *) (* Date and Time Returned as a String *) (* *) (* The Date and Time Returned as a String routine returns the VMS system *) (* date and time in the semantics of a user-provided string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$date_time ( VAR date_time_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$DAY *) (* *) (* Day Number Returned as a Longword Integer *) (* *) (* The Day Number Returned as a Longword Integer routine returns the number *) (* of days since the system zero date of November 17, 1858, or the number *) (* of days from November 17, 1858, to a user-supplied date. *) (* *) [ASYNCHRONOUS] FUNCTION lib$day ( VAR number_of_days : [VOLATILE] INTEGER; user_time : $UQUAD := %IMMED 0; VAR day_time : [VOLATILE] INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DAY_OF_WEEK *) (* *) (* Show Numeric Day of Week *) (* *) (* The Show Numeric Day of Week routine returns the numeric day of the week *) (* for an input time value. If 0 is the input time value, the current day *) (* of the week is returned. The days are numbered 1 through 7, with Monday *) (* as day 1 and Sunday as day 7. *) (* *) [ASYNCHRONOUS] FUNCTION lib$day_of_week ( user_time : $UQUAD := %IMMED 0; VAR day_number : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$DECODE_FAULT *) (* *) (* Decode Instruction Stream During Fault *) (* *) (* The Decode Instruction Stream During Fault routine is a tool for building *) (* condition handlers that process instruction fault exceptions. It is *) (* called from a condition handler. *) (* *) (* This routine is not available to native Alpha VMS programs, but is *) (* available to translated VAX images. *) (* *) [ASYNCHRONOUS] FUNCTION lib$decode_fault ( %REF signal_arguments : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF mechanism_arguments : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_procedure; %IMMED unspecified_user_argument : [UNSAFE] INTEGER := %IMMED 0; %REF instruction_definitions : ARRAY [$l5..$u5:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DEC_OVER *) (* *) (* Enable or Disable Decimal Overflow Detection *) (* *) (* The Enable or Disable Decimal Overflow Detection routine enables or *) (* disables decimal overflow detection for the calling routine activation. *) (* The previous decimal overflow setting is returned. *) (* *) (* This routine is available on Alpha VMS systems in translated form *) (* and is applicable to translated VAX images only. *) (* *) [ASYNCHRONOUS] FUNCTION lib$dec_over ( new_setting : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$DELETE_FILE *) (* *) (* Delete One or More Files *) (* *) (* The Delete One or More Files routine deletes one or more files. The *) (* specification of the file(s) to be deleted may include wildcards. *) (* LIB$DELETE_FILE is similar in function to the DCL command DELETE. *) (* *) [ASYNCHRONOUS] FUNCTION lib$delete_file ( filespec : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; default_filespec : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; related_filespec : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_success_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_error_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_confirm_procedure := %IMMED 0; %IMMED user_specified_argument : [UNSAFE] INTEGER := %IMMED 0; VAR resultant_name : [CLASS_S,VOLATILE] PACKED ARRAY [$l8..$u8:INTEGER] OF CHAR := %IMMED 0; VAR file_scan_context : [VOLATILE] UNSIGNED := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DELETE_LOGICAL *) (* *) (* Delete Logical Name *) (* *) (* The Delete Logical Name routine requests the calling process's Command *) (* Language Interpreter (CLI) to delete a supervisor-mode process logical *) (* name. LIB$DELETE_LOGICAL provides the same function as the DCL command *) (* DEASSIGN. *) (* *) [ASYNCHRONOUS] FUNCTION lib$delete_logical ( logical_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; table_name : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DELETE_SYMBOL *) (* *) (* Delete CLI Symbol *) (* *) (* The Delete CLI Symbol routine requests the calling process's Command *) (* Language Interpreter (CLI) to delete an existing CLI symbol. *) (* *) [ASYNCHRONOUS] FUNCTION lib$delete_symbol ( symbol : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; table_type_indicator : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DELETE_VM_ZONE *) (* *) (* Delete Virtual Memory Zone *) (* *) (* The Delete Virtual Memory Zone routine deletes a zone and *) (* returns all pages on VAX or pagelets on Alpha owned by the *) (* zone to the processwide page pool. *) (* *) [ASYNCHRONOUS] FUNCTION lib$delete_vm_zone ( zone_id : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$DELETE_VM_ZONE_64 *) (* *) (* Delete Virtual Memory Zone *) (* *) (* The Delete Virtual Memory Zone routine deletes a zone and *) (* returns all pages on VAX or pagelets on Alpha owned by the *) (* zone to the processwide page pool. *) (* *) [ASYNCHRONOUS] FUNCTION lib$delete_vm_zone_64 ( zone_id : $UQUAD) : INTEGER; EXTERNAL; (* LIB$DIGIT_SEP *) (* *) (* Get Digit Separator Symbol *) (* *) (* The Get Digit Separator Symbol routine returns the system's digit *) (* separator symbol. *) (* *) [ASYNCHRONOUS] FUNCTION lib$digit_sep ( VAR digit_separator_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DISABLE_CTRL *) (* *) (* Disable CLI Interception of Control Characters *) (* *) (* The Disable CLI Interception of Control Characters routine requests the *) (* calling process's Command Language Interpreter (CLI) to not intercept *) (* the selected control characters when they are typed during an interactive *) (* terminal session. LIB$DISABLE_CTRL provides the same function as the *) (* DCL command SET NOCONTROL. *) (* *) [ASYNCHRONOUS] FUNCTION lib$disable_ctrl ( disable_mask : UNSIGNED; VAR old_mask : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$DO_COMMAND *) (* *) (* Execute Command *) (* *) (* The Execute Command routine stops program execution and directs the *) (* Command Language Interpreter to execute a command which you supply as *) (* the argument. If successful, LIB$DO_COMMAND does not return control *) (* to the calling program. Instead, LIB$DO_COMMAND begins execution of *) (* the specified command. If you want control to return to the caller, *) (* use LIB$SPAWN instead. *) (* *) [ASYNCHRONOUS] FUNCTION lib$do_command ( command_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$EDIV *) (* *) (* Extended-Precision Divide *) (* *) (* The Extended-Precision Divide routine performs extended-precision *) (* division. LIB$EDIV makes the VAX EDIV instruction available as a *) (* callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$ediv ( longword_integer_divisor : INTEGER; quadword_integer_dividend : $QUAD; VAR longword_integer_quotient : [VOLATILE] INTEGER; VAR remainder : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$EMODD *) (* *) (* Extended Multiply and Integerize Routines for D-Floating Point Values *) (* *) (* The Extended Multiply and Integerize routine (D-Floating Point Values) *) (* allows higher-level language users to perform accurate range reduction *) (* of D-floating arguments. *) (* *) (* D-floating point values are not supported in full precision on Alpha *) (* systems. They are precise to 56 bits on VAX systems, 53 bits on Alpha *) (* systems. *) (* *) [ASYNCHRONOUS] FUNCTION lib$emodd ( floating_point_multiplier : D_FLOAT$$TYPE; multiplier_extension : $UBYTE; floating_point_multiplicand : D_FLOAT$$TYPE; VAR integer_portion : [VOLATILE] INTEGER; VAR fractional_portion : [VOLATILE] D_FLOAT$$TYPE) : INTEGER; EXTERNAL; (* LIB$EMODT *) (* *) (* Extended Multiply and Integerize Routines for T-Floating Point Values *) (* *) (* The Extended Multiply and Integerize routine (T-Floating Point Values) *) (* allows higher-level language users to perform accurate range reduction *) (* of T-floating arguments. *) (* *) (* *) [ASYNCHRONOUS] FUNCTION lib$emodt ( floating_point_multiplier : D_FLOAT$$TYPE; multiplier_extension : $UBYTE; floating_point_multiplicand : D_FLOAT$$TYPE; VAR integer_portion : [VOLATILE] INTEGER; VAR fractional_portion : [VOLATILE] D_FLOAT$$TYPE) : INTEGER; EXTERNAL; (* LIB$EMODF *) (* *) (* Extended Multiply and Integerize Routines for F-Floating Point Values *) (* *) (* The Extended Multiply and Integerize routine (F-Floating Point Values) *) (* allows higher-level language users to perform accurate range reduction *) (* of F-floating arguments. *) (* *) [ASYNCHRONOUS] FUNCTION lib$emodf ( floating_point_multiplier : SINGLE; multiplier_extension : $UBYTE; floating_point_multiplicand : SINGLE; VAR integer_portion : [VOLATILE] INTEGER; VAR fractional_portion : [VOLATILE] SINGLE) : INTEGER; EXTERNAL; (* LIB$EMODG *) (* *) (* Extended Multiply and Integerize Routines for G-Floating Point Values *) (* *) (* The Extended Multiply and Integerize routine (G-Floating Point Values) *) (* allows higher-level language users to perform accurate range reduction *) (* of G-floating arguments. *) (* *) [ASYNCHRONOUS] FUNCTION lib$emodg ( floating_point_multiplier : G_FLOAT$$TYPE; multiplier_extension : $UWORD; floating_point_multiplicand : G_FLOAT$$TYPE; VAR integer_portion : [VOLATILE] INTEGER; VAR fractional_portion : [VOLATILE] G_FLOAT$$TYPE) : INTEGER; EXTERNAL; (* LIB$EMODH *) (* *) (* Extended Multiply and Integerize Routines for H-Floating Point Values *) (* *) (* On VAX VMS, the Extended Multiply and Integerize routine (H-Floating *) (* Point Values) allows higher-level language users to perform accurate *) (* range reduction of H-floating arguments. *) (* *) [ASYNCHRONOUS] FUNCTION lib$emodh ( floating_point_multiplier : QUADRUPLE; multiplier_extension : $UWORD; floating_point_multiplicand : QUADRUPLE; VAR integer_portion : [VOLATILE] INTEGER; VAR fractional_portion : [VOLATILE] QUADRUPLE) : INTEGER; EXTERNAL; (* LIB$EMUL *) (* *) (* Extended-Precision Multiply *) (* *) (* The Extended-Precision Multiply routine performs extended-precision *) (* multiplication. LIB$EMUL makes the VAX EMUL instruction available as *) (* a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$emul ( longword_integer_multiplier : INTEGER; longword_integer_multiplicand : INTEGER; addend : INTEGER; VAR product : [VOLATILE] $QUAD) : INTEGER; EXTERNAL; (* LIB$ENABLE_CTRL *) (* *) (* Enable CLI Interception of Control Characters *) (* *) (* The Enable CLI Interception of Control Characters routine requests the *) (* calling process's Command Language Interpreter (CLI) to resume *) (* interception of the selected control characters when they are typed *) (* during an interactive terminal session. LIB$ENABLE_CTRL provides the *) (* same function as the DCL command SET CONTROL. *) (* *) [ASYNCHRONOUS] FUNCTION lib$enable_ctrl ( enable_mask : UNSIGNED; VAR old_mask : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$ESTABLISH *) (* *) (* Establish a Condition Handler *) (* *) (* The Establish a Condition Handler routine moves the address of a *) (* condition handling routine (which can be a user-written or a library *) (* routine) to longword 0 of the stack frame of the caller of LIB$ESTABLISH. *) (* *) (* ENTRY lib$establish ALIAS $lib_establish PARAMETER ( *) (* ADDRESS (ENTRY) NAMED new_handler IN *) (* TYPENAME procedure VALUE ) *) (* RETURNS ADDRESS (ENTRY) NAMED RESULT TYPENAME routine; *) (* LIB$EXPAND_NODENAME *) (* *) (* Expand a Node Name to its Full Name equivalent *) (* *) (* The Expand a Node Name to its Full Name equivalent routine *) (* expands a node name to its full name equivalent. *) (* *) [ASYNCHRONOUS] FUNCTION lib$expand_nodename ( nodename : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR fullname : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$EXTV *) (* *) (* Extract a Field and Sign-Extend *) (* *) (* The Extract a Field and Sign-Extend routine returns a sign-extended *) (* longword field that has been extracted from the specified variable bit *) (* field. LIB$EXTV makes the VAX EXTV instruction available as a callable *) (* routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$extv ( position : INTEGER; size : $UBYTE; %IMMED base_address : $DEFPTR) : INTEGER; EXTERNAL; (* LIB$EXTZV *) (* *) (* Extract a Zero-Extended Field *) (* *) (* The Extract a Zero-Extended Field routine returns a longword *) (* zero-extended field that has been extracted from the specified *) (* variable bit field. LIB$EXTZV makes the VAX EXTZV instruction *) (* available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$extzv ( position : INTEGER; size : $UBYTE; %IMMED base_address : $DEFPTR) : INTEGER; EXTERNAL; (* LIB$FFC *) (* *) (* Find First Clear or Set Bit *) (* *) (* The Find First Clear or Set Bit routines search the field specified by *) (* the start position, size, and base for the first clear or set bit. *) (* LIB$FFC and LIB$FFS make the VAX FFC and VAX FFS instructions available *) (* as callable routines. *) (* *) (* On Alpha VMS systems, Alpha instructions perform the *) (* equivalent operations. *) (* *) [ASYNCHRONOUS] FUNCTION lib$ffc ( position : INTEGER; size : $UBYTE; base : $DEFPTR; VAR find_position : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$FFS *) (* *) (* Find First Clear or Set Bit *) (* *) (* The Find First Clear or Set Bit routines search the field specified by *) (* the start position, size, and base for the first clear or set bit. *) (* LIB$FFC and LIB$FFS make the VAX FFC and VAX FFS instructions available *) (* as callable routines. *) (* *) (* On Alpha VMS systems, Alpha instructions perform the *) (* equivalent operations. *) (* *) [ASYNCHRONOUS] FUNCTION lib$ffs ( position : INTEGER; size : $UBYTE; base : $DEFPTR; VAR find_position : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$FID_TO_NAME *) (* *) (* Convert Device and File ID to File Specification *) (* *) (* The Convert Device and File ID to File Specification routine converts a *) (* disk device name and file identifier to a file specification. *) (* *) [ASYNCHRONOUS] FUNCTION lib$fid_to_name ( device_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; %REF file_id : ARRAY [$l2..$u2:INTEGER] OF $UWORD; VAR filespec : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; VAR filespec_length : [VOLATILE] $UWORD := %IMMED 0; %REF directory_id : ARRAY [$l5..$u5:INTEGER] OF $UWORD := %IMMED 0; VAR acp_status : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FILE_SCAN *) (* *) (* File Scan *) (* *) (* The File Scan routine searches an area, such as a directory, for all *) (* files matching the file specification given and transfers program *) (* execution to the specified user-written routine. Wildcards are *) (* acceptable. An action routine is called for each file and/or error *) (* found. LIB$FILE_SCAN allows the search sequence to continue even if *) (* an error occurs while processing a particular file. *) (* CP120606 - Changed fab type from unsigned int * to struct _fabdef * *) (* and data types of arguments to user_success_procedure and *) (* user_error_procedure from void to __unknown_params *) (* *) [ASYNCHRONOUS] FUNCTION lib$file_scan ( fab : lib$routines$$typ2; %IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION user_success_procedure : INTEGER; %IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION user_error_procedure : INTEGER; VAR context : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FILE_SCAN_END *) (* *) (* End-of-File Scan *) (* *) (* The End-of-File Scan routine is called after each sequence of calls to *) (* LIB$FILE_SCAN. LIB$FILE_SCAN_END deallocates any saved Record Management *) (* Service (RMS) context and/or deallocates the virtual memory that had been *) (* allocated for holding the related file specification information. *) (* CP - Changed fab type from unsigned int * to struct _fabdef * *) (* *) [ASYNCHRONOUS] FUNCTION lib$file_scan_end ( VAR fab : [VOLATILE] lib$routines$$typ3 := %IMMED 0; VAR context : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FIND_FILE *) (* *) (* Find File *) (* *) (* The Find File routine is called with a wildcard file specification for *) (* which it searches. LIB$FIND_FILE returns all file specifications that *) (* satisfy that wildcard file specification. *) (* *) [ASYNCHRONOUS] FUNCTION lib$find_file ( filespec : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_filespec : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR context : [VOLATILE] UNSIGNED; default_filespec : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; related_filespec : [CLASS_S] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0; VAR status_value : [VOLATILE] UNSIGNED := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FIND_FILE_END *) (* *) (* End of Find File *) (* *) (* The End of Find File routine is called once after each sequence of calls *) (* to LIB$FIND_FILE. LIB$FIND_FILE_END deallocates any saved Record *) (* Management Service (RMS) context and deallocates the virtual memory used *) (* to hold the allocated context block. *) (* *) [ASYNCHRONOUS] FUNCTION lib$find_file_end ( context : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$FIND_IMAGE_SYMBOL *) (* *) (* Find Universal Symbol in Shareable Image File *) (* *) (* The Find Universal Symbol in Shareable Image File routine reads *) (* universal symbols from the shareable image file. This routine then *) (* dynamically activates a shareable image into the P0 address space of *) (* a process. *) (* *) [ASYNCHRONOUS] FUNCTION lib$find_image_symbol ( filename : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; symbol : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR symbol_value : [VOLATILE] INTEGER; image_name : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; %IMMED flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FIND_VM_ZONE *) (* *) (* Return the Next Valid Zone Identifier *) (* *) (* The Return the Next Valid Zone Identifier routine returns the *) (* zone identifier of the next valid zone in the heap management *) (* database. *) (* *) [ASYNCHRONOUS] FUNCTION lib$find_vm_zone ( VAR context : [VOLATILE] UNSIGNED; VAR zone_id : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$FIND_VM_ZONE_64 *) (* *) (* Return the Next Valid Zone Identifier *) (* *) (* The Return the Next Valid Zone Identifier routine returns the *) (* zone identifier of the next valid zone in the heap management *) (* database. *) (* *) [ASYNCHRONOUS] FUNCTION lib$find_vm_zone_64 ( VAR context : [VOLATILE] $UQUAD; VAR zone_id : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$FIT_NODENAME *) (* *) (* Fit a Node Name into an output field *) (* *) (* The Fit a Node Name into an output field routine *) (* fits a Node Name into an output field. *) (* *) [ASYNCHRONOUS] FUNCTION lib$fit_nodename ( nodename : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR output_buffer : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; output_width : $UWORD := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FIXUP_FLT *) (* *) (* Fix Floating Reserved Operand *) (* *) (* The Fix Floating Reserved Operand routine finds the reserved operand of *) (* any F-floating, D-floating, G-floating, or H-floating instruction (with *) (* some exceptions) after a reserved operand fault has been signaled. *) (* LIB$FIXUP_FLT changes the reserved operand from --0.0 to the value of *) (* the new-operand argument, if present; or to +0.0 if new-operand is *) (* absent. *) (* *) (* This routine is available on Alpha VMS systems in translated form *) (* and is applicable to translated VAX images only. *) (* *) [ASYNCHRONOUS] FUNCTION lib$fixup_flt ( %REF signal_arguments : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF mechanism_arguments : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; new_operand : SINGLE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FLT_UNDER *) (* *) (* Floating-Point Underflow Detection *) (* *) (* The Floating-Point Underflow Detection routine enables or disables *) (* floating-point underflow detection for the calling routine activation. *) (* The previous setting is returned as a function value. *) (* *) (* This routine is available on Alpha VMS systems in translated form *) (* and is applicable to translated VAX images only. *) (* *) [ASYNCHRONOUS] FUNCTION lib$flt_under ( new_setting : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$FORMAT_DATE_TIME *) (* *) (* Format Date and/or Time *) (* *) (* The Format Date and/or Time routine allows the user to select at run time *) (* a specific output language and format for a date or time, or both. *) (* *) [ASYNCHRONOUS] FUNCTION lib$format_date_time ( VAR date_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; date : $UQUAD := %IMMED 0; VAR user_context : [VOLATILE] UNSIGNED := %IMMED 0; VAR date_length : [VOLATILE] INTEGER := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FORMAT_SOGW_PROT *) (* *) (* Format Protection Mask *) (* *) (* The Format Protection Mask routine translates a protection mask *) (* into a formatted string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$format_sogw_prot ( protection_mask : $UWORD; %REF access_names : ARRAY [$l2..$u2:INTEGER] OF $UQUAD := %IMMED 0; %REF ownership_names : ARRAY [$l3..$u3:INTEGER] OF $UQUAD := %IMMED 0; ownership_separator : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; list_separator : [CLASS_S] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0; VAR protection_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l6..$u6:INTEGER] OF CHAR; VAR protection_length : [VOLATILE] $WORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FREE_DATE_TIME_CONTEXT *) (* *) (* Free the Context Area Used When Formatting Dates and Times for Input or *) (* Output *) (* *) (* The Free the Context Area Used When Formatting Dates and Times for Input *) (* or Output routine frees the virtual memory associated with the context *) (* area used by the date/time input and output Formatting Routines. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_date_time_context ( VAR user_context : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FREE_EF *) (* *) (* Free Event Flag *) (* *) (* The Free Event Flag routine frees a local event flag previously allocated *) (* by LIB$GET_EF. LIB$FREE_EF is the complement of LIB$GET_EF. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_ef ( event_flag_number : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$FREE_LUN *) (* *) (* Free Logical Unit Number *) (* *) (* The Free Logical Unit Number routine releases a logical unit number *) (* allocated by LIB$GET_LUN to the pool of available numbers. LIB$FREE_LUN *) (* is the complement of LIB$GET_LUN. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_lun ( logical_unit_number : INTEGER) : INTEGER; EXTERNAL; (* LIB$FREE_TIMER *) (* *) (* Free Timer Storage *) (* *) (* The Free Timer Storage routine frees the storage allocated *) (* by LIB$INIT_TIMER. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_timer ( VAR handle_address : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$FREE_VM *) (* *) (* Free Virtual Memory from Program Region *) (* *) (* The Free Virtual Memory from Program Region routine deallocates an *) (* entire block of contiguous bytes that were allocated by a previous call *) (* to LIB$GET_VM. The arguments passed are the same as for LIB$GET_VM. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_vm ( number_of_bytes : INTEGER; base_address : $DEFPTR; zone_id : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FREE_VM_64 *) (* *) (* Free Virtual Memory from Program Region *) (* *) (* The Free Virtual Memory from Program Region routine deallocates an *) (* entire block of contiguous bytes that were allocated by a previous call *) (* to LIB$GET_VM_64. The arguments passed are the same as for *) (* LIB$GET_VM_64. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_vm_64 ( number_of_bytes : $QUAD; base_address : lib$routines$$typ4; zone_id : $UQUAD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$FREE_VM_PAGE *) (* *) (* Free Virtual Memory Page *) (* *) (* The Free Virtual Memory Page routine deallocates a block of *) (* contiguous pages on VAX or pagelets on Alpha that were allocated *) (* by previous calls to LIB$GET_VM_PAGE. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_vm_page ( number_of_pages : INTEGER; base_address : $DEFPTR) : INTEGER; EXTERNAL; (* LIB$FREE_VM_PAGE_64 *) (* *) (* Free Virtual Memory Page *) (* *) (* The Free Virtual Memory Page routine deallocates a block of *) (* contiguous pages on VAX or pagelets on Alpha that were allocated *) (* by previous calls to LIB$GET_VM_PAGE_64. *) (* *) [ASYNCHRONOUS] FUNCTION lib$free_vm_page_64 ( number_of_pages : $QUAD; base_address : lib$routines$$typ5) : INTEGER; EXTERNAL; (* LIB$GETDVI *) (* *) (* Get Device/Volume Information *) (* *) (* The Get Device/Volume Information routine provides a simplified interface *) (* to the $GETDVI system service. It returns information about the primary *) (* and secondary device characteristics of an I/O device. The calling *) (* process need not have a channel assigned to the device about which it *) (* wants information. *) (* *) [ASYNCHRONOUS] FUNCTION lib$getdvi ( item_code : INTEGER; channel : $UWORD := %IMMED 0; device_name : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; VAR longword_integer_value : [VOLATILE] INTEGER := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; path_name : [CLASS_S] PACKED ARRAY [$l7..$u7:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GETJPI *) (* *) (* Get Job/Process Information *) (* *) (* The Get Job/Process Information routine provides a simplified interface *) (* to the $GETJPI system service. It provides accounting, status, and *) (* identification information about a specified process. *) (* LIB$GETJPI obtains only one item of information in a single call. *) (* *) [ASYNCHRONOUS] FUNCTION lib$getjpi ( item_code : INTEGER; VAR process_id : [VOLATILE] UNSIGNED := %IMMED 0; process_name : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; %REF resultant_value : [VOLATILE,UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GETQUI *) (* *) (* Get Queue Information *) (* *) (* The Get Queue Information routine provides a simplified interface to the *) (* $GETQUI system service. It provides queue, job, file, characteristic, *) (* and form information about a specified process. *) (* LIB$GETQUI obtains only one item of information in a single call. *) (* *) [ASYNCHRONOUS] FUNCTION lib$getqui ( function_code : INTEGER; item_code : INTEGER := %IMMED 0; search_number : INTEGER := %IMMED 0; search_name : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; search_flags : UNSIGNED := %IMMED 0; %REF resultant_value : [VOLATILE,UNSAFE] ARRAY [$l6..$u6:INTEGER] OF $UBYTE := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l7..$u7:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $WORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GETSYI *) (* *) (* Get Systemwide Information *) (* *) (* The Get Systemwide Information routine provides a simplified interface *) (* to the $GETSYI system service. The $GETSYI system service obtains status *) (* and identification information about the system. *) (* LIB$GETSYI returns only one item of information in a single call. *) (* *) [ASYNCHRONOUS] FUNCTION lib$getsyi ( item_code : INTEGER; %REF resultant_value : [VOLATILE,UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR cluster_system_id : [VOLATILE] UNSIGNED := %IMMED 0; node_name : [CLASS_S] PACKED ARRAY [$l6..$u6:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_ACCNAM *) (* *) (* Get Access Name Table for Protected Object Class *) (* *) (* The Get Access Name Table for Protected Object Class routine returns *) (* a pointer to the access name table for a protected object class that *) (* is specified by name. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_accnam ( clsnam : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR := %IMMED 0; objnam : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; VAR accnam : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$GET_ACCNAM_BY_CONTEXT *) (* *) (* Get Access Name Table for Protected Object Class *) (* *) (* The Get Access Name Table for Protected Object Class routine returns *) (* a pointer to the access name table for a protected object class that *) (* is specified by a context. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_accnam_by_context ( contxt : UNSIGNED; VAR accnam : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$GET_COMMAND *) (* *) (* Get Line from SYS$COMMAND *) (* *) (* The Get Line from SYS$COMMAND routine gets one record of ASCII text from *) (* the current controlling input device, specified by the logical name *) (* SYS$COMMAND. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_command ( VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; prompt_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_COMMON *) (* *) (* Get String from Common *) (* *) (* The Get String from Common routine copies a string in the common area to *) (* the destination string. (The common area is an area of storage which *) (* remains defined across multiple image activations in a process.) The *) (* string length is taken from the first longword of the common area. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_common ( VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_DATE_FORMAT *) (* *) (* Get the User's Date Input Format *) (* *) (* The Get The User's Date Input Format routine returns information about *) (* the user's choice of a date/time input format. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_date_format ( VAR format_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR user_context : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_EF *) (* *) (* Get Event Flag *) (* *) (* The Get Event Flag routine allocates one local event flag from a *) (* process-wide pool and returns the number of the allocated flag to the *) (* caller. If no flags are available, LIB$GET_EF returns an error as its *) (* function value. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_ef ( VAR event_flag_number : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$GET_FOREIGN *) (* *) (* Get Foreign Command Line *) (* *) (* The Get Foreign Command Line routine requests the calling image's *) (* Command Language Interpreter (CLI) to return the contents of the *) (* foreign command line that activated the current image. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_foreign ( VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; prompt_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR flags : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_FULLNAME_OFFSET *) (* *) (* Get the Offset to the Starting Position of the Most Significant *) (* Part of a Full Name *) (* *) (* The Get the Offset to the Starting Position of the Most Significant *) (* Part of a Full Name routine gets the offset to the starting *) (* position of the most significant part of a full name. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_fullname_offset ( fullname : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR offset : [VOLATILE] $UWORD) : INTEGER; EXTERNAL; (* LIB$GET_HOSTNAME *) (* *) (* Get Host Node Name *) (* *) (* The Get Host Node Name routine returns the host node name of *) (* the local system. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_hostname ( VAR hostname : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_INPUT *) (* *) (* Get Line from SYS$INPUT *) (* *) (* The Get Line from SYS$INPUT routine gets one record of ASCII text from *) (* the current controlling input device, specified by SYS$INPUT. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_input ( VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; prompt_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_LOGICAL *) (* *) (* Get Logical *) (* *) (* The Get Logical routine gets the logical name information by calling *) (* the system service routine SYS$TRNLNM. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_logical ( logical_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; table_name : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; VAR max_index : [VOLATILE] INTEGER := %IMMED 0; index : UNSIGNED := %IMMED 0; acmode : $UBYTE := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_LUN *) (* *) (* Get Logical Unit Number *) (* *) (* The Get Logical Unit Number routine allocates one logical unit number *) (* from a process-wide pool. If a unit is available, its number is returned *) (* to the caller. Otherwise, an error is returned as the function value. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_lun ( VAR logical_unit_number : [VOLATILE] INTEGER) : INTEGER; EXTERNAL; (* LIB$GET_MAXIMUM_DATE_LENGTH *) (* *) (* Retrieve the Maximum Length of a Date/Time String *) (* *) (* Given an output format and language, the Retrieve the Maximum Length *) (* of a Date/Time String routine determines the maximum possible length for *) (* the date-string string returned by LIB$FORMAT_DATE_TIME. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_maximum_date_length ( VAR date_length : [VOLATILE] INTEGER; VAR user_context : [VOLATILE] UNSIGNED := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_SYMBOL *) (* *) (* Get Value of CLI Symbol *) (* *) (* The Get Value of CLI Symbol routine requests the calling process's *) (* Command Language Interpreter (CLI) to return the value of a CLI symbol *) (* as a string. LIB$GET_SYMBOL then returns the string to the caller. *) (* Optionally, LIB$GET_SYMBOL can return the length of the returned value *) (* and the table in which the symbol was found. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_symbol ( symbol : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR table_type_indicator : [VOLATILE] INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_UIB_INFO ** IPF only ** *) (* *) (* Returns information from the unwind information block (UIB). *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_uib_info ( uib_va : lib$routines$$typ6; handler_base : lib$routines$$typ7 := %IMMED 0; VAR uw_desc_va : [VOLATILE] lib$routines$$typ8 := %IMMED 0; VAR uw_desc_len : [VOLATILE] lib$routines$$typ9 := %IMMED 0; VAR handler_fv : [VOLATILE] lib$routines$$typ10 := %IMMED 0; VAR ossd_va : [VOLATILE] lib$routines$$typ11 := %IMMED 0; VAR lsda_va : [VOLATILE] lib$routines$$typ12 := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_USERS_LANGUAGE *) (* *) (* Return the User's Language *) (* *) (* The Return the User's Language routine determines the user's choice of *) (* a natural language. The choice is determined by translating the logical *) (* SYS$LANGUAGE. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_users_language ( VAR language : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$GET_VM *) (* *) (* Allocate Virtual Memory *) (* *) (* The Allocate Virtual Memory routine allocates a specified number of *) (* contiguous bytes in the program region and returns the virtual address *) (* of the first byte allocated. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_vm ( number_of_bytes : INTEGER; VAR base_address : [VOLATILE] $DEFPTR; zone_id : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_VM_64 *) (* *) (* Allocate Virtual Memory *) (* *) (* The Allocate Virtual Memory routine allocates a specified number of *) (* contiguous bytes in the program region and returns the virtual address *) (* of the first byte allocated. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_vm_64 ( number_of_bytes : $QUAD; VAR base_address : [VOLATILE] lib$routines$$typ13; zone_id : $UQUAD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$GET_VM_PAGE *) (* *) (* Get Virtual Memory Page *) (* *) (* The Get Virtual Memory Page routine allocates a specified number of *) (* contiguous pages on VAX and pagelets on Alpha of memory in the program *) (* region and returns the virtual address of the first allocated page on *) (* VAX and pagelet on Alpha. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_vm_page ( number_of_pages : INTEGER; VAR base_address : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$GET_VM_PAGE_64 *) (* *) (* Get Virtual Memory Page *) (* *) (* The Get Virtual Memory Page routine allocates a specified number of *) (* contiguous pages on VAX and pagelets on Alpha of memory in the program *) (* region and returns the virtual address of the first allocated page on *) (* VAX and pagelet on Alpha. *) (* *) [ASYNCHRONOUS] FUNCTION lib$get_vm_page_64 ( number_of_pages : $QUAD; VAR base_address : [VOLATILE] lib$routines$$typ14) : INTEGER; EXTERNAL; (* LIB$ICHAR *) (* *) (* Convert First Character of String to Integer *) (* *) (* The Convert First Character of String to Integer routine converts the *) (* first character of a source string to an 8-bit ASCII integer extended *) (* to a longword. *) (* *) [ASYNCHRONOUS] FUNCTION lib$ichar ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$INDEX *) (* *) (* Index to Relative Position of Substring *) (* *) (* The Index to Relative Position of Substring routine returns an index, *) (* which is the relative position of the first occurrence of a substring *) (* in the source string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$index ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; sub_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$INIT_DATE_TIME_CONTEXT *) (* *) (* Initialize the Context Area Used in Formatting Dates and Times for Input *) (* or Output *) (* *) (* The Initialize the Context Area Used in Formatting Dates and Times for *) (* Input or Output routine allows the user to initialize the context area *) (* used by LIB$FORMAT_DATE_TIME or LIB$CONVERT_DATE_STRING with specific *) (* strings, instead of through logical name translation. *) (* *) [ASYNCHRONOUS] FUNCTION lib$init_date_time_context ( VAR user_context : [VOLATILE] UNSIGNED; component : INTEGER; init_string : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$INIT_TIMER *) (* *) (* Initialize Times and Counts *) (* *) (* The Initialize Times and Counts routine stores the current values of *) (* specified times and counts for use by LIB$SHOW_TIMER or LIB$STAT_TIMER. *) (* *) [ASYNCHRONOUS] FUNCTION lib$init_timer ( VAR context : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSERT_TREE *) (* *) (* Insert Entry in a Balanced Binary Tree *) (* *) (* The Insert Entry in a Balanced Binary Tree routine inserts a node in a *) (* balanced binary tree. *) (* *) [ASYNCHRONOUS] FUNCTION lib$insert_tree ( VAR treehead : [VOLATILE] $DEFPTR; %REF symbol : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; flags : UNSIGNED; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_compare_routine; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_allocation_procedure; VAR new_node : [VOLATILE] $DEFPTR; %IMMED user_data : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSERT_TREE_64 *) (* *) (* Insert Entry in a Balanced Binary Tree *) (* *) (* The Insert Entry in a Balanced Binary Tree routine inserts a node in a *) (* balanced binary tree. *) (* *) [ASYNCHRONOUS] FUNCTION lib$insert_tree_64 ( VAR treehead : [VOLATILE] lib$routines$$typ15; %REF symbol : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; flags : UNSIGNED; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_compare_routine; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_allocation_procedure; VAR new_node : [VOLATILE] lib$routines$$typ16; %IMMED user_data : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSQHI *) (* *) (* Insert Entry at Head of Queue *) (* *) (* The Insert Entry at Head of Queue routine inserts a queue entry at the *) (* head of the specified self-relative interlocked longword queue. *) (* LIB$INSQHI makes the VAX INSQHI instruction available as a callable *) (* routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$insqhi ( %REF ENTRY : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; VAR header : [VOLATILE] $QUAD; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSQHIQ *) (* *) (* Insert Entry at Head of Queue (Quadword) *) (* *) (* The Insert Entry at Head of Queue routine inserts a queue entry at the *) (* head of the specified self-relative interlocked quadword queue. *) (* LIB$INSQHIQ makes the Alpha unprivileged PALcode instruction INSQHIQ *) (* available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$insqhiq ( %REF ENTRY : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; VAR header : [VOLATILE] $OCTA; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSQTI *) (* *) (* Insert Entry at Tail of Queue *) (* *) (* The Insert Entry at Tail of Queue routine inserts a queue entry at the *) (* tail of the specified self-relative interlocked longword queue. *) (* LIB$INSQTI makes the VAX INSQTI instruction available as a callable *) (* routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$insqti ( %REF ENTRY : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; VAR header : [VOLATILE] $QUAD; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSQTIQ *) (* *) (* Insert Entry at Tail of Queue (Quadword) *) (* *) (* The Insert Entry at Tail of Queue routine inserts a queue entry at the *) (* tail of the specified self-relative interlocked quadword queue. *) (* LIB$INSQTIQ makes the Alpha unprivileged PALcode instruction INSQTIQ *) (* available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$insqtiq ( %REF ENTRY : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; VAR header : [VOLATILE] $OCTA; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$INSV *) (* *) (* Insert a Variable Bit Field *) (* *) (* The Insert a Variable Bit Field routine replaces the variable bit field *) (* specified by the base, position, and size arguments with bits 0 through *) (* of the source field. If the size of the bit field is zero, nothing is *) (* inserted. LIB$INSV makes the VAX INSV instruction available as a *) (* callable routine. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$insv ( longword_integer_source : INTEGER; position : INTEGER; size : $UBYTE; %IMMED base_address : $DEFPTR); EXTERNAL; (* LIB$INT_OVER *) (* *) (* Integer Overflow Detection *) (* *) (* The Integer Overflow Detection routine enables or disables integer *) (* overflow detection for the calling routine activation. The previous *) (* integer overflow enable setting is returned. *) (* *) (* This routine is available on Alpha VMS systems in translated form *) (* and is applicable to translated VAX images only. *) (* *) [ASYNCHRONOUS] FUNCTION lib$int_over ( new_setting : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$I64_CREATE_INVO_CONTEXT ** IPF only ** *) (* *) (* A thread can allocte an invocation context block on the heap by using the *) (* following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_create_invo_context ( %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_malloc := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_free := %IMMED 0; %IMMED user_ident : INTEGER := %IMMED 0) : $DEFPTR; EXTERNAL; (* LIB$I64_FREE_INVO_CONTEXT ** IPF only ** *) (* *) (* A thread can free an invocation context block to the heap by using the *) (* following function format: *) (* *) [ASYNCHRONOUS] PROCEDURE lib$i64_free_invo_context ( invo_context : $DEFPTR); EXTERNAL; (* LIB$I64_GET_CURR_INVO_CONTEXT ** IPF only ** *) (* *) (* A thread can obtain the invocation context of the current procedure by using the *) (* following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_curr_invo_context ( VAR invo_context : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$I64_GET_CURR_INVO_HANDLE ** IPF only ** *) (* *) (* A thread can obtain the invocation handle corresponding to current invocation *) (* context of the current procedure by using the following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_curr_invo_handle ( VAR invo_handle : [VOLATILE] lib$routines$$typ17) : INTEGER; EXTERNAL; (* LIB$I64_GET_INVO_CONTEXT ** IPF only ** *) (* *) (* A thread can obtain the invocation context of any active procedure by using the *) (* following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_invo_context ( invo_handle : lib$routines$$typ18; VAR invo_context : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$I64_GET_INVO_HANDLE ** IPF only ** *) (* *) (* A thread can obtain an invocation handle corresponding to any invocation context *) (* block by using the following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_invo_handle ( invo_context : $DEFPTR; VAR invo_handle : [VOLATILE] lib$routines$$typ19) : INTEGER; EXTERNAL; (* LIB$I64_GET_PREV_INVO_CONTEXT ** IPF only ** *) (* *) (* A thread can obtain the invocation context of the procedure context preceding any *) (* other procedure context by using the following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_prev_invo_context ( VAR invo_context : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$I64_GET_PREV_INVO_HANDLE ** IPF only ** *) (* *) (* A thread can obtain an invocation handle of the procedure context preceding that *) (* of a specified procedure context by using the following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_prev_invo_handle ( invo_handle_in : lib$routines$$typ20; VAR invo_handle_out : [VOLATILE] lib$routines$$typ21) : INTEGER; EXTERNAL; (* LIB$I64_INIT_INVO_CONTEXT ** IPF only ** *) (* *) (* A thread can initialize an invocation context block by using the *) (* following function format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_init_invo_context ( VAR invo_context : [VOLATILE] $DEFPTR; %IMMED invo_version : INTEGER; %IMMED cache_unwind_flag : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$I64_PREV_INVO_END ** IPF only ** *) (* *) (* This routine should be called at the conclusion of call tracing operations to *) (* free the memory used to process unwind descriptors. The call tracing routines *) (* are LIB$I64_GET_INVO_CONTEXT, LIB$I64_GET_PREV_INVO_CONTEXT, and *) (* LIB$I64_GET_CURR_INVO_CONTEXT. *) (* *) (* To provide efficient call tracing, some unwind information can be tracked in heap *) (* storage from one call to the next. This heap storage should be freed before you *) (* release or reuse the invocation context block. *) (* *) (* Calling this routine is only necessary if the LIBICB$V_UO_FLAG_CACHE_UNWIND *) (* flag is set in the LIBICB$Q_UO_FLAGS field of the invocation context *) (* block. This flag causes unwind information to be cached between *) (* calls. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_prev_invo_end ( VAR invo_context : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$I64_PUT_INVO_REGISTERS ** IPF only ** *) (* *) (* The fields of a given procedure invocation context can be updated with new *) (* register contents by calling a system library function in the following format: *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_put_invo_registers ( invo_handle : lib$routines$$typ22; invo_context : $DEFPTR; gr_mask : lib$routines$$typ23 := %IMMED 0; fr_mask : lib$routines$$typ24 := %IMMED 0; br_mask : lib$routines$$typ25 := %IMMED 0; pr_mask : lib$routines$$typ26 := %IMMED 0; misc_mask : lib$routines$$typ27 := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$I64_SET_FPSR ** IPF only ** *) (* *) (* Given an invocation context block and a quadword FPSR value in fpsr_copy, *) (* write the fpsr_copy value to the invocation context block FPSR and then use *) (* LIB$I64_PUT_INVO_REGISTERS to write to the actual context. The invocation *) (* context block remains unchanged if the routine fails. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_set_fpsr ( VAR invo_context : [VOLATILE] $DEFPTR; fpsr_copy : lib$routines$$typ28) : INTEGER; EXTERNAL; (* LIB$I64_GET_FR ** IPF only ** *) (* *) (* Given an invocation context block and floating-point register index such that *) (* 2 <= index < 128, copy the register value to fr_copy. For example, an index *) (* value of 4 fetches the invocation context block FREG[4] value, which represents *) (* the contents of F4 for the context. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_fr ( invo_context : $DEFPTR; %IMMED index : UNSIGNED; VAR fr_copy : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$I64_SET_FR ** IPF only ** *) (* *) (* Given an invocation context block, a floating-point register index, and a floatingpoint *) (* register value in fr_copy, writes the corresponding invocation context block *) (* FREG entry, and calls LIB$I64_PUT_INVO_REGISTERS to write the actual *) (* context. The invocation context block remains unchanged if the routine fails. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_set_fr ( VAR invo_context : [VOLATILE] $DEFPTR; %IMMED index : UNSIGNED; VAR fr_copy : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$I64_GET_GR ** IPF only ** *) (* *) (* Given an invocation context block and general register index such that *) (* 0 < index < 128,) copy the register value to gr_copy, for example, index 4 *) (* fetches the invocation context block IREG[4] value, which represents the contents *) (* of R4 for the context. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_gr ( invo_context : $DEFPTR; %IMMED index : UNSIGNED; VAR gr_copy : [VOLATILE] lib$routines$$typ29) : INTEGER; EXTERNAL; (* LIB$I64_SET_GR ** IPF only ** *) (* *) (* Given an invocation context block, a general register index such that *) (* 0 < index < 128, and a quadword value gr_copy, writes the corresponding *) (* invocation context block general register, clears the corresponding NaT bit *) (* and uses LIB$I64_PUT_INVO_REGISTERS to write to the actual context. The *) (* invocation context block remains unchanged if the routine fails. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_set_gr ( VAR invo_context : [VOLATILE] $DEFPTR; %IMMED index : UNSIGNED; gr_copy : lib$routines$$typ30) : INTEGER; EXTERNAL; (* LIB$I64_SET_PC ** IPF only ** *) (* *) (* Given an invocation context block and a quadword PC value in pc_copy, write *) (* the pc_copy value to the invocation context block PC and then use LIB$I64_PUT_ *) (* INVO_REGISTERS to write to the actual context. The invocation context block *) (* remains unchanged if the routine fails. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_set_pc ( VAR invo_context : [VOLATILE] $DEFPTR; pc_copy : lib$routines$$typ31) : INTEGER; EXTERNAL; (* LIB$I64_GET_UNWIND_HANDLER_FV ** IPF only ** *) (* *) (* Given a pc_value, find the function value (address of the procedure descriptor) *) (* for the condition handler, if present, and write it to handler_fv. If not present, *) (* then write 0 to handler_fv. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_unwind_handler_fv ( pc_value : lib$routines$$typ32; VAR handler_fv : [VOLATILE] lib$routines$$typ33) : INTEGER; EXTERNAL; (* LIB$I64_GET_UNWIND_LSDA ** IPF only ** *) (* *) (* Given a pc_value, find the address of the unwind information block *) (* language-specific data area (LSDA), if present, and write it to unwind_lsda_p. *) (* If not present, then write 0 to unwind_lsda_va. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_unwind_lsda ( pc_value : lib$routines$$typ34; VAR unwind_lsda_va : [VOLATILE] lib$routines$$typ35) : INTEGER; EXTERNAL; (* LIB$I64_GET_UNWIND_OSSD ** IPF only ** *) (* *) (* Given a pc_value, find the address of the unwind information block operating *) (* system-specific data area, if present, and write it to unwind_ossd_p. If not *) (* present, then write 0 to unwind_ossd_p. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_get_unwind_ossd ( pc_value : lib$routines$$typ36; VAR unwind_ossd_va : [VOLATILE] lib$routines$$typ37) : INTEGER; EXTERNAL; (* LIB$I64_IS_AST_DISPATCH_FRAME ** IPF only ** *) (* *) (* Used to determine whether a given PC value *) (* represents the AST dispatch frame. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_is_ast_dispatch_frame ( pc_value : lib$routines$$typ38) : INTEGER; EXTERNAL; (* LIB$I64_IS_EXC_DISPATCH_FRAME ** IPF only ** *) (* *) (* Used to determine whether a given PC value *) (* represents the exception dispatch frame. *) (* *) [ASYNCHRONOUS] FUNCTION lib$i64_is_exc_dispatch_frame ( pc_value : lib$routines$$typ39) : INTEGER; EXTERNAL; (* LIB$LEN *) (* *) (* Length of String Returned as Longword Value *) (* *) (* The Length of String Returned as Longword Value routine returns the *) (* length of a string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$len ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : $UWORD; EXTERNAL; (* LIB$LOCC *) (* *) (* Locate a Character *) (* *) (* The Locate a Character routine locates a character in a string by *) (* comparing successive bytes in the string with the character specified. *) (* The search continues until the character is found or the string has no *) (* more characters. LIB$LOCC makes the VAX LOCC instruction available as *) (* a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$locc ( character_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; source_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$LOCK_IMAGE *) (* *) (* Lock Image in working set *) (* *) (* Lock all address ranges associated with a specified image *) (* into the working set. *) (* *) [ASYNCHRONOUS] FUNCTION lib$lock_image ( va : $QUAD) : INTEGER; EXTERNAL; (* LIB$LOOKUP_KEY *) (* *) (* Look Up Keyword in Table *) (* *) (* The Look Up Keyword In Table routine scans a table of keywords to find *) (* one that matches the keyword or keyword abbreviation specified by *) (* search-string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$lookup_key ( search_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; %REF key_table_array : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; VAR key_value : [VOLATILE] UNSIGNED := %IMMED 0; VAR keyword_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$LOOKUP_TREE *) (* *) (* Look Up an Entry in a Balanced Binary Tree *) (* *) (* The Look Up an Entry in a Balanced Binary Tree routine looks up an *) (* entry in a balanced binary tree. *) (* *) [ASYNCHRONOUS] FUNCTION lib$lookup_tree ( treehead : $DEFPTR; %REF symbol : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_compare_routine; VAR new_node : [VOLATILE] $DEFPTR) : INTEGER; EXTERNAL; (* LIB$LOOKUP_TREE_64 *) (* *) (* Look Up an Entry in a Balanced Binary Tree *) (* *) (* The Look Up an Entry in a Balanced Binary Tree routine looks up an *) (* entry in a balanced binary tree. *) (* *) [ASYNCHRONOUS] FUNCTION lib$lookup_tree_64 ( treehead : lib$routines$$typ40; %REF symbol : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_compare_routine; VAR new_node : [VOLATILE] lib$routines$$typ41) : INTEGER; EXTERNAL; (* LIB$LP_LINES *) (* *) (* Lines on Each Printer Page *) (* *) (* The Lines on Each Printer Page routine computes the default number of *) (* lines on a printer page. This routine can be used by native-mode VMS *) (* utilities that produce listing files and paginate files. *) (* *) [ASYNCHRONOUS] FUNCTION lib$lp_lines : INTEGER; EXTERNAL; (* LIB$MATCHC *) (* *) (* Match Characters, Return Relative Position *) (* *) (* The Match Characters and Return Relative Position routine searches a *) (* source string for a specified substring and returns an index, which is *) (* the relative position of the first occurrence of a substring in the *) (* source string. The relative character positions returned by LIB$MATCHC *) (* are numbered 1, 2, , n. Thus, zero means that the substring was not *) (* found. *) (* *) [ASYNCHRONOUS] FUNCTION lib$matchc ( sub_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; source_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$MATCH_COND *) (* *) (* Match Condition Values *) (* *) (* The Match Condition Values routine checks to see if a given condition *) (* value matches a list of condition values that you supply. *) (* *) [ASYNCHRONOUS] FUNCTION lib$match_cond ( match_condition_value : UNSIGNED; compare_condition_value : UNSIGNED; $p3 : [LIST] UNSIGNED) : INTEGER; EXTERNAL; (* LIB$MOVC3 *) (* *) (* Move Characters *) (* *) (* The Move Characters routine makes the VAX MOVC3 instruction available *) (* as a callable routine. The source item is moved to the destination item. *) (* Overlap of the source and destination items does not affect the result. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$movc3 ( word_integer_length : $UWORD; %REF source : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %REF destination : [VOLATILE,UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE); EXTERNAL; (* LIB$MOVC5 *) (* *) (* Move Characters with Fill *) (* *) (* The Move Characters with Fill routine makes the VAX MOVC5 instruction *) (* available as a callable routine. The source item is moved to the *) (* destination item. Overlap of the source and destination items does not *) (* affect the result. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$movc5 ( word_integer_source_length : $UWORD; %REF source : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; FILL : $BYTE; word_integer_destination_length : $UWORD; %REF destination : [VOLATILE,UNSAFE] ARRAY [$l5..$u5:INTEGER] OF $UBYTE); EXTERNAL; (* LIB$MOVTC *) (* *) (* Move Translated Characters *) (* *) (* The Move Translated Characters routine moves the source string, *) (* character by character, to the destination string after translating *) (* each character using the specified translation table. *) (* LIB$MOVTC makes the VAX MOVTC instruction available as a callable *) (* routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$movtc ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; fill_character : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; translation_table : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$MOVTUC *) (* *) (* Move Translated Until Character *) (* *) (* The Move Translated Until Character routine moves the source string, *) (* character by character, to the destination string after translating each *) (* character using the specified translation table until the stop character *) (* is encountered. LIB$MOVTUC makes the VAX MOVTUC instruction available *) (* as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$movtuc ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; stop_character : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; translation_table : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR; fill_character : [CLASS_S] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$MT_DENSITY_CONVERSION *) (* *) (* Convert the DCL command line qualifiers specfied for *) (* /DENSITY, /COMPACTION, /MEDIA_FORMAT=DENSITY= and *) (* /MEDIA_FORMAT=COMPACTION to a OpenVMS density/compression *) (* code (MT3DEF or MTDEF symbols) and return value indicating *) (* the tape driver owning the device is MTD enhanced or not. *) (* *) [ASYNCHRONOUS] FUNCTION lib$mt_density_conversion ( %IMMED device_channel : UNSIGNED; VAR mt_density_symbol : [VOLATILE] UNSIGNED; VAR mt3_enhanced_driver : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* *) (* LIB$MT_DENSITY_VERIFICATION *) (* *) (* Verify a OpenVMS density/compression code (MT3DEF or MTDEF *) (* symbols) is indeed an acceptable density/compression code *) (* for both MTD enhanced tape device drivers and non enhanced *) (* tape device drivers. Also return a value indicating *) (* the driver owning the device is MTD enhanced or not. *) (* *) [ASYNCHRONOUS] FUNCTION lib$mt_density_verification ( %IMMED device_channel : UNSIGNED; %IMMED mt_density_symbol : UNSIGNED; VAR mt3_enhanced_driver : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL; (* *) (* *) (* LIB$MT_DENSITY_STRCVT *) (* *) (* Copies the string equivalent of a OpenVMS density/compression *) (* code into a user supplied buffer. This works for both MT3DEF *) (* symbols and MTDEF symbols. *) (* *) (* *) [ASYNCHRONOUS] FUNCTION lib$mt_density_strcvt ( %IMMED mt_density_symbol : UNSIGNED; %REF out_string : [VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$MULTF_DELTA_TIME *) (* *) (* Multiply Delta Time by an F_Floating Scalar *) (* *) (* The Multiply Delta Time by an F-Floating Scalar routine multiplies a *) (* delta time by an F-floating scalar. *) (* *) [ASYNCHRONOUS] FUNCTION lib$multf_delta_time ( multiplier : SINGLE; VAR delta_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$MULT_DELTA_TIME *) (* *) (* Multiply Delta Time by Scalar *) (* *) (* The Multiply Delta Time by Scalar routine multiplies a delta time by *) (* a longword integer scalar. *) (* *) [ASYNCHRONOUS] FUNCTION lib$mult_delta_time ( multiplier : INTEGER; VAR delta_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$PARSE_ACCESS_CODE *) (* *) (* Parse Access Encoded Name String *) (* *) (* The Parse Access Encoded Name String routine parses and translates *) (* a string of access names into a mask for a particular ownership *) (* category. *) (* *) [ASYNCHRONOUS] FUNCTION lib$parse_access_code ( access_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; %REF access_names : ARRAY [$l2..$u2:INTEGER] OF $UQUAD := %IMMED 0; ownership_category : $UWORD; VAR access_mask : [VOLATILE] $UWORD; VAR end_position : [VOLATILE] $WORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$PARSE_SOGW_PROT *) (* *) (* Parse Protection String *) (* *) (* The Parse Protection String routine parses and translates *) (* a protection string into a protection mask. *) (* *) [ASYNCHRONOUS] FUNCTION lib$parse_sogw_prot ( protection_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; %REF access_names : ARRAY [$l2..$u2:INTEGER] OF $UQUAD := %IMMED 0; VAR protection_mask : [VOLATILE] $UWORD; VAR ownership_mask : [VOLATILE] $UWORD; VAR end_position : [VOLATILE] $WORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$PAUSE *) (* *) (* Pause Program Execution *) (* *) (* The Pause Program Execution routine suspends program execution and *) (* returns control to the calling command level. *) (* *) [ASYNCHRONOUS] FUNCTION lib$pause : INTEGER; EXTERNAL; (* LIB$POLYD *) (* *) (* Evaluate Polynomials *) (* *) (* The Evaluate Polynomials routine (D-floating point values) allows *) (* higher-level language users to evaluate D-floating point value *) (* polynomials. *) (* *) [ASYNCHRONOUS] FUNCTION lib$polyd ( polynomial_argument : D_FLOAT$$TYPE; degree : $WORD; %REF coefficient : ARRAY [$l3..$u3:INTEGER] OF D_FLOAT$$TYPE; VAR floating_point_result : [VOLATILE] D_FLOAT$$TYPE) : INTEGER; EXTERNAL; (* LIB$POLYF *) (* *) (* Evaluate Polynomials *) (* *) (* The Evaluate Polynomials routine (F-floating point values) allows *) (* higher-level language users to evaluate F-floating point *) (* polynomials. *) (* *) [ASYNCHRONOUS] FUNCTION lib$polyf ( polynomial_argument : SINGLE; degree : $WORD; %REF coefficient : ARRAY [$l3..$u3:INTEGER] OF SINGLE; VAR floating_point_result : [VOLATILE] SINGLE) : INTEGER; EXTERNAL; (* LIB$POLYT *) (* *) (* Evaluate Polynomials *) (* *) (* The Evaluate Polynomials routine (T-floating point values) allows *) (* higher-level language users to evaluate T-floating point value *) (* polynomials. *) (* *) [ASYNCHRONOUS] FUNCTION lib$polyt ( polynomial_argument : D_FLOAT$$TYPE; degree : $WORD; %REF coefficient : ARRAY [$l3..$u3:INTEGER] OF D_FLOAT$$TYPE; VAR floating_point_result : [VOLATILE] D_FLOAT$$TYPE) : INTEGER; EXTERNAL; (* LIB$POLYG *) (* *) (* Evaluate Polynomials *) (* *) (* The Evaluate Polynomials routine (G-floating point values) allows *) (* higher-level language users to evaluate G-floating point value *) (* polynomials. *) (* *) [ASYNCHRONOUS] FUNCTION lib$polyg ( polynomial_argument : G_FLOAT$$TYPE; degree : $WORD; %REF coefficient : ARRAY [$l3..$u3:INTEGER] OF G_FLOAT$$TYPE; VAR floating_point_result : [VOLATILE] G_FLOAT$$TYPE) : INTEGER; EXTERNAL; (* LIB$POLYH *) (* *) (* Evaluate Polynomials *) (* *) (* On VAX VMS, the Evaluate Polynomials routine (H-floating point values) *) (* allows higher-level language users to evaluate H-floating point value *) (* polynomials. *) (* *) (* This routine is not available to native Alpha VMS programs, but is *) (* available to translated VAX images. *) (* *) (* This routine is not available to native Alpha VMS programs, but is *) (* recognized and handled appropriately by most Digital high-level language *) (* compilers. *) (* *) [ASYNCHRONOUS] FUNCTION lib$polyh ( polynomial_argument : QUADRUPLE; degree : $WORD; %REF coefficient : ARRAY [$l3..$u3:INTEGER] OF QUADRUPLE; VAR floating_point_result : [VOLATILE] QUADRUPLE) : INTEGER; EXTERNAL; (* LIB$PUT_COMMON *) (* *) (* Put String to Common *) (* *) (* The Put String to Common routine copies the contents of a string into *) (* the common area. The common area is an area of storage which remains *) (* defined across multiple image activations in a process. Optionally, *) (* LIB$PUT_COMMON returns the actual number of characters copied. *) (* The maximum number of characters that can be copied is 252. *) (* *) [ASYNCHRONOUS] FUNCTION lib$put_common ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$PUT_OUTPUT *) (* *) (* Put Line to SYS$OUTPUT *) (* *) (* The Put Line to SYS$OUTPUT routine writes a record to the current *) (* controlling output device, specified by SYS$OUTPUT using the RMS $PUT *) (* service. *) (* *) [ASYNCHRONOUS] FUNCTION lib$put_output ( message_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$RADIX_POINT *) (* *) (* Radix Point Symbol *) (* *) (* The Radix Point Symbol routine returns the system's radix point symbol. *) (* This symbol is used inside a digit string to separate the integer part *) (* from the fraction part. This routine works by attempting to translate *) (* the logical name SYS$RADIX_POINT as a process, group, or system logical *) (* name. *) (* *) [ASYNCHRONOUS] FUNCTION lib$radix_point ( VAR radix_point_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$REMQHI *) (* *) (* Remove Entry from Head of Queue *) (* *) (* The Remove Entry from Head of Queue routine removes an entry from the *) (* head of the specified self-relative interlocked longword queue. *) (* LIB$REMQHI makes the VAX REMQHI instruction available as *) (* a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$remqhi ( VAR header : [VOLATILE] $QUAD; VAR remque_address : [VOLATILE] $DEFPTR; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$REMQHIQ *) (* *) (* Remove Entry from Head of Queue (Quadword) *) (* *) (* The Remove Entry from Head of Queue routine removes an entry from the *) (* head of the specified self-relative interlocked quadword queue. *) (* LIB$REMQHIQ makes the Alpha unprivileged PALcode instruction REMQHIQ *) (* available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$remqhiq ( VAR header : [VOLATILE] $OCTA; VAR remque_address : [VOLATILE] lib$routines$$typ42; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$REMQTI *) (* *) (* Remove Entry from Tail of Queue *) (* *) (* The Remove Entry from Tail of Queue routine removes an entry from the *) (* tail of the specified self-relative interlocked longword queue. *) (* LIB$REMQTI makes the VAX REMQTI instruction available as a *) (* callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$remqti ( VAR header : [VOLATILE] $QUAD; VAR remque_address : [VOLATILE] $DEFPTR; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$REMQTIQ *) (* *) (* Remove Entry from Tail of Queue (Quadword) *) (* *) (* The Remove Entry from Tail of Queue routine removes an entry from the *) (* tail of the specified self-relative interlocked quadword queue. *) (* LIB$REMQTIQ makes the Alpha unprivileged PALcode instruction REMQTIQ *) (* available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$remqtiq ( VAR header : [VOLATILE] $OCTA; VAR remque_address : [VOLATILE] lib$routines$$typ43; retry_count : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$RENAME_FILE *) (* *) (* Rename One or More Files *) (* *) (* The Rename One or More Files routine changes the names of one or more *) (* files. The specification of the files to be renamed may include *) (* wildcards. LIB$RENAME_FILE is similar in function to the DCL command *) (* RENAME. *) (* *) [ASYNCHRONOUS] FUNCTION lib$rename_file ( old_filespec : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; new_filespec : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; default_filespec : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; related_filespec : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0; flags : UNSIGNED := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_success_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_error_procedure := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_confirm_procedure := %IMMED 0; %IMMED user_specified_argument : UNSIGNED := %IMMED 0; VAR old_resultant_name : [CLASS_S,VOLATILE] PACKED ARRAY [$l10..$u10:INTEGER] OF CHAR := %IMMED 0; VAR new_resultant_name : [CLASS_S,VOLATILE] PACKED ARRAY [$l11..$u11:INTEGER] OF CHAR := %IMMED 0; VAR file_scan_context : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$RESERVE_EF *) (* *) (* Reserve Event Flag *) (* *) (* The Reserve Event Flag routine allocates a local event flag number *) (* specified by event-flag-number. *) (* *) [ASYNCHRONOUS] FUNCTION lib$reserve_ef ( event_flag_number : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$RESET_VM_ZONE *) (* *) (* Reset Virtual Memory Zone *) (* *) (* The Reset Virtual Memory Zone routine frees all blocks of memory that *) (* were previously allocated from the zone. *) (* *) [ASYNCHRONOUS] FUNCTION lib$reset_vm_zone ( zone_id : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$RESET_VM_ZONE_64 *) (* *) (* Reset Virtual Memory Zone *) (* *) (* The Reset Virtual Memory Zone routine frees all blocks of memory that *) (* were previously allocated from the zone. *) (* *) [ASYNCHRONOUS] FUNCTION lib$reset_vm_zone_64 ( zone_id : $UQUAD) : INTEGER; EXTERNAL; (* LIB$REVERT *) (* *) (* Revert to the Handler of the Routine Activator *) (* *) (* The Revert to the Handler of the Routine Activator routine deletes the *) (* condition handler established by LIB$ESTABLISH by clearing the address *) (* pointing to the condition handler from the activated routine's stack *) (* frame. *) (* *) (* ENTRY lib$revert ALIAS $lib_revert *) (* RETURNS ADDRESS NAMED RESULT TYPENAME address; *) (* LIB$RUN_PROGRAM *) (* *) (* Run New Program *) (* *) (* The Run New Program routine causes the current program to stop running *) (* and begins execution of another program. *) (* *) [ASYNCHRONOUS] FUNCTION lib$run_program ( program_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$SCANC *) (* *) (* Scan for Characters and Return Relative Position *) (* *) (* The Scan for Characters and Return Relative Position routine is used to *) (* find a specified set of characters in the source string. *) (* LIB$SCANC makes the VAX SCANC instruction available as a *) (* callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$scanc ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; %REF table_array : ARRAY [$l2..$u2:INTEGER] OF $UBYTE; byte_integer_mask : $UBYTE) : INTEGER; EXTERNAL; (* LIB$SCOPY_DXDX *) (* *) (* Copy Source String Passed by Descriptor to Destination *) (* *) (* The Copy Source String Passed by Descriptor to Destination routine *) (* copies a source string passed by descriptor to a destination string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$scopy_dxdx ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$SCOPY_R_DX *) (* *) (* Copy Source String Passed by Reference to Destination String *) (* *) (* The Copy Source String Passed by Reference to Destination String routine *) (* copies a source string passed by reference to a destination string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$scopy_r_dx ( word_integer_source_length : $UWORD; %REF source_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$SCOPY_R_DX_64 *) (* *) (* Copy Source String Passed by Reference to Destination String *) (* *) (* The Copy Source String Passed by Reference to Destination String routine *) (* copies a source string passed by reference to a destination string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$scopy_r_dx_64 ( quad_integer_source_length : $UQUAD; %REF source_string : PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$SET_LOGICAL *) (* *) (* Set Logical Name *) (* *) (* The Set Logical Name routine requests the calling process's Command *) (* Language Interpreter (CLI) to define or redefine a supervisor-mode *) (* process logical name. It provides the same function as the DCL DEFINE *) (* command. *) (* *) [ASYNCHRONOUS] FUNCTION lib$set_logical ( logical_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; value_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; table : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; attributes : UNSIGNED := %IMMED 0; %REF item_list : [UNSAFE] ARRAY [$l5..$u5:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SET_SYMBOL *) (* *) (* Set Value of CLI Symbol *) (* *) (* The Set Value of CLI Symbol routine requests the calling process's *) (* Command Language Interpreter (CLI) to define or redefine a CLI symbol. *) (* *) [ASYNCHRONOUS] FUNCTION lib$set_symbol ( symbol : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; value_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; table_type_indicator : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SFREE1_DD *) (* *) (* Free One Dynamic String *) (* *) (* The Free One Dynamic String routine returns the dynamically allocated *) (* storage for a dynamic string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sfree1_dd ( VAR descriptor_address : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$SFREEN_DD *) (* *) (* Free One or More Dynamic Strings *) (* *) (* The Free One or More Dynamic Strings routine returns one or more dynamic *) (* strings to free storage. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sfreen_dd ( number_of_descriptors : UNSIGNED; %REF first_descriptor_array : [VOLATILE] ARRAY [$l2..$u2:INTEGER] OF $UQUAD) : INTEGER; EXTERNAL; (* LIB$SGET1_DD *) (* *) (* Get One Dynamic String *) (* *) (* The Get One Dynamic String routine allocates dynamic virtual memory to *) (* the string descriptor you specify. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sget1_dd ( word_integer_length : $UWORD; VAR descriptor_part : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$SGET1_DD_64 *) (* *) (* Get One Dynamic String *) (* *) (* The Get One Dynamic String routine allocates dynamic virtual memory to *) (* the string descriptor you specify. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sget1_dd_64 ( quad_integer_length : $UQUAD; VAR descriptor_part : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$SHOW_TIMER *) (* *) (* Show Accumulated Times and Counts *) (* *) (* The Show Accumulated Times and Counts routine returns times and counts *) (* accumulated since the last call to LIB$INIT_TIMER and displays them on *) (* SYS$OUTPUT. (LIB$INIT_TIMER must be called prior to invoking this *) (* routine.) A user-supplied action routine may change this default *) (* behavior. *) (* *) [ASYNCHRONOUS] FUNCTION lib$show_timer ( handle_address : $DEFPTR := %IMMED 0; code : INTEGER := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure := %IMMED 0; %IMMED user_argument_value : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SHOW_VM *) (* *) (* Show Virtual Memory Statistics *) (* *) (* The Show Virtual Memory Statistics routine returns the statistics *) (* accumulated from calls to LIB$GET_VM, LIB$FREE_VM, LIB$GET_VM_PAGE, *) (* and LIB$FREE_VM_PAGE. *) (* *) [ASYNCHRONOUS] FUNCTION lib$show_vm ( code : INTEGER := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure := %IMMED 0; %IMMED user_specified_argument : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SHOW_VM_64 *) (* *) (* Show Virtual Memory Statistics *) (* *) (* The Show Virtual Memory Statistics routine returns the statistics *) (* accumulated from calls to LIB$GET_VM_64, LIB$FREE_VM_64, *) (* LIB$GET_VM_PAGE_64, and LIB$FREE_VM_PAGE_64. *) (* *) [ASYNCHRONOUS] FUNCTION lib$show_vm_64 ( code : $QUAD := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure := %IMMED 0; %IMMED user_specified_argument : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SHOW_VM_ZONE *) (* *) (* Return Information About a Zone *) (* *) (* The Return Information About a Zone routine returns formatted information *) (* about the specified zone, detailing such information as the zone's name, *) (* characteristics, and areas, and then passes the information to the *) (* specified or default action routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$show_vm_zone ( zone_id : UNSIGNED; detail_level : INTEGER := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure := %IMMED 0; %IMMED user_arg : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SHOW_VM_ZONE_64 *) (* *) (* Return Information About a Zone *) (* *) (* The Return Information About a Zone routine returns formatted information *) (* about the specified zone, detailing such information as the zone's name, *) (* characteristics, and areas, and then passes the information to the *) (* specified or default action routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$show_vm_zone_64 ( zone_id : $UQUAD; detail_level : $QUAD := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure := %IMMED 0; %IMMED user_arg : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SIGNAL *) (* *) (* Signal Exception Condition *) (* *) (* The Signal Exception Condition routine generates a signal that indicates *) (* that an exception condition has occurred in your program. If a condition *) (* handler does not take corrective action and the condition is severe, then *) (* your program will exit. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$signal ( %IMMED condition_value : UNSIGNED; %IMMED number_of_arguments : INTEGER := %IMMED 0; %IMMED FAO_argument : [LIST,UNSAFE] INTEGER); EXTERNAL; (* LIB$SIG_TO_RET *) (* *) (* Signal Converted to a Return Status *) (* *) (* The Signal Converted to a Return Status routine converts any signaled *) (* condition value to a value returned as a function. The signaled condition *) (* is returned to the caller of the user routine that established the *) (* handler that is calling LIB$SIG_TO_RET. This routine may be established *) (* as or called from a condition handler. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sig_to_ret ( %REF signal_arguments : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF mechanism_arguments : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* LIB$SIG_TO_STOP *) (* *) (* Convert a Signaled Condition to a Signaled Stop *) (* *) (* The Convert a Signaled Condition to a Signaled Stop routine converts a *) (* signaled condition to a signaled condition that cannot be continued. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sig_to_stop ( %REF signal_arguments : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF mechanism_arguments : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* LIB$SIM_TRAP *) (* *) (* Simulate Floating Trap *) (* *) (* The Simulate Floating Trap routine converts floating faults to floating *) (* traps. It can be enabled as a condition handler or can be called by one. *) (* *) (* This routine is not available to native Alpha VMS programs, but is *) (* available to translated VAX images. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sim_trap ( %REF signal_arguments : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF mechanism_arguments : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* LIB$SKPC *) (* *) (* Skip Equal Characters *) (* *) (* The Skip Equal Characters routine compares each character of a given *) (* string with a given character and returns the relative position of the *) (* first nonequal character as an index. LIB$SKPC makes the VAX SKPC *) (* instruction available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$skpc ( character_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; source_string : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$SPANC *) (* *) (* Skip Selected Characters *) (* *) (* The Skip Selected Characters routine is used to skip a specified set of *) (* characters in the source string. LIB$SPANC makes the VAX SPANC *) (* instruction available as a callable routine. *) (* *) [ASYNCHRONOUS] FUNCTION lib$spanc ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; %REF table_array : ARRAY [$l2..$u2:INTEGER] OF $UBYTE; byte_integer_mask : $UBYTE) : INTEGER; EXTERNAL; (* LIB$SPAWN *) (* *) (* Spawn Subprocess *) (* *) (* The Spawn Subprocess routine requests the command language interpreter *) (* (CLI) of the calling process to spawn a subprocess for executing CLI *) (* commands. LIB$SPAWN provides the same function as the DCL SPAWN command. *) (* *) [ASYNCHRONOUS] FUNCTION lib$spawn ( command_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR := %IMMED 0; input_file : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0; output_file : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0; flags : UNSIGNED := %IMMED 0; process_name : [CLASS_S] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0; VAR process_id : [VOLATILE] UNSIGNED := %IMMED 0; %IMMED completion_status_address : $DEFPTR := %IMMED 0; byte_integer_event_flag_num : $UBYTE := %IMMED 0; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE AST_address := %IMMED 0; %IMMED varying_AST_argument : [UNSAFE] INTEGER := %IMMED 0; prompt_string : [CLASS_S] PACKED ARRAY [$l11..$u11:INTEGER] OF CHAR := %IMMED 0; cli : [CLASS_S] PACKED ARRAY [$l12..$u12:INTEGER] OF CHAR := %IMMED 0; table : [CLASS_S] PACKED ARRAY [$l13..$u13:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$STAT_TIMER *) (* *) (* Statistics, Return Accumulated Times and Counts *) (* *) (* The Statistics, Return Accumulated Times and Counts routine returns *) (* to its caller one of five available statistics accumulated since the *) (* last call to LIB$INIT_TIMER. Unlike LIB$SHOW_TIMER, which formats the *) (* values for output, LIB$STAT_TIMER returns the value as an unsigned *) (* longword or quadword. *) (* *) [ASYNCHRONOUS] FUNCTION lib$stat_timer ( code : INTEGER; %REF value_argument : [VOLATILE,UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; handle_address : $DEFPTR := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$STAT_VM *) (* *) (* Return Virtual Memory Statistics *) (* *) (* The Return Virtual Memory Statistics routine returns to its caller one *) (* of six statistics available from calls to LIB$GET_VM/LIB$FREE_VM and *) (* LIB$GET_VM_PAGE/LIB$FREE_VM_PAGE. Unlike LIB$SHOW_VM, which formats *) (* the values for output and displays them on SYS$OUTPUT, LIB$STAT_VM *) (* returns the statistic in the value-argument argument. Only one of the *) (* statistics is returned by each call to LIB$STAT_VM. *) (* *) [ASYNCHRONOUS] FUNCTION lib$stat_vm ( code : INTEGER; %REF value_argument : [VOLATILE,UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* LIB$STAT_VM_64 *) (* *) (* Return Virtual Memory Statistics *) (* *) (* The Return Virtual Memory Statistics routine returns to its caller one of *) (* six statistics available from calls to LIB$GET_VM_64/LIB$FREE_VM_64 and *) (* LIB$GET_VM_PAGE_64/LIB$FREE_VM_PAGE_64. Unlike LIB$SHOW_VM, which formats *) (* the values for output and displays them on SYS$OUTPUT, LIB$STAT_VM_64 *) (* returns the statistic in the value-argument argument. Only one of the *) (* statistics is returned by each call to LIB$STAT_VM_64. *) (* *) [ASYNCHRONOUS] FUNCTION lib$stat_vm_64 ( code : $QUAD; %REF value_argument : [VOLATILE,UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* LIB$STAT_VM_ZONE *) (* *) (* Return Information About a Zone *) (* *) (* The Return Information About a Zone routine returns a single piece of *) (* information about the specified zone. *) (* *) (* Edit: Routine LIB$STAT_VM_ZONE is not yet implemented. *) (* *) (* ENTRY lib$stat_vm_zone ALIAS $lib_stat_vm_zone PARAMETER ( *) (* LONGWORD UNSIGNED NAMED zone_id IN *) (* TYPENAME identifier REFERENCE, *) (* LONGWORD NAMED item_code IN *) (* TYPENAME longword_signed REFERENCE, *) (* LONGWORD NAMED resultant_value OUT OPTIONAL *) (* TYPENAME longword_signed REFERENCE, *) (* CHARACTER RTL_STR_DESC NAMED resultant_string OUT OPTIONAL *) (* TYPENAME char_string, *) (* WORD UNSIGNED NAMED resultant_length OUT OPTIONAL *) (* TYPENAME word_unsigned REFERENCE ) *) (* RETURNS LONGWORD UNSIGNED TYPENAME cond_value; *) (* LIB$STOP *) (* *) (* Stop Execution and Signal the Condition *) (* *) (* The Stop Execution and Signal the Condition routine generates a signal *) (* that indicates that an exception condition has occurred in your program. *) (* Exception conditions signaled by LIB$STOP cannot be continued from the *) (* point of the signal. *) (* *) [ASYNCHRONOUS] PROCEDURE lib$stop ( %IMMED condition_value : UNSIGNED; %IMMED number_of_arguments : INTEGER := %IMMED 0; %IMMED FAO_argument : [LIST,UNSAFE] INTEGER); EXTERNAL; (* LIB$SUBX *) (* *) (* Multiple-Precision Binary Subtraction *) (* *) (* The Multiple-Precision Binary Subtraction routine performs subtraction *) (* on signed two's complement integers of arbitrary length. *) (* *) [ASYNCHRONOUS] FUNCTION lib$subx ( %REF minuend_array : [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF subtrahend_array : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %REF difference_array : [VOLATILE,UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE; array_length : INTEGER := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SUB_TIMES *) (* *) (* Subtract Two Quadword Times *) (* *) (* The Subtract Two Quadword Times routine subtracts two VMS *) (* internal-time-format times. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sub_times ( time1 : $UQUAD; time2 : $UQUAD; VAR resultant_time : [VOLATILE] $UQUAD) : INTEGER; EXTERNAL; (* LIB$SYS_ASCTIM *) (* *) (* Invoke $ASCTIM to Convert Binary Time to ASCII String *) (* *) (* The Invoke $ASCTIM to Convert Binary Time to ASCII String routine calls the *) (* system service $ASCTIM to convert a binary date and time value, returning the *) (* ASCII string using the semantics of the caller's string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sys_asctim ( VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR time_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; user_time : $UQUAD := %IMMED 0; flags : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SYS_FAO *) (* *) (* Invoke $FAO System Service to Format Output *) (* *) (* The Invoke $FAO System Service to Format Output routine calls $FAO, *) (* returning a string in the semantics you provide. If called with other *) (* than a fixed-length string for output, the length of the resultant *) (* string is limited to 256 bytes and truncation will occur. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sys_fao ( character_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; %REF directive_argument : [LIST,UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* LIB$SYS_FAOL *) (* *) (* Invoke $FAOL System Service to Format Output *) (* *) (* The Invoke $FAOL System Service to Format Output routine calls the *) (* system service routine $FAOL, returning the string in the semantics *) (* you provide. If called with other than a fixed-length string for *) (* output, the length of the resultant string is limited to 256 bytes *) (* and truncation will occur. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sys_faol ( character_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; directive_argument_address : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$SYS_FAOL_64 *) (* *) (* Invoke $FAOL System Service to Format Output *) (* *) (* The Invoke $FAOL System Service to Format Output routine calls the *) (* system service routine $FAOL, returning the string in the semantics *) (* you provide. If called with other than a fixed-length string for *) (* output, the length of the resultant string is limited to 256 bytes *) (* and truncation will occur. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sys_faol_64 ( character_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0; VAR resultant_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; directive_argument_address : $UQUAD) : INTEGER; EXTERNAL; (* LIB$SYS_GETMSG *) (* *) (* Invoke $GETMSG System Service to Get Message Text *) (* *) (* The Invoke $GETMSG System Service to Get Message Text routine calls *) (* the System Service $GETMSG and returns a message string into *) (* destination-string using the semantics of the caller's string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sys_getmsg ( message_id : UNSIGNED; VAR message_length : [VOLATILE] $UWORD := %IMMED 0; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; flags : UNSIGNED := %IMMED 0; %REF unsigned_resultant_array : [VOLATILE,UNSAFE] ARRAY [$l5..$u5:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$SYS_TRNLOG *) (* *) (* Invoke $TRNLOG System Service to Translate Logical Name *) (* *) (* The Invoke $TRNLOG System Service to Translate Logical Name routine *) (* uses the system service $TRNLOG to translate a logical name. *) (* LIB$SYS_TRNLOG returns the logical name's translation using the *) (* semantics of the caller's string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$sys_trnlog ( logical_name : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR word_integer_dest_length : [VOLATILE] $UWORD := %IMMED 0; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR; VAR byte_integer_table : [VOLATILE] $BYTE := %IMMED 0; VAR access_mode : [VOLATILE] $UBYTE := %IMMED 0; byte_integer_disable_mask : $UBYTE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$TPARSE/LIB$TABLE_PARSE *) (* *) (* Table-Driven Finite-State Parser *) (* *) (* The Table-Driven Finite State Parser routine is a general-purpose, *) (* table-driven parser implemented as a finite-state automaton, with *) (* extensions that make it suitable for a wide range of applications. *) (* It parses a string and returns a message indicating whether or not *) (* the input string is valid. *) (* *) (* LIB$TPARSE performs this function on VAX VMS. *) (* *) (* LIB$TABLE_PARSE performs this function on Alpha VMS and is available *) (* only on Alpha VMS. LIB$TPARSE is available in translated form on Alpha *) (* VMS. LIB$TABLE_PARSE differs from LIB$TPARSE only in the way that user *) (* specified action routines are called. *) (* *) [ASYNCHRONOUS] FUNCTION lib$table_parse ( %REF argument_block : [VOLATILE,UNSAFE] ARRAY [$l1..$u1:INTEGER] OF $UBYTE; %REF state_table : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE; %REF key_table : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL; (* ENTRY lib$tparse ALIAS $lib_tparse PARAMETER ( *) (* ANY NAMED argument_block IN OUT *) (* TYPENAME any REFERENCE, *) (* ANY NAMED state_table IN *) (* TYPENAME any REFERENCE, *) (* ANY NAMED key_table IN *) (* TYPENAME any REFERENCE ) *) (* RETURNS LONGWORD UNSIGNED TYPENAME cond_value; *) (* LIB$TRAVERSE_TREE *) (* *) (* Traverse a Balanced Binary Tree *) (* *) (* The Traverse a Balanced Binary Tree routine calls an action routine *) (* for each node in a binary tree. *) (* *) [ASYNCHRONOUS] FUNCTION lib$traverse_tree ( treehead : $DEFPTR; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure; %REF user_data_address : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$TRAVERSE_TREE_64 *) (* *) (* Traverse a Balanced Binary Tree *) (* *) (* The Traverse a Balanced Binary Tree routine calls an action routine *) (* for each node in a binary tree. *) (* *) [ASYNCHRONOUS] FUNCTION lib$traverse_tree_64 ( treehead : lib$routines$$typ44; %IMMED [UNBOUND, ASYNCHRONOUS] PROCEDURE user_action_procedure; %REF user_data_address : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$TRA_ASC_EBC *) (* *) (* Translate ASCII to EBCDIC *) (* *) (* The Translate ASCII to EBCDIC routine translates an ASCII string *) (* to an EBCDIC string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$tra_asc_ebc ( source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR byte_integer_dest_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$TRA_EBC_ASC *) (* *) (* Translate EBCDIC to ASCII *) (* *) (* The Translate EBCDIC to ASCII routine translates an EBCDIC string *) (* to an ASCII string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$tra_ebc_asc ( byte_integer_source_string : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR destination_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$TRIM_FILESPEC *) (* *) (* Fit Long File Specification into Fixed Field *) (* *) (* The Fit Long File Specification into Fixed Field routine takes a file *) (* specification, such as an RMS resultant name string, and shortens it *) (* (if necessary) so that it fits into a field of fixed width. *) (* *) [ASYNCHRONOUS] FUNCTION lib$trim_filespec ( old_filespec : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR new_filespec : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; word_integer_width : $UWORD := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$TRIM_FULLNAME *) (* *) (* Trim a Full Name to Fit into a Desired Output Field *) (* *) (* The Trim a Full Name to Fit into a Desired Output Field routine *) (* trims a full name to fit into a desired output field. *) (* *) [ASYNCHRONOUS] FUNCTION lib$trim_fullname ( fullname : [CLASS_S] PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR; VAR trimmed_nodename : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR; output_width : $UWORD := %IMMED 0; VAR resultant_length : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL; (* LIB$UID_TO_ASCII *) (* *) (* Convert a UID to Text *) (* *) (* The Convert a UID to Text routine converts a UID to *) (* standard representation ina an ASCII text string. *) (* *) [ASYNCHRONOUS] FUNCTION lib$uid_to_ascii ( input_uid : $UOCTA; VAR output_string : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL; (* LIB$UNLOCK_IMAGE *) (* *) (* Unlock Image from working set *) (* *) (* Unlock all address ranges associated with a specified image *) (* from the working set. *) (* *) [ASYNCHRONOUS] FUNCTION lib$unlock_image ( va : $QUAD) : INTEGER; EXTERNAL; (* LIB$VERIFY_VM_ZONE *) (* *) (* Verify a Zone *) (* *) (* The Verify a Zone routine performs verification of a zone. *) (* *) [ASYNCHRONOUS] FUNCTION lib$verify_vm_zone ( zone_id : UNSIGNED) : INTEGER; EXTERNAL; (* LIB$VERIFY_VM_ZONE_64 *) (* *) (* Verify a Zone *) (* *) (* The Verify a Zone routine performs verification of a zone. *) (* *) [ASYNCHRONOUS] FUNCTION lib$verify_vm_zone_64 ( zone_id : $UQUAD) : INTEGER; EXTERNAL; (* LIB$WAIT *) (* *) (* Wait a Specified Period of Time *) (* *) (* The Wait a Specified Period of Time routine places the current process *) (* into hibernation for the number of seconds specified in its argument. *) (* *) [ASYNCHRONOUS] FUNCTION lib$wait ( seconds : SINGLE; flags : UNSIGNED := %IMMED 0; float_type : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL; (* END. *) END.