[PEN_CHECKING_STYLE(NONE)] MODULE PASCAL$LBR_ROUTINES;
{   © Copyright 2005 Hewlett-Packard Development Company, L.P.                 }
{                                                                              }
{   Confidential computer software.  Valid license from HP and/or              }
{   its subsidiaries required for possession, use, or copying.                 }
{                                                                              }
{   Consistent with FAR 12.211 and 12.212, Commercial Computer Software,       }
{   Computer Software Documentation, and Technical Data for Commercial         }
{   Items are licensed to the U.S. Government under vendor's standard          }
{   commercial license.                                                        }
{                                                                              }
{   Neither HP nor any of its subsidiaries shall be liable for technical       }
{   or editorial errors or omissions contained herein.  The information        }
{   in this document is provided "as is" without warranty of any kind and      }
{   is subject to change without notice.  The warranties for HP products       }
{   are set forth in the express limited warranty statements accompanying      }
{   such products.  Nothing herein should be construed as constituting an      }
{   additional warranty.                                                       }
{                                                                              }

[HIDDEN] TYPE	(**** Pre-declared data types ****)
	$BYTE = [BYTE] -128..127;
	$WORD = [WORD] -32768..32767;
	$QUAD = [QUAD,UNSAFE] RECORD
		L0:UNSIGNED; L1:INTEGER; END;
	$OCTA = [OCTA,UNSAFE] RECORD
		L0,L1,L2:UNSIGNED; L3:INTEGER; END;
	$UBYTE = [BYTE] 0..255;
	$UWORD = [WORD] 0..65535;
	$UQUAD = [QUAD,UNSAFE] RECORD
		L0,L1:UNSIGNED; END;
	$UOCTA = [OCTA,UNSAFE] RECORD
		L0,L1,L2,L3:UNSIGNED; END;
	$PACKED_DEC = [BIT(4),UNSAFE] 0..15;
	$DEFTYP = [UNSAFE] INTEGER;
	$DEFPTR = [UNSAFE] ^$DEFTYP;
	$BOOL = [BIT(1),UNSAFE] BOOLEAN;
	$BIT  = [BIT(1),UNSAFE] BOOLEAN;
	$BIT2 = [BIT(2),UNSAFE] 0..3;
	$BIT3 = [BIT(3),UNSAFE] 0..7;
	$BIT4 = [BIT(4),UNSAFE] 0..15;
	$BIT5 = [BIT(5),UNSAFE] 0..31;
	$BIT6 = [BIT(6),UNSAFE] 0..63;
	$BIT7 = [BIT(7),UNSAFE] 0..127;
	$BIT8 = [BIT(8),UNSAFE] 0..255;
	$BIT9 = [BIT(9),UNSAFE] 0..511;
	$BIT10 = [BIT(10),UNSAFE] 0..1023;
	$BIT11 = [BIT(11),UNSAFE] 0..2047;
	$BIT12 = [BIT(12),UNSAFE] 0..4095;
	$BIT13 = [BIT(13),UNSAFE] 0..8191;
	$BIT14 = [BIT(14),UNSAFE] 0..16383;
	$BIT15 = [BIT(15),UNSAFE] 0..32767;
	$BIT16 = [BIT(16),UNSAFE] 0..65535;
	$BIT17 = [BIT(17),UNSAFE] 0..131071;
	$BIT18 = [BIT(18),UNSAFE] 0..262143;
	$BIT19 = [BIT(19),UNSAFE] 0..524287;
	$BIT20 = [BIT(20),UNSAFE] 0..1048575;
	$BIT21 = [BIT(21),UNSAFE] 0..2097151;
	$BIT22 = [BIT(22),UNSAFE] 0..4194303;
	$BIT23 = [BIT(23),UNSAFE] 0..8388607;
	$BIT24 = [BIT(24),UNSAFE] 0..16777215;
	$BIT25 = [BIT(25),UNSAFE] 0..33554431;
	$BIT26 = [BIT(26),UNSAFE] 0..67108863;
	$BIT27 = [BIT(27),UNSAFE] 0..134217727;
	$BIT28 = [BIT(28),UNSAFE] 0..268435455;
	$BIT29 = [BIT(29),UNSAFE] 0..536870911;
	$BIT30 = [BIT(30),UNSAFE] 0..1073741823;
	$BIT31 = [BIT(31),UNSAFE] 0..2147483647;
	$BIT32 = [BIT(32),UNSAFE] UNSIGNED;
 
 
(* MODULE LBR$ROUTINES ;                                                    *)
 
(* [HIDDEN] TYPE	(**** Pre-declared data types ***??                 *)
(* 	$BYTE = [BYTE] -128..127;                                           *)
(* 	$WORD = [WORD] -32768..32767;                                       *)
(* 	$QUAD = [QUAD,UNSAFE] RECORD                                        *)
(* 		L0:UNSIGNED; L1:INTEGER; END;                               *)
(* 	$OCTA = [OCTA,UNSAFE] RECORD                                        *)
(* 		L0,L1,L2:UNSIGNED; L3:INTEGER; END;                         *)
(* 	$UBYTE = [BYTE] 0..255;                                             *)
(* 	$UWORD = [WORD] 0..65535;                                           *)
(* 	$UQUAD = [QUAD,UNSAFE] RECORD                                       *)
(* 		L0,L1:UNSIGNED; END;                                        *)
(* 	$UOCTA = [OCTA,UNSAFE] RECORD                                       *)
(* 		L0,L1,L2,L3:UNSIGNED; END;                                  *)
(* 	$UOCTAQUAD = [OCTA(2),UNSAFE] RECORD                                *)
(* 		L0,L1,L2,L3,L4,L5,L6,L7:UNSIGNED; END;                      *)
(* 	$PACKED_DEC = [BIT(4),UNSAFE] 0..15;                                *)
(* 	$DEFTYP = [UNSAFE] INTEGER;                                         *)
(* 	$DEFPTR = [UNSAFE] ^$DEFTYP;                                        *)
(* 	$BOOL = [BIT(1),UNSAFE] BOOLEAN;                                    *)
(* 	$BIT2 = [BIT(2),UNSAFE] 0..3;                                       *)
(* 	$BIT3 = [BIT(3),UNSAFE] 0..7;                                       *)
(* 	$BIT4 = [BIT(4),UNSAFE] 0..15;                                      *)
(* 	$BIT5 = [BIT(5),UNSAFE] 0..31;                                      *)
(* 	$BIT6 = [BIT(6),UNSAFE] 0..63;                                      *)
(* 	$BIT7 = [BIT(7),UNSAFE] 0..127;                                     *)
(* 	$BIT8 = [BIT(8),UNSAFE] 0..255;                                     *)
(* 	$BIT9 = [BIT(9),UNSAFE] 0..511;                                     *)
(* 	$BIT10 = [BIT(10),UNSAFE] 0..1023;                                  *)
(* 	$BIT11 = [BIT(11),UNSAFE] 0..2047;                                  *)
(* 	$BIT12 = [BIT(12),UNSAFE] 0..4095;                                  *)
(* 	$BIT13 = [BIT(13),UNSAFE] 0..8191;                                  *)
(* 	$BIT14 = [BIT(14),UNSAFE] 0..16383;                                 *)
(* 	$BIT15 = [BIT(15),UNSAFE] 0..32767;                                 *)
(* 	$BIT16 = [BIT(16),UNSAFE] 0..65535;                                 *)
(* 	$BIT17 = [BIT(17),UNSAFE] 0..131071;                                *)
(* 	$BIT18 = [BIT(18),UNSAFE] 0..262143;                                *)
(* 	$BIT19 = [BIT(19),UNSAFE] 0..524287;                                *)
(* 	$BIT20 = [BIT(20),UNSAFE] 0..1048575;                               *)
(* 	$BIT21 = [BIT(21),UNSAFE] 0..2097151;                               *)
(* 	$BIT22 = [BIT(22),UNSAFE] 0..4194303;                               *)
(* 	$BIT23 = [BIT(23),UNSAFE] 0..8388607;                               *)
(* 	$BIT24 = [BIT(24),UNSAFE] 0..16777215;                              *)
(* 	$BIT25 = [BIT(25),UNSAFE] 0..33554431;                              *)
(* 	$BIT26 = [BIT(26),UNSAFE] 0..67108863;                              *)
(* 	$BIT27 = [BIT(27),UNSAFE] 0..134217727;                             *)
(* 	$BIT28 = [BIT(28),UNSAFE] 0..268435455;                             *)
(* 	$BIT29 = [BIT(29),UNSAFE] 0..536870911;                             *)
(* 	$BIT30 = [BIT(30),UNSAFE] 0..1073741823;                            *)
(* 	$BIT31 = [BIT(31),UNSAFE] 0..2147483647;                            *)
(* 	$BIT32 = [BIT(32),UNSAFE] UNSIGNED;                                 *)
 
(*** MODULE LBR$ROUTINES IDENT X-4 ***)
 
(*                                                                          *)
(*                                                                          *)
(* This package defines the interfaces to the Librarian utility             *)
(* routines as documented in the OpenVMS Utility Routines Reference         *)
(* Manual.                                                                  *)
(*                                                                          *)
(*                                                                          *)
(* LBR$CLOSE - CLose a library                                              *)
(*                                                                          *)
(* status = LBR$CLOSE (library_index)                                       *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$CLOSE (
	LIBRARY_INDEX : UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$DELETE_DATA - Delete a module's data                                 *)
(*                                                                          *)
(* status = LBR$DELETE_DATA (library_index, txtrfa [,flags])                *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  txtrfa        - RFA of module header for module to delete               *)
(*  flags	  - key flags                                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$DELETE_DATA (
	LIBRARY_INDEX : UNSIGNED;
	%REF TXTRFA : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	%IMMED FLAGS : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$DELETE_KEY - Delete a key                                            *)
(*                                                                          *)
(* status = LBR$DELETE_KEY (library_index, key_name [,txtrfa] [,flags])     *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  key_name      - Key to be deleted - for binary keys, passed by          *)
(*                  reference, for string keys, by descriptor               *)
(*  txtrfa	  - RFA of module header for key to delete                  *)
(*  flags	  - key flags                                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$DELETE_KEY (
	LIBRARY_INDEX : UNSIGNED;
	%REF KEY_NAME : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	%REF TXTRFA : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE := %IMMED 0;
	%IMMED FLAGS : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$FIND - Lookup a module by its RFA                                    *)
(*                                                                          *)
(* status = LBR$FIND (library_index, txtrfa)                                *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  txtrfa        - RFA of module to access                                 *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$FIND (
	LIBRARY_INDEX : UNSIGNED;
	%REF TXTRFA : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$FLUSH - Recover virtual memory                                       *)
(*                                                                          *)
(* status = LBR$FLUSH (library_index, block_type)                           *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  block_type    - Extent of the flush operation                           *)
 
[ASYNCHRONOUS] FUNCTION LBR$FLUSH (
	LIBRARY_INDEX : UNSIGNED;
	%IMMED BLOCK_TYPE : UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$GET_HEADER - Retrieve library header information                     *)
(*                                                                          *)
(* status = LBR$GET_HEADER (library_index, retary)                          *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  retary        - Array of 128 longwords to receive library header        *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$GET_HEADER (
	LIBRARY_INDEX : UNSIGNED;
	%REF RETARY : [VOLATILE,UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$GET_HELP - Retrieve help text                                        *)
(*                                                                          *)
(* status = LBR$GET_HELP (library_index [,line_width] [,routine]            *)
(*                        [,data] [,key_n...])                              *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  line_width    - Width of the help text line                             *)
(*  routine       - Routine called to output text line                      *)
(*  data          - User data passed to routine                             *)
(*  key_n         - Zero or more key strings                                *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$GET_HELP (
	LIBRARY_INDEX : UNSIGNED;
	LINE_WIDTH : INTEGER := %IMMED 0;
	%IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION ROUTINE : INTEGER := %IMMED 0;
	%REF DATA : [UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE := %IMMED 0;
	KEY_1 : [CLASS_S] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0;
	KEY_2 : [CLASS_S] PACKED ARRAY [$l6..$u6:INTEGER] OF CHAR := %IMMED 0;
	KEY_3 : [CLASS_S] PACKED ARRAY [$l7..$u7:INTEGER] OF CHAR := %IMMED 0;
	KEY_4 : [CLASS_S] PACKED ARRAY [$l8..$u8:INTEGER] OF CHAR := %IMMED 0;
	KEY_5 : [CLASS_S] PACKED ARRAY [$l9..$u9:INTEGER] OF CHAR := %IMMED 0;
	KEY_6 : [CLASS_S] PACKED ARRAY [$l10..$u10:INTEGER] OF CHAR := %IMMED 0;
	KEY_7 : [CLASS_S] PACKED ARRAY [$l11..$u11:INTEGER] OF CHAR := %IMMED 0;
	KEY_8 : [CLASS_S] PACKED ARRAY [$l12..$u12:INTEGER] OF CHAR := %IMMED 0;
	KEY_9 : [CLASS_S] PACKED ARRAY [$l13..$u13:INTEGER] OF CHAR := %IMMED 0;
	KEY_10 : [CLASS_S] PACKED ARRAY [$l14..$u14:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$GET_HISTORY - Retrieve a library history update record               *)
(*                                                                          *)
(* status = LBR$GET_HISTORY (library_index, action_routine)                 *)
(*                                                                          *)
(*  library_index  - Index value returned by LBR$INI_CONTROL                *)
(*  action_routine - Routine to process history records                     *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$GET_HISTORY (
	LIBRARY_INDEX : INTEGER;
	%IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION ACTION_ROUTINE : INTEGER) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$GET_INDEX - Call routine for selected index keys                     *)
(*                                                                          *)
(* status = LBR$GET_INDEX (library_index, index_number, routine_name        *)
(*                        [,match_desc] [,flags])                           *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  index_number  - Number of the index to search                           *)
(*  routine_name  - User routine to process selections                      *)
(*  match_desc    - Key matching string                                     *)
(*  flags	  - Key flags                                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$GET_INDEX (
	LIBRARY_INDEX : UNSIGNED;
	INDEX_NUMBER : UNSIGNED;
	%IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION ROUTINE_NAME : INTEGER;
	MATCH_DESC : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0;
	%IMMED FLAGS : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$GET_RECORD - Read a data record                                      *)
(*                                                                          *)
(* status = LBR$GET_RECORD (library_index [,inbufdes] [,outbufdes])         *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  inbufdes      - Buffer to receive record                                *)
(*  outbufdes     - Descriptor receiving information about record           *)
 
[ASYNCHRONOUS] FUNCTION LBR$GET_RECORD (
	LIBRARY_INDEX : UNSIGNED;
	VAR INBUFDES : [CLASS_S,VOLATILE] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0;
	%REF OUTBUFDES : [VOLATILE,UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$INI_CONTROL - Initialize a library control structure                 *)
(*                                                                          *)
(* status = LBR$INI_CONTROL (library_index, func [,type] [,namblk])         *)
(*                                                                          *)
(*  library_index - Receives index value                                    *)
(*  func          - Function to be performed                                *)
(*  type          - Type of library                                         *)
(*  namblk        - RMS NAM block for library                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$INI_CONTROL (
	VAR LIBRARY_INDEX : [VOLATILE] UNSIGNED;
	FUNC : UNSIGNED;
	TYPE_ : UNSIGNED := %IMMED 0;
	%REF NAMBLK : [UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$INSERT_KEY - Insert a new key                                        *)
(*                                                                          *)
(* status = LBR$INSERT_KEY (library_index, key_name, txtrfa [,flags])       *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  key_name      - Name of key to insert (reference for binary key,        *)
(*                  descriptor for text key)                                *)
(*  txtrfa        - RFA of module                                           *)
(*  flags	  - key flags                                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$INSERT_KEY (
	LIBRARY_INDEX : UNSIGNED;
	%REF KEY_NAME : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	%REF TXTRFA : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE;
	%IMMED FLAGS : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$LOOKUP_KEY - Look up a library key                                   *)
(*                                                                          *)
(* status = LBR$LOOKUP_KEY (library_index, key_name, txtrfa [,flags])       *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  key_name      - Name of key to insert (reference for binary key,        *)
(*                  descriptor for text key)                                *)
(*  txtrfa        - Receives RFA of module                                  *)
(*  flags	  - Receives key flags                                      *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$LOOKUP_KEY (
	LIBRARY_INDEX : UNSIGNED;
	%REF KEY_NAME : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	%REF TXTRFA : [VOLATILE,UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE;
	VAR FLAGS : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$LOOKUP_TYPE - Look up a type of key with specified RFA in            *)
(*   		     library's current index                                *)
(*                                                                          *)
(* status = LBR$LOOKUP_TYPE (library_index, key_name, txtrfa, flags)        *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  key_name      - Name of key to insert (reference for binary key,        *)
(*                  descriptor for text key)                                *)
(*  txtrfa        - RFA of module                                           *)
(*  flags	  - Receives type of key                                    *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$LOOKUP_TYPE (
	LIBRARY_INDEX : UNSIGNED;
	%REF KEY_NAME : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	%REF TXTRFA : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE;
	VAR FLAGS : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$OPEN - Open or create a library                                      *)
(*                                                                          *)
(* status = LBR$OPEN (library_index [,fns] [,create_options] [,dns]         *)
(*                   [,rlfna] [,rns] [,rnslen])                             *)
(*                                                                          *)
(*  library_index  - Index value returned by LBR$INI_CONTROL                *)
(*  fns            - File specification of the library                      *)
(*  create_options - Library characteristics ($LBRDEF, $CREDEF)             *)
(*  dns            - Default file specification                             *)
(*  rlfna          - Related file name block                                *)
(*  rns            - Receives resultant file specification                  *)
(*  rnslen         - Receives length of resultant file specification        *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$OPEN (
	LIBRARY_INDEX : UNSIGNED;
	FNS : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR := %IMMED 0;
	%REF CREATE_OPTIONS : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE := %IMMED 0;
	DNS : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0;
	%REF RLFNA : [UNSAFE] ARRAY [$l5..$u5:INTEGER] OF $UBYTE := %IMMED 0;
	VAR RNS : [CLASS_S,VOLATILE] PACKED ARRAY [$l6..$u6:INTEGER] OF CHAR := %IMMED 0;
	VAR RNSLEN : [VOLATILE] INTEGER := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$OUTPUT_HELP - Output help messages                                   *)
(*                                                                          *)
(* status = LBR$OUTPUT_HELP (output_routine [,output_width] [,line_desc]    *)
(*                           [,library_name] [,flags] [,input_routine])     *)
(*                                                                          *)
(*  output_routine - Routine called to output text lines                    *)
(*  output_width   - Maximum width of output lines                          *)
(*  line_desc      - Help request line                                      *)
(*  library_name   - Name of the help library                               *)
(*  flags          - Flags to control operation                             *)
(*  input_routine  - Routine used for prompting                             *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$OUTPUT_HELP (
	%IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION OUTPUT_ROUTINE : INTEGER;
	OUTPUT_WIDTH : INTEGER := %IMMED 0;
	LINE_DESC : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0;
	LIBRARY_NAME : [CLASS_S] PACKED ARRAY [$l4..$u4:INTEGER] OF CHAR := %IMMED 0;
	FLAGS : UNSIGNED := %IMMED 0;
	%IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION INPUT_ROUTINE : INTEGER := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$PUT_MODULE - Put an ELF object module to the ELF object library.     *)
(*                                                                          *)
(* status = LBR$PUT_MODULE (library_index, addr, size, txtrfa)              *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  addr - address of the ELF object module                                 *)
(*  size - Size of the ELF object module                                    *)
(*  txtrfa - Receives RFA of module                                         *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$PUT_MODULE (
	LIBRARY_INDEX : UNSIGNED;
	ADDR : $UQUAD;
	SIZE : $UQUAD;
	%REF TXTRFA : [VOLATILE,UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$PUT_END - Write an end-of-module record                              *)
(*                                                                          *)
(* status = LBR$PUT_END (library_index)                                     *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$PUT_END (
	LIBRARY_INDEX : UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$PUT_HISTORY - Write an update history record                         *)
(*                                                                          *)
(* status = LBR$PUT_HISTORY (library_index, record_desc)                    *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  record_desc   - History record                                          *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$PUT_HISTORY (
	LIBRARY_INDEX : UNSIGNED;
	RECORD_DESC : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$PUT_RECORD - Write a data record                                     *)
(*                                                                          *)
(* status = LBR$PUT_RECORD (library_index, bufdes, txtrfa [,modsize])       *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  bufdes        - Record to be written                                    *)
(*  txtrfa        - Receives RFA of module                                  *)
(*  modsize	  - ELF object module size                                  *)
 
[ASYNCHRONOUS] FUNCTION LBR$PUT_RECORD (
	LIBRARY_INDEX : UNSIGNED;
	BUFDES : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR;
	%REF TXTRFA : [VOLATILE,UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE;
	MODSIZE : $UQUAD := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$REPLACE_KEY - Replace a library key                                  *)
(*                                                                          *)
(* status = LBR$REPLACE_KEY (library_index, key_name, oldrfa, newrfa [,flags]) *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  key_name      - Name of key, passed by reference or descriptor          *)
(*  oldrfa        - RFA of old module header                                *)
(*  newrfa        - RFA of new module header                                *)
(*  flags	  - key flags                                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$REPLACE_KEY (
	LIBRARY_INDEX : UNSIGNED;
	%REF KEY_NAME : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	%REF OLDRFA : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE;
	%REF NEWRFA : [VOLATILE,UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE;
	%IMMED FLAGS : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$RET_RMSSTV - Return VMS RMS status value                             *)
(*                                                                          *)
(* status = LBR$RET_RMSSTV ()                                               *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$RET_RMSSTV : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$SEARCH - Search an index                                             *)
(*                                                                          *)
(* status = LBR$SEARCH (library_index, index_number, rfa_to_find,           *)
(*	                routine_name [,flags])                              *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  index_number  - Number of index to search                               *)
(*  rfa_to_find   - RFA of module to search for                             *)
(*  routine_name  - Routine called to process keys                          *)
(*  flags	  - Key flags                                               *)
 
[ASYNCHRONOUS] FUNCTION LBR$SEARCH (
	LIBRARY_INDEX : UNSIGNED;
	INDEX_NUMBER : UNSIGNED;
	%REF RFA_TO_FIND : [UNSAFE] ARRAY [$l3..$u3:INTEGER] OF $UBYTE;
	%IMMED [UNBOUND, ASYNCHRONOUS] FUNCTION ROUTINE_NAME : INTEGER;
	%IMMED FLAGS : UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$SET_INDEX - Set the current index number                             *)
(*                                                                          *)
(* status = LBR$SET_INDEX (library_index, index_number)                     *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  index_number  - New index number                                        *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$SET_INDEX (
	LIBRARY_INDEX : UNSIGNED;
	INDEX_NUMBER : UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$SET_LOCATE - Set record access to locate mode                        *)
(*                                                                          *)
(* status = LBR$SET_LOCATE (library_index)                                  *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$SET_LOCATE (
	LIBRARY_INDEX : UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$SET_MODULE - Read or update a module header                          *)
(*                                                                          *)
(* status = LBR$SET_MODULE (library_index, rfa [,bufdesc]                   *)
(*		           [,buflen] [,updatedesc])                         *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  rfa           - RFA of module header                                    *)
(*  bufdesc       - Receives module header                                  *)
(*  buflen        - Receives length of module header                        *)
(*  updatedesc    - Additional information to be stored in module header    *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$SET_MODULE (
	LIBRARY_INDEX : UNSIGNED;
	%REF RFA : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE;
	BUFDESC : [CLASS_S] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR := %IMMED 0;
	VAR BUFLEN : [VOLATILE] INTEGER := %IMMED 0;
	UPDATEDESC : [CLASS_S] PACKED ARRAY [$l5..$u5:INTEGER] OF CHAR := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$SET_MOVE - Set record access to move mode                            *)
(*                                                                          *)
(* status = LBR$SET_MOVE (library_index)                                    *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$SET_MOVE (
	LIBRARY_INDEX : UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$MAP_MODULE - Copy/map an ELF object module from current library      *)
(*		    to the memory space                                     *)
(*                                                                          *)
(* statust = LBR$MAP_MODULE (library_index, addr, len, rfa)                 *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  addr - Receives address of the module                                   *)
(*  len - Receives length of module                                         *)
(*  rfa	- RFA of module                                                     *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$MAP_MODULE (
	LIBRARY_INDEX : UNSIGNED;
	VAR ADDR : [VOLATILE] $UQUAD;
	VAR LEN : [VOLATILE] $UQUAD;
	%REF RFA : [UNSAFE] ARRAY [$l4..$u4:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* LBR$UNMAP_MODULE - Remove/release an ELF object module from the memory space *)
(*                                                                          *)
(* status = LBR$UNMAP_MODULE (library_index, rfa)                           *)
(*                                                                          *)
(*  library_index - Index value returned by LBR$INI_CONTROL                 *)
(*  rfa	- RFA of module                                                     *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION LBR$UNMAP_MODULE (
	LIBRARY_INDEX : UNSIGNED;
	%REF RFA : [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF $UBYTE) : INTEGER; EXTERNAL;
 
(* END.                                                                     *)
 
END.