Binder Universal Classes

This comment is from the 5.0 Binder Symbol.

The Binder Universal Class and SubClass definitions are below.

COMMENT THE FORMAT OF THE PROGRAM DESCRIPTION IS AS FOLLOWS:

                             UNIVERSAL INFO                              
                             --------- ----                              
A TYPICAL ENTRY HAS THE FORM:                                            
         ----------------------------                                    
         : UC :    SC    :    N     :                                    
         ----------------------------  -                                 
         :                          :   :                                
         :                          :   :                                
         :         STUFF            :    > N WORDS                       
         :                          :   :                                
         :                          :   :                                
         ----------------------------  -                                 
    WHERE UC FIELD = [47:8]                                              
          SC FIELD = [39:20]                                             
          N  FIELD = [19:20]                                             
    WE MAY DENOTE SUCH AN ENTRY BY (UC,SC,N,STUFF).

PROGRAM DESCRIPTION

THE PROGRAM DESCRIPTION CONSISTS OF ONE OR MORE PORTIONS OF THE CODE FILE WHICH DESCRIBES THE OBJECT PROGRAM SUFFICIENTLY FOR BINDING OR RUN TIME LINKING. THESE PORTIONS CONFORM TO THE GENERAL FORM (UC,SC,N,DESCRIPTION). THEIR PRESENCE AND CONTENT DEPEND UPON THE STRUCTURE OF THE OBJECT PROGRAM:

1. COMPLETE PROGRAM THERE IS NO PROGRAM DESCRIPTION.
2. BLOCK PROGRAM(OR PROCEDURE PROGRAM AT LEVEL 2) WITH EXTERNAL PROCEDURES
THE GENERAL PROGRAM DESCRIPTION IS CONTAINED IN A PORTION OF THE CODE FILE DESCRIBED BY WORD 16 OF SEGMENT 0. THIS WILL CONTAIN THE FOLLOWING INFORMATION: (0,4,N,GLOBALDIRECTORY)
(0,14,N,MAKEARRAYDESCPNTRS)
(0,18,1,ENDOFD2CODE)
WHERE THE GLOBALDIRECTORY CONTAINS ITEM DESCRIPTIONS OF ALL OUTER BLOCK ITEMS WHICH MAY BE REFERENCED BY EXTERNAL ITEMS. IN ADDITION TO THE GENERAL PROGRAM DESCRIPTION THERE IS A DESCRIPTION FOR EACH EXTERNAL PROCEDURE(SEE BELOW). 14
3. PROCEDURE PROGRAM(HIGHER THAN LEVEL 2) FOR THIS PROGRAM THE GENERAL DESCRIPTION CONTAINS:
(UC,SC,N,PROCEDUREITEM)
(0,4,N,GLOBALDIRECTORY)
(0,5,N,D1REFERENCES)
(0,11,N,OWNDIRECTORY) IF OWNS DECLARED
(0,14,N,MAKEARRAYDESCPNTRS)
(0,19,1,FIRSTEX)
EXTERNAL PROCEDURE DESCRIPTIONS ARE THE SAME AS IN BLOCK PRO- GRAMS.
4. EXTERNAL PROCEDURE DESCRIPTION FOR EACH EXTERNAL PROCEDURE THERE IS A VALUE ARRAY WHOSE DESCRIPTOR OCCUPIES THE D1 STACK LOCATION RESERVED FOR THE SEGMENT DESCRIPTOR. THIS ARRAY CONTAINS THE FOLLOWING:
(UC,SC,N,PROCEDUREITEM)
(0,4,N,GLOBALDIRECTORY)
IF NON D2 GLOBALS DECLARED THE GLOBALDIRECTORY IN THIS CASE CONTAINS ALL GLOBALS REFERENCED BY THE EXTERNAL PROCEDURE WHICH WERE NOT DECLARED AT LEVEL 2.

UNIVERSAL CLASSES

