/********************************************************************************************************************************/ /* Created: 15-MAR-2001 23:37:22 by OpenVMS SDL EV1-33 */ /* Source: 15-MAR-2001 23:34:44 _$11$DUA933:[BUILD.SDL]LIB$ROUTINES.SDI;1 */ /********************************************************************************************************************************/ /*** MODULE lib$routines ***/ #ifndef __LIB$ROUTINES_LOADED #define __LIB$ROUTINES_LOADED 1 #pragma nostandard #ifdef __cplusplus extern "C" { #define __unknown_params ... #else #define __unknown_params #endif #if !defined(__VAXC) && !defined(VAXC) #define __struct struct #define __union union #else #define __struct variant_struct #define __union variant_union #endif /**************************************************************************** */ /* * */ /* COPYRIGHT (c) 1988, 1994, 1996, 1997 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. */ /* */ unsigned int lib$adawi(__unknown_params); /* 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. */ /* */ unsigned int lib$addx(__unknown_params); /* LIB$ADD_TIMES */ /* */ /* Add Two Quadword Times */ /* */ /* The Add Two Quadword Times routine adds two VMS internal time format times. */ /* */ unsigned int lib$add_times(__unknown_params); /* 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. */ /* */ unsigned int lib$analyze_sdesc(__unknown_params); /* 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. */ /* */ unsigned int lib$ascii_to_uid(__unknown_params); /* 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. */ /* */ unsigned int lib$asn_wth_mbx(__unknown_params); /* LIB$AST_IN_PROG */ /* */ /* AST in Progress */ /* */ /* The AST in Progress routine indicates whether an AST is currently in progress. */ /* */ char lib$ast_in_prog(void); /* 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. */ /* */ unsigned int lib$attach(__unknown_params); /* 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. */ /* */ unsigned int lib$bbcci(__unknown_params); /* 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. */ /* */ unsigned int lib$bbssi(__unknown_params); /* 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. */ /* */ unsigned int lib$build_nodespec(__unknown_params); /* LIB$CALLG */ /* */ /* Call Routine with General 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. */ /* */ unsigned int lib$callg(__unknown_params); /* 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. */ /* */ unsigned int lib$char(__unknown_params); /* 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. */ /* */ unsigned int lib$compare_nodename(__unknown_params); /* LIB$COMPARE_UID */ /* */ /* Compare Two UIDs */ /* */ /* The Compare Two UIDs routine compares the contents */ /* of two UIDs for total lexical ordering. */ /* */ unsigned int lib$compare_uid(__unknown_params); /* 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. */ /* */ unsigned int lib$compress_nodename(__unknown_params); /* 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. */ /* */ unsigned int lib$convert_date_string(__unknown_params); /* 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. */ /* */ unsigned int lib$crc(__unknown_params); /* 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. */ /* */ void lib$crc_table(__unknown_params); /* LIB$CREATE_DIR */ /* */ /* Create a Directory */ /* */ /* The Create a Directory routine creates a directory or subdirectory. */ /* */ unsigned int lib$create_dir(__unknown_params); /* LIB$CREATE_USER_VM_ZONE */ /* */ /* Create User-Defined Storage Zone */ /* */ /* The Create User-Defined Storage Zone routine creates a new user-defined storage */ /* zone. */ /* */ unsigned int lib$create_user_vm_zone(__unknown_params); /* LIB$CREATE_VM_ZONE */ /* */ /* Create a New Zone */ /* */ /* The Create a New Zone routine creates a new storage zone according to specified */ /* arguments. */ /* */ unsigned int lib$create_vm_zone(__unknown_params); /* 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. */ /* */ void lib$crf_ins_key(__unknown_params); /* 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. */ /* */ void lib$crf_ins_ref(__unknown_params); /* 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. */ /* */ void lib$crf_output(__unknown_params); /* LIB$CURRENCY */ /* */ /* Get System Currency Symbol */ /* */ /* The Get System Currency Symbol routine returns the system's currency symbol. */ /* */ unsigned int lib$currency(__unknown_params); /* 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. */ /* */ unsigned int lib$cvtf_from_internal_time(__unknown_params); /* 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. */ /* */ unsigned int lib$cvtf_to_internal_time(__unknown_params); /* LIB$CVT_DTB */ /* */ /* Convert Numeric Text to Binary */ /* */ /* The Convert Numeric Text to Binary routines return a binary representation of */ /* the ASCII text string representation of a decimal, hexadecimal, or octal number. */ /* */ unsigned int lib$cvt_dtb(__unknown_params); /* 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. */ /* */ unsigned int lib$cvt_dx_dx(__unknown_params); /* 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. */ /* */ unsigned int lib$cvt_from_internal_time(__unknown_params); /* LIB$CVT_HTB */ /* */ /* Convert Numeric Text to Binary */ /* */ /* The Convert Numeric Text to Binary routines return a binary */ /* representation of the ASCII text string representation of a */ /* decimal, hexadecimal, or octal number. */ /* */ unsigned int lib$cvt_htb(__unknown_params); /* LIB$CVT_OTB */ /* */ /* Convert Numeric Text to Binary */ /* */ /* The Convert Numeric Text to Binary routines return a binary */ /* representation of the ASCII text string representation of a */ /* decimal, hexadecimal, or octal number. */ /* */ unsigned int lib$cvt_otb(__unknown_params); /* 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. */ /* */ unsigned int lib$cvt_to_internal_time(__unknown_params); /* 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. */ /* */ unsigned int lib$cvt_vectim(__unknown_params); /* 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. */ /* */ unsigned int lib$date_time(__unknown_params); /* 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. */ /* */ unsigned int lib$day(__unknown_params); /* 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. */ /* */ unsigned int lib$day_of_week(__unknown_params); /* 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. */ /* */ unsigned int lib$decode_fault(__unknown_params); /* 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. */ /* */ unsigned int lib$dec_over(__unknown_params); /* 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. */ /* */ unsigned int lib$delete_file(__unknown_params); /* 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. */ /* */ unsigned int lib$delete_logical(__unknown_params); /* 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. */ /* */ unsigned int lib$delete_symbol(__unknown_params); /* 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. */ /* */ unsigned int lib$delete_vm_zone(__unknown_params); /* LIB$DIGIT_SEP */ /* */ /* Get Digit Separator Symbol */ /* */ /* The Get Digit Separator Symbol routine returns the system's digit separator */ /* symbol. */ /* */ unsigned int lib$digit_sep(__unknown_params); /* 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. */ /* */ unsigned int lib$disable_ctrl(__unknown_params); /* 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. */ /* */ unsigned int lib$do_command(__unknown_params); /* 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. */ /* */ unsigned int lib$ediv(__unknown_params); /* 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. */ /* */ unsigned int lib$emodd(__unknown_params); /* 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. */ /* */ unsigned int lib$emodf(__unknown_params); /* 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. */ /* */ unsigned int lib$emodg(__unknown_params); /* 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. */ /* */ unsigned int lib$emodh(__unknown_params); /* 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. */ /* */ unsigned int lib$emul(__unknown_params); /* 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. */ /* */ unsigned int lib$enable_ctrl(__unknown_params); /* 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. */ /* */ int *lib$establish(__unknown_params); /* 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. */ /* */ unsigned int lib$expand_nodename(__unknown_params); /* 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. */ /* */ int lib$extv(__unknown_params); /* 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. */ /* */ int lib$extzv(__unknown_params); /* 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. */ /* */ unsigned int lib$ffc(__unknown_params); /* 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. */ /* */ unsigned int lib$ffs(__unknown_params); /* 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. */ /* */ unsigned int lib$fid_to_name(__unknown_params); /* 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. */ /* */ unsigned int lib$file_scan(__unknown_params); /* 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. */ /* */ unsigned int lib$file_scan_end(__unknown_params); /* 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. */ /* */ unsigned int lib$find_file(__unknown_params); /* 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. */ /* */ unsigned int lib$find_file_end(__unknown_params); /* 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. */ /* */ unsigned int lib$find_image_symbol(__unknown_params); /* 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. */ /* */ unsigned int lib$find_vm_zone(__unknown_params); /* 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. */ /* */ unsigned int lib$fit_nodename(__unknown_params); /* 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. */ /* */ unsigned int lib$fixup_flt(__unknown_params); /* 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. */ /* */ unsigned int lib$flt_under(__unknown_params); /* 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. */ /* */ unsigned int lib$format_date_time(__unknown_params); /* 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. */ /* */ unsigned int lib$free_date_time_context(__unknown_params); /* 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. */ /* */ unsigned int lib$free_ef(__unknown_params); /* 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. */ /* */ unsigned int lib$free_lun(__unknown_params); /* LIB$FREE_TIMER */ /* */ /* Free Timer Storage */ /* */ /* The Free Timer Storage routine frees the storage allocated */ /* by LIB$INIT_TIMER. */ /* */ unsigned int lib$free_timer(__unknown_params); /* 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. */ /* */ unsigned int lib$free_vm(__unknown_params); /* 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. */ /* */ unsigned int lib$free_vm_page(__unknown_params); /* 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. */ /* */ unsigned int lib$getdvi(__unknown_params); /* 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. */ /* */ unsigned int lib$getjpi(__unknown_params); /* 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. */ /* */ unsigned int lib$getqui(__unknown_params); /* 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. */ /* */ unsigned int lib$getsyi(__unknown_params); /* 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. */ /* */ unsigned int lib$get_accnam(__unknown_params); /* 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. */ /* */ unsigned int lib$get_accnam_by_context(__unknown_params); /* 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. */ /* */ unsigned int lib$get_command(__unknown_params); /* 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. */ /* */ unsigned int lib$get_common(__unknown_params); /* LIB$GET_CURR_INVO_CONTEXT */ /* */ /* Get Current Invocation Context */ /* */ /* The Get Current Invocation Context routine gets the current invocation */ /* context of any active procedure. */ /* */ /* ENTRY lib$get_curr_invo_context ALIAS $lib_get_curr_invo_context PARAMETER ( */ /* LONGWORD UNSIGNED NAMED invo_context OUT */ /* TYPENAME invo_context_blk REFERENCE ); */ /* LIB$GET_CURR_INVO_HANDLE */ /* */ /* Get Current Invocation Handle */ /* */ /* The Get Current Invocation Handle routine gets the current invocation */ /* handle of any active procedure. */ /* */ /* ENTRY lib$get_curr_invo_handle ALIAS $lib_get_curr_invo_handle */ /* RETURNS LONGWORD UNSIGNED NAMED RESULT TYPENAME longword_unsigned; */ /* 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. */ /* */ unsigned int lib$get_date_format(__unknown_params); /* 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. */ /* */ unsigned int lib$get_ef(__unknown_params); /* 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. */ /* foreign */ /* */ unsigned int lib$get_foreign(__unknown_params); /* 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. */ /* */ unsigned int lib$get_fullname_offset(__unknown_params); /* LIB$GET_HOSTNAME */ /* */ /* Get Host Node Name */ /* */ /* The Get Host Node Name routine returns the host node name of */ /* the local system. */ /* */ unsigned int lib$get_hostname(__unknown_params); /* 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. */ /* */ unsigned int lib$get_input(__unknown_params); /* LIB$GET_INVO_CONTEXT */ /* */ /* Get Invocation Context */ /* */ /* The Get Invocation Context routine gets the invocation context */ /* of any active procedure. */ /* */ /* ENTRY lib$get_invo_context ALIAS $lib_get_invo_context PARAMETER ( */ /* LONGWORD UNSIGNED NAMED invo_handle IN */ /* TYPENAME invo_handle VALUE, */ /* LONGWORD UNSIGNED NAMED invo_context OUT */ /* TYPENAME invo_context_blk REFERENCE ) */ /* RETURNS LONGWORD UNSIGNED NAMED RESULT TYPENAME longword_unsigned; */ /* LIB$GET_INVO_HANDLE */ /* */ /* Get Invocation Handle */ /* */ /* The Get Invocation Handle routine gets the invocation handle */ /* of any active procedure. */ /* */ /* ENTRY lib$get_invo_handle ALIAS $lib_get_invo_handle PARAMETER ( */ /* LONGWORD UNSIGNED NAMED invo_context OUT */ /* TYPENAME invo_context_blk REFERENCE ) */ /* RETURNS LONGWORD UNSIGNED NAMED RESULT TYPENAME longword_unsigned; */ /* LIB$GET_LOGICAL */ /* */ /* Get Logical */ /* */ /* The Get Logical routine gets the logical name information by calling */ /* the system service routine SYS$TRNLNM. */ /* */ unsigned int lib$get_logical(__unknown_params); /* 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. */ /* */ unsigned int lib$get_lun(__unknown_params); /* 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. */ /* */ unsigned int lib$get_maximum_date_length(__unknown_params); /* LIB$GET_PREV_INVO_CONTEXT */ /* */ /* Get Previous Invocation Context */ /* */ /* The Get Previous Invocation Context routine gets the previous invocation */ /* context of any active procedure. */ /* */ /* ENTRY lib$get_prev_invo_context ALIAS $lib_get_prev_invo_context PARAMETER ( */ /* LONGWORD UNSIGNED NAMED invo_context IN OUT */ /* TYPENAME invo_context_blk REFERENCE ) */ /* RETURNS LONGWORD UNSIGNED NAMED RESULT TYPENAME longword_unsigned; */ /* LIB$GET_PREV_INVO_HANDLE */ /* */ /* Get Previous Invocation Handle */ /* */ /* The Get Previous Invocation Handle routine gets the previous invocation */ /* handle of any active procedure. */ /* */ /* ENTRY lib$get_prev_invo_handle ALIAS $lib_get_prev_invo_handle PARAMETER ( */ /* LONGWORD UNSIGNED NAMED invo_handle IN */ /* TYPENAME invo_handle VALUE ) */ /* RETURNS LONGWORD UNSIGNED NAMED RESULT TYPENAME longword_unsigned; */ /* 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. */ /* */ unsigned int lib$get_symbol(__unknown_params); /* 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. */ /* */ unsigned int lib$get_users_language(__unknown_params); /* 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. */ /* */ unsigned int lib$get_vm(__unknown_params); /* 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. */ /* */ unsigned int lib$get_vm_page(__unknown_params); /* 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. */ /* */ unsigned int lib$ichar(__unknown_params); /* 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. */ /* */ unsigned int lib$index(__unknown_params); /* 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. */ /* */ unsigned int lib$init_date_time_context(__unknown_params); /* 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. */ /* */ unsigned int lib$init_timer(__unknown_params); /* 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. */ /* */ int lib$insert_tree(__unknown_params); /* 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 queue. LIB$INSQHI makes the VAX */ /* INSQHI instruction available as a callable routine. */ /* */ unsigned int lib$insqhi(__unknown_params); /* 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 queue. LIB$INSQTI */ /* makes the VAX INSQTI instruction available as a callable routine. */ /* */ unsigned int lib$insqti(__unknown_params); /* 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. */ /* */ void lib$insv(__unknown_params); /* 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. */ /* */ unsigned int lib$int_over(__unknown_params); /* LIB$LEN */ /* */ /* Length of String Returned as Longword Value */ /* */ /* The Length of String Returned as Longword Value routine returns the length of a */ /* string. */ /* */ unsigned short int lib$len(__unknown_params); /* 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. */ /* */ unsigned int lib$locc(__unknown_params); /* 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. */ /* */ unsigned int lib$lookup_key(__unknown_params); /* 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. */ /* */ unsigned int lib$lookup_tree(__unknown_params); /* 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. */ /* */ int lib$lp_lines(void); /* 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. */ /* */ unsigned int lib$matchc(__unknown_params); /* 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. */ /* */ unsigned int lib$match_cond(__unknown_params); /* 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. */ /* */ void lib$movc3(__unknown_params); /* 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. */ /* */ void lib$movc5(__unknown_params); /* 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. */ /* */ unsigned int lib$movtc(__unknown_params); /* 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. */ /* */ unsigned int lib$movtuc(__unknown_params); /* 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. */ /* */ unsigned int lib$multf_delta_time(__unknown_params); /* 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. */ /* */ unsigned int lib$mult_delta_time(__unknown_params); /* 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. */ /* */ unsigned int lib$parse_access_code(__unknown_params); /* LIB$PARSE_SOGW_PROT */ /* */ /* Parse Protection String */ /* */ /* The Parse Protection String routine parses and translates */ /* a protection string into a protection mask. */ /* */ unsigned int lib$parse_sogw_prot(__unknown_params); /* LIB$PAUSE */ /* */ /* Pause Program Execution */ /* */ /* The Pause Program Execution routine suspends program execution and returns */ /* control to the calling command level. */ /* */ unsigned int lib$pause(void); /* LIB$POLYD */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (D-floating point values) allows higher-level */ /* language users to evaluate D-floating point value polynomials. */ /* */ unsigned int lib$polyd(__unknown_params); /* LIB$POLYF */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (F-floating point values) allows higher-level */ /* language users to evaluate F-floating point polynomials. */ /* */ unsigned int lib$polyf(__unknown_params); /* LIB$POLYG */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (G-floating point values) allows higher-level */ /* language users to evaluate G-floating point value polynomials. */ /* */ unsigned int lib$polyg(__unknown_params); /* 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. */ /* */ unsigned int lib$polyh(__unknown_params); /* 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. */ /* */ unsigned int lib$put_common(__unknown_params); /* LIB$PUT_INVO_REGISTERS */ /* */ /* Put Invocation Registers */ /* */ /* The Put Invocation Registers routine updates a given procedure invocation */ /* context's fields with new register contents. */ /* */ /* ENTRY lib$put_invo_registers ALIAS $lib_put_invo_registers PARAMETER ( */ /* LONGWORD UNSIGNED NAMED invo_handle IN */ /* TYPENAME invo_handle VALUE, */ /* LONGWORD UNSIGNED NAMED invo_context IN */ /* TYPENAME invo_context_blk REFERENCE, */ /* QUADWORD UNSIGNED NAMED invo_mask IN */ /* TYPENAME mask_quadword REFERENCE ) */ /* RETURNS LONGWORD UNSIGNED TYPENAME cond_value; */ /* 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. */ /* */ unsigned int lib$put_output(__unknown_params); /* 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. */ /* */ unsigned int lib$radix_point(__unknown_params); /* 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 queue. */ /* LIB$REMQHI makes the VAX REMQHI */ /* */ /* instruction available as a callable routine. */ /* */ unsigned int lib$remqhi(__unknown_params); /* 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 queue. */ /* LIB$REMQTI makes the VAX REMQTI */ /* */ /* instruction available as a callable routine. */ /* */ unsigned int lib$remqti(__unknown_params); /* 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. */ /* */ unsigned int lib$rename_file(__unknown_params); /* LIB$RESERVE_EF */ /* */ /* Reserve Event Flag */ /* */ /* The Reserve Event Flag routine allocates a local event flag number specified by */ /* event-flag-number. */ /* */ unsigned int lib$reserve_ef(__unknown_params); /* 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. */ /* */ unsigned int lib$reset_vm_zone(__unknown_params); /* 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. */ /* */ void *lib$revert(void); /* LIB$RUN_PROGRAM */ /* */ /* Run New Program */ /* */ /* The Run New Program routine causes the current program to stop running and */ /* begins execution of another program. */ /* */ unsigned int lib$run_program(__unknown_params); /* 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. */ /* */ unsigned int lib$scanc(__unknown_params); /* 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. */ /* */ unsigned int lib$scopy_dxdx(__unknown_params); /* 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. */ /* */ unsigned int lib$scopy_r_dx(__unknown_params); /* 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. */ /* */ unsigned int lib$set_logical(__unknown_params); /* 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. */ /* */ unsigned int lib$set_symbol(__unknown_params); /* LIB$SFREE1_DD */ /* */ /* Free One Dynamic String */ /* */ /* The Free One Dynamic String routine returns the dynamically allocated */ /* storage for a dynamic string. */ /* */ unsigned int lib$sfree1_dd(__unknown_params); /* 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. */ /* */ unsigned int lib$sfreen_dd(__unknown_params); /* LIB$SGET1_DD */ /* */ /* Get One Dynamic String */ /* */ /* The Get One Dynamic String routine allocates dynamic virtual memory to the */ /* string descriptor you specify. */ /* */ unsigned int lib$sget1_dd(__unknown_params); /* 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. */ /* */ unsigned int lib$show_timer(__unknown_params); /* 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 */ /* and LIB$GET_VM_PAGE/LIB$FREE_VM_PAGE. */ /* */ unsigned int lib$show_vm(__unknown_params); /* 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. */ /* */ unsigned int lib$show_vm_zone(__unknown_params); /* 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. */ /* */ void lib$signal(__unknown_params); /* 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. */ /* */ unsigned int lib$sig_to_ret(__unknown_params); /* 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. */ /* */ unsigned int lib$sig_to_stop(__unknown_params); /* 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. */ /* */ unsigned int lib$sim_trap(__unknown_params); /* 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. */ /* */ unsigned int lib$skpc(__unknown_params); /* 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. */ /* */ unsigned int lib$spanc(__unknown_params); /* 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. */ /* */ unsigned int lib$spawn(__unknown_params); /* 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. */ /* */ unsigned int lib$stat_timer(__unknown_params); /* 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. */ /* */ unsigned int lib$stat_vm(__unknown_params); /* 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. */ /* */ void lib$stop(__unknown_params); /* LIB$SUBX */ /* */ /* Multiple-Precision Binary Subtraction */ /* */ /* The Multiple-Precision Binary Subtraction routine performs subtraction on signed */ /* two's complement integers of arbitrary length. */ /* */ unsigned int lib$subx(__unknown_params); /* LIB$SUB_TIMES */ /* */ /* Subtract Two Quadword Times */ /* */ /* The Subtract Two Quadword Times routine subtracts two VMS */ /* internal-time-format times. */ /* */ unsigned int lib$sub_times(__unknown_params); /* 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. */ /* */ unsigned int lib$sys_asctim(__unknown_params); /* 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. */ /* */ unsigned int lib$sys_fao(__unknown_params); /* 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. */ /* */ unsigned int lib$sys_faol(__unknown_params); /* 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. */ /* */ unsigned int lib$sys_getmsg(__unknown_params); /* 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. */ /* */ unsigned int lib$sys_trnlog(__unknown_params); /* 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. */ /* */ unsigned int lib$table_parse(__unknown_params); unsigned int lib$tparse(__unknown_params); /* 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. */ /* */ unsigned int lib$traverse_tree(__unknown_params); /* LIB$TRA_ASC_EBC */ /* */ /* Translate ASCII to EBCDIC */ /* */ /* The Translate ASCII to EBCDIC routine translates an ASCII string to an EBCDIC */ /* string. */ /* */ unsigned int lib$tra_asc_ebc(__unknown_params); /* LIB$TRA_EBC_ASC */ /* */ /* Translate EBCDIC to ASCII */ /* */ /* The Translate EBCDIC to ASCII routine translates an EBCDIC string to */ /* an ASCII string. */ /* */ unsigned int lib$tra_ebc_asc(__unknown_params); /* 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. */ /* */ unsigned int lib$trim_filespec(__unknown_params); /* 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. */ /* */ unsigned int lib$trim_fullname(__unknown_params); /* 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. */ /* */ unsigned int lib$uid_to_ascii(__unknown_params); /* LIB$VERIFY_VM_ZONE */ /* */ /* Verify a Zone */ /* */ /* The Verify a Zone routine performs verification of a zone. */ /* */ unsigned int lib$verify_vm_zone(__unknown_params); /* 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. */ /* */ unsigned int lib$wait(__unknown_params); #ifdef __cplusplus } #endif #pragma standard #endif /* __LIB$ROUTINES_LOADED */