/********************************************************************************************************************************/ /* Created: 30-Mar-2010 17:30:00 by OpenVMS SDL EV3-3 */ /* Source: 18-FEB-2010 16:45:43 $1$DGA7274:[STARLET.SRC]LIB$ROUTINES.SDL;1 */ /********************************************************************************************************************************/ /*** MODULE lib$routines ***/ #ifndef __LIB_ROUTINES_LOADED #define __LIB_ROUTINES_LOADED 1 #pragma __nostandard /* This file uses non-ANSI-Standard features */ #pragma __member_alignment __save #pragma __nomember_alignment #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __save /* Save the previously-defined required ptr size */ #pragma __required_pointer_size __short /* And set ptr size default to 32-bit pointers */ #endif #ifdef __cplusplus extern "C" { #define __unknown_params ... #define __optional_params ... #else #define __unknown_params #define __optional_params ... #endif #ifndef __struct #if !defined(__VAXC) #define __struct struct #else #define __struct variant_struct #endif #endif #ifndef __union #if !defined(__VAXC) #define __union union #else #define __union variant_union #endif #endif /**************************************************************************** */ /* * */ /* COPYRIGHT (c) 1992, 1994, 1995, 1996, 1997, 2003, 2010 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. * */ /* * */ /* * */ /**************************************************************************** */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$adawi LIB$ADAWI #ifdef __NEW_STARLET unsigned int lib$adawi( short int *add, short int *sum, short int *sign); #else /* __OLD_STARLET */ unsigned int lib$adawi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$addx LIB$ADDX #ifdef __NEW_STARLET unsigned int lib$addx( unsigned int *addend_array, unsigned int *augend_array, unsigned int *resultant_array, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$addx(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$ADD_TIMES */ /* */ /* Add Two Quadword Times */ /* */ /* The Add Two Quadword Times routine adds two VMS internal time format */ /* times. */ /* */ #define lib$add_times LIB$ADD_TIMES #ifdef __NEW_STARLET unsigned int lib$add_times( unsigned __int64 *time1, unsigned __int64 *time2, unsigned __int64 *resultant_time); #else /* __OLD_STARLET */ unsigned int lib$add_times(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$analyze_sdesc LIB$ANALYZE_SDESC #ifdef __NEW_STARLET unsigned int lib$analyze_sdesc( unsigned __int64 *input_descriptor, unsigned short int *data_length, void *data_address); #else /* __OLD_STARLET */ unsigned int lib$analyze_sdesc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$analyze_sdesc_64 LIB$ANALYZE_SDESC_64 #ifdef __NEW_STARLET unsigned int lib$analyze_sdesc_64( unsigned __int64 *input_descriptor, unsigned __int64 *data_length, void *(*(data_address)), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$analyze_sdesc_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$ascii_to_uid LIB$ASCII_TO_UID #ifdef __NEW_STARLET unsigned int lib$ascii_to_uid( void *input_string, unsigned int output_uid [4]); #else /* __OLD_STARLET */ unsigned int lib$ascii_to_uid(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$asn_wth_mbx LIB$ASN_WTH_MBX #ifdef __NEW_STARLET unsigned int lib$asn_wth_mbx( void *device_name, int *maximum_message_size, int *buffer_quota, unsigned short int *device_channel, unsigned short int *mailbox_channel); #else /* __OLD_STARLET */ unsigned int lib$asn_wth_mbx(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$AST_IN_PROG */ /* */ /* AST in Progress */ /* */ /* The AST in Progress routine indicates whether an AST is currently in */ /* progress. */ /* */ #define lib$ast_in_prog LIB$AST_IN_PROG #ifdef __NEW_STARLET char lib$ast_in_prog(void); #else /* __OLD_STARLET */ char lib$ast_in_prog(void); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$attach LIB$ATTACH #ifdef __NEW_STARLET unsigned int lib$attach( unsigned int *process_id); #else /* __OLD_STARLET */ unsigned int lib$attach(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$bbcci LIB$BBCCI #ifdef __NEW_STARLET unsigned int lib$bbcci( int *position, void *bit_zero_address); #else /* __OLD_STARLET */ unsigned int lib$bbcci(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$bbssi LIB$BBSSI #ifdef __NEW_STARLET unsigned int lib$bbssi( int *position, void *bit_zero_address); #else /* __OLD_STARLET */ unsigned int lib$bbssi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$build_nodespec LIB$BUILD_NODESPEC #ifdef __NEW_STARLET unsigned int lib$build_nodespec( void *primary_nodename, void *nodespec, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$build_nodespec(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$callg LIB$CALLG #ifdef __NEW_STARLET unsigned int lib$callg( unsigned int *argument_list, int (*user_procedure)(void)); #else /* __OLD_STARLET */ unsigned int lib$callg(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$callg_64 LIB$CALLG_64 #ifdef __NEW_STARLET unsigned int lib$callg_64( unsigned __int64 argument_list [], int (*user_procedure)(void)); #else /* __OLD_STARLET */ unsigned int lib$callg_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$char LIB$CHAR #ifdef __NEW_STARLET unsigned int lib$char( void *one_character_string, unsigned char *ascii_code); #else /* __OLD_STARLET */ unsigned int lib$char(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$compare_nodename LIB$COMPARE_NODENAME #ifdef __NEW_STARLET unsigned int lib$compare_nodename( void *nodename1, void *nodename2, unsigned int *comparison_result); #else /* __OLD_STARLET */ unsigned int lib$compare_nodename(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$COMPARE_UID */ /* */ /* Compare Two UIDs */ /* */ /* The Compare Two UIDs routine compares the contents */ /* of two UIDs for total lexical ordering. */ /* */ #define lib$compare_uid LIB$COMPARE_UID #ifdef __NEW_STARLET unsigned int lib$compare_uid( unsigned int first_uid [4], unsigned int second_uid [4], int *match_result); #else /* __OLD_STARLET */ unsigned int lib$compare_uid(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$compress_nodename LIB$COMPRESS_NODENAME #ifdef __NEW_STARLET unsigned int lib$compress_nodename( void *nodename, void *compressed_nodename, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$compress_nodename(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$convert_date_string LIB$CONVERT_DATE_STRING #ifdef __NEW_STARLET unsigned int lib$convert_date_string( void *date_string, unsigned __int64 *date_time, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$convert_date_string(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$crc LIB$CRC #ifdef __NEW_STARLET unsigned int lib$crc( int crc_table [], int *initial_crc, void *stream); #else /* __OLD_STARLET */ unsigned int lib$crc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$crc_table LIB$CRC_TABLE #ifdef __NEW_STARLET int lib$crc_table( unsigned int *polynomial_coefficient, int crc_table []); #else /* __OLD_STARLET */ int lib$crc_table(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$CREATE_DIR */ /* */ /* Create a Directory */ /* */ /* The Create a Directory routine creates a directory or subdirectory. */ /* */ #define lib$create_dir LIB$CREATE_DIR #ifdef __NEW_STARLET unsigned int lib$create_dir( void *device_directory_spec, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$create_dir(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* LIB$CREATE_USER_VM_ZONE */ /* */ /* Create User-Defined Storage Zone */ /* */ /* The Create User-Defined Storage Zone routine creates a new user-defined */ /* storage zone. */ /* */ #define lib$create_user_vm_zone LIB$CREATE_USER_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$create_user_vm_zone( unsigned int *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$create_user_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$create_user_vm_zone_64 LIB$CREATE_USER_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$create_user_vm_zone_64( unsigned __int64 *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$create_user_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* LIB$CREATE_VM_ZONE */ /* */ /* Create a New Zone */ /* */ /* The Create a New Zone routine creates a new storage zone according to */ /* specified arguments. */ /* */ #define lib$create_vm_zone LIB$CREATE_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$create_vm_zone( unsigned int *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$create_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* LIB$CREATE_VM_ZONE_64 */ /* */ /* Create a New Zone */ /* */ /* The Create a New Zone routine creates a new storage zone according to */ /* specified arguments. */ /* */ #define lib$create_vm_zone_64 LIB$CREATE_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$create_vm_zone_64( unsigned __int64 *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$create_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$crf_ins_key LIB$CRF_INS_KEY #ifdef __NEW_STARLET int lib$crf_ins_key( int control_table [], void *key_string, int *symbol_value, unsigned int *flags); #else /* __OLD_STARLET */ int lib$crf_ins_key(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$crf_ins_ref LIB$CRF_INS_REF #ifdef __NEW_STARLET int lib$crf_ins_ref( int control_table [], int *longword_integer_key, void *reference_string, int *longword_integer_reference, int *ref_definition_indicator); #else /* __OLD_STARLET */ int lib$crf_ins_ref(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$crf_output LIB$CRF_OUTPUT #ifdef __NEW_STARLET int lib$crf_output( int control_table [], int *output_line_width, int *page1, int *page2, int *mode_indicator, int *delete_save_indicator); #else /* __OLD_STARLET */ int lib$crf_output(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* LIB$CURRENCY */ /* */ /* Get System Currency Symbol */ /* */ /* The Get System Currency Symbol routine returns the system's currency */ /* symbol. */ /* */ #define lib$currency LIB$CURRENCY #ifdef __NEW_STARLET unsigned int lib$currency( void *currency_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$currency(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$CVTS_FROM_INTERNAL_TIME */ /* */ /* Convert Internal Time to External Time (S-Floating Point Value) */ /* */ /* The Convert Internal Time to External Time (S-Floating Point Value) */ /* routine converts a delta internal VMS system time into an external */ /* S-floating time. */ /* */ #define lib$cvts_from_internal_time LIB$CVTS_FROM_INTERNAL_TIME #ifdef __NEW_STARLET unsigned int lib$cvts_from_internal_time( unsigned int *operation, float *resultant_time, unsigned __int64 *input_time); #else /* __OLD_STARLET */ unsigned int lib$cvts_from_internal_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvtf_from_internal_time LIB$CVTF_FROM_INTERNAL_TIME #ifdef __NEW_STARLET unsigned int lib$cvtf_from_internal_time( unsigned int *operation, float *resultant_time, unsigned __int64 *input_time); #else /* __OLD_STARLET */ unsigned int lib$cvtf_from_internal_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$CVTS_TO_INTERNAL_TIME */ /* */ /* Convert External Time to Internal Time (S-Floating Point Value) */ /* */ /* The Convert External Time to Internal Time (S-Floating Point Value) */ /* routine converts an external time interval into a VMS internal format */ /* S-floating delta time. */ /* */ /* */ #define lib$cvts_to_internal_time LIB$CVTS_TO_INTERNAL_TIME #ifdef __NEW_STARLET unsigned int lib$cvts_to_internal_time( unsigned int *operation, float *input_time, unsigned __int64 *resultant_time); #else /* __OLD_STARLET */ unsigned int lib$cvts_to_internal_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvtf_to_internal_time LIB$CVTF_TO_INTERNAL_TIME #ifdef __NEW_STARLET unsigned int lib$cvtf_to_internal_time( unsigned int *operation, float *input_time, unsigned __int64 *resultant_time); #else /* __OLD_STARLET */ unsigned int lib$cvtf_to_internal_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_dtb LIB$CVT_DTB #ifdef __NEW_STARLET unsigned int lib$cvt_dtb( int byte_count, char *numeric_string, int *result); #else /* __OLD_STARLET */ unsigned int lib$cvt_dtb(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_dtb_64 LIB$CVT_DTB_64 #ifdef __NEW_STARLET unsigned int lib$cvt_dtb_64( int byte_count, char *numeric_string, __int64 *result); #else /* __OLD_STARLET */ unsigned int lib$cvt_dtb_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_dx_dx LIB$CVT_DX_DX #ifdef __NEW_STARLET unsigned int lib$cvt_dx_dx( unsigned int *source_item, unsigned int *destination_item, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$cvt_dx_dx(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_from_internal_time LIB$CVT_FROM_INTERNAL_TIME #ifdef __NEW_STARLET unsigned int lib$cvt_from_internal_time( unsigned int *operation, unsigned int *resultant_time, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$cvt_from_internal_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_htb LIB$CVT_HTB #ifdef __NEW_STARLET unsigned int lib$cvt_htb( int byte_count, char *numeric_string, int *result); #else /* __OLD_STARLET */ unsigned int lib$cvt_htb(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_htb_64 LIB$CVT_HTB_64 #ifdef __NEW_STARLET unsigned int lib$cvt_htb_64( int byte_count, char *numeric_string, __int64 *result); #else /* __OLD_STARLET */ unsigned int lib$cvt_htb_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_otb LIB$CVT_OTB #ifdef __NEW_STARLET unsigned int lib$cvt_otb( int byte_count, char *numeric_string, int *result); #else /* __OLD_STARLET */ unsigned int lib$cvt_otb(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_otb_64 LIB$CVT_OTB_64 #ifdef __NEW_STARLET unsigned int lib$cvt_otb_64( int byte_count, char *numeric_string, __int64 *result); #else /* __OLD_STARLET */ unsigned int lib$cvt_otb_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_to_internal_time LIB$CVT_TO_INTERNAL_TIME #ifdef __NEW_STARLET unsigned int lib$cvt_to_internal_time( unsigned int *operation, int *input_time, unsigned __int64 *resultant_time); #else /* __OLD_STARLET */ unsigned int lib$cvt_to_internal_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$cvt_vectim LIB$CVT_VECTIM #ifdef __NEW_STARLET unsigned int lib$cvt_vectim( unsigned short int input_time [], unsigned __int64 *resultant_time); #else /* __OLD_STARLET */ unsigned int lib$cvt_vectim(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$date_time LIB$DATE_TIME #ifdef __NEW_STARLET unsigned int lib$date_time( void *date_time_string); #else /* __OLD_STARLET */ unsigned int lib$date_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$day LIB$DAY #ifdef __NEW_STARLET unsigned int lib$day( int *number_of_days, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$day(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$day_of_week LIB$DAY_OF_WEEK #ifdef __NEW_STARLET unsigned int lib$day_of_week( unsigned __int64 *user_time, unsigned int *day_number); #else /* __OLD_STARLET */ unsigned int lib$day_of_week(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$decode_fault LIB$DECODE_FAULT #ifdef __NEW_STARLET unsigned int lib$decode_fault( unsigned int *signal_arguments, unsigned int *mechanism_arguments, int (*user_procedure)(void), __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$decode_fault(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$dec_over LIB$DEC_OVER #ifdef __NEW_STARLET unsigned int lib$dec_over( unsigned int *new_setting); #else /* __OLD_STARLET */ unsigned int lib$dec_over(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$delete_file LIB$DELETE_FILE #ifdef __NEW_STARLET unsigned int lib$delete_file( void *filespec, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$delete_file(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$delete_logical LIB$DELETE_LOGICAL #ifdef __NEW_STARLET unsigned int lib$delete_logical( void *logical_name, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$delete_logical(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$delete_symbol LIB$DELETE_SYMBOL #ifdef __NEW_STARLET unsigned int lib$delete_symbol( void *symbol, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$delete_symbol(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$delete_vm_zone LIB$DELETE_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$delete_vm_zone( unsigned int *zone_id); #else /* __OLD_STARLET */ unsigned int lib$delete_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$delete_vm_zone_64 LIB$DELETE_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$delete_vm_zone_64( unsigned __int64 *zone_id); #else /* __OLD_STARLET */ unsigned int lib$delete_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* LIB$DIGIT_SEP */ /* */ /* Get Digit Separator Symbol */ /* */ /* The Get Digit Separator Symbol routine returns the system's digit */ /* separator symbol. */ /* */ #define lib$digit_sep LIB$DIGIT_SEP #ifdef __NEW_STARLET unsigned int lib$digit_sep( void *digit_separator_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$digit_sep(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$disable_ctrl LIB$DISABLE_CTRL #ifdef __NEW_STARLET unsigned int lib$disable_ctrl( unsigned int *disable_mask, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$disable_ctrl(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$do_command LIB$DO_COMMAND #ifdef __NEW_STARLET unsigned int lib$do_command( void *command_string); #else /* __OLD_STARLET */ unsigned int lib$do_command(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$ediv LIB$EDIV #ifdef __NEW_STARLET unsigned int lib$ediv( int *longword_integer_divisor, __int64 *quadword_integer_dividend, int *longword_integer_quotient, int *remainder); #else /* __OLD_STARLET */ unsigned int lib$ediv(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$emodd LIB$EMODD #ifdef __NEW_STARLET unsigned int lib$emodd( double *floating_point_multiplier, unsigned char *multiplier_extension, double *floating_point_multiplicand, int *integer_portion, double *fractional_portion); #else /* __OLD_STARLET */ unsigned int lib$emodd(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ /* */ #define lib$emodt LIB$EMODT #ifdef __NEW_STARLET unsigned int lib$emodt( double *floating_point_multiplier, unsigned char *multiplier_extension, double *floating_point_multiplicand, int *integer_portion, double *fractional_portion); #else /* __OLD_STARLET */ unsigned int lib$emodt(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$EMODS */ /* */ /* Extended Multiply and Integerize Routines for S-Floating Point Values */ /* */ /* The Extended Multiply and Integerize routine (S-Floating Point Values) */ /* allows higher-level language users to perform accurate range reduction */ /* of S-floating arguments. */ /* */ #define lib$emods LIB$EMODS #ifdef __NEW_STARLET unsigned int lib$emods( float *floating_point_multiplier, unsigned char *multiplier_extension, float *floating_point_multiplicand, int *integer_portion, float *fractional_portion); #else /* __OLD_STARLET */ unsigned int lib$emods(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$emodf LIB$EMODF #ifdef __NEW_STARLET unsigned int lib$emodf( float *floating_point_multiplier, unsigned char *multiplier_extension, float *floating_point_multiplicand, int *integer_portion, float *fractional_portion); #else /* __OLD_STARLET */ unsigned int lib$emodf(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$emodg LIB$EMODG #ifdef __NEW_STARLET unsigned int lib$emodg( double *floating_point_multiplier, unsigned short int *multiplier_extension, double *floating_point_multiplicand, int *integer_portion, double *fractional_portion); #else /* __OLD_STARLET */ unsigned int lib$emodg(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$emodh LIB$EMODH #ifdef __NEW_STARLET unsigned int lib$emodh( int floating_point_multiplier [4], unsigned short int *multiplier_extension, int floating_point_multiplicand [4], int *integer_portion, int fractional_portion [4]); #else /* __OLD_STARLET */ unsigned int lib$emodh(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$emul LIB$EMUL #ifdef __NEW_STARLET unsigned int lib$emul( int *longword_integer_multiplier, int *longword_integer_multiplicand, int *addend, __int64 *product); #else /* __OLD_STARLET */ unsigned int lib$emul(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$enable_ctrl LIB$ENABLE_CTRL #ifdef __NEW_STARLET unsigned int lib$enable_ctrl( unsigned int *enable_mask, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$enable_ctrl(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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; */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$expand_nodename LIB$EXPAND_NODENAME #ifdef __NEW_STARLET unsigned int lib$expand_nodename( void *nodename, void *fullname, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$expand_nodename(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$extv LIB$EXTV #ifdef __NEW_STARLET int lib$extv( int *position, unsigned char *size, void *base_address); #else /* __OLD_STARLET */ int lib$extv(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$extzv LIB$EXTZV #ifdef __NEW_STARLET int lib$extzv( int *position, unsigned char *size, void *base_address); #else /* __OLD_STARLET */ int lib$extzv(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$ffc LIB$FFC #ifdef __NEW_STARLET unsigned int lib$ffc( int *position, unsigned char *size, void *base, int *find_position); #else /* __OLD_STARLET */ unsigned int lib$ffc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$ffs LIB$FFS #ifdef __NEW_STARLET unsigned int lib$ffs( int *position, unsigned char *size, void *base, int *find_position); #else /* __OLD_STARLET */ unsigned int lib$ffs(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$fid_to_name LIB$FID_TO_NAME #ifdef __NEW_STARLET unsigned int lib$fid_to_name( void *device_name, unsigned short int file_id [], void *filespec, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$fid_to_name(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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 */ /* */ #define lib$file_scan LIB$FILE_SCAN #ifdef __cplusplus /* Define structure prototypes */ struct _fabdef; #endif /* #ifdef __cplusplus */ #ifdef __NEW_STARLET unsigned int lib$file_scan( struct _fabdef *fab, int (*user_success_procedure)(__unknown_params), int (*user_error_procedure)(__unknown_params), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$file_scan(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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 * */ /* */ #define lib$file_scan_end LIB$FILE_SCAN_END #ifdef __cplusplus /* Define structure prototypes */ struct _fabdef; #endif /* #ifdef __cplusplus */ #ifdef __NEW_STARLET unsigned int lib$file_scan_end( __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$file_scan_end(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$find_file LIB$FIND_FILE #ifdef __NEW_STARLET unsigned int lib$find_file( void *filespec, void *resultant_filespec, unsigned int *context, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$find_file(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$find_file_end LIB$FIND_FILE_END #ifdef __NEW_STARLET unsigned int lib$find_file_end( unsigned int *context); #else /* __OLD_STARLET */ unsigned int lib$find_file_end(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$find_image_symbol LIB$FIND_IMAGE_SYMBOL #ifdef __NEW_STARLET unsigned int lib$find_image_symbol( void *filename, void *symbol, int *symbol_value, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$find_image_symbol(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$find_vm_zone LIB$FIND_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$find_vm_zone( unsigned int *context, unsigned int *zone_id); #else /* __OLD_STARLET */ unsigned int lib$find_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$find_vm_zone_64 LIB$FIND_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$find_vm_zone_64( unsigned __int64 *context, unsigned __int64 *zone_id); #else /* __OLD_STARLET */ unsigned int lib$find_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$fit_nodename LIB$FIT_NODENAME #ifdef __NEW_STARLET unsigned int lib$fit_nodename( void *nodename, void *output_buffer, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$fit_nodename(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$fixup_flt LIB$FIXUP_FLT #ifdef __NEW_STARLET unsigned int lib$fixup_flt( unsigned int *signal_arguments, unsigned int *mechanism_arguments, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$fixup_flt(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$flt_under LIB$FLT_UNDER #ifdef __NEW_STARLET unsigned int lib$flt_under( unsigned int *new_setting); #else /* __OLD_STARLET */ unsigned int lib$flt_under(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$format_date_time LIB$FORMAT_DATE_TIME #ifdef __NEW_STARLET unsigned int lib$format_date_time( void *date_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$format_date_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* LIB$FORMAT_SOGW_PROT */ /* */ /* Format Protection Mask */ /* */ /* The Format Protection Mask routine translates a protection mask */ /* into a formatted string. */ /* */ #define lib$format_sogw_prot LIB$FORMAT_SOGW_PROT #ifdef __NEW_STARLET unsigned int lib$format_sogw_prot( unsigned short int *protection_mask, unsigned __int64 access_names [], unsigned __int64 ownership_names [], void *ownership_separator, void *list_separator, void *protection_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$format_sogw_prot(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$free_date_time_context LIB$FREE_DATE_TIME_CONTEXT #ifdef __NEW_STARLET unsigned int lib$free_date_time_context( __optional_params); #else /* __OLD_STARLET */ unsigned int lib$free_date_time_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$free_ef LIB$FREE_EF #ifdef __NEW_STARLET unsigned int lib$free_ef( unsigned int *event_flag_number); #else /* __OLD_STARLET */ unsigned int lib$free_ef(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$free_lun LIB$FREE_LUN #ifdef __NEW_STARLET unsigned int lib$free_lun( int *logical_unit_number); #else /* __OLD_STARLET */ unsigned int lib$free_lun(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$FREE_TIMER */ /* */ /* Free Timer Storage */ /* */ /* The Free Timer Storage routine frees the storage allocated */ /* by LIB$INIT_TIMER. */ /* */ #define lib$free_timer LIB$FREE_TIMER #ifdef __NEW_STARLET unsigned int lib$free_timer( void *handle_address); #else /* __OLD_STARLET */ unsigned int lib$free_timer(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$free_vm LIB$FREE_VM #ifdef __NEW_STARLET unsigned int lib$free_vm( int *number_of_bytes, void *base_address, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$free_vm(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$free_vm_64 LIB$FREE_VM_64 #ifdef __NEW_STARLET unsigned int lib$free_vm_64( __int64 *number_of_bytes, void *(*(base_address)), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$free_vm_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$free_vm_page LIB$FREE_VM_PAGE #ifdef __NEW_STARLET unsigned int lib$free_vm_page( int *number_of_pages, void *base_address); #else /* __OLD_STARLET */ unsigned int lib$free_vm_page(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$free_vm_page_64 LIB$FREE_VM_PAGE_64 #ifdef __NEW_STARLET unsigned int lib$free_vm_page_64( __int64 *number_of_pages, void *(*(base_address))); #else /* __OLD_STARLET */ unsigned int lib$free_vm_page_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$getdvi LIB$GETDVI #ifdef __NEW_STARLET unsigned int lib$getdvi( int *item_code, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$getdvi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$getjpi LIB$GETJPI #ifdef __NEW_STARLET unsigned int lib$getjpi( int *item_code, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$getjpi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$getqui LIB$GETQUI #ifdef __NEW_STARLET unsigned int lib$getqui( int *function_code, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$getqui(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$getsyi LIB$GETSYI #ifdef __NEW_STARLET unsigned int lib$getsyi( int *item_code, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$getsyi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$get_accnam LIB$GET_ACCNAM #ifdef __NEW_STARLET unsigned int lib$get_accnam( void *clsnam, void *objnam, unsigned int *accnam); #else /* __OLD_STARLET */ unsigned int lib$get_accnam(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_accnam_by_context LIB$GET_ACCNAM_BY_CONTEXT #ifdef __NEW_STARLET unsigned int lib$get_accnam_by_context( unsigned int *contxt, unsigned int *accnam); #else /* __OLD_STARLET */ unsigned int lib$get_accnam_by_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$get_command LIB$GET_COMMAND #ifdef __NEW_STARLET unsigned int lib$get_command( void *resultant_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_command(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_common LIB$GET_COMMON #ifdef __NEW_STARLET unsigned int lib$get_common( void *resultant_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$get_common(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_CURR_INVO_CONTEXT ** Alpha only ** */ /* */ /* Get Current Invocation Context */ /* */ /* The Get Current Invocation Context routine gets the current invocation */ /* context of any active procedure. */ /* */ #define lib$get_curr_invo_context LIB$GET_CURR_INVO_CONTEXT #ifdef __NEW_STARLET int lib$get_curr_invo_context( void *invo_context); #else /* __OLD_STARLET */ int lib$get_curr_invo_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_CURR_INVO_HANDLE ** Alpha only ** */ /* */ /* Get Current Invocation Handle */ /* */ /* The Get Current Invocation Handle routine gets the current invocation */ /* handle of any active procedure. */ /* */ #define lib$get_curr_invo_handle LIB$GET_CURR_INVO_HANDLE #ifdef __NEW_STARLET unsigned int lib$get_curr_invo_handle(void); #else /* __OLD_STARLET */ unsigned int lib$get_curr_invo_handle(void); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_date_format LIB$GET_DATE_FORMAT #ifdef __NEW_STARLET unsigned int lib$get_date_format( void *format_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$get_date_format(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_ef LIB$GET_EF #ifdef __NEW_STARLET unsigned int lib$get_ef( unsigned int *event_flag_number); #else /* __OLD_STARLET */ unsigned int lib$get_ef(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_foreign LIB$GET_FOREIGN #ifdef __NEW_STARLET unsigned int lib$get_foreign( void *resultant_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_foreign(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$get_fullname_offset LIB$GET_FULLNAME_OFFSET #ifdef __NEW_STARLET unsigned int lib$get_fullname_offset( void *fullname, unsigned short int *offset); #else /* __OLD_STARLET */ unsigned int lib$get_fullname_offset(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_HOSTNAME */ /* */ /* Get Host Node Name */ /* */ /* The Get Host Node Name routine returns the host node name of */ /* the local system. */ /* */ #define lib$get_hostname LIB$GET_HOSTNAME #ifdef __NEW_STARLET unsigned int lib$get_hostname( void *hostname, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_hostname(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$get_input LIB$GET_INPUT #ifdef __NEW_STARLET unsigned int lib$get_input( void *resultant_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_input(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_INVO_CONTEXT ** Alpha only ** */ /* */ /* Get Invocation Context */ /* */ /* The Get Invocation Context routine gets the invocation context */ /* of any active procedure. */ /* */ #define lib$get_invo_context LIB$GET_INVO_CONTEXT #ifdef __NEW_STARLET unsigned int lib$get_invo_context( unsigned int invo_handle, void *invo_context); #else /* __OLD_STARLET */ unsigned int lib$get_invo_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_INVO_HANDLE ** Alpha only ** */ /* */ /* Get Invocation Handle */ /* */ /* The Get Invocation Handle routine gets the invocation handle */ /* of any active procedure. */ /* */ #define lib$get_invo_handle LIB$GET_INVO_HANDLE #ifdef __NEW_STARLET unsigned int lib$get_invo_handle( void *invo_context); #else /* __OLD_STARLET */ unsigned int lib$get_invo_handle(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_LOGICAL */ /* */ /* Get Logical */ /* */ /* The Get Logical routine gets the logical name information by calling */ /* the system service routine SYS$TRNLNM. */ /* */ #define lib$get_logical LIB$GET_LOGICAL #ifdef __NEW_STARLET unsigned int lib$get_logical( void *logical_name, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_logical(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_lun LIB$GET_LUN #ifdef __NEW_STARLET unsigned int lib$get_lun( int *logical_unit_number); #else /* __OLD_STARLET */ unsigned int lib$get_lun(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_maximum_date_length LIB$GET_MAXIMUM_DATE_LENGTH #ifdef __NEW_STARLET unsigned int lib$get_maximum_date_length( int *date_length, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_maximum_date_length(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_PREV_INVO_CONTEXT ** Alpha only ** */ /* */ /* Get Previous Invocation Context */ /* */ /* The Get Previous Invocation Context routine gets the previous invocation */ /* context of any active procedure. */ /* */ #define lib$get_prev_invo_context LIB$GET_PREV_INVO_CONTEXT #ifdef __NEW_STARLET unsigned int lib$get_prev_invo_context( void *invo_context); #else /* __OLD_STARLET */ unsigned int lib$get_prev_invo_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$GET_PREV_INVO_HANDLE ** Alpha only ** */ /* */ /* Get Previous Invocation Handle */ /* */ /* The Get Previous Invocation Handle routine gets the previous invocation */ /* handle of any active procedure. */ /* */ #define lib$get_prev_invo_handle LIB$GET_PREV_INVO_HANDLE #ifdef __NEW_STARLET unsigned int lib$get_prev_invo_handle( unsigned int invo_handle); #else /* __OLD_STARLET */ unsigned int lib$get_prev_invo_handle(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_symbol LIB$GET_SYMBOL #ifdef __NEW_STARLET unsigned int lib$get_symbol( void *symbol, void *resultant_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$get_symbol(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$get_users_language LIB$GET_USERS_LANGUAGE #ifdef __NEW_STARLET unsigned int lib$get_users_language( void *language); #else /* __OLD_STARLET */ unsigned int lib$get_users_language(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$get_vm LIB$GET_VM #ifdef __NEW_STARLET unsigned int lib$get_vm( int *number_of_bytes, void *base_address, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$get_vm(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$get_vm_64 LIB$GET_VM_64 #ifdef __NEW_STARLET unsigned int lib$get_vm_64( __int64 *number_of_bytes, void *(*(base_address)), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$get_vm_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$get_vm_page LIB$GET_VM_PAGE #ifdef __NEW_STARLET unsigned int lib$get_vm_page( int *number_of_pages, void *base_address); #else /* __OLD_STARLET */ unsigned int lib$get_vm_page(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$get_vm_page_64 LIB$GET_VM_PAGE_64 #ifdef __NEW_STARLET unsigned int lib$get_vm_page_64( __int64 *number_of_pages, void *(*(base_address))); #else /* __OLD_STARLET */ unsigned int lib$get_vm_page_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$ichar LIB$ICHAR #ifdef __NEW_STARLET unsigned int lib$ichar( void *source_string); #else /* __OLD_STARLET */ unsigned int lib$ichar(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$index LIB$INDEX #ifdef __NEW_STARLET unsigned int lib$index( void *source_string, void *sub_string); #else /* __OLD_STARLET */ unsigned int lib$index(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$init_date_time_context LIB$INIT_DATE_TIME_CONTEXT #ifdef __NEW_STARLET unsigned int lib$init_date_time_context( unsigned int *user_context, int *component, void *init_string); #else /* __OLD_STARLET */ unsigned int lib$init_date_time_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$init_timer LIB$INIT_TIMER #ifdef __NEW_STARLET unsigned int lib$init_timer( __optional_params); #else /* __OLD_STARLET */ unsigned int lib$init_timer(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$insert_tree LIB$INSERT_TREE #ifdef __NEW_STARLET int lib$insert_tree( void *treehead, unsigned int *symbol, unsigned int *flags, int (*user_compare_routine)(void), int (*user_allocation_procedure)(void), void *new_node, __optional_params); #else /* __OLD_STARLET */ int lib$insert_tree(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$insert_tree_64 LIB$INSERT_TREE_64 #ifdef __NEW_STARLET int lib$insert_tree_64( void *(*(treehead)), unsigned int *symbol, unsigned int *flags, int (*user_compare_routine)(void), int (*user_allocation_procedure)(void), void *(*(new_node)), __optional_params); #else /* __OLD_STARLET */ int lib$insert_tree_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$insqhi LIB$INSQHI #ifdef __NEW_STARLET unsigned int lib$insqhi( unsigned int *entry, __int64 *header, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$insqhi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$insqhiq LIB$INSQHIQ #ifdef __NEW_STARLET unsigned int lib$insqhiq( unsigned int *entry, int header [4], __optional_params); #else /* __OLD_STARLET */ unsigned int lib$insqhiq(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$insqti LIB$INSQTI #ifdef __NEW_STARLET unsigned int lib$insqti( unsigned int *entry, __int64 *header, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$insqti(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$insqtiq LIB$INSQTIQ #ifdef __NEW_STARLET unsigned int lib$insqtiq( unsigned int *entry, int header [4], __optional_params); #else /* __OLD_STARLET */ unsigned int lib$insqtiq(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$insv LIB$INSV #ifdef __NEW_STARLET int lib$insv( int *longword_integer_source, int *position, unsigned char *size, void *base_address); #else /* __OLD_STARLET */ int lib$insv(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$int_over LIB$INT_OVER #ifdef __NEW_STARLET unsigned int lib$int_over( unsigned int *new_setting); #else /* __OLD_STARLET */ unsigned int lib$int_over(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* LIB$LEN */ /* */ /* Length of String Returned as Longword Value */ /* */ /* The Length of String Returned as Longword Value routine returns the */ /* length of a string. */ /* */ #define lib$len LIB$LEN #ifdef __NEW_STARLET unsigned short int lib$len( void *source_string); #else /* __OLD_STARLET */ unsigned short int lib$len(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$locc LIB$LOCC #ifdef __NEW_STARLET unsigned int lib$locc( void *character_string, void *source_string); #else /* __OLD_STARLET */ unsigned int lib$locc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$LOCK_IMAGE */ /* */ /* Lock Image in working set */ /* */ /* Lock all address ranges associated with a specified image */ /* into the working set. */ /* */ #define lib$lock_image LIB$LOCK_IMAGE #ifdef __NEW_STARLET unsigned int lib$lock_image( #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __long /* And set ptr size default to 64-bit pointers */ void *va #else unsigned __int64 va #endif ); #else /* __OLD_STARLET */ unsigned int lib$lock_image(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$lookup_key LIB$LOOKUP_KEY #ifdef __NEW_STARLET unsigned int lib$lookup_key( void *search_string, #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __short /* And set ptr size default to 32-bit pointers */ #endif unsigned int *key_table_array, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$lookup_key(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$lookup_tree LIB$LOOKUP_TREE #ifdef __NEW_STARLET unsigned int lib$lookup_tree( void *treehead, unsigned int *symbol, int (*user_compare_routine)(void), void *new_node); #else /* __OLD_STARLET */ unsigned int lib$lookup_tree(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$lookup_tree_64 LIB$LOOKUP_TREE_64 #ifdef __NEW_STARLET unsigned int lib$lookup_tree_64( void *(*(treehead)), unsigned int *symbol, int (*user_compare_routine)(void), void *(*(new_node))); #else /* __OLD_STARLET */ unsigned int lib$lookup_tree_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$lp_lines LIB$LP_LINES #ifdef __NEW_STARLET int lib$lp_lines(void); #else /* __OLD_STARLET */ int lib$lp_lines(void); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$matchc LIB$MATCHC #ifdef __NEW_STARLET unsigned int lib$matchc( void *sub_string, void *source_string); #else /* __OLD_STARLET */ unsigned int lib$matchc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$match_cond LIB$MATCH_COND #ifdef __NEW_STARLET unsigned int lib$match_cond( unsigned int *match_condition_value, unsigned int *compare_condition_value, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$match_cond(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$movc3 LIB$MOVC3 #ifdef __NEW_STARLET int lib$movc3( unsigned short int *word_integer_length, unsigned int *source, unsigned int *destination); #else /* __OLD_STARLET */ int lib$movc3(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$movc5 LIB$MOVC5 #ifdef __NEW_STARLET int lib$movc5( unsigned short int *word_integer_source_length, unsigned int *source, char *fill, unsigned short int *word_integer_destination_length, unsigned int *destination); #else /* __OLD_STARLET */ int lib$movc5(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$movtc LIB$MOVTC #ifdef __NEW_STARLET unsigned int lib$movtc( void *source_string, void *fill_character, void *translation_table, void *destination_string); #else /* __OLD_STARLET */ unsigned int lib$movtc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$movtuc LIB$MOVTUC #ifdef __NEW_STARLET unsigned int lib$movtuc( void *source_string, void *stop_character, void *translation_table, void *destination_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$movtuc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$mt_density_conversion LIB$MT_DENSITY_CONVERSION #ifdef __NEW_STARLET unsigned int lib$mt_density_conversion( unsigned int device_channel, unsigned int *mt_density_symbol, unsigned int *mt3_enhanced_driver); #else /* __OLD_STARLET */ unsigned int lib$mt_density_conversion(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* 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. */ /* */ #define lib$mt_density_verification LIB$MT_DENSITY_VERIFICATION #ifdef __NEW_STARLET unsigned int lib$mt_density_verification( unsigned int device_channel, unsigned int mt_density_symbol, unsigned int *mt3_enhanced_driver); #else /* __OLD_STARLET */ unsigned int lib$mt_density_verification(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* */ /* 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. */ /* */ /* */ #define lib$mt_density_strcvt LIB$MT_DENSITY_STRCVT #ifdef __NEW_STARLET unsigned int lib$mt_density_strcvt( unsigned int mt_density_symbol, char *out_string); #else /* __OLD_STARLET */ unsigned int lib$mt_density_strcvt(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$multf_delta_time LIB$MULTF_DELTA_TIME #ifdef __NEW_STARLET unsigned int lib$multf_delta_time( float *multiplier, unsigned __int64 *delta_time); #else /* __OLD_STARLET */ unsigned int lib$multf_delta_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$MULTS_DELTA_TIME */ /* */ /* Multiply Delta Time by an S_Floating Scalar */ /* */ /* The Multiply Delta Time by an S-Floating Scalar routine multiplies a */ /* delta time by an S-floating scalar. */ /* */ #define lib$mults_delta_time LIB$MULTS_DELTA_TIME #ifdef __NEW_STARLET unsigned int lib$mults_delta_time( float *multiplier, unsigned __int64 *delta_time); #else /* __OLD_STARLET */ unsigned int lib$mults_delta_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$mult_delta_time LIB$MULT_DELTA_TIME #ifdef __NEW_STARLET unsigned int lib$mult_delta_time( int *multiplier, unsigned __int64 *delta_time); #else /* __OLD_STARLET */ unsigned int lib$mult_delta_time(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$parse_access_code LIB$PARSE_ACCESS_CODE #ifdef __NEW_STARLET unsigned int lib$parse_access_code( void *access_string, unsigned __int64 access_names [], unsigned short int *ownership_category, unsigned short int *access_mask, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$parse_access_code(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$PARSE_SOGW_PROT */ /* */ /* Parse Protection String */ /* */ /* The Parse Protection String routine parses and translates */ /* a protection string into a protection mask. */ /* */ #define lib$parse_sogw_prot LIB$PARSE_SOGW_PROT #ifdef __NEW_STARLET unsigned int lib$parse_sogw_prot( void *protection_string, unsigned __int64 access_names [], unsigned short int *protection_mask, unsigned short int *ownership_mask, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$parse_sogw_prot(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* LIB$PAUSE */ /* */ /* Pause Program Execution */ /* */ /* The Pause Program Execution routine suspends program execution and */ /* returns control to the calling command level. */ /* */ #define lib$pause LIB$PAUSE #ifdef __NEW_STARLET unsigned int lib$pause(void); #else /* __OLD_STARLET */ unsigned int lib$pause(void); #endif /* #ifdef __NEW_STARLET */ /* LIB$POLYD */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (D-floating point values) allows */ /* higher-level language users to evaluate D-floating point value */ /* polynomials. */ /* */ #define lib$polyd LIB$POLYD #ifdef __NEW_STARLET unsigned int lib$polyd( double *polynomial_argument, short int *degree, double coefficient [], double *floating_point_result); #else /* __OLD_STARLET */ unsigned int lib$polyd(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$POLYF */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (F-floating point values) allows */ /* higher-level language users to evaluate F-floating point */ /* polynomials. */ /* */ #define lib$polyf LIB$POLYF #ifdef __NEW_STARLET unsigned int lib$polyf( float *polynomial_argument, short int *degree, float coefficient [], float *floating_point_result); #else /* __OLD_STARLET */ unsigned int lib$polyf(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$POLYT */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (T-floating point values) allows */ /* higher-level language users to evaluate T-floating point value */ /* polynomials. */ /* */ #define lib$polyt LIB$POLYT #ifdef __NEW_STARLET unsigned int lib$polyt( double *polynomial_argument, short int *degree, double coefficient [], double *floating_point_result); #else /* __OLD_STARLET */ unsigned int lib$polyt(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$POLYS */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (S-floating point values) allows */ /* higher-level language users to evaluate S-floating point */ /* polynomials. */ /* */ #define lib$polys LIB$POLYS #ifdef __NEW_STARLET unsigned int lib$polys( float *polynomial_argument, short int *degree, float coefficient [], float *floating_point_result); #else /* __OLD_STARLET */ unsigned int lib$polys(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$POLYG */ /* */ /* Evaluate Polynomials */ /* */ /* The Evaluate Polynomials routine (G-floating point values) allows */ /* higher-level language users to evaluate G-floating point value */ /* polynomials. */ /* */ #define lib$polyg LIB$POLYG #ifdef __NEW_STARLET unsigned int lib$polyg( double *polynomial_argument, short int *degree, double coefficient [], double *floating_point_result); #else /* __OLD_STARLET */ unsigned int lib$polyg(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$polyh LIB$POLYH #ifdef __NEW_STARLET unsigned int lib$polyh( int polynomial_argument [4], short int *degree, int coefficient [] [4], int floating_point_result [4]); #else /* __OLD_STARLET */ unsigned int lib$polyh(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$put_common LIB$PUT_COMMON #ifdef __NEW_STARLET unsigned int lib$put_common( void *source_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$put_common(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$PUT_INVO_REGISTERS ** Alpha only ** */ /* */ /* Put Invocation Registers */ /* */ /* The Put Invocation Registers routine updates a given procedure invocation */ /* context's fields with new register contents. */ /* */ #define lib$put_invo_registers LIB$PUT_INVO_REGISTERS #ifdef __NEW_STARLET unsigned int lib$put_invo_registers( unsigned int invo_handle, void *invo_context, unsigned __int64 *invo_mask); #else /* __OLD_STARLET */ unsigned int lib$put_invo_registers(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$put_output LIB$PUT_OUTPUT #ifdef __NEW_STARLET unsigned int lib$put_output( void *message_string); #else /* __OLD_STARLET */ unsigned int lib$put_output(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$radix_point LIB$RADIX_POINT #ifdef __NEW_STARLET unsigned int lib$radix_point( void *radix_point_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$radix_point(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$remqhi LIB$REMQHI #ifdef __NEW_STARLET unsigned int lib$remqhi( __int64 *header, void *remque_address, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$remqhi(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$remqhiq LIB$REMQHIQ #ifdef __NEW_STARLET unsigned int lib$remqhiq( int header [4], void *(*(remque_address)), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$remqhiq(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$remqti LIB$REMQTI #ifdef __NEW_STARLET unsigned int lib$remqti( __int64 *header, void *remque_address, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$remqti(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$remqtiq LIB$REMQTIQ #ifdef __NEW_STARLET unsigned int lib$remqtiq( int header [4], void *(*(remque_address)), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$remqtiq(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$rename_file LIB$RENAME_FILE #ifdef __NEW_STARLET unsigned int lib$rename_file( void *old_filespec, void *new_filespec, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$rename_file(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$RESERVE_EF */ /* */ /* Reserve Event Flag */ /* */ /* The Reserve Event Flag routine allocates a local event flag number */ /* specified by event-flag-number. */ /* */ #define lib$reserve_ef LIB$RESERVE_EF #ifdef __NEW_STARLET unsigned int lib$reserve_ef( unsigned int *event_flag_number); #else /* __OLD_STARLET */ unsigned int lib$reserve_ef(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$reset_vm_zone LIB$RESET_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$reset_vm_zone( unsigned int *zone_id); #else /* __OLD_STARLET */ unsigned int lib$reset_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$reset_vm_zone_64 LIB$RESET_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$reset_vm_zone_64( unsigned __int64 *zone_id); #else /* __OLD_STARLET */ unsigned int lib$reset_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$run_program LIB$RUN_PROGRAM #ifdef __NEW_STARLET unsigned int lib$run_program( void *program_name); #else /* __OLD_STARLET */ unsigned int lib$run_program(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$scanc LIB$SCANC #ifdef __NEW_STARLET unsigned int lib$scanc( void *source_string, unsigned char table_array [], unsigned char *byte_integer_mask); #else /* __OLD_STARLET */ unsigned int lib$scanc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$scopy_dxdx LIB$SCOPY_DXDX #ifdef __NEW_STARLET unsigned int lib$scopy_dxdx( void *source_string, void *destination_string); #else /* __OLD_STARLET */ unsigned int lib$scopy_dxdx(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$scopy_r_dx LIB$SCOPY_R_DX #ifdef __NEW_STARLET unsigned int lib$scopy_r_dx( unsigned short int *word_integer_source_length, char *source_string, void *destination_string); #else /* __OLD_STARLET */ unsigned int lib$scopy_r_dx(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$scopy_r_dx_64 LIB$SCOPY_R_DX_64 #ifdef __NEW_STARLET unsigned int lib$scopy_r_dx_64( unsigned __int64 *quad_integer_source_length, char *source_string, void *destination_string); #else /* __OLD_STARLET */ unsigned int lib$scopy_r_dx_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$set_logical LIB$SET_LOGICAL #ifdef __NEW_STARLET unsigned int lib$set_logical( void *logical_name, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$set_logical(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$set_symbol LIB$SET_SYMBOL #ifdef __NEW_STARLET unsigned int lib$set_symbol( void *symbol, void *value_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$set_symbol(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$SFREE1_DD */ /* */ /* Free One Dynamic String */ /* */ /* The Free One Dynamic String routine returns the dynamically allocated */ /* storage for a dynamic string. */ /* */ #define lib$sfree1_dd LIB$SFREE1_DD #ifdef __NEW_STARLET unsigned int lib$sfree1_dd( unsigned __int64 *descriptor_address); #else /* __OLD_STARLET */ unsigned int lib$sfree1_dd(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sfreen_dd LIB$SFREEN_DD #ifdef __NEW_STARLET unsigned int lib$sfreen_dd( unsigned int *number_of_descriptors, unsigned __int64 first_descriptor_array []); #else /* __OLD_STARLET */ unsigned int lib$sfreen_dd(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$SGET1_DD */ /* */ /* Get One Dynamic String */ /* */ /* The Get One Dynamic String routine allocates dynamic virtual memory to */ /* the string descriptor you specify. */ /* */ #define lib$sget1_dd LIB$SGET1_DD #ifdef __NEW_STARLET unsigned int lib$sget1_dd( unsigned short int *word_integer_length, unsigned __int64 *descriptor_part); #else /* __OLD_STARLET */ unsigned int lib$sget1_dd(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$SGET1_DD_64 */ /* */ /* Get One Dynamic String */ /* */ /* The Get One Dynamic String routine allocates dynamic virtual memory to */ /* the string descriptor you specify. */ /* */ #define lib$sget1_dd_64 LIB$SGET1_DD_64 #ifdef __NEW_STARLET unsigned int lib$sget1_dd_64( unsigned __int64 *quad_integer_length, unsigned __int64 *descriptor_part); #else /* __OLD_STARLET */ unsigned int lib$sget1_dd_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$show_timer LIB$SHOW_TIMER #ifdef __NEW_STARLET unsigned int lib$show_timer( __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$show_timer(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$show_vm LIB$SHOW_VM #ifdef __NEW_STARLET unsigned int lib$show_vm( __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$show_vm(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$show_vm_64 LIB$SHOW_VM_64 #ifdef __NEW_STARLET unsigned int lib$show_vm_64( __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$show_vm_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$show_vm_zone LIB$SHOW_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$show_vm_zone( unsigned int *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$show_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$show_vm_zone_64 LIB$SHOW_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$show_vm_zone_64( unsigned __int64 *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$show_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$signal LIB$SIGNAL #ifdef __NEW_STARLET int lib$signal( unsigned int condition_value, __optional_params ); #else /* __OLD_STARLET */ int lib$signal(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sig_to_ret LIB$SIG_TO_RET #ifdef __NEW_STARLET unsigned int lib$sig_to_ret( unsigned int *signal_arguments, unsigned int *mechanism_arguments); #else /* __OLD_STARLET */ unsigned int lib$sig_to_ret(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sig_to_stop LIB$SIG_TO_STOP #ifdef __NEW_STARLET unsigned int lib$sig_to_stop( unsigned int *signal_arguments, unsigned int *mechanism_arguments); #else /* __OLD_STARLET */ unsigned int lib$sig_to_stop(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$sim_trap LIB$SIM_TRAP #ifdef __NEW_STARLET unsigned int lib$sim_trap( unsigned int *signal_arguments, unsigned int *mechanism_arguments); #else /* __OLD_STARLET */ unsigned int lib$sim_trap(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$skpc LIB$SKPC #ifdef __NEW_STARLET unsigned int lib$skpc( void *character_string, void *source_string); #else /* __OLD_STARLET */ unsigned int lib$skpc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$spanc LIB$SPANC #ifdef __NEW_STARLET unsigned int lib$spanc( void *source_string, unsigned char table_array [], unsigned char *byte_integer_mask); #else /* __OLD_STARLET */ unsigned int lib$spanc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$spawn LIB$SPAWN #ifdef __NEW_STARLET unsigned int lib$spawn( __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$spawn(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$stat_timer LIB$STAT_TIMER #ifdef __NEW_STARLET unsigned int lib$stat_timer( int *code, unsigned int *value_argument, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$stat_timer(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$stat_vm LIB$STAT_VM #ifdef __NEW_STARLET unsigned int lib$stat_vm( int *code, unsigned int *value_argument); #else /* __OLD_STARLET */ unsigned int lib$stat_vm(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$stat_vm_64 LIB$STAT_VM_64 #ifdef __NEW_STARLET unsigned int lib$stat_vm_64( __int64 *code, unsigned __int64 *value_argument); #else /* __OLD_STARLET */ unsigned int lib$stat_vm_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$stop LIB$STOP #ifdef __NEW_STARLET int lib$stop( unsigned int condition_value, __optional_params ); #else /* __OLD_STARLET */ int lib$stop(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$SUBX */ /* */ /* Multiple-Precision Binary Subtraction */ /* */ /* The Multiple-Precision Binary Subtraction routine performs subtraction */ /* on signed two's complement integers of arbitrary length. */ /* */ #define lib$subx LIB$SUBX #ifdef __NEW_STARLET unsigned int lib$subx( unsigned int *minuend_array, unsigned int *subtrahend_array, unsigned int *difference_array, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$subx(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$SUB_TIMES */ /* */ /* Subtract Two Quadword Times */ /* */ /* The Subtract Two Quadword Times routine subtracts two VMS */ /* internal-time-format times. */ /* */ #define lib$sub_times LIB$SUB_TIMES #ifdef __NEW_STARLET unsigned int lib$sub_times( unsigned __int64 *time1, unsigned __int64 *time2, unsigned __int64 *resultant_time); #else /* __OLD_STARLET */ unsigned int lib$sub_times(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sys_asctim LIB$SYS_ASCTIM #ifdef __NEW_STARLET unsigned int lib$sys_asctim( unsigned short int *resultant_length, void *time_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$sys_asctim(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sys_fao LIB$SYS_FAO #ifdef __NEW_STARLET unsigned int lib$sys_fao( void *character_string, unsigned short int *resultant_length, void *resultant_string, __optional_params); #else /* __OLD_STARLET */ unsigned int lib$sys_fao(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sys_faol LIB$SYS_FAOL #ifdef __NEW_STARLET unsigned int lib$sys_faol( void *character_string, unsigned short int *resultant_length, void *resultant_string, unsigned int *directive_argument_address); #else /* __OLD_STARLET */ unsigned int lib$sys_faol(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sys_faol_64 LIB$SYS_FAOL_64 #ifdef __NEW_STARLET unsigned int lib$sys_faol_64( void *character_string, unsigned short int *resultant_length, void *resultant_string, unsigned __int64 *directive_argument_address); #else /* __OLD_STARLET */ unsigned int lib$sys_faol_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sys_getmsg LIB$SYS_GETMSG #ifdef __NEW_STARLET unsigned int lib$sys_getmsg( unsigned int *message_id, unsigned short int *message_length, void *destination_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$sys_getmsg(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$sys_trnlog LIB$SYS_TRNLOG #ifdef __NEW_STARLET unsigned int lib$sys_trnlog( void *logical_name, unsigned short int *word_integer_dest_length, void *destination_string, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$sys_trnlog(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$table_parse LIB$TABLE_PARSE #ifdef __NEW_STARLET unsigned int lib$table_parse( unsigned int *argument_block, unsigned int *state_table, unsigned int *key_table); #else /* __OLD_STARLET */ unsigned int lib$table_parse(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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; */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$traverse_tree LIB$TRAVERSE_TREE #ifdef __NEW_STARLET unsigned int lib$traverse_tree( void *treehead, int (*user_action_procedure)(void), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$traverse_tree(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* 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. */ /* */ #define lib$traverse_tree_64 LIB$TRAVERSE_TREE_64 #ifdef __NEW_STARLET unsigned int lib$traverse_tree_64( void *(*(treehead)), int (*user_action_procedure)(void), __optional_params); #else /* __OLD_STARLET */ unsigned int lib$traverse_tree_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$TRA_ASC_EBC */ /* */ /* Translate ASCII to EBCDIC */ /* */ /* The Translate ASCII to EBCDIC routine translates an ASCII string */ /* to an EBCDIC string. */ /* */ #define lib$tra_asc_ebc LIB$TRA_ASC_EBC #ifdef __NEW_STARLET unsigned int lib$tra_asc_ebc( void *source_string, void *byte_integer_dest_string); #else /* __OLD_STARLET */ unsigned int lib$tra_asc_ebc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$TRA_EBC_ASC */ /* */ /* Translate EBCDIC to ASCII */ /* */ /* The Translate EBCDIC to ASCII routine translates an EBCDIC string */ /* to an ASCII string. */ /* */ #define lib$tra_ebc_asc LIB$TRA_EBC_ASC #ifdef __NEW_STARLET unsigned int lib$tra_ebc_asc( void *byte_integer_source_string, void *destination_string); #else /* __OLD_STARLET */ unsigned int lib$tra_ebc_asc(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$trim_filespec LIB$TRIM_FILESPEC #ifdef __NEW_STARLET unsigned int lib$trim_filespec( void *old_filespec, void *new_filespec, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$trim_filespec(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* 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. */ /* */ #define lib$trim_fullname LIB$TRIM_FULLNAME #ifdef __NEW_STARLET unsigned int lib$trim_fullname( void *fullname, void *trimmed_nodename, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$trim_fullname(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$uid_to_ascii LIB$UID_TO_ASCII #ifdef __NEW_STARLET unsigned int lib$uid_to_ascii( unsigned int input_uid [4], void *output_string); #else /* __OLD_STARLET */ unsigned int lib$uid_to_ascii(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$UNLOCK_IMAGE */ /* */ /* Unlock Image from working set */ /* */ /* Unlock all address ranges associated with a specified image */ /* from the working set. */ /* */ #define lib$unlock_image LIB$UNLOCK_IMAGE #ifdef __NEW_STARLET unsigned int lib$unlock_image( #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __long /* And set ptr size default to 64-bit pointers */ void *va #else unsigned __int64 va #endif ); #else /* __OLD_STARLET */ unsigned int lib$unlock_image(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* LIB$VERIFY_VM_ZONE */ /* */ /* Verify a Zone */ /* */ /* The Verify a Zone routine performs verification of a zone. */ /* */ #define lib$verify_vm_zone LIB$VERIFY_VM_ZONE #ifdef __NEW_STARLET unsigned int lib$verify_vm_zone( #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __short /* And set ptr size default to 32-bit pointers */ #endif unsigned int *zone_id); #else /* __OLD_STARLET */ unsigned int lib$verify_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif /* LIB$VERIFY_VM_ZONE_64 */ /* */ /* Verify a Zone */ /* */ /* The Verify a Zone routine performs verification of a zone. */ /* */ #define lib$verify_vm_zone_64 LIB$VERIFY_VM_ZONE_64 #ifdef __NEW_STARLET unsigned int lib$verify_vm_zone_64( unsigned __int64 *zone_id); #else /* __OLD_STARLET */ unsigned int lib$verify_vm_zone_64(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* 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. */ /* */ #define lib$wait LIB$WAIT #ifdef __NEW_STARLET unsigned int lib$wait( float *seconds, __optional_params ); #else /* __OLD_STARLET */ unsigned int lib$wait(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #pragma __member_alignment __restore #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __restore /* Restore the previously-defined required ptr size */ #endif #ifdef __cplusplus } #endif #pragma __standard #endif /* __LIB_ROUTINES_LOADED */