UC	UC DESCRIPTION
0	INFO KEYWORD
2	48 BIT OPERAND (ANY TAG 0)
4	96 BIT OPERAND (ANY TAG 2)
6	DATA DESCRIPTOR (D=0,I=0)
8	DATA DESCRIPTOR (D=0,I=1)
10	DATA DESCRIPTOR (D=1,I=0)
12	DATA DESCRIPTOR (D=1,I=1)
14	STRING DESCRIPTOR (I=0)
16	STRING DESCRIPTOR (I=1)
18	PCW (UNTYPED PROCEDURE OR SUBROUTINE)
20	PCW (TYPED PROCEDURE OR FUNCTION
22	FILE
24	TASK
26	PAIR OF DATA DESCRIPTORS TO ONE ARRAY (FIRST IS SP,SECOND IS DP) THIS IS PRIMARILY FOR FORTRAN COMMON BLOCKS AND EQUIVALENCE GROUPS
28	INTERRUPT
30	MESSAGE OR MESSAGE ARRAY
32	QUEUE OR QUEUE ARRAY
34	INTRINSIC (SUBROUTINE)
36	INTRINSIC (FUNCTION)
38	WAS PL/I VARIABLES
40	DATABASE
42	STRING VARIABLE
44	STRING VARIABLE ARRAY
46	STRING PROCEDURE
48	ALTERNATIVE ITEM GROUP
50	DATA DICTIONARY DESCRIPTIONS
52	TRANSACTION BASE
54	LIBRARY
56	LIBRARY ENTRY POINT
58	EXPORTED SUBROUTINE OR FUNCTION
60	BY-CALLING SUBROUTINE OR FUNCTION NOTES: (1) SUBROUTINE = UNTYPED PROCEDURE FUNCTION = TYPED PROCEDURE (2) AN ODD UC IMPLIES CALL-BY-NAME
62	FORTRAN77 DOUBLE PRECISION FUNCTION (NOT USED IN ACTUAL BINDINFO)
64	FORTRAN77 HEAP VECTOR
66	COBOL CD'S
68	INTERLOCKS AND INTERLOCK ARRAYS
70	SIM ENTITY REFERENCE
72	SIM QUERY VARIABLE
76	SINGLE ITEM IN SLICE 1-D HEAP
78	DOUBLE ITEM IN SLICE 1-D HEAP
80	HEX ITEM IN SLICE 1-D HEAP
82	EBCDIC ITEM IN SLICE 1-D HEAP
84	SINGLE ITEM IN SLICE 2-D HEAP
86	DOUBLE ITEM IN SLICE 2-D HEAP
88	HEX ITEM IN SLICE 2-D HEAP
90	EBCDIC ITEM IN SLICE 2-D HEAP
92	STRUCTURE AND CONNECTION BLOCK INTERNAL ITEMS
94	GLOBAL DIRECTORY BLOCK
100	INTERNAL TO BINDER: SKIP_IT_UC

SUBCLASSES

UC	SC	DESCRIPTION
0	1	IDENTIFIER
	2	ADDRESS COUPLE
	3	PARAMETERS
	4	GLOBAL DIRECTORY
	5	D1 REFERENCES
	6	GLOBAL REFERENCES
	7	LT48 POINTER FOR MAKING PCW
	8	SEGMENTS
	9	NUMBER PARAMETERS
	10	EXTERNAL IDENTIFIER
	11	OWN DIRECTORY
	12	OWN REFERENCES
	13	D2 STACK BUILDING CODE ARRAY
	14	LT48 POINTERS FOR MAKING VALUE ARRAY DESCRIPTORS
	15	NUMBER DIMENSIONS(PARAMETER WITH LOWER BOUNDS OR GLOBAL)
	16	ARRAY LENGTH (SEGMENTATION ALLOWED)
	17	SEGMENT DICTIONARY INDEX
	18	END OF D2 STACK POINTER
	19	FIRST EXECUTABLE CODE SYLLABLE
	20	SUBSCRIPTED VARIABLE POINTER (FORTRAN)
	21	GLOBAL STACK SIZE
	22	ARRAY LENGTH (SEGMENTATION NOT ALLOWED)
	23	LT48 POINTER FOR COMMON BLOCK LENGTH
	24	REFERENCES TO DOUBLE AND COMPLEX ITEMS IN COMMON
	25	BLOCK EXIT POINTER FOR FORTRAN STOP IN SUBPROGRAM
	26	INTRINSIC SPECIAL INFORMATION
	27	NUMBER DIMENSIONS(PARAMETER WITHOUT LOWER BOUNDS)
	28	INITIAL VALUE OF A VARIABLE OR ARRAY
	29	CODE COPYING STARTING AND ENDING LOCATIONS
	30	HEX REFERENCES TO OWNS
	31	BCL REFERENCES TO OWNS
	32	EBCDIC REFERENCES TO OWNS
	33	LOCAL DIRECTORY
	34	PROCEDURE DIRECTORY
	35	NUMBER OF ADDRESS COUPLES (PARAMETERS)
	36	CHECKING CODE FOR FORMAL PROCEDURE (ADR CPL,MPCW SYL PTR,FIREX)
	37	WAS EXTRA SEGS FOR PLI CONTROLLED VARIABLES
	38	WAS INITIAL CODE SCW AND # OF STACK CELLS (PL/I)
	39	TIMESTAMP FOR DATABASE
	40	FIRST ADDRESS COUPLE OF SIB FOR DATABASE
	41	LIST OF (STR NAME, STR #, ADR CPL) GROUPS FOR DATABASE
	42	LEVEL 2 SOFTWARE CONTROL WORD IMAGE
	43	LEVEL 2 EPILOG OR EXCEPTION OR STATISTICS PCW IMAGE (DCALGOL)
	44	LT48 POINTER FOR MAKING EPILOG OR EXCEPTION PCW BELOW SCW (DCALGOL)
	45	TRANSACTION BASE CREATION TIMESTAMP AND UPDATE TIMESTAMP
	46	LIST OF FORMATS AND SUBFORMATS INVOKED FOR TRANSACTION BASE
	47	TRANSACTION BASE FORMAT
	48	TRANSACTION BASE SUBFORMAT
	49	TRANSACTION BASE ASSOCIATED WITH TR RECORD OR RECORD ARRAY
	50	PROCEDURE/SUBROUTINE COMPILERINFO WORD
	51	LIBRARY TEMPLATE ATTRIBUTES
	52	DATA DICTIONARY INVOCATION DIRECTORY
	53	DATA DICTIONARY USAGE DIRECTORY
	54	ENTRY POINT DESCRIPTION OF A LIBRARY ENTRY POINT
	55	LIBRARY TO WHICH AN ENTRY POINT BELONGS
	56	LENGTH OF DM TEMPORARY ARRAY BELONGING TO DATABASE
	57	LT48 POINTERS TO TWO DESCRIPTORS FOR DM TEMPORARY ARRAY
	58	OUTPUT MESSAGE ARRAY INFORMATION FOR MULTILINGUAL SYSTEM (MLS)
	59	CRITICAL BLOCK INDICATORS FOR ALGOL PROCESS AND CALL STATEMENTS
	60	CODE POINTER TO CRITICAL BLOCK INDICATOR (NAMC LL,0)
	61	POINTER TO LT48 FOR ARRAY DESCRIPTOR
	62	POINTER TO LT48 FOR ARRAY LENGTH
	63	LT48 POINTER TO OUTPUT MESSAGE ARRAY
	64	PCW VALUE FOR FORTRAN77 INITIALIZATION PROCEDURE
	65	LT48 FOR OUTPUT MESSAGE ARRAY NAME
	66	FORTRAN77 FIX UP CODE FOR PARAMETERS
	67	SIM SAVED_QUERY_TEXT VALUE ARRAY POINTER
	68	SIM QUERY CODE ADDRESSES OF QUERY NUMBERS
	69	SIM ENTITY REFERENCE OR QUERY VARIABLE CLASSINFO
	70	SIM QUALIFYING IDENTIFIER
	71	SIM QUERY_DRIVER TEMPLATE BODY DISK ADDR AND LENGTH IN WORDS
	72	SIM LIST OF INDICES INTO Q_D TEMPLATE FOR EACH ENTRY POINT
	73	LT48 POINTER TO F77 HEAP VECTOR OFFSET
	74	DISK ADDRESS AND LENGTH OF SDF FORM RECORD LIBRARY APPLICATION RECORD DESCRIPTION OR LIBRARY TEMPLATE
	75	NUMBER OF HEAP WORDS REQUIRED FOR AN ITEM IN SLICE HEAP
	76	LT POINTER TO LT48 TO CREATE A SLICE HEAP ADDRESS VARIABLE BY EMITTING THE NUMBER OF HEAP WORDS REQUIRED FOR THE PREVIOUS HEAP ADDRESS VARIABLE.
	77	LT POINTER TO LT48 TO CREATE A SLICE HEAP ADDRESS VARIABLE BY EMITTING THE NUMBER OF WORDS PREVIOUSLY STACKED (AT LEX LVL 2) IN THE SOFTWARE STACK.
	78	LT POINTER TO LT48 TO CALCULATE THE TOTAL NUMBER OF SOFTWARE STACK WORDS AT LEX LEVEL 2 BY EMITTING (<TOTAL NUMBER OF HEAP WORDS STACKED> - <NUMBER OF HEAP WORDS STACKED FOR ALL HEAP ADDR VARS IN ORIGINAL HOST EXCEPT THE LAST ONE>) Bit 46 in the LT48 pointer indicates whether to use the 1D or 2D softstack: 0 means 1D, 1 means 2D.
	79	LT POINTER TO LT48 TO CALCULATE THE TOTAL NUMBER OF SOFTWARE STACK WORDS AT LEX LEVEL 2 BY EMITTING THE TOTAL NUMBER OF HEAP WORDS STACKED. Bit 46 in the LT48 pointer indicates whether to use the 1D or 2D softstack: 0 means 1D, 1 means 2D.
	80	SLICE HEAP ITEM ACCESS, BIT 0 = EXTERNAL, BIT 1 = PUBLIC.
	81	LT POINTER TO A "ZERO" OP WHICH WILL NEED TO BE CHANGED TO A "ONE" OP IF A DOUBLE SLICE HEAP ITEM ADDR VAR IS ADDED TO THE OUTER BLOCK (D2). USED FOR SLICE 2D HEAP ONLY.
	82	LT POINTER TO PREAMBLE CODE (AND # OF CODE SYLLS) WHICH IS USED TO CHECK TO SEE IF THE ADDRESSES IN THE SLICE SOFTWARE STACK SHOULD CONTINUE IN CURRENT HEAP ROW OR THE NEXT HEAP ROW (USED FOR SLICE 2D HEAP).
	83	LT POINTER (AND # OF CODE SYLLS) TO THE CALL ON Make_2d_heap. THIS CODE COMES AFTER THE CODE FOR THE SCW IN THE D2 STK BLDING CODE. THE BINDER NEEDS TO COPY THIS CODE FROM THE HOST AND PLACE IT AFTER THE CODE TO BUILD THE SCW. -- FOR SLICE 2D HEAP
	84	SLICE MEMORY MODEL. 0 = TINY, 1 = SMALL, 2 = LARGE, 3 = HUGE. TINY AND SMALL ARE 1D HEAPS. LARGE AND HUGE ARE 2D HEAPS.
	85	SLICE HEAP ROW SIZE (IN WORDS).
	86	SLICE NUMBER OF ADDRESSED PROCEDURES (HOST ONLY)
	87	SLICE PROCEDURE ADDRESS
	88	SLICE LT16 POINTER TO PROCEDURE ADDRESS
	89	SLICE NUMBER OF CALLS TO PROCEDURE VIA ADDRESS
	90	SLICE FORMAL CALL INFORMATION
	91	SLICE FORMAL CALL NUMBER
	92	SLICE FORMAL CALL INDEX
	93	SLICE LT16 POINTER CALL TO (FORMAL_CALL_NUM MOD 48)
	94	SLICE CODE POINTER TO ISOL OR BSET
	95	SLICE LT48 CALL TO FORMAL CALL INDEX
	96	SLICE LT16 POINTER TO ROUTINE_ARG_STRIDE
	97	SLICE ROUTINE-ARG-INDEX-LOC
	98	SLICE ROUTINE-ARG-TABLE-LOC
	99	SLICE SLICE-CHECK-TABLE-ID
	100	SLICE SLICE-SIRW-TAB-ID
	101	SLICE SLICE-SIRW-TAB-INIT
	102	SLICE BRANCH LOCATIONS IN THE D2 STACK BUILDING CODE
	103	SLICE BRANCH LOCATIONS IN THE D2 INITIALIZATION CODE
	104	SLICE LOCATION OF BRANCH USED TO START D2 INITIALIZATION
	105	SLICE COPY OF SLICE HEAP ADDRESS VARIABLE
	106	SLICE TADS PROCEDURE NUMBER.
	107	SLICE TADS PROCEDURE NUMBER REFERENCE.
	108	SLICE TADS LAST PROCEDURE NUMBER.
	109	SLICE CONCURRENT EXECUTION OPTION.
	110	STATISTICS EPILOG. This identifies the current procedure as an epilog procedure for printing statistics. The next word holds the code address of the end of the epilog procedure, which has EXIT NVLD NVLD. If statistics epilogs occur in multiple subprograms, the Binder overwrites the EXIT NVLD NVLD with a NAMC to another epilog's PCW and a DBUN in order to link the epilogs so that all are executed.
	111	SLICE DOUBLE ALIGNMENT OPTION
	112	FARHEAP STACKSIZE. Value of FARHEAP(STACKSIZE) option.
	113	FARHEAP STACKSIZE LT48. Location in host program code to put maximum FARHEAP(STACKSIZE) value.
	114	Two strings follow, if the first string is found in another BINDER_MATCH option, then the two second strings must match.
	115
	116
	117
	118	SB_CB_NAME_SC. Structure or Connection Block type.
	119	CL_SB_DESC_SC. LT48 pointer to Connection Library or Structure Block variable/array descriptor.
	120	OPERAND_ACCESS_SC. The following word tells if the operand is defined as public in [1:1] and if it is initialized in [3:1].
	121	BIND_LARGE_PROGRAM_SC. Bind Large Program option is set.
	122	TADS_RESOURCE_SC. Value of $TADS(RESOURCE).
	123	D2_STACK_BUILDING_SEGS_SC. Each following word contains the segment dictionary index of a D2 stack-building code segment.
2	0	SP OPERAND (INTEGER)
	1	SP OPERAND (REAL)
	2	SP OPERAND (BOOLEAN)
	3	WORD VARIABLE
	4	REFERENCE VARIABLE
	5	SLICE HEAP ADDRESS VARIABLE (CONTAINS A HEAP ADDRESS)
	7	HEAP_POINTER_48_SC -- HEAP POINTER (48 BIT UNITS)
	8	HEAP_POINTER_8_SC -- HEAP POINTER ( 8 BIT UNITS)
	9	HEAP_POINTER_96_SC -- HEAP POINTER (96 BIT UNITS)
	10	HEAP_POINTER_4_SC -- HEAP POINTER ( 4 BIT UNITS)
	11	FARHEAP_POINTER_48_SC -- FARHEAP POINTER (48 BIT UNITS)
	12	FARHEAP_POINTER_8_SC -- FARHEAP POINTER ( 8 BIT UNITS)
	13	FARHEAP_POINTER_96_SC -- FARHEAP POINTER (96 BIT UNITS)
	14	FARHEAP_POINTER_4_SC -- FARHEAP POINTER ( 4 BIT UNITS)
4	1	EVENT 3 DP OPERAND 4 COMPLEX OPERAND
6	0	SP ARRAY (INTEGER)
	1	SP ARRAY (REAL)
	2	SP ARRAY (BOOLEAN)
	3	WORD ARRAY
	4	REFERENCE ARRAY
	5	DIRECT INTEGER ARRAY
	6	DIRECT REAL ARRAY
	7	DIRECT BOOLEAN ARRAY
	8	COBOL SEGMENTED ARRAY
	9	FORTRAN VARFILE ARRAY
	10	NEW FORMAT ARRAY
	11	TRANSACTION RECORD OR RECORD ARRAY
	12	FORTRAN77 VARIABLE FILE ARRAY
	13	PROCEDURE REFERENCE ARRAY (BOOLEAN)
	14	PROCEDURE REFERENCE ARRAY (DOUBLE PRECISION)
	15	PROCEDURE REFERENCE ARRAY (REAL)
	16	PROCEDURE REFERENCE ARRAY (INTEGER)
	17	PROCEDURE REFERENCE ARRAY (COMPLEX)
	18	PROCEDURE REFERENCE ARRAY (EBCDIC STRING)
	19	PROCEDURE REFERNECE ARRAY (ASCII STRING)
	20	PROCEDURE REFERENCE ARRAY (HEX STRING)
	21	PROCEDURE REFERENCE ARRAY (UNTYPED)
	22	PROCEDURE REFERENCE ARRAY (POINTER)
	23	PROCEDURE REFERENCE ARRAY (WORD)
	24	PROCEDURE REFERENCE ARRAY (DESCRIPTOR)
	25	PROCEDURE REFERENCE ARRAY (USER TYPE)
	28	PICTURE ARRAY
8	0	SP SUBSCRIPTED VARIABLE (INTEGER)
	1	SP SUBSCRIPTED VARIABLE (REAL)
	2	SP SUBSCRIPTED VARIABLE (BOOLEAN)
	3	FORMAT(ALGOL) 4 PICTURE(ALGOL)
10	2	EVENT ARRAY
	3	DP ARRAY
	4	COMPLEX ARRAY
	5	DIRECT DOUBLE ARRAY
	6	FORTRAN77 DOUBLE PRECISION ARRAY AS SINGLE DESCRIPTOR
	7	FORTRAN77 COMPLEX ARRAY AS SINGLE DESCRIPTOR
	8	FORTRAN77 DOUBLE PRECISION ARRAY AS DOUBLE DESCRIPTOR (NOT CURRENTLY USED--SUBCLASS 3 IS USED INSTEAD)
	9	FORTRAN77 COMPLEX ARRAY AS DOUBLE DESCRIPTOR (NOT CURRENTLY USED--SUBCLASS 4 IS USED INSTEAD)
12	3	DP SUBSCRIPTED VARIABLE
	4	COMPLEX SUBSCRIPTED VARIABLE
	6	FORTRAN77 DP SUBSCRIPTED VARIABLE AS SINGLE DESCRIPTOR
	7	FORTRAN77 COMPLEX SUBSCRIPTED VARIABLE AS SINGLE DESCRIPTOR
	8	FORTRAN77 DP SUBSCRIPTED VARIABLE AS DOUBLE DESCRIPTOR
	9	FORTRAN77 COMPLEX SUBSCRIPTED VARIABLE AS DOUBLE DESCRIPTOR
14	1	CHARACTER ARRAY, SIZE = 4
	2	CHARACTER ARRAY, SIZE = 6
	3	CHARACTER ARRAY, SIZE = 8
	4	NON REENTRANT FORMAT ARRAY(FORTRAN)
	5	DIRECT CHARACTER ARRAY, SIZE = 4
	6	DIRECT CHARACTER ARRAY, SIZE = 6
	7	DIRECT CHARACTER ARRAY, SIZE = 8
	8	COBOL74 DATA STRUCTURE
16	1	POINTER
18	0	SUBROUTINE
	1	INITIALIZATION SUBROUTINE (FORTRAN)
	2	LABEL
	3	SWITCH(LABEL)
	4	LABEL FOR STOP IN SUBROUTINE (FORTRAN)
	5	SWITCH(FORMAT)
	6	3.9 AND EARLIER SWITCH(LIST)
	7	SWITCH(FILE)
	8	SWITCH(DIRECT FILE)
	9	MCP SAVE CODE(SEGMENT 1 AND/OR 5)
	10	FORMAL LABEL - II.4 OR LATER
	11	EPILOG OR EXCEPTION PROCEDURE (DCALGOL)
	12	FORTRAN77 BLOCKDATA SUBPROGRAM
	13	FORTRAN77 FORMAL LABEL
	14	SWITCH(LIST)
	16	NULL PROCEDURE REFERENCE
	17	COBOL85 CALL MODULE ENTRY POINT
20	0	FUNCTION (INTEGER)
	1	FUNCTION (REAL)
	2	FUNCTION (BOOLEAN)
	3	FUNCTION (DOUBLE PRECISION)
	4	FUNCTION (COMPLEX)
	5	FORTRAN EXTERNAL SUBPROGRAM (NOTHING KNOWN) OR EXTERNAL INTRINSIC
	6	3.9 AND EARLIER I/O LIST(ALGOL)
	7	POINTER PROCEDURE
	8	WORD PROCEDURE
	9	REFERENCE PROCEDURE
	10	I/O LIST(ALGOL)
	11	NULL PROCEDURE REFERENCE
22	1	FILE
	2	DIRECT FILE
	3	COBOL FILE
	4	D.M. RESTART FILE (COBOL)
24	1	TASK 2 TASK ARRAY
26	1	FORTRAN COMMON BLOCK
	2	FORTRAN EQUIVALENCE ARRAY
	3	FORTRAN77 ARITHMETIC COMMON BLOCK
	4	FORTRAN77 CHARACTER COMMON BLOCK
28	1	INTERRUPT
30	1	MESSAGE
	2	MESSAGE ARRAY
32	1	QUEUE 2 QUEUE ARRAY
34	0	INTRINSIC (SUBROUTINE)
36	0	INTRINSIC (INTEGER)
	1	INTRINSIC (REAL)
	2	INTRINSIC (BOOLEAN)
	3	INTRINSIC (DOUBLE PRECISION)
	4	INTRINSIC (COMPLEX)
38	-	WAS PL/I VARIABLES
40	0	DATABASE
42	0	EBCDIC STRING VARIABLE (ALGOL)
	1	ASCII STRING VARIABLE (ALGOL)
	2	HEX STRING VARIABLE (ALGOL)
44	0	EBCDIC STRING VARIABLE ARRAY (ALGOL)
	1	ASCII STRING VARIABLE ARRAY (ALGOL)
	2	HEX STRING VARIABLE ARRAY (ALGOL)
46	0	EBCDIC STRING PROCEDURE (ALGOL)
	1	ASCII STRING PROCEDURE (ALGOL)
	2	HEX STRING PROCEDURE (ALGOL)
	3	NULL PROCEDURE REFERENCE
48	0	ALTERNATIVE ITEM GROUP (NEWP)
50	1	DATA DICTIONARY DESCRIPTION OF DATABASE
	2	DATA DICTIONARY DESCRIPTION OF TRANSACTION BASE
	3	DATA DICTIONARY DESCRIPTION OF DATA SET
	4	DATA DICTIONARY DESCRIPTION OF TRANSACTION FORMAT
	5	DATA DICTIONARY DESCRIPTION OF EXPLICITLY-INVOKED DISJOINT SET
	6	DATA DICTIONARY DESCRIPTION OF GLOBAL DATA SET
52	0	TRANSACTION BASE
54	0	LIBRARY
	1	SIM QUERY_DRIVER LIBRARY TEMPLATE
56	0	LIBRARY ENTRY POINT
58	0	EXPORTED SUBROUTINE
	1	EXPORTED INTEGER FUNCTION
	2	EXPORTED REAL FUNCTION
	3	EXPORTED BOOLEAN FUNCTION
	4	EXPORTED DOUBLE FUNCTION
	5	EXPORTED COMPLEX FUNCTION
	6	EXPORTED EBCDIC STRING PROCEDURE
	7	EXPORTED ASCII STRING PROCEDURE 8 EXPORTED HEX STRING PROCEDURE
60	0	BY-CALLING SUBROUTINE OR FUNCTION
62	3	FUNCTION (DOUBLE PRECISION) %%% NOT USED BY BINDER %%%
	4	FUNCTION (COMPLEX) %%% NOT USED BY BINDER %%%
64	0	HEAP VECTOR (FORTRAN77)
66	0	COBOL74 REGULAR CD INPUT 8-BIT
	1	COBOL74 REGULAR CD OUTPUT 8-BIT
	2	COBOL74 BINARY CD INPUT 48-BIT
	3	COBOL74 BINARY CD INPUT 8-BIT
	4	COBOL74 BINARY CD INPUT 4-BIT
	5	COBOL74 BINARY CD OUTPUT 48-BIT
	6	COBOL74 BINARY CD OUTPUT 8-BIT
	7	COBOL74 BINARY CD OUTPUT 4-BIT
68	0	INTERLOCK
	1	INTERLOCK ARRAY
70	0	SIM ENTITY REFERENCE VARIABLE
	1	SIM ENTITY REFERENCE ARRAY
72	0	SIM QUERY VARIABLE
74	0	SDF FORM LIBRARY APPLICATION RECORD DESCRIPTION
76	1	SINGLE ITEM IN SLICE 1-D HEAP (INTEGER)
	2	SINGLE ITEM IN SLICE 1-D HEAP (UNSIGNED INTEGER)
	3	SINGLE ITEM IN SLICE 1-D HEAP (REAL)
	4	SINGLE ITEM IN SLICE 1-D HEAP (BOOLEAN)
	5	SINGLE ITEM IN SLICE 1-D HEAP (CARDINAL)
	6	SINGLE ITEM IN SLICE 1-D HEAP (DATA POINTER)
	7	SINGLE ITEM IN SLICE 1-D HEAP (SHORT INTEGER)
	8	SINGLE ITEM IN SLICE 1-D HEAP (SHORT UNSIGNED INTEGER)
	9	SINGLE ITEM IN SLICE 1-D HEAP (CODE POINTER)
	10	SINGLE ITEM IN SLICE 1-D HEAP (BIT SET)
	11	SINGLE ITEM IN SLICE 1-D HEAP (BINARY)
78	1	DOUBLE ITEM IN SLICE 1-D HEAP (DOUBLE)
	2	DOUBLE ITEM IN SLICE 1-D HEAP (COMPLEX)
	3	DOUBLE ITEM IN SLICE 1-D HEAP (LONG INTEGER)
	4	DOUBLE ITEM IN SLICE 1-D HEAP (LONG UNSIGNED INTEGER)
80	1	HEX ITEM IN SLICE 1-D HEAP (HEXADECIMAL)
	2	HEX ITEM IN SLICE 1-D HEAP (PACKED)
82	1	EBCDIC ITEM IN SLICE 1-D HEAP (CHAR TYPE)
	2	EBCDIC ITEM IN SLICE 1-D HEAP (CHARACTER)
	3	EBCDIC ITEM IN SLICE 1-D HEAP (DISPLAY)
84	1	SINGLE ITEM IN SLICE 2-D HEAP (INTEGER)
	2	SINGLE ITEM IN SLICE 2-D HEAP (UNSIGNED INTEGER)
	3	SINGLE ITEM IN SLICE 2-D HEAP (REAL)
	4	SINGLE ITEM IN SLICE 2-D HEAP (BOOLEAN)
	5	SINGLE ITEM IN SLICE 2-D HEAP (CARDINAL)
	6	SINGLE ITEM IN SLICE 2-D HEAP (DATA POINTER)
	7	SINGLE ITEM IN SLICE 2-D HEAP (SHORT INTEGER)
	8	SINGLE ITEM IN SLICE 2-D HEAP (SHORT UNSIGNED INTEGER)
	9	SINGLE ITEM IN SLICE 2-D HEAP (CODE POINTER)
	10	SINGLE ITEM IN SLICE 2-D HEAP (BIT SET)
	11	SINGLE ITEM IN SLICE 2-D HEAP (BINARY)
86	1	DOUBLE ITEM IN SLICE 2-D HEAP (DOUBLE)
	2	DOUBLE ITEM IN SLICE 2-D HEAP (COMPLEX)
	3	DOUBLE ITEM IN SLICE 2-D HEAP (LONG INTEGER)
	4	DOUBLE ITEM IN SLICE 2-D HEAP (LONG UNSIGNED INTEGER)
88	1	HEX ITEM IN SLICE 2-D HEAP (HEXADECIMAL)
	2	HEX ITEM IN SLICE 2-D HEAP (PACKED)
90	1	EBCDIC ITEM IN SLICE 2-D HEAP (CHAR TYPE)
	2	EBCDIC ITEM IN SLICE 2-D HEAP (CHARACTER)
	3	EBCDIC ITEM IN SLICE 2-D HEAP (DISPLAY)
92	0	STRUCTURE/CONNECTION BLOCK TYPE PCW
	1	STRUCTURE BLOCK TYPE
	2	CONNECTION BLOCK TYPE
	3	STRUCTURE BLOCK VARIABLE
	4	SINGLE CONNECTION LIBRARY
	5	STRUCTURE BLOCK/CONNECTION LIBRARY ARRAY DIMENSION
	6	STRUCTURE BLOCK ARRAY
	7	MULTI CONNECTION LIBRARY
	8	CONNECTION LIBRARY TEMPLATE
	9	CONNECTION FORMAL PARAMETER
94	0	EXTERNAL STRUCTURE BLOCK
	1	EXTERNAL CONNECTION BLOCK
100	0	INTERNAL TO BINDER: SKIP_IT_UC

KEYWORD DESCRIPTIONS

                         
(0,1,N,IDENTIFIER)                                                       
    IDENTIFIER HAS THE FORM:                                             
         4"TT0101CC"8"XX---X"                                            
    WHERE CC IS THE NUMBER OF CHARACTERS IN THE IDENTIFIER STRING,       
          TT = CC + 4 (TOTAL NUMBER OF BYTES IN STRING) AND              
          N = (TT + 5) DIV 6                                             
    THE STRING IS LEFT JUSTIFIED AND THE LAST WORD CONTAINS UNDEFINED    
    FILLER.                                                              
(0,2,1,ADDRESSCOUPLE)                                                    
    ADDRESS COUPLE HAS THE FORM:                                         
            ----------------------------                                 
            :////:  LEVEL   :   DISP   :                                 
            ----------------------------                                 
    WHERE LEVEL = [39:20] AND                                            
          DISP  = [19:20].                                               
(0,3,N,PARAMETERS)                                                       
    PARAMETERS HAS THE FORM:                                             
                             --                                          
         (0,9,1,P)             :                                         
                               :                                         
         (UC1,SC1,M1,ITEM1)    :                                         
                               :                                         
         (UC2,SC2,M2,ITEM2)     > N WORDS                                
                 :             :                                         
                 :             :                                         
         (UCP,SCP,MP,ITEMP)    :                                         
                             --                                          
    WHERE P IS THE NUMBER OF PARAMETERS (P GEQ 0)                        
          N IS THE TOTAL NUMBER OF WORDS DESCRIBING PARAMETERS (N GEQ 0) 
          EACH ITEM IS A DESCRIPTION OF A PARAMETER.  THE ITEMS MUST     
              APPEAR IN THE ORDER OF THE REQUIRED PARAMETERS.            
(0,4,N,GLOBALDIRECTORY)                                                  
    GLOBALDIRECTORY HAS THE FORM:                                        
                              -                                          
         (UC1,SC1,M1,ITEM1)    :                                         
                 :             :                                         
                 :              > N WORDS                                
                 :             :                                         
         (UCP,SCP,MP,ITEMP)    :                                         
                              -                                          
    WHERE N IS THE TOTAL NUMBER OF WORDS IN THE BLOCK AND                
          EACH ITEM IS A DESCRIPTION OF SOMETHING GLOBAL TO AN           
              EXTERNAL PROCEDURE.                                        
          FOR A BLOCK PROGRAM EACH ITEM DESCRIPTION MUST CONTAIN:        
              (0,1,N1,IDENTIFIER)                                        
              (0,2,N2,ADDRESSCOUPLE)                                     
              (0,13,1,NUMBERDIMENSIONS) IF ARRAY                         
              (0,7,N7,MPCWPOINTER)      IF EXTERNAL PROCEDURE            
              (0,14,1,LENGTH)           IF FORTRAN COMMON BLOCK          
              (0,3,N3,PARAMETERS)       IF PROCEDURE WITH PARAMETERS     
          FOR A PROCEDURE PROGRAM, EACH ITEM DESCRIPTION MUST CONTAIN    
          THE ABOVE PLUS:                                                
              (0,6,N6,GLOBALREFERENCES)                                  
    THE DESCRIPTION FOR AN EXTERNAL PROCEDURE IS CONTAINED IN A VALUE    
    ARRAY WHOSE DESCRIPTOR IS IN THE SEGMENT DICTIONARY.  IN THIS CASE   
    THE GLOBAL DIRECTORY ENTRY MAY CONTAIN:                              
              (UC,SC,2)                                                  
              (0,17,1,SDI)                                               
    WHERE SDI IS THE SEGMENT DICTIONARY INDEX FOR THE DESCRIPTOR, OR IT  
    MAY BE A NORMAL ENTRY.                                               
(0,5,N,D1REFERENCES)                                                     
    D1REFERENCES HAS THE FORM:                                           
                   -                                                     
              SP1   :                                                    
                    :                                                    
              SP2    > N WORDS                                           
               :    :                                                    
              SPN   :                                                    
                   -                                                     
    WHERE EACH SP IS A "SYLLABLE POINTER" TO A NAMC, VALC OR MPCW        
          OPERATOR REFERRING TO A LEVEL 1 ITEM.  THE SYLLABLE POINTER    
          HAS THE FORM OF A PCW WITH A TAG OF 0. THE GAMMA- SYLLABLE     
          POINTER IS A FOLLOWS:                                          
              -------------------------------                            
              ://////:PSR: PIR  : :LL: SDI  :                            
              -------------------------------                            
          PSR = [35:3]    - SYLLABLE INDEX FOR START OF THE OPERATOR     
          PIR = [32:13]   - WORD INDEX FOR START OF OPERATOR             
          DELTAF = [18:1] - FALSE FOR PRE-DELTA                          
          LL =  [17:4]    - LEX LEVEL AT WHICH OPERATOR IS EXECUTED      
          D0/D1 = [13:1]  - SEGMENT DICTIONARY LEVEL                     
          SDI = [12:13]   - SEGMENT DICTIONARY INDEX FOR CODE SEGMENT    
                            CONTAINING THE OPERATOR                      
                                                                         
    THE DELTA SYLLABLE POINTER IS AS FOLLOWS:                            
              -------------------------------                            
              ://////:PIR: PSR  : :LL: SDI  :                            
              -------------------------------                            
          PIR = [35:13]   - WORD INDEX FOR START OF OPERATOR             
          PSR = [22:3]    - SYLLABLE INDEX FOR START OF THE OPERATOR     
          DELTAF = [18:1] - TRUE FOR DELTA+                              
          LL =  [17:4]    - LEX LEVEL AT WHICH OPERATOR IS EXECUTED      
          D0/D1 = [13:1]  - SEGMENT DICTIONARY LEVEL                     
          SDI = [12:16]   - SEGMENT DICTIONARY INDEX FOR CODE SEGMENT    
                            CONTAINING THE OPERATOR                      
(0,6,N,GLOBALREFERENCES)                                                 
    GLOBALREFERENCES HAS THE SAME FORM AS D1REFERENCES.  THE NAMC OR     
    VALC MAY REFERENCE ANY LEVEL GLOBAL TO THE PROCEDURE IN WHICH IT     
    OCCURS.                                                              
(0,7,N,MPCWPOINTERS)                                                     
    MPCWPOINTER IS A SYLLABLE POINTER TO A LT48 OPERATOR                 
    WHICH  IS USED TO MAKE A LITERAL CONTAINING THE SDI OF THE VALUE     
    ARRAY DESCRIPTOR FOR THE EXTERNAL PROCEDURE.                         
(0,9,1,NUMBERPARAMETERS)                                                 
    NUMBERPARAMETERS IS THE NUMBER OF PARAMETERS REQUIRED BY THIS PRO-   
    GRAM,PROCEDURE OR ENTRY.                                             
(0,10,N,EXTERNALID)                                                      
    EXTERNALID IS AN EXPLICIT FILE IDENTIFIER IN KUNKERFORM.             
(0,11,N,OWNDIRECTORY)                                                    
    OWNDIRECTORY IS A LIST OF OWN VARIABLES WHICH WERE DECLARED IN A     
    PROCEDURE PROGRAM.  THESE ARE ITEMS WHICH MUST BE ADDED TO THE       
    HOST D2 STACK.  THE FORMAT IS THE SAME AS THAT IN THE GLOBAL         
    DIRECTORY.                                                           
(0,12,N,OWNREFERENCES)                                                   
    OWNREFERENCES IS A LIST OF SYLLABLE POINTERS TO ALL REFERENCES TO    
    AN OWN VARIABLE.                                                     
(0,13,N,D2STACKBUILDINGCODEARRAY)                                        
    PNOTE %NEW BIND INFO REQUIRED FOR E-MODE LEVEL DELTA? CANNOT FIND    
          %A REFERENCE TO SEGMENT NUMBER FIELD.                          
    D2STACKBUILDINGCODEARRAY IS THE D2 STACK BUILDING CODE ARRAY.  FOR   
    A GIVEN D2 STACK LOCATION, THERE MAY BE A WORD IN THE ARRAY WHICH    
    DESCRIBES CERTAIN FEATURES OF THE CELL AND GIVES THE CELL'S STARTING 
    CODE ADDRESS.  THE FORMAT FOR EACH WORD IS:                          
        [47:16]   NUMBER OF SYLLABLES OF CODE TO CREATE THE STACK CELL   
        [31:03]   PSR                                                    
        [28:13]   PIR                                                    
        [15:01]   DID A LT48 OR MPCW                                     
        [14:01]   WAS USED IN PL/I FOR INITIALIZATION AND BRANCH FIX-UPS 
        [13:01]   CONTENTS OF ARRAY ARE INITIALIZED IN CODE FILE         
        [12:13]   SEGMENT NUMBER                                         
(0,14,N,MAKEARRAYDESCPNTRS)                                              
    MAKEARRAYDESCPNTRS IS A LIST OF SYLLABLE POINTERS TO LT48 OPERATORS  
    FOR MAKING VALUE ARRAY OR FIB DESCRIPTORS.  ONE OF THESE IS REQUIRED 
    FOR EACH VALUE ARRAY (SUCH AS A FORMAT STRING) WHICH DOES NOT HAVE A 
    D1 DESCRIPTOR, AS WELL AS FOR EACH FILE.                             
(0,15,1,NUMBERDIMENSIONS)                                                
    NUMBERDIMENSIONS IS THE NUMBER OF DIMENSIONS(IN THE ALGOL OR HARD-   
    WARE SENSE) REQUIRED BY AN ARRAY.                                    
(0,16,1,LENGTH)                                                          
    LENGTH IS THE NUMBER OF 48 BIT WORDS IN A FORTRAN COMMON BLOCK.      
(0,17,1,SDI)                                                             
    SDI IS THE SEGMENT DICTIONARY INDEX OF THE VALUE ARRAY DESCRIPTOR    
    FOR AN EXTERNAL PROCEDURE.                                           
(0,18,1,ENDOFD2CODE)                                                     
    ENDOFD2CODE IS A SYLLABLE POINTER TO THE SYLLABLE IMMEDIATELY        
    AFTER THE D2 STACK BUILDING CODE.                                    
(0,19,1,FIRSTEX)                                                         
    FIRSTEX IS A SYLLABLE POINTER TO THE FIRST EXECUTABLE CODE           
    SYLLABLE OF A SEPARATELY COMPILED PRECEDURE.  (THIS REFERS TO THE    
    PROCEDURE ITSELF, NOT THE PSEUDO OUTER BLOCK)                        
(0,67,1,D1_OFFSET)                                                       
    IN [15:16] IS D1_OFFSET OF SAVED_QUERY_TEXT ARRAY                    
(0,68,N,CODEADDR)                                                        
    CODEADDR IS A LIT16                                                  
(0,69,1,CLASSINFO)                                                       
    CLASSINFO CONSISTS OF 1 WORD,CLASS IDENTIFIER INDEX NUMBER [39:20]   
    AND SIZE IN WORDS [19:20]                                            
(0,70,ENTRYSIZE,DMRECORDINFO)                                            
    DMRECORDINFO CONSISTS OF: (0,1,N,DM RECORD TYPE IDENTIFIER)          
(0,71,1,TEMPLATE INFO)                                                   
    TEMPLATE INFO CONSISTS OF: DISK ADDR.[19:20],LENGTH[39:20]           
(0,72,ENTRYSIZE, TEMPLATE INDICES LIST)                                  
    TEMPLATE INDICES LIST CONSISTS OF:UP TO 3 INDICES (OF ENTRY POINTS   
    INTO TEMPLATE) PER WORD [44:13], [28:13], [12:13]                    
(0,73,N,F77HEAPVECTOROFFSETPOINTERS)                                     
    F77HEAPVECTOROFFSETPOINTERS IS A LIST OF SYLLABLE POINTERS TO HEAP   
    VECTOR OFFSETS.  THESE INDICES MUST BE FIXED UP IN THE CODE IF THE   
    HEAP VECTOR IS MODIFIED.  NOTE THAT "HEAP" REFERS TO F77 HEAP HERE.  
    THIS SHOULD NOT BE CONFUSED WITH THE SLICE HEAP (WHICH IS SOMETHING  
    COMPLETELY DIFFERENT).                                               
(0,75,1,SLICE HEAP WORDS REQUIRED)                                       
    THE NUMBER OF HEAP WORDS REQUIRED FOR AN ITEM IN THE SLICE HEAP.     
(0,76,1,LT48 PTR TO CREATE SLICE HEAP ADDR VAR (USING PREV ITEM))        
    LT POINTER TO LT48 TO CREATE A SLICE HEAP ADDRESS VARIABLE BY        
    EMITTING THE NUMBER OF HEAP WORDS REQUIRED FOR THE PREVIOUS HEAP     
    ADDRESS VARIABLE.                                                    
(0,77,1,LT48 PTR TO CREATE SLICE HEAP ADDR VAR (USING WORDS STACKED))    
    LT POINTER TO LT48 TO CREATE A SLICE HEAP ADDRESS VARIABLE BY        
    EMITTING THE NUMBER OF WORDS PREVIOUSLY STACKED (AT LEX LEVEL 2)     
    IN THE SOFTWARE STACK.                                               
(0,78,1,LT48 PTR TO CALC SOFT STACK WORDS (USING PREV WORDS))            
    LT POINTER TO LT48 TO CALCULATE THE TOTAL NUMBER OF SOFTWARE STACK   
    WORDS AT LEX LEVEL 2 BY EMITTING (<TOTAL NUMBER OF HEAP WORDS        
    STACKED> - <NUMBER OF HEAP WORDS STACKED FOR ALL HEAP ADDR VARS IN   
    ORIGINAL HOST EXCEPT THE LAST ONE>)                                  
(0,79,1,LT48 PTR TO CALC SOFT STACK WORDS (USING WORDS STACKED))         
    LT POINTER TO LT48 TO CALCULATE THE TOTAL NUMBER OF SOFTWARE STACK   
    WORDS AT LEX LEVEL 2 BY EMITTING THE TOTAL NUMBER OF HEAP WORDS      
    STACKED.                                                             
(0,80,1,SLICE HEAP ITEM ACCESS)                                          
    SLICE HEAP ITEM ACCESS, BIT 0 = EXTERNAL, BIT 1 = PUBLIC.            
(0,81,1,LT PTR TO PUT ONE IF DOUBLE ADDED TO SLICE SOFT STACK)           
    LT POINTER TO A "ZERO" OP WHICH WILL NEED TO BE CHANGED TO A "ONE"   
    OP IF A DOUBLE SLICE HEAP ITEM ADDR VAR IS ADDED TO THE OUTER BLOCK. 
    USED FOR SLICE 2D HEAP ONLY.                                         
(0,82,2,LT PTR TO CHECK 2D HEAP ROW BUMP)                                
    LT POINTER TO PREAMBLE CODE WHICH IS USED TO CHECK TO SEE IF THE     
    ADDRESSES IN THE SLICE SOFTWARE STACK SHOULD CONTINUE IN CURRENT     
    HEAP ROW OR THE NEXT HEAP ROW.  USED FOR SLICE 2D HEAP ONLY.         
    THE 2ND WORD CONTAINS THE NUMBER OF CODE SYLLABLES FOR THIS CODE.    
(0,83,2,LT POINTER TO MAKE_2D_HEAP CALL)                                 
    LT POINTER TO THE CALL ON Make_2d_heap.  THIS CODE COMES AFTER THE   
    CODE FOR THE SCW IN THE D2 STK BUILDING CODE.  THE BINDER NEEDS TO   
    COPY THIS CODE FROM THE HOST AND PLACE IT AFTER THE CODE TO BUILD    
    THE SCW.  USED FOR SLICE 2D HEAP ONLY.                               
    THE 2ND WORD CONTAINS THE NUMBER OF CODE SYLLABLES FOR THIS CODE.    
(0,84,1,SLICE MEMORY MODEL)                                              
    SLICE MEMORY MODEL.  0 = TINY, 1 = SMALL, 2 = LARGE, 3 = HUGE.       
    TINY AND SMALL ARE 1D HEAPS.  LARGE AND HUGE ARE 2D HEAPS.           
(0,85,1,SLICE HEAP ROW SIZE)                                             
    SLICE HEAP ROW SIZE (IN WORDS).                                      
(0,114,N,BINDER_MATCH STRINGS)                                           
    CONTAINS (LNG, STRING-NAME) (LNG, STRING-VALUE)                      
                                                                         
(18,SC,N,PROCEDUREITEM) OR                                               
(20,SC,N,PROCEDUREITEM)                                                  
    PROCEDUREITEM IS A DESCRIPTION OF A PROCEDURE.  THIS MAY BE FOUND:   
    (1) AS THE FIRST ENTRY IN THE PROGRAM DESCRIPTION FOR A PROCEDURE    
        PROGRAM                                                          
    (2) AS AN EXTERNAL PROCEDURE DESCRIPTION                             
    (3) AS AN ENTRY IN THE GLOBAL DIRECTORY IN EITHER THE PROGRAM        
        DESCRIPTION OR AN EXTERNAL PROCEDURE DESCRIPTION.                
     A PROCEDURE ITEM MUST INCLUDE:                                      
         (0,1,N,IDENTIFIER)                                              
         (0,2,1,ADDRESSCOUPLE)                                           
         (0,3,N,PARAMETERS)       IF IT HAS PARAMETERS                   
         (0,7,1,MPCWPOINTER)      IF EXTERNAL PROCEDURE DESCRIPTION      
(54,SC,ENTRYSIZE, LIBRARY)                                               
      MUST INCLUDE:                                                      
         (0,1,N,IDENTIFIER)                                              
         (0,2,1,ADDRESSCOUPLE)                                           
         (0,51,N,LIBRARY ATTRIBUTES)                                     
      MAY INCLUDE AFTER RELEASE 38 FOR THE HOST OUTER BLOCK ONLY:        
         (0,61,1,LOCATION OF LT48)                                       
         (0,74,1,Constant array disk address and length)                 
(56,0,ENTRYSIZE, LIBRARY OBJECT)                                         
      MUST INCLUDE:                                                      
         (0,1,N,IDENTIFIER)                                              
         (0,2,1,ADDRESSCOUPLE)                                           
         (0,54,N,OBJECT DESCRIPITON)                                     
         (0,55,N,LIBRARY TO WHICH THIS OBJECT BELONGS)                   
      MAY INCLUDE AFTER RELEASE 38:                                      
         (0,61,1,LOCATION OF LT48)                                       
(70,0,ENTRYSIZE,ENTITY REFERENCE VARIABLES)                              
     AN ENTITY REFERENCE VARIABLE MUST INCLUDE:                          
         (0,1,ENTRYSIZE,IDENTIFIER)                                      
         (0,2,1,ADDRESSCOUPLE)                                           
         (0,1,ENTRYSIZE,DATABASE TYPE IDENTIFIER)                        
         (0,69,1,CLASSINFO)                                              
(70,1,ENTRYSIZE,ENTITY REFERENCE ARRAY)                                  
     AN ENTITY REFERENCE ARRAY MUST INCLUDE:                             
         (0,1,N,IDENTIFIER)                                              
         (0,2,1,ADDRESSCOUPLE)                                           
         (0.15,1,NUMBER OF DIMENSIONS)                                   
         (0,16,1,ARRAY LEN-SEGMENTATION ALLOWED) OR                      
           (0,22,1,ARRAY LEN-SEGMENTATION NOT ALLOWED)                   
         (0,61,1,LT48 PTR TO ARRAY DESC)                                 
         (0,1,N,DATABASE TYPE IDENTIFIER)                                
         (0,69,1,CLASSINF0)                                              
(72,0,ENTRYSIZE,QUERY VARIABLES)                                         
     A QUERY VARIABLE MUST INCLUDE:                                      
         (0,1,N,IDENTIFIER)                                              
         (0,2,1,ADDRESSCOUPLE)                                           
         (0,15,1,DIMENSIONS)                                             
             WHERE DIMENSIONS = 1                                        
         (0,16,1,LENGTH)                                                 
         (0,69,1,CLASSINFO)  OR                                          
           (0,70,ENTRYSIZE,DMRECORDINFO)                                 
(74,0,ENTRYSIZE,SDF FORM RECORD LIBRARY APPLICATION RECORD DESCRIPTION)  
      MUST INCLUDE:                                                      
         (0,1,N,IDENTIFIER)                                              
         (0,2,1,ADDRESSCOUPLE)                                           
         (0,74,Constant array disk address and length)                   
(76,SC,ENTRYSIZE,SINGLE ITEM IN SLICE 1-D HEAP)                          
(78,SC,ENTRYSIZE,DOUBLE ITEM IN SLICE 1-D HEAP)                          
(80,SC,ENTRYSIZE,HEX    ITEM IN SLICE 1-D HEAP)                          
(82,SC,ENTRYSIZE,EBCDIC ITEM IN SLICE 1-D HEAP)                          
(84,SC,ENTRYSIZE,SINGLE ITEM IN SLICE 2-D HEAP)                          
(86,SC,ENTRYSIZE,DOUBLE ITEM IN SLICE 2-D HEAP)                          
(88,SC,ENTRYSIZE,HEX    ITEM IN SLICE 2-D HEAP)                          
(90,SC,ENTRYSIZE,EBCDIC ITEM IN SLICE 2-D HEAP)                          
      SLICE HEAP ITEM DESCRIPTIONS (UC 76..90) INCLUDE:                  
         (0,75,1,SLICE HEAP WORDS REQUIRED)

BINDING NEWP

THE BINDINFO ONLY CONTAINS A VERY LIMITED PROGRAM DESCRIPTION (ONLY A PROCEDURE DIRECTORY POINTER), A PROCEDURE DIRECTORY, A LOCAL DIRECTORY FOR THE OUTERBLOCK, AND LOCAL DIRECTORIES FOR BLOCKS THAT IMMEDIATLY CONTAIN EXTERNAL PROCEDURES (THESE INTERNAL LOCAL DIRECTORIES CONTAIN INFORMATION ONLY ABOUT THE EXTERNAL PROC).

THE PROCEDURE DIRECTORY HAS THE 'BIT46' SET FOR ALL PROCEDURES THAT ARE DECLARED EXTERNAL. IT IS ONLY THESE PROCEDURES THAT THE BINDER WILL BIND OR RE-BIND. THE BINDER PRESERVES THIS BIT IN THE BOUND FILE.

IF THERE IS MAKEHOST INFORMATION IN THE HOST FILE THEN THERE IS A SEPCOMP DICTIONARY WITH THE FOLLOWING CONTENTS. IT NEEDS TO BE UPDATED AND COPIED TO THE CODEFILE.

Word	Definition	Updated by Binder	Format	Comments
0	SEPENDOFCODE	YES	INTEGER	COPY HOSTFILE UP TO THIS POINT
1	SEPRD	YES	*	REGION DICTIONARY FOR NEWP SEPCOMP
2	SEPPARAMS	YES	*	PARAMETER DESCRIPTION INFO
3	SEPSEGDICT	YES	*	SEGMENT DICTIONARY
4	SEPLINEINFO	YES	*	LINE INFO DICTIONARY
5	SEPRDSTART	NO	INTEGER	STARTING INDEX IN REGION DICTIONARY
6	SEPTAPEFILE	YES	**	TITLE OF TAPE FILE
7	SEPUSEROPTIONS	NO	***	LIST OF USER OPTIONS SET IN HOST
8	SEPVERSION	NO	INTEGER	HOST'S VERSION
9	SEPFIXEDD0SIZE	NO	INTEGER	SZ OF FIXED PART OF D0STACK
10	SEPOUTERDESCLEN	NO	INTEGER &BINDINFOTOG IN [47:1]	LENGTH OF OUTER PROC. DESCRIPTION ****
11	SEPMCPSEG1	NO		MCP SEGMENT 1
12	SEPMCPSEG5	NO		MCP SEGMENT 5
13	SEPMCPSEG6	NO		MCP SEGMENT 6
14	SEPMODSTACKLIST	YES	*	MODSTACKLIST ARRAY IF THERE IS ONE, ZERO OTHERWISE
29	SEPLEVEL	NO	STRUCTURE	FIELDS DESCRIBED BELOW
	SEPINFOLEVEL	[23:24]		LEVEL OF SEPCOMP INFO

*	SEPDISKADDR = STARTING DISK SEGMENT ADDRESS. SEPLEN = LENGTH IN WORDS.
**	SEPDISKADDR = STARTING DISK SEGMENT ADDRESS. SEPLEN = NUMBER OF SEGMENTS.
***	SEPDISKADDR = STARTING DISK SEGMENT ADDRESS. SEPLEN = NUMBER OF VARIABLE LENGTH ENTRIES.
****	IF BINDINFOTOG THEN PROC DIR KEYWORD FOLLOWS OUTER PROC DESCRIPTION AND OCCURS AT THIS OFFSET IN PROGRAM DESCRIPTION.

IF PSEUDO SEG0[29].[47:1] IS OFF THEN THERE IS MAKEHOST INFORMATION IN THE HOSTFILE. THE REST OF THE WORD CONTAINS THE SEGMENT NUMBER OF THE SEPCOMP DICTIONARY. IF PSEUDO SEG0[29].[47:1] IS ON THEN THERE IS NO MAKEHOST INFORMATION IN THE HOSTFILE. THE REST OF THE WORD CONTAINS THE NUMBER OF SEGMENTS TO COPY DIRECTLY TO THE CODEFILE FROM THE HOST FILE. (THIS VALUE WILL BE IN WORD 0 OF THE SEPCOMP DICTIONARY IF THERE IS MAKEHOST INFORMATION.) THESE SEGMENTS CONTAIN THE BOOTSTRAP, PSUEDO SEG0 (WHICH IS ALWAYS IN SEGMENT NO. 1), MAKEHOST INFO IF THERE IS ANY AND ANY CODE, LINEINFO, EXTERNAL DESCRIPTIONS, POOLS, ETC. THAT WHERE GENERATED.

DEFINITIONS
BLOCK PROGRAM	ALGOL-A PROGRAM WITH AN OUTER BLOCK. COBOL-A PROGRAM INCLUDING A DATA DIVISION. FORTRAN-A PROGRAM INCLUDING THE MAIN PROGRAM.
PROCEDURE PROGRAM	ALGOL - A PROGRAM CONSISTING OF ONE PROCEDURE WITH OR WITHOUT NESTED PROCEDURES. COBOL - FORTRAN - A PROGRAM CONSISTING OF ONE SUBROUTINE OR FUNCTION.
EXTERNAL PROCEDURE	ALGOL-A PROCEDURE DECLARED EXTERNAL COBOL- FORTRAN-A SUBROUTINE OR FUNCTION WHICH WAS REFERENCED BUT NOT FOUND.