COMPILATION LISTING OF SEGMENT call_op
	Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983
	Compiled at: Honeywell LCPD Phoenix, System M
	Compiled on: 10/03/83  1623.8 mst Mon
	    Options: optimize map

        1 /* ***********************************************************
        2*   *                                                         *
        3*   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        4*   *                                                         *
        5*   * Copyright (c) 1972 by Massachusetts Institute of        *
        6*   * Technology and Honeywell Information Systems, Inc.      *
        7*   *                                                         *
        8*   *********************************************************** */
        9 
       10 
       11 /* procedure to compile calls
       12*
       13*   Initial Version: 16 April 1971 by BLW for Version II
       14*	Modified:  5 November 1972 by BLW	
       15*	Modified:	15 February 1973 by RAB
       16*	Modified:	25 June 1973 by RAB	
       17*	Modified: 2 August 1974 by RAB for constant arg list calls
       18*	Modified:	16 November 1974 by RAB to fix bug 1232
       19*	Modified:	17 November 1974 by RAB to fix bug 1255
       20*	Modified:	12 December 1975 by RAB to remove call to state_man$erase_reg
       21*	Modified:	23 June 1976 by RAB to centralize use of cg_stat$last_call
       22*	Modified:	10 September 1977 by RAB to fix 1613 by adding 3rd arg to store_bit_address
       23*	Modified: 23 April 1979 by PCK to implement 4-bit decimal 
       24*	Modified: 23 June 1981 by EBush to increase max size of arg lists 
       25*	Modified: 11 September 81 by EBush to add prepare_call_long and 
       26*		prepare_quick_call_long macros.  */
       27 
       28 call_op:	proc(pt) returns(ptr);
       29 
       30 dcl	pt ptr;		/* points at call operator node */
       31 
       32 dcl	(cg_stat$cur_tree,cg_stat$double_temp,cg_stat$temp_ref,cg_stat$cur_node) ptr ext,
       33 	cg_stat$cur_block ptr ext,
       34 	cg_stat$text_pos fixed bin(18) ext,
       35 	cg_stat$cur_level fixed bin ext;
       36 
       37 dcl	(p,q,node_pt,ret_pt,ent_pt,sal_pt,arglist,ap,p2,p2s,p3,
       38 	arg(3),args,descs,ent_blk,save_cur_node) ptr,
       39 	(i,j,n,skip,ent_type,n_args,arg_pos,dt) fixed bin,
       40 	(macro1,macro2) fixed bin(15),
       41 	last_freed fixed bin(18),
       42 	arg_list_extent fixed bin(35),
       43 	xr fixed bin(3),
       44 	(atom,useless,quick,reset,use_itp) bit(1) aligned;
       45 
       46 dcl	prepare_operand entry(ptr,fixed bin,bit(1) aligned) returns(ptr),
       47 	expmac entry(fixed bin(15),ptr),
       48 	copy_temp entry(ptr) returns(ptr),
       49 	(stack_temp$assign_temp,stack_temp$free_temp) entry(ptr),
       50 	compile_exp$save entry(ptr) returns(ptr),
       51 	compile_exp$save_exp entry(ptr) returns(ptr),
       52 	(compile_exp,load_size) entry(ptr);
       53 dcl	compare_expression entry(ptr,ptr) returns(bit(1) aligned) reducible;
       54 dcl	share_expression entry(ptr) returns(ptr),
       55 	base_man$store_ptr_to entry(ptr,ptr),
       56 	store_bit_address entry(ptr,ptr,fixed bin(18)),
       57 	base_man$load_var entry(fixed bin,ptr,fixed bin),
       58 	c_a entry(fixed bin,fixed bin) returns(ptr),
       59 	(long_op$extend_stack,adjust_ref_count) entry(ptr,fixed bin(15)),
       60 	store$save_string_temp entry(ptr),
       61 	long_op$c_or_b entry(ptr,fixed bin,fixed bin(15)),
       62 	need_temp entry(ptr,bit(2) aligned),
       63 	xr_man$load_any_const entry(fixed bin,fixed bin(3)),
       64 	xr_man$load_const entry(fixed bin,fixed bin),
       65 	xr_man$super_lock entry(fixed bin),
       66 	m_a entry(ptr,bit(2) aligned),
       67 	expmac$zero entry(fixed bin(15)),
       68 	expmac$many entry(fixed bin(15),ptr,fixed bin),
       69 	state_man$flush entry,
       70 	state_man$flush_address entry(ptr),
       71 	cg_error entry(fixed bin,fixed bin),
       72 	generate_constant$relocatable entry(ptr,fixed bin,bit(1) aligned) returns(ptr);
       73 
       74 dcl	(addr,bit,fixed,hbound,null,substr) builtin;
       75 
       76 dcl (	call_ent_var	init(230),
       77 	zero_mac		init(308),
       78 	lda		init(1),
       79 	alloc_char_temp	init(89),
       80 	realloc_char_temp	init(92),
       81 	prepare_call	init(362),
       82 	prepare_quick_call	init(363),
       83 	prepare_call_long   init(741),
       84 	prepare_quick_call_long  init(742),
       85 	quick_call	init(367)) fixed bin(15) int static;
       86 
  1     1 /* BEGIN INCLUDE FILE ... cg_reference.incl.pl1 */
  1     2 
  1     3 dcl	1 reference		based aligned,
  1     4 	2 node_type		bit(9) unaligned,
  1     5 	2 array_ref		bit(1) unaligned,
  1     6 	2 varying_ref		bit(1) unaligned,
  1     7 	2 shared			bit(1) unaligned,
  1     8 	2 put_data_sw		bit(1) unaligned,
  1     9 	2 processed		bit(1) unaligned,
  1    10 	2 units			fixed(3) unaligned,
  1    11 	2 ref_count		fixed(17) unaligned,
  1    12 	2 c_offset		fixed(24),
  1    13 	2 c_length		fixed(24),
  1    14 	2 symbol			ptr unaligned,
  1    15 	2 qualifier		ptr unaligned,
  1    16 	2 offset			ptr unaligned,
  1    17 	2 length			ptr unaligned,
  1    18 						/* these fields are used by the 645 code generator */
  1    19 	2 c_f_offset		fixed bin(6),
  1    20 	2 address			structure unaligned,
  1    21 	  3 base			bit(3),
  1    22 	  3 offset		bit(15),
  1    23 	  3 op			bit(9),
  1    24 	  3 no_address		bit(1),
  1    25 	  3 inhibit		bit(1),
  1    26 	  3 ext_base		bit(1),
  1    27 	  3 tag			bit(6),
  1    28 	2 info			structure unaligned,
  1    29 	  3 address_in		structure,
  1    30 	    4 b			dimension(0:7) bit(1),
  1    31 	    4 storage		bit(1),
  1    32 	  3 value_in		structure,
  1    33 	    4 a			bit(1),
  1    34 	    4 q			bit(1),
  1    35 	    4 aq			bit(1),
  1    36 	    4 string_aq		bit(1),
  1    37 	    4 complex_aq		bit(1),
  1    38 	    4 decimal_aq		bit(1),
  1    39 	    4 b			dimension(0:7) bit(1),
  1    40 	    4 storage		bit(1),
  1    41 	    4 indicators		bit(1),
  1    42 	    4 x			dimension(0:7) bit(1),
  1    43 	  3 other			structure,
  1    44 	    4 big_offset		bit(1),
  1    45 	    4 big_length		bit(1),
  1    46 	    4 modword_in_offset	bit(1),
  1    47 	2 data_type		fixed(5) unaligned,
  1    48 	2 bits			structure unaligned,
  1    49 	  3 padded_ref		bit(1),
  1    50 	  3 aligned_ref		bit(1),
  1    51 	  3 long_ref		bit(1),
  1    52 	  3 forward_ref		bit(1),
  1    53 	  3 ic_ref		bit(1),
  1    54 	  3 temp_ref		bit(1),
  1    55 	  3 defined_ref		bit(1),
  1    56 	  3 evaluated		bit(1),
  1    57 	  3 allocate		bit(1),
  1    58 	  3 allocated		bit(1),
  1    59 	  3 aliasable		bit(1),
  1    60 	  3 even			bit(1),
  1    61 	  3 perm_address		bit(1),
  1    62 	  3 aggregate		bit(1),
  1    63 	  3 hit_zero		bit(1),
  1    64 	  3 dont_save		bit(1),
  1    65 	  3 fo_in_qual		bit(1),
  1    66 	  3 hard_to_load		bit(1),
  1    67 	2 relocation		bit(12) unaligned,
  1    68 	2 more_bits		structure unaligned,
  1    69 	  3 substr		bit(1),
  1    70 	  3 padded_for_store_ref	bit(1),
  1    71 	  3 aligned_for_store_ref	bit(1),
  1    72 	  3 mbz			bit(15),
  1    73 	2 store_ins		bit(18) unaligned;
  1    74 
  1    75 /* END INCLUDE FILE ... cg_reference.incl.pl1 */
       87 
  2     1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */
  2     2 
  2     3 /*	Modified: 2 Apr 1980 by PCK to add max_number_of_operands */
  2     4 
  2     5 /* format: style3 */
  2     6 dcl	1 operator	based aligned,
  2     7 	  2 node_type	bit (9) unaligned,
  2     8 	  2 op_code	bit (9) unaligned,
  2     9 	  2 shared	bit (1) unaligned,
  2    10 	  2 processed	bit (1) unaligned,
  2    11 	  2 optimized	bit (1) unaligned,
  2    12 	  2 number	fixed (14) unaligned,
  2    13 	  2 operand	dimension (n refer (operator.number)) ptr unaligned;
  2    14 
  2    15 dcl	max_number_of_operands
  2    16 			fixed bin (15) int static options (constant) initial (32767);
  2    17 
  2    18 /* END INCLUDE FILE ... operator.incl.pl1 */
       88 
  3     1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */
  3     2 
  3     3 /* Modified 26 June 81 by EBush to add max_list_elements */
  3     4 
  3     5 
  3     6 dcl	1 list		based aligned,
  3     7 	2 node_type	bit(9) unaligned,
  3     8 	2 reserved	bit(12) unaligned,
  3     9 	2 number		fixed(14) unaligned,
  3    10 	2 element		dimension(n refer(list.number)) ptr unaligned;
  3    11 
  3    12 dcl       max_list_elements   fixed bin(17) internal static options (constant)
  3    13 	                    init(16383);
  3    14 
  3    15 /* END INCLUDE FILE ... list.incl.pl1 */
       89 
  4     1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */
  4     2 
  4     3 dcl	1 symbol			based aligned,
  4     4 	2 node_type		bit(9) unal,
  4     5 	2 source_id		structure unal,
  4     6 	  3 file_number		bit(8),
  4     7 	  3 line_number		bit(14),
  4     8 	  3 statement_number	bit(5),
  4     9 	2 location		fixed(18) unal unsigned,
  4    10 	2 allocated		bit(1) unal,
  4    11 	2 dcl_type		bit(3) unal,
  4    12 	2 reserved		bit(6) unal,
  4    13 	2 pix			unal,
  4    14 	  3 pic_fixed		bit(1) unal,
  4    15 	  3 pic_float		bit(1) unal,
  4    16 	  3 pic_char		bit(1) unal,
  4    17 	  3 pic_scale		fixed(7) unal,
  4    18 	  3 pic_size		fixed(7) unal,
  4    19 	2 level			fixed(8) unal,
  4    20 	2 boundary		fixed(3) unal,
  4    21 	2 size_units		fixed(3) unal,
  4    22 	2 scale			fixed(7) unal,
  4    23 	2 runtime			bit(18) unal,
  4    24 	2 runtime_offset		bit(18) unal,
  4    25 	2 block_node		ptr unal,
  4    26 	2 token			ptr unal,
  4    27 	2 next			ptr unal,
  4    28 	2 multi_use		ptr unal,
  4    29 	2 cross_references		ptr unal,
  4    30 	2 initial			ptr unal,
  4    31 	2 array			ptr unal,
  4    32 	2 descriptor		ptr unal,
  4    33 	2 equivalence		ptr unal,
  4    34 	2 reference		ptr unal,
  4    35 	2 general			ptr unal,
  4    36 	2 father			ptr unal,
  4    37 	2 brother			ptr unal,
  4    38 	2 son			ptr unal,
  4    39 	2 word_size		ptr unal,
  4    40 	2 bit_size		ptr unal,
  4    41 	2 dcl_size		ptr unal,
  4    42 	2 symtab_size		ptr unal,
  4    43 	2 c_word_size		fixed(24),
  4    44 	2 c_bit_size		fixed(24),
  4    45 	2 c_dcl_size		fixed(24),
  4    46 
  4    47 	2 attributes		structure aligned,
  4    48 	  3 data_type		structure unal,
  4    49 	    4 structure		bit(1) ,
  4    50 	    4 fixed		bit(1),
  4    51 	    4 float		bit(1),
  4    52 	    4 bit			bit(1),
  4    53 	    4 char		bit(1),
  4    54 	    4 ptr			bit(1),
  4    55 	    4 offset		bit(1),
  4    56 	    4 area		bit(1),
  4    57 	    4 label		bit(1),
  4    58 	    4 entry		bit(1),
  4    59 	    4 file		bit(1),
  4    60 	    4 arg_descriptor	bit(1),
  4    61 	    4 storage_block		bit(1),
  4    62 	    4 explicit_packed	bit(1), /* options(packed) */
  4    63 	    4 condition		bit(1),
  4    64 	    4 format		bit(1),
  4    65 	    4 builtin		bit(1),
  4    66 	    4 generic		bit(1),
  4    67 	    4 picture		bit(1),
  4    68 
  4    69 	  3 misc_attributes		structure unal,
  4    70 	    4 dimensioned		bit(1),
  4    71 	    4 initialed		bit(1),
  4    72 	    4 aligned		bit(1),
  4    73 	    4 unaligned		bit(1),
  4    74 	    4 signed		bit(1),
  4    75 	    4 unsigned		bit(1),
  4    76 	    4 precision		bit(1),
  4    77 	    4 varying		bit(1),
  4    78 	    4 local		bit(1),
  4    79 	    4 decimal		bit(1),
  4    80 	    4 binary		bit(1),
  4    81 	    4 real		bit(1),
  4    82 	    4 complex		bit(1),
  4    83 	    4 variable		bit(1),
  4    84 	    4 reducible		bit(1),
  4    85 	    4 irreducible		bit(1),
  4    86 	    4 returns		bit(1),
  4    87 	    4 position		bit(1),
  4    88 	    4 internal		bit(1),
  4    89 	    4 external		bit(1),
  4    90 	    4 like		bit(1),
  4    91 	    4 member		bit(1),
  4    92 	    4 non_varying		bit(1),
  4    93 	    4 options		bit(1),
  4    94 	    4 variable_arg_list 	bit(1),		/* options(variable) */
  4    95 	    4 alloc_in_text		bit(1),		/* options(constant) */
  4    96 
  4    97 	  3 storage_class		structure unal,
  4    98 	    4 auto		bit(1),
  4    99 	    4 based		bit(1),
  4   100 	    4 static		bit(1),
  4   101 	    4 controlled		bit(1),
  4   102 	    4 defined		bit(1),
  4   103 	    4 parameter		bit(1),
  4   104 	    4 param_desc		bit(1),
  4   105 	    4 constant		bit(1),
  4   106 	    4 temporary		bit(1),
  4   107 	    4 return_value		bit(1),
  4   108 
  4   109 	  3 file_attributes		structure unal,
  4   110 	    4 print		bit(1),
  4   111 	    4 input		bit(1),
  4   112 	    4 output		bit(1),
  4   113 	    4 update		bit(1),
  4   114 	    4 stream		bit(1),
  4   115 	    4 reserved_1		bit(1),
  4   116 	    4 record		bit(1),
  4   117 	    4 sequential		bit(1),
  4   118 	    4 direct		bit(1),
  4   119 	    4 interactive		bit(1),		/* env(interactive) */
  4   120 	    4 reserved_2		bit(1),
  4   121 	    4 reserved_3		bit(1),
  4   122 	    4 stringvalue		bit(1),		/* env(stringvalue) */
  4   123 	    4 keyed		bit(1),
  4   124 	    4 reserved_4		bit(1),
  4   125 	    4 environment		bit(1),
  4   126 
  4   127 	  3 compiler_developed	structure unal,
  4   128 	    4 aliasable		bit(1),
  4   129 	    4 packed		bit(1),
  4   130 	    4 passed_as_arg		bit(1),
  4   131 	    4 allocate		bit(1),
  4   132 	    4 set			bit(1),
  4   133 	    4 exp_extents		bit(1),
  4   134 	    4 refer_extents		bit(1),
  4   135 	    4 star_extents		bit(1),
  4   136 	    4 isub		bit(1),
  4   137 	    4 put_in_symtab		bit(1),
  4   138 	    4 contiguous		bit(1),
  4   139 	    4 put_data		bit(1),
  4   140 	    4 overlayed		bit(1),
  4   141 	    4 error		bit(1),
  4   142 	    4 symtab_processed	bit(1),
  4   143 	    4 overlayed_by_builtin	bit(1),
  4   144 	    4 defaulted		bit(1),
  4   145 	    4 connected		bit(1);
  4   146 
  4   147 /* END INCLUDE FILE ... symbol.incl.pl1 */
       90 
  5     1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */
  5     2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */
  5     3 /* format: style3,idind30 */
  5     4 
  5     5 declare	1 block			aligned based,
  5     6 	  2 node_type		bit (9) unaligned,
  5     7 	  2 source_id		structure unaligned,
  5     8 	    3 file_number		bit (8),
  5     9 	    3 line_number		bit (14),
  5    10 	    3 statement_number	bit (5),
  5    11 	  2 father		ptr unaligned,
  5    12 	  2 brother		ptr unaligned,
  5    13 	  2 son			ptr unaligned,
  5    14 	  2 declaration		ptr unaligned,
  5    15 	  2 end_declaration		ptr unaligned,
  5    16 	  2 default		ptr unaligned,
  5    17 	  2 end_default		ptr unaligned,
  5    18 	  2 context		ptr unaligned,
  5    19 	  2 prologue		ptr unaligned,
  5    20 	  2 end_prologue		ptr unaligned,
  5    21 	  2 main			ptr unaligned,
  5    22 	  2 end_main		ptr unaligned,
  5    23 	  2 return_values		ptr unaligned,
  5    24 	  2 return_count		ptr unaligned,
  5    25 	  2 plio_ps		ptr unaligned,
  5    26 	  2 plio_fa		ptr unaligned,
  5    27 	  2 plio_ffsb		ptr unaligned,
  5    28 	  2 plio_ssl		ptr unaligned,
  5    29 	  2 plio_fab2		ptr unaligned,
  5    30 	  2 block_type		bit (9) unaligned,
  5    31 	  2 prefix		bit (12) unaligned,
  5    32 	  2 like_attribute		bit (1) unaligned,
  5    33 	  2 no_stack		bit (1) unaligned,
  5    34 	  2 get_data		bit (1) unaligned,
  5    35 	  2 flush_at_call		bit (1) unaligned,
  5    36 	  2 processed		bit (1) unaligned,
  5    37 	  2 text_displayed		bit (1) unaligned,
  5    38 	  2 number		fixed bin (9) unsigned unaligned,
  5    39 	  2 free_temps		dimension (3) ptr,	/* these fields are used by the code generator */
  5    40 	  2 temp_list		ptr,
  5    41 	  2 entry_list		ptr,
  5    42 	  2 o_and_s		ptr,
  5    43 	  2 why_nonquick		aligned,
  5    44 	    3 auto_adjustable_storage bit (1) unaligned,
  5    45 	    3 returns_star_extents	bit (1) unaligned,
  5    46 	    3 stack_extended_by_args	bit (1) unaligned,
  5    47 	    3 invoked_by_format	bit (1) unaligned,
  5    48 	    3 format_statement	bit (1) unaligned,
  5    49 	    3 io_statements		bit (1) unaligned,
  5    50 	    3 assigned_to_entry_var	bit (1) unaligned,
  5    51 	    3 condition_statements	bit (1) unaligned,
  5    52 	    3 no_owner		bit (1) unaligned,
  5    53 	    3 recursive_call	bit (1) unaligned,
  5    54 	    3 options_non_quick	bit (1) unaligned,
  5    55 	    3 options_variable	bit (1) unaligned,
  5    56 	    3 never_referenced	bit (1) unaligned,
  5    57 	    3 pad_nonquick		bit (5) unaligned,
  5    58 	  2 prologue_flag		bit (1) unaligned,
  5    59 	  2 options_main		bit (1) unaligned,
  5    60 	  2 pad			bit (16) unaligned,
  5    61 	  2 number_of_entries	fixed bin (17),
  5    62 	  2 level			fixed bin (17),
  5    63 	  2 last_auto_loc		fixed bin (17),
  5    64 	  2 symbol_block		fixed bin (17),
  5    65 	  2 entry_info		fixed bin (18),
  5    66 	  2 enter			structure unaligned,
  5    67 	    3 start		fixed bin (17),
  5    68 	    3 end			fixed bin (17),
  5    69 	  2 leave			structure unaligned,
  5    70 	    3 start		fixed bin (17),
  5    71 	    3 end			fixed bin (17),
  5    72 	  2 owner			ptr;
  5    73 
  5    74 declare	max_block_number		fixed bin internal static options (constant) initial (511);
  5    75 
  5    76 /* END INCLUDE FILE ... block.incl.pl1 */
       91 
  6     1 /* BEGIN INCLUDE FILE ... temporary.incl.pl1 */
  6     2 
  6     3 dcl	1 temporary	based,
  6     4 	2 node_type	bit(9),	/* type is "000001010"b */
  6     5 	2 size		fixed bin(18),
  6     6 	2 next		ptr,
  6     7 	2 location	fixed bin(18),
  6     8 	2 ref_count	fixed bin,
  6     9 	2 symbol		ptr unal,
  6    10 	2 last_freed	fixed bin(18);
  6    11 
  6    12 /* END INCLUDE FILE ... temporary.incl.pl1 */
       92 
  7     1 dcl (	real_fix_bin_1		init(1),
  7     2 	real_fix_bin_2		init(2),
  7     3 	real_flt_bin_1		init(3),
  7     4 	real_flt_bin_2		init(4),
  7     5 	complex_fix_bin_1		init(5),
  7     6 	complex_fix_bin_2		init(6),
  7     7 	complex_flt_bin_1		init(7),
  7     8 	complex_flt_bin_2		init(8),
  7     9 	real_fix_dec		init(9),
  7    10 	real_flt_dec		init(10),
  7    11 	complex_fix_dec		init(11),
  7    12 	complex_flt_dec		init(12),
  7    13 	char_string		init(13),
  7    14 	bit_string		init(14),
  7    15 	label_constant		init(15),
  7    16 	local_label_variable	init(16),
  7    17 	label_variable		init(17),
  7    18 	entry_variable		init(18),
  7    19 	ext_entry_in		init(19),
  7    20 	ext_entry_out		init(20),
  7    21 	int_entry			init(21),
  7    22 	int_entry_other		init(22),
  7    23 	unpacked_ptr		init(23),
  7    24 	packed_ptr		init(24)) fixed bin(15) int static options(constant);
       93 
  8     1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */
  8     2 
  8     3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */
  8     4 /* Modified: 6 Jun 1979 by PG to add rank and byte */
  8     5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */
  8     6 /* Modified: 26 July 82 BIM wordno, segno */
  8     7 
  8     8 dcl (	add		initial("000010001"b),	/* opnd(1) <- opnd(2)+opnd(3)		*/
  8     9 	sub		initial("000010010"b),	/* opnd(1) <- opnd(2)-opnd(3)		*/
  8    10 	mult		initial("000010011"b),	/* opnd(1) <- opnd(2)*opnd(3)		*/
  8    11 	div		initial("000010100"b),	/* opnd(1) <- opnd(2)/opnd(3)		*/
  8    12 	negate		initial("000010101"b),	/* opnd(1) <- -opnd(2)  		*/
  8    13 	exp		initial("000010110"b),	/* opnd(1) <- opnd(2) ** opnd(3)	*/
  8    14 
  8    15 	and_bits		initial("000100001"b),	/* opnd(1) <- opnd(2) & opnd(3)	*/
  8    16 	or_bits		initial("000100010"b),	/* opnd(1) <- opnd(2)|opnd(3)		*/
  8    17 	xor_bits		initial("000100011"b),	/* opnd(1) <- opnd(2) xor opnd(3)	*/
  8    18 	not_bits		initial("000100100"b),	/* opnd(1) <- ^opnd(2)		*/
  8    19 	cat_string	initial("000100101"b),	/* opnd(1) <- opnd(2)||opnd(3)	*/
  8    20 	bool_fun		initial("000100110"b),	/* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */
  8    21 
  8    22 	assign		initial("000110001"b),	/* opnd(1) <- opnd(2)		*/
  8    23 	assign_size_ck	initial("000110010"b),	/* opnd(1) <- opnd(2)		*/
  8    24 	assign_zero	initial("000110011"b),	/* opnd(1) <- 0			*/
  8    25 	copy_words	initial("000110100"b),	/* move opnd(2) to opnd(1) by opnd(3) words */
  8    26 	copy_string	initial("000110101"b),	/* move opnd(2) to opnd(1) by opnd(3) units */
  8    27 	make_desc		initial("000110110"b),	/* opnd(1) <- descriptor(opnd(2),opnd(3)) */
  8    28 	assign_round	initial("000110111"b),	/* opnd(1) <- opnd(2) rounded		*/
  8    29 	pack		initial("000111000"b),	/* opnd(1) <- encode to picture opnd(2) */
  8    30 	unpack		initial("000111001"b),	/* opnd(1) <- decode from picture opnd(2) */
  8    31 
  8    32 	less_than		initial("001000100"b),	/* opnd(1) <- opnd(2) < opnd(3)	*/
  8    33 	greater_than	initial("001000101"b),	/* opnd(1) <- opnd(2) > opnd(3)	*/
  8    34 	equal		initial("001000110"b),	/* opnd(1) <- opnd(2) = opnd(3)	*/
  8    35 	not_equal		initial("001000111"b),	/* opnd(1) <- opnd(2) ^= opnd(3)	*/
  8    36 	less_or_equal	initial("001001000"b),	/* opnd(1) <- opnd(2) <= opnd(3)	*/
  8    37 	greater_or_equal	initial("001001001"b),	/* opnd(1) <- opnd(2) >= opnd(3)	*/
  8    38 
  8    39 	jump		initial("001010001"b),	/* go to opnd(1) unconditionally	*/
  8    40 	jump_true		initial("001010010"b),	/* go to opnd(1) if opnd(2) is not 0	*/
  8    41 	jump_false	initial("001010011"b),	/* go to opnd(1) if opnd(2) is all 0	*/
  8    42 	jump_if_lt	initial("001010100"b),	/* go to opnd(1) if opnd(2) < opnd(3)	*/
  8    43 	jump_if_gt	initial("001010101"b),	/* go to opnd(1) if opnd(2) > opnd(3)	*/
  8    44 	jump_if_eq	initial("001010110"b),	/* go to opnd(1) if opnd(2) = opnd(3)	*/
  8    45 	jump_if_ne	initial("001010111"b),	/* go to opnd(1) if opnd(2) ^= opnd(3)	*/
  8    46 	jump_if_le	initial("001011000"b),	/* go to opnd(1) if opnd(2) <= opnd(3)	*/
  8    47 	jump_if_ge	initial("001011001"b),	/* go to opnd(1) if opnd(2) >= opnd(3)	*/
  8    48 
  8    49 	std_arg_list	initial("001100001"b),	/* opnd(1) <- arglist(opnd(2) desclist(opnd(3)))	*/
  8    50 	return_words	initial("001100010"b),	/* return aggregate opnd(1), opnd(2) is length in words */
  8    51 	std_call		initial("001100011"b),	/* opnd(1) <- call opnd(2) with opnd(3)		*/
  8    52 	return_bits	initial("001100100"b),	/* return aggregate opnd(1), opnd(2) is length in bits */
  8    53 	std_entry		initial("001100101"b),	/* entry(opnd(1)... opnd(n))			*/
  8    54 	return_string	initial("001100110"b),	/* return string opnd(1) */
  8    55 	ex_prologue	initial("001100111"b),	/* execute the prologue -no operands-		*/
  8    56 	allot_auto	initial("001101000"b),	/* opnd(1) <- addrel(stack,opnd(2))		*/
  8    57 	param_ptr		initial("001101001"b),	/* opnd(1) <- ptr to opnd(2) in  block opnd(3)	*/
  8    58 	param_desc_ptr	initial("001101010"b),	/* opnd(1) <- ptr to opnd(2) in block opnd(3)	*/
  8    59 	std_return	initial("001101011"b),	/* return -no arguments-			*/
  8    60 	allot_ctl		initial("001101100"b),	/* allocate opnd(1) , length in words is opnd(2) 	*/
  8    61 	free_ctl		initial("001101101"b),	/* free opnd(1)				*/
  8    62 	stop		initial("001101110"b),	/* stop - terminate run unit			*/
  8    63 
  8    64 	mod_bit		initial("001110000"b),	/* opnd(1) <- mod(opnd(3),36),
  8    65*						   opnd(2) <- opnd(3) / 36		*/
  8    66 	mod_byte		initial("001110001"b),	/* opnd(1) <- mod(opnd(3),4),
  8    67*						   opnd(2) <- opnd(3) / 4		*/
  8    68 	mod_half		initial("001110010"b),	/* opnd(1) <- mod(opnd(3),2),
  8    69*						   opnd(2) <- opnd(3) / 2		*/
  8    70 	mod_word		initial("001110011"b),	/* TO BE DEFINED BY BLW			*/
  8    71 
  8    72 	bit_to_char	initial("010000000"b),	/* opnd(1) <- (opnd(2)+8)/9		*/
  8    73 	bit_to_word	initial("010000001"b),	/* opnd(1) <- (opnd(2)+35)/36		*/
  8    74 	char_to_word	initial("010000010"b),	/* opnd(1) <- (opnd(2)+3)/4		*/
  8    75 	half_to_word	initial("010000011"b),	/* opnd(1) <- (opnd(2)+1)/2		*/
  8    76 	word_to_mod2	initial("010000100"b),	/* opnd(1) <- (opnd(2)+1)/2*2		*/
  8    77 	word_to_mod4	initial("010000101"b),	/* opnd(1) <- (opnd(2)+3)/4*4		*/
  8    78 	word_to_mod8	initial("010000110"b),	/* opnd(1) <- (opnd(2)+7)/8*8		*/
  8    79 	rel_fun		initial("010000111"b),	/* opnd(1) <- rel(opnd(2))		*/
  8    80 	baseno_fun	initial("010001000"b),	/* opnd(1) <- baseno(opnd(2))		*/
  8    81 	desc_size		initial("010001001"b),	/* opnd(1) <- substr(opnd(2),13,24)	*/
  8    82 	bit_pointer	initial("010001010"b),	/* opnd(1) <- bit offset of opnd(2)	*/
  8    83 	index_before_fun	initial("010001011"b),	/* opnd(1) <- length of before(opnd(2),opnd(3)) */
  8    84 	index_after_fun	initial("010001100"b),	/* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */
  8    85 	verify_ltrim_fun	initial("010001101"b),	/* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */
  8    86 	verify_rtrim_fun	initial("010001110"b),	/* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */
  8    87 	digit_to_bit	initial("010001111"b),	/* opnd(1) <- 9*opnd(2)/2		*/
  8    88 
  8    89 	ceil_fun		initial("010010000"b),	/* opnd(1) <- ceil(opnd(2))		*/
  8    90 	floor_fun		initial("010010001"b),	/* opnd(1) <- floor(opnd(2))		*/
  8    91 	round_fun		initial("010010010"b),	/* opnd(1) <- round(opnd(2))		*/
  8    92 	sign_fun		initial("010010011"b),	/* opnd(1) <- sign(opnd(2))		*/
  8    93 	abs_fun		initial("010010100"b),	/* opnd(1) <- abs(opnd(2))		*/
  8    94 	trunc_fun		initial("010010101"b),	/* opnd(1) <- trunc(opnd(2))		*/
  8    95 	byte_fun		initial("010010110"b),	/* opnd(1) <- byte(opnd(2))		*/
  8    96 	rank_fun		initial("010010111"b),	/* opnd(1) <- rank(opnd(2))		*/
  8    97 	index_rev_fun	initial("010011000"b),	/* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */
  8    98 	search_rev_fun	initial("010011001"b),	/* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */
  8    99 	verify_rev_fun	initial("010011010"b),	/* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */
  8   100 	wordno_fun	initial("010011011"b),        /* opnd(1) <- wordno (opnd(2)) */
  8   101 	segno_fun		initial("010011100"b),        /* opnd(1) <- segno (opnd(2)) */
  8   102 	bitno_fun           initial("010011101"b),        /* opnd(1) <- bitno (opnd(2)) */
  8   103 	charno_fun	initial("010011110"b),        /* opnd(1) <- charno (opnd(2)) */
  8   104 
  8   105 	index_fun		initial("010100000"b),	/* opnd(1) <- index(opnd(2),opnd(3))	*/
  8   106 	off_fun		initial("010100001"b),	/* opnd(1) <- offset(opnd(2),opnd(3))	*/
  8   107 	complex_fun	initial("010100010"b),	/* opnd(1) <- complex(opnd(2),opnd(3))	*/
  8   108 	conjg_fun		initial("010100011"b),	/* opnd(1) <- conjg(opnd(2),opnd(3))	*/
  8   109 	mod_fun		initial("010100100"b),	/* opnd(1) <- mod(opnd(2),opnd(3))	*/
  8   110 	repeat_fun	initial("010100101"b),	/* opnd(1) <- repeat(opnd(2),opnd(3))	*/
  8   111 	verify_fun	initial("010100110"b),	/* opnd(1) <- verify(opnd(2),opnd(3))	*/
  8   112 	translate_fun	initial("010100111"b),	/* opnd(1) <- translate(opnd(2),opnd(3))*/
  8   113 	real_fun   	initial("010101001"b),	/* opnd(1) <- real(opnd(2))		*/
  8   114 	imag_fun   	initial("010101010"b),	/* opnd(1) <- imag(opnd(2))		*/
  8   115 	length_fun	initial("010101011"b),	/* opnd(1) <- length(opnd(2))	*/
  8   116 	pl1_mod_fun	initial("010101100"b),	/* opnd(1) <- mod(opnd(2)) */
  8   117 	search_fun	initial("010101101"b),	/* opnd(1) <- search(opnd(2),opnd(3)) */
  8   118 	allocation_fun	initial("010101110"b),	/* opnd(1) <- allocation(opnd(2)) */
  8   119 	reverse_fun	initial("010101111"b),	/* opnd(1) <- reverse(opnd(2)) */
  8   120 
  8   121 	addr_fun		initial("010110000"b),	/* opnd(1) <- addr(opnd(2))		*/
  8   122 	addr_fun_bits	initial("010110001"b),	/* opnd(1) <- addr(opnd(2))		*/
  8   123 	ptr_fun		initial("010110010"b),	/* opnd(1) <- ptr(opnd(2),opnd(3))	*/
  8   124 	baseptr_fun	initial("010110011"b),	/* opnd(1) <- baseptr(opnd(2))	*/
  8   125 	addrel_fun	initial("010110100"b),	/* opnd(1) <- addrel(opnd(2),opnd(3))	*/
  8   126 	codeptr_fun	initial("010110101"b),	/* opnd(1) <- codeptr(opnd(2))	*/
  8   127 	environmentptr_fun	initial("010110110"b),	/* opnd(1) <- environmentptr(opnd(2))	*/
  8   128 	stackbaseptr_fun	initial("010110111"b),	/* opnd(1) is ptr to base of current stack	*/
  8   129 	stackframeptr_fun	initial("010111000"b),	/* opnd(1) is ptr to current block's stack frame	*/
  8   130 	setcharno_fun	initial("010111001"b),	/* opnd(1) <- opnd(2) with charno opnd(3) */
  8   131 	addcharno_fun	initial("010111010"b),	/* opnd(1) <- opnd(2) with charno = charno + opnd(3) */
  8   132 	setbitno_fun	initial("010111011"b),	/* setcharno for bitsno */
  8   133 	addbitno_fun	initial("010111100"b),	/* addcharno for bitno */
  8   134 
  8   135 	min_fun		initial("011000000"b),	/* opnd(1) <- min(opnd(1),opnd(2),...)	*/
  8   136 	max_fun		initial("011000001"b),	/* opnd(1) <- max(opnd(1),opnd(2),...)	*/
  8   137 
  8   138 	stack_ptr		initial("011010001"b),	/* opnd(1) <- stack frame ptr		*/
  8   139 	empty_area	initial("011010010"b),	/* empty opnd(1), length in words is opnd(2) */
  8   140 	enable_on		initial("011010100"b),	/* opnd(1) is the cond name
  8   141*						   opnd(2) is the file name
  8   142*						   opnd(3) is the block	*/
  8   143 	revert_on		initial("011010101"b),	/* opnd(1) is the cond name,
  8   144*						   opnd(2) is the file name	*/
  8   145 	signal_on		initial("011010110"b),	/* opnd(1) is the cond name
  8   146*						   opnd(2) is the file name */
  8   147 
  8   148 	lock_fun		initial("011010111"b),	/* opnd(1) <- stac(opnd(2),opnd(3))	*/
  8   149 	stacq_fun		initial("011011000"b),	/* opnd(1) is result, opnd(2) is ptr to lock word,
  8   150*						   opnd(3) is old value, (4) is new value. */
  8   151 	clock_fun		initial("011011001"b),	/* opnd(1) is the clock time		*/
  8   152 	vclock_fun	initial("011011010"b),	/* opnd(1) is the virtual clock time	*/
  8   153 
  8   154 	bound_ck		initial("011100000"b),	/* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */
  8   155 	range_ck		initial("011100001"b),	/* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */
  8   156 	loop		initial("011100010"b),	/* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1,
  8   157*						   opnd(5) is the list */
  8   158 	join		initial("011100011"b),	/* do opnd(1), opnd(2) ... opnd(n)	*/
  8   159 	allot_based	initial("011100100"b),	/* allocate opnd(2) words in opnd(3), set opnd(1) */
  8   160 	free_based	initial("011100101"b),	/* free opnd(1) in opnd(3), length is opnd(2) words */
  8   161 
  8   162 	r_parn		initial("011110001"b),	/* format op code			*/
  8   163 	l_parn		initial("011110010"b),
  8   164 	r_format		initial("011110011"b),
  8   165 	c_format		initial("011110100"b),
  8   166 	f_format		initial("011110101"b),
  8   167 	e_format		initial("011110110"b),
  8   168 	b_format		initial("011110111"b),
  8   169 	a_format		initial("011111000"b),
  8   170 	x_format		initial("011111001"b),
  8   171 	skip_format	initial("011111010"b),
  8   172 	column_format	initial("011111011"b),
  8   173 	page_format	initial("011111100"b),
  8   174 	line_format	initial("011111101"b),
  8   175 	picture_format	initial("011111110"b),
  8   176 	bn_format		initial("011111111"b),	/* bit format, length(opnd(2)), radix factor(opnd(3)) */
  8   177 
  8   178 	get_list_trans	initial("100000000"b),	/* getlist(opnd(2) with desc(opnd(1)))	*/
  8   179 	get_edit_trans	initial("100000001"b),	/* getedit(opnd(2) with desc(opnd(1)))	*/
  8   180 	get_data_trans	initial("100000010"b),	/* getdata(opnd(1) to opnd(n))	*/
  8   181 	put_list_trans	initial("100000011"b),	/* putlist(opnd(2) with desc(opnd(1)))	*/
  8   182 	put_edit_trans	initial("100000100"b),	/* putedit(opnd(2) with desc(opnd(1)))	*/
  8   183 	put_data_trans	initial("100000101"b),	/* putdata(opnd(2)) with subscript-list opnd(1) */
  8   184 	terminate_trans	initial("100000110"b),	/* terminate stream transmission	*/
  8   185 	stream_prep	initial("100000111"b),	/* initiate stream transmission	*/
  8   186 	record_io		initial("100001000"b),	/* perform record io operation	*/
  8   187 	fortran_read	initial("100001001"b),	/* A complete read statement		*/
  8   188 	fortran_write	initial("100001010"b),	/* A complete write statement		*/
  8   189 	ftn_file_manip	initial("100001011"b),	/* endfile,backspace,rewind,etc.	*/
  8   190 	ftn_trans_loop	initial("100001100"b),	/* An implied do in i/o list		*/
  8   191 	put_control	initial("100001101"b),	/* put control opnd(1) opnd(2) times	*/
  8   192 	put_field		initial("100001110"b),	/* putlist(opnd(2)) of length(opnd(1))	*/
  8   193 	put_field_chk	initial("100001111"b),	/* putlist(op(2)) of len(op(1)) check char index(op(3)) */
  8   194 
  8   195 /* These operators are produced by the parse but are not used as input to the code generator.	*/
  8   196 /* They are processed by the semantic translator.						*/
  8   197 
  8   198 	return_value	initial("100010010"b),	/* return(opnd(1))			*/
  8   199 	allot_var		initial("100010011"b),	/* allot opnd(1) in opnd(2)		*/
  8   200 	free_var		initial("100010100"b),	/* free opnd(1) out of opnd(2)	*/
  8   201 	get_file		initial("100010101"b),	/* opnd(1) is filename,opnd(2) is copy	*/
  8   202 						/* opnd(3) is skip, opnd(4) is list	*/
  8   203 	get_string	initial("100010110"b),	/* opnd(1) is string,opnd(2) is list	*/
  8   204 	put_file		initial("100010111"b),	/* opnd(1) is filename,opnd(2) is page	*/
  8   205 						/* opnd(3) is skip,opnd(4) is line	*/
  8   206 	put_string	initial("100011000"b),	/* opnd(1) is string,opnd(2) is list	*/
  8   207 	open_file		initial("100011001"b),
  8   208 	close_file	initial("100011010"b),
  8   209 	read_file		initial("100011011"b),
  8   210 	write_file	initial("100011100"b),
  8   211 	locate_file	initial("100011101"b),
  8   212 	do_fun		initial("100011110"b),	/* opnd(1) is join of a list		*/
  8   213 						/* opnd(2) is control variable ref	*/
  8   214 						/* opnd(3) is specification operator	*/
  8   215 	do_spec		initial("100011111"b),	/* opnd(1) to opnd(2) by opnd(3) 	*/
  8   216 						/* repeat opnd(4) while opnd(5)	*/
  8   217 						/* opnd(6) is next specification	*/
  8   218 
  8   219 	rewrite_file	initial("100100000"b),
  8   220 	delete_file	initial("100100001"b),
  8   221 	unlock_file	initial("100100010"b),
  8   222 	lock_file		initial("100100011"b),
  8   223 	refer		initial("100100101"b),	/* opnd(1) refer(opnd(2))		*/
  8   224 	prefix_plus	initial("100100110"b),	/* opnd(1) <- +opnd(2)		*/
  8   225 	nop		initial("100100111"b),	/* no-op */
  8   226 	assign_by_name	initial("100101000"b),	/* opnd(1) <- opnd(2),by name		*/
  8   227 
  8   228 /* These operators are produced by the semantic translator in processing the math
  8   229*   builtin functions and are used as input to the code generator			*/
  8   230 
  8   231 	sqrt_fun		initial("100110000"b),	/* opnd(1) <- sqrt(opnd(2))	*/
  8   232 	sin_fun		initial("100110001"b),	/* opnd(1) <- sin(opnd(2))	*/
  8   233 	sind_fun		initial("100110010"b),	/* opnd(1) <- sind(opnd(2))	*/
  8   234 	cos_fun		initial("100110011"b),	/* opnd(1) <- cos(opnd(2))	*/
  8   235 	cosd_fun		initial("100110100"b),	/* opnd(1) <- cosd(opnd(2))	*/
  8   236 	tan_fun		initial("100110101"b),	/* opnd(1) <- tan(opnd(2))	*/
  8   237 	tand_fun		initial("100110110"b),	/* opnd(1) <- tand(opnd(2))	*/
  8   238 	asin_fun		initial("100110111"b),	/* opnd(1) <- asin(opnd(2))	*/
  8   239 	asind_fun		initial("100111000"b),	/* opnd(1) <- asind(opnd(2))	*/
  8   240 	acos_fun		initial("100111001"b),	/* opnd(1) <- acos(opnd(2))	*/
  8   241 	acosd_fun		initial("100111010"b),	/* opnd(1) <- acosd(opnd(2))	*/
  8   242 	atan_fun		initial("100111011"b),	/* opnd(1) <- atan(opnd(2)[,opnd(3)])	*/
  8   243 	atand_fun		initial("100111100"b),	/* opnd(1) <- atand(opnd(2)[,opnd(3)])	*/
  8   244 	log2_fun		initial("100111101"b),	/* opnd(1) <- log2(opnd(2))	*/
  8   245 	log_fun		initial("100111110"b),	/* opnd(1) <- log(opnd(2))	*/
  8   246 	log10_fun		initial("100111111"b),	/* opnd(1) <- log10(opnd(2))	*/
  8   247 
  8   248 	exp_fun		initial("101000000"b))	/* opnd(1) <- exp(opnd(2))	*/
  8   249 
  8   250 			bit(9) aligned internal static options(constant);
  8   251 
  8   252 /* END INCLUDE FILE ... op_codes.incl.pl1 */
       94 
  9     1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */
  9     2 
  9     3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */
  9     4 
  9     5 dcl (	block_node		initial("000000001"b),
  9     6 	statement_node		initial("000000010"b),
  9     7 	operator_node		initial("000000011"b),
  9     8 	reference_node		initial("000000100"b),
  9     9 	token_node		initial("000000101"b),
  9    10 	symbol_node		initial("000000110"b),
  9    11 	context_node		initial("000000111"b),
  9    12 	array_node		initial("000001000"b),
  9    13 	bound_node		initial("000001001"b),
  9    14 	format_value_node		initial("000001010"b),
  9    15 	list_node			initial("000001011"b),
  9    16 	default_node		initial("000001100"b),
  9    17 	machine_state_node		initial("000001101"b),
  9    18 	source_node		initial("000001110"b),
  9    19 	label_node		initial("000001111"b),
  9    20 	cross_reference_node	initial("000010000"b),
  9    21 	sf_par_node		initial("000010001"b),
  9    22 	temporary_node		initial("000010010"b),
  9    23 	label_array_element_node	initial("000010011"b),
  9    24 	by_name_agg_node		initial("000010100"b))
  9    25 				bit(9) internal static aligned options(constant);
  9    26 
  9    27 dcl	1 node			based aligned,
  9    28 	2 type			unal bit(9),
  9    29 	2 source_id		unal structure,
  9    30 	  3 file_number		bit(8),
  9    31 	  3 line_number		bit(14),
  9    32 	  3 statement_number	bit(5);
  9    33 
  9    34 /* END INCLUDE FILE ... nodes.incl.pl1 */
       95 
 10     1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */
 10     2 
 10     3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */
 10     4 
 10     5 dcl (	bit_		init(1),
 10     6 	digit_		init(2),
 10     7 	character_	init(3),
 10     8 	half_		init(4),
 10     9 	word_		init(5),
 10    10 	mod2_		init(6),
 10    11 	mod4_		init(7)) fixed bin(3) int static options(constant);
 10    12 
 10    13 /* END INCLUDE FILE ... boundary.incl.pl1 */
       96 
 11     1 /* BEGIN INCLUDE FILE ... cgsystem.incl.pl1 */
 11     2 
 11     3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */
 11     4 
 11     5 dcl (	bits_per_char		init(9),
 11     6 	bits_per_half		init(18),
 11     7 	bits_per_word		init(36),
 11     8 	bits_per_two_words		init(72),
 11     9 	bits_per_four_words		init(144),
 11    10 	bits_per_words(2)		init(36,72),
 11    11 	packed_digits_per_char	init(2),
 11    12 	chars_per_word		init(4),
 11    13 	packed_digits_per_word	init(8),
 11    14 
 11    15 	break_even_bits		init(216),
 11    16 	break_even_words		init(6),
 11    17 
 11    18 	label_size		init(4),
 11    19 
 11    20 	convert_size(13:14)		init(9,1),
 11    21 	max_offset(13:14)		init(27,35),
 11    22 	max_short_size(13:14)	init(8,72),
 11    23 
 11    24 	units_per_word(0:5)		init(1,36,8,4,2,1),
 11    25 
 11    26 	max_dec_scale		init(32),
 11    27 	min_dec_scale		init(-31),
 11    28 	max_p_xreg		init(18),
 11    29 	max_p_fix_bin_1		init(35),
 11    30 	max_p_flt_bin_1		init(27),
 11    31 	max_p_fix_dec		init(59),
 11    32 	max_length_p		init(24),
 11    33 	default_fix_bin_p		init(17)) fixed bin(8) int static options(constant);
 11    34 
 11    35 dcl      (convert_offset(0:5)		init(36,1,4.5,9,18,36),
 11    36 	bits_per_packed_digit	init(4.5)) fixed bin(8,1) int static options(constant);
 11    37 
 11    38 dcl	max_index_register_value	init(262143) fixed bin(31) int static options(constant);
 11    39 
 11    40 /* END INCLUDE FILE ... cgsystem.incl.pl1 */
 11    41 
       97 
 12     1 /* BEGIN INCLUDE FILE its.incl.pl1
 12     2*   modified 27 July 79 by JRDavis to add its_unsigned
 12     3*   Internal format of ITS pointer, including ring-number field for follow-on processor */
 12     4 
 12     5 dcl 1 its based aligned,				/* declaration for ITS type pointer */
 12     6     2 pad1 bit (3) unaligned,
 12     7     2 segno bit (15) unaligned,			/* segment number within the pointer */
 12     8     2 ringno bit (3) unaligned,			/* ring number within the pointer */
 12     9     2 pad2 bit (9) unaligned,
 12    10     2 its_mod bit (6) unaligned,			/* should be 43(8) */
 12    11 
 12    12     2 offset bit (18) unaligned,			/* word offset within the addressed segment */
 12    13     2 pad3 bit (3) unaligned,
 12    14     2 bit_offset bit (6) unaligned,			/* bit offset within the word */
 12    15     2 pad4 bit (3) unaligned,
 12    16     2 mod bit (6) unaligned;				/* further modification */
 12    17 
 12    18 dcl 1 itp based aligned,				/* declaration for ITP type pointer */
 12    19     2 pr_no bit (3) unaligned,			/* number of pointer register to use */
 12    20     2 pad1 bit (27) unaligned,
 12    21     2 itp_mod bit (6) unaligned,			/* should be 41(8) */
 12    22 
 12    23     2 offset bit (18) unaligned,			/* word offset from pointer register word offset */
 12    24     2 pad2 bit (3) unaligned,
 12    25     2 bit_offset bit (6) unaligned,			/* bit offset relative to new word offset */
 12    26     2 pad3 bit (3) unaligned,
 12    27     2 mod bit (6) unaligned;				/* further modification */
 12    28 
 12    29 
 12    30 dcl 1 its_unsigned based aligned,			/* just like its, but with unsigned binary */
 12    31     2 pad1 bit (3) unaligned,
 12    32     2 segno fixed bin (15) unsigned unaligned,
 12    33     2 ringno fixed bin (3) unsigned unaligned,
 12    34     2 pad2 bit (9) unaligned,
 12    35     2 its_mod bit (6) unaligned,
 12    36 
 12    37     2 offset fixed bin (18) unsigned unaligned,
 12    38     2 pad3 bit (3) unaligned,
 12    39     2 bit_offset fixed bin (6) unsigned unaligned,
 12    40     2 pad4 bit (3) unaligned,
 12    41     2 mod bit (6) unaligned;
 12    42 
 12    43 dcl 1 itp_unsigned based aligned,			/* just like itp, but with unsigned binary where appropriate */
 12    44     2 pr_no fixed bin (3) unsigned unaligned,
 12    45     2 pad1 bit (27) unaligned,
 12    46     2 itp_mod bit (6) unaligned,
 12    47 
 12    48     2 offset fixed bin (18) unsigned unaligned,
 12    49     2 pad2 bit (3) unaligned,
 12    50     2 bit_offset fixed bin (6) unsigned unaligned,
 12    51     2 pad3 bit (3) unaligned,
 12    52     2 mod bit (6) unaligned;
 12    53 
 12    54 
 12    55 dcl  ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3);
 12    56 dcl  ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3);
 12    57 
 12    58 /* END INCLUDE FILE   its.incl.pl1 */
       98 
       99 
      100 	save_cur_node = cg_stat$cur_node;
      101 	node_pt, cg_stat$cur_node = pt;
      102 	ret_pt = node_pt -> operand(1);
      103 
      104 	/* get info about entry */
      105 
      106 	q = node_pt -> operand(2);
      107 	ent_pt = prepare_operand(q,1,atom);
      108 	if ^ atom then ent_pt = compile_exp$save(q);
      109 
      110 	ent_type = ent_pt -> reference.data_type;
      111 	if ent_type ^= int_entry then quick = "0"b;
      112 	else do;
      113 	     ent_blk = ent_pt -> reference.symbol -> symbol.equivalence;
      114 	     quick = ent_blk -> block.no_stack;
      115 	     end;
      116 
      117 	/* get ptr to std_arg_list operator */
      118 
      119 	sal_pt = node_pt -> operand(3);
      120 
      121 	/* The rest of the main procedure is put in a begin block so that
      122*	   the extents of arrays (and bit vectors) that hold values for
      123*	   each arg in the arg_list will conform to the number of args, via
      124*	   auto adjustable storage, thus avoiding an artificial limit on
      125*	   the number of args in a call. */
      126 
      127 	if sal_pt = null
      128 	     then arg_list_extent = 1;
      129 	     else arg_list_extent = sal_pt->operand(2)->list.number;
      130 
      131      begin;
      132 	dcl rand_pt(arg_list_extent) ptr;
      133 	dcl (adjust,already)  bit(arg_list_extent);
      134      
      135 
      136 	if sal_pt = null
      137 	then do;
      138 
      139 	     /* no arguments, no sweat if this is quick call */
      140 
      141 	     if quick
      142 	     then do;
      143 		call state_man$flush;
      144 		call expmac((quick_call),ent_pt);
      145 		goto done;
      146 		end;
      147 
      148 	     /* use temp location for arglist */
      149 
      150 	     arglist = cg_stat$double_temp;
      151 	     descs = null;
      152 	     n_args = 0;
      153 	     goto l3;
      154 	     end;
      155 
      156 	/* get ptr to arglist and skip if we already evaluated it */
      157 
      158 	arglist = sal_pt -> operand(1);
      159 	arglist -> reference.units = word_;
      160 	arglist -> reference.perm_address = "0"b;
      161 	if arglist -> reference.evaluated 
      162 	then do;
      163 	     arglist->reference.no_address = "1"b;
      164 	     goto l2;
      165 	     end;
      166 
      167 	args = sal_pt -> operand(2);
      168 	n_args = args -> list.number;
      169 
      170 	if n_args > max_list_elements
      171 	then do;
      172 	     call cg_error(340,max_list_elements);
      173 	     n_args = max_list_elements;
      174 	     end;
      175 
      176 	/* get info about all the arguments of the call */
      177 
      178 	do i = 1 to n_args;
      179 	     q = args -> element(i);
      180 	     p = prepare_operand(q,-1,atom);
      181 
      182 	     if atom then goto step;
      183 	     if q -> node.type ^= operator_node then goto step;
      184 
      185 	     if q -> operator.op_code = assign | q -> operator.op_code = assign_size_ck
      186 	     then do;
      187 
      188 		if p -> reference.length = null then goto l1;
      189 
      190 		/* we have adjustable string temp = something,
      191*		   check to see if we have the same size on both
      192*		   sides of the assignment */
      193 
      194 		/* We have to be prepared to restore the
      195*		   original value of the data_type field
      196*		   of operand(2) if it is a reference,
      197*		   because if we don't, prepare_operand
      198*		   will get confused and not evaluate
      199*		   the length expression, if any. */
      200 
      201 		p2 = q -> operand(2);
      202 		if p2 -> node.type = operator_node 
      203 		     then p2 = p2 -> operand(1);
      204 		dt = p2 -> reference.data_type;
      205 
      206 		p2 = prepare_operand((q -> operand(2)),-1,atom);
      207 		p2s = p2 -> reference.length;
      208 
      209 		reset = "0"b;
      210 
      211 		if p2s = p -> reference.length
      212 		then;
      213 		else if compare_expression(p2s,(p -> reference.length))
      214 		     then do;
      215 
      216 			/* Have same size on both sides of assign, so optimize */
      217 
      218 			p2s = share_expression(p2s);
      219 			if p2s -> node.type = reference_node
      220 			     then p2s = prepare_operand(p2s,1,useless);
      221 			p -> reference.length = p2s;
      222 			end;
      223 		     else reset = "1"b;
      224 
      225 		if (p -> reference.data_type ^= p2 -> reference.data_type) | atom
      226 		then do;
      227 
      228 		     /* We restore the data_type field before
      229*		        calling compile_exp$save if the
      230*		        2 length exprs were not the
      231*		        same, as previously mentioned */
      232 
      233 		     if reset
      234 			then p2 -> reference.data_type = dt;
      235 		     p = compile_exp$save(q);
      236 		     end;
      237 		else do;
      238 		     p -> reference.ref_count = p -> reference.ref_count + 1;
      239 		     dt = p -> reference.data_type - char_string;
      240 		     call compile_exp((q -> operand(2)));
      241 		     call long_op$extend_stack(p,realloc_char_temp+dt);
      242 		     call store$save_string_temp(p);
      243 		     call adjust_ref_count((q -> operand(2)),-1);
      244 		     end;
      245 
      246 		goto step;
      247 		end;
      248 
      249 	     if p -> reference.long_ref
      250 	     then p = compile_exp$save_exp(q);
      251 	     else do;
      252 l1:		if p -> reference.c_length > 0
      253 		 | p -> reference.data_type < char_string
      254 		 | p -> reference.data_type > bit_string
      255 		then p = compile_exp$save_exp(q);
      256 		else do;
      257 
      258 		     /* have zero length string being passed out */
      259 
      260 		     p = q -> operand(1);
      261 
      262 		     call stack_temp$assign_temp(p);
      263 
      264 		     if p -> reference.varying_ref
      265 		     then do;
      266 			p -> reference.c_offset = p -> reference.c_offset - 1;
      267 			p -> reference.ref_count = p -> reference.ref_count + 1;
      268 			call expmac((zero_mac),p);
      269 			p -> reference.c_offset = p -> reference.c_offset + 1;
      270 			end;
      271 		     end;
      272 		end;
      273 
      274 step:	     rand_pt(i) = p;
      275 	     if p -> reference.length ^= null
      276 	     then if p -> reference.ref_count = 1
      277 		then call need_temp(p,"01"b);
      278 	     end;
      279 
      280 	/* allocate space for temp result of function, if necessary */
      281 
      282 	if p -> reference.temp_ref
      283 	then if ^ p -> reference.allocated
      284 	     then do;
      285 
      286 		if ^ p -> reference.allocate
      287 		then do;
      288 		     p, ret_pt, rand_pt(n_args) = copy_temp(p);
      289 		     p -> reference.ref_count = 2;
      290 		     end;
      291 
      292 		call stack_temp$assign_temp(p);
      293 		p -> reference.value_in.storage = "1"b;
      294 		end;
      295 
      296 	/* check to see if we can generate a constant arg list */
      297 
      298 	if quick
      299 	then do;
      300 	     use_itp = check_arg_addrs();
      301 	     if use_itp
      302 	     then do;
      303 		call gen_itp_list;
      304 		go to l2;
      305 		end;
      306 	     end;
      307 
      308 	/* allocate space for arg list if necessary */
      309 
      310 	if ^ arglist -> reference.allocated
      311 	then do;
      312 	     if ^ arglist -> reference.allocate then arglist = copy_temp(arglist);
      313 	     call stack_temp$assign_temp(arglist);
      314 	     end;
      315 
      316 	last_freed = arglist -> reference.qualifier -> temporary.last_freed;
      317 
      318 	arg_pos = arglist -> reference.qualifier -> temporary.location;
      319 
      320 	if arg_pos + 2*n_args + 1 < 16384
      321 	     then ap = c_a(arg_pos,4);
      322 	     else do;
      323 		ap = c_a(0,4);
      324 		call xr_man$load_const(arg_pos,1);	/* xr1 is safe because it is out of the pool */
      325 		ap -> address.tag = "001001"b;
      326 		arg_pos = 0;
      327 		string(arglist -> reference.address) = string(ap -> reference.address);
      328 		arglist->reference.perm_address = "1"b;
      329 		end;
      330 
      331 	/* put ptrs to arguments into arg list.  If an arg is a temporary, we will
      332*	   adjust the reference count up by 1 so that the temporary remains allocated
      333*	   until we return from call_op.  If we did not do this and some of the
      334*	   registers had to be saved in storage, one of the temporaries used for
      335*	   an arg passed by value might get used. */
      336 
      337 	adjust = "0"b;
      338 	do i = 1 to n_args;
      339 	     ap -> address.offset = bit(fixed(arg_pos + 2*i,15),15);
      340 	     p = rand_pt(i);
      341 
      342 	     if p -> reference.temp_ref
      343 	     then do;
      344 		p -> reference.ref_count = p -> reference.ref_count + 1;
      345 		substr(adjust,i,1) = "1"b;
      346 		end;
      347 
      348 	     call store_bit_address(ap,p,last_freed);
      349 	     end;
      350 
      351 	/* decide if we have to skip a position in the arg list for stack ptr */
      352 
      353 	skip = fixed(((ent_type = int_entry) & ^ quick) | (ent_type = entry_variable),1) + n_args;
      354 
      355 	descs = sal_pt -> operand(3);
      356 	if descs = null then goto l2;
      357 
      358 	/* put ptrs to descriptors into arg list */
      359 
      360 	already = "0"b;
      361 	do i = 1 to n_args;
      362 
      363 	     if substr(already,i,1) then goto next;
      364 
      365 	     ap -> address.offset = bit(fixed(arg_pos + 2*(i+skip),15),15);
      366 	     p = prepare_operand((descs -> element(i)),1,atom);
      367 	     call base_man$store_ptr_to(p,ap);
      368 
      369 	    /* if same descriptor used later, store ptr to it now */
      370 
      371 	     do j = i + 1 to n_args;
      372 		if p = descs -> element(j)
      373 		then do;
      374 		     ap -> address.offset = bit(fixed(arg_pos + 2*(j+skip),15),15);
      375 		     call base_man$store_ptr_to(p,ap);
      376 		     substr(already,j,1) = "1"b;
      377 		     end;
      378 		end;
      379 
      380 next:	     end;
      381 
      382 l2:
      383 
      384 	/* generate call */
      385 
      386 l3:	arg(1) = arglist;
      387 	if n_args > 127
      388 	     then arg(2) = c_a((n_args*2),3);   /* for prepare_call_long macros */
      389 	     else arg(2) = c_a((n_args*2048),2);  /* for prepare_call macros */
      390 
      391 	if ent_type = int_entry & ^ quick
      392 	then do;
      393 	     j = cg_stat$cur_level - ent_pt -> reference.symbol -> symbol.block_node -> block.level;
      394 
      395 	     if j ^= 0
      396 	     then do;
      397 		call xr_man$load_const(j,7);
      398 		call xr_man$super_lock(7);
      399 		ent_type = int_entry_other;
      400 		end;
      401 
      402 	     end;
      403 
      404 	if ret_pt ^= null
      405 	then if ^ ret_pt -> reference.shared
      406 	     then if cg_stat$cur_tree = node_pt
      407 		then call adjust_ref_count(ret_pt,-1);
      408 
      409 	if quick
      410 	then do;
      411 	     if use_itp
      412 	     then do;
      413 		call base_man$load_var(2,arglist,1);
      414 		if descs ^= null
      415 		     then call expmac((lda),arglist);
      416 		end;
      417 	     else if n_args > 127
      418 		    then call expmac$many((prepare_quick_call_long),addr(arg),2);
      419 	              else call expmac$many((prepare_quick_call),addr(arg),2);
      420 
      421 	     call state_man$flush;
      422 	     call expmac((quick_call),ent_pt);
      423 	     end;
      424 	else do;
      425 	     if n_args > 127
      426 		then call expmac$many((prepare_call_long),addr(arg),2);
      427 		else call expmac$many((prepare_call),addr(arg),2);
      428 	     call base_man$load_var(2,ent_pt,1);
      429 	     call state_man$flush;
      430 	     call expmac$zero(call_ent_var + 2*(ent_type - entry_variable) + fixed(descs ^= null,1));
      431 	     end;
      432 
      433 	if adjust = "0"b then goto done;
      434 
      435 	do i = 1 to n_args;
      436 	     if substr(adjust,i,1)
      437 	     then do;
      438 		p = rand_pt(i);
      439 		call adjust_ref_count(p,-1);
      440 		end;
      441 	     end;
      442 
      443 done:
      444 	ent_pt -> reference.perm_address = "0"b;
      445 	cg_stat$cur_node = save_cur_node;
      446 
      447 	if ret_pt ^= null
      448 	then if ^ ret_pt -> reference.shared
      449 	     then ret_pt -> reference.evaluated = "1"b;
      450 
      451 	return(ret_pt);
      452 /**/
      453 check_arg_addrs:	proc reducible returns(bit(1) aligned);
      454 
      455 dcl	     (f,p,s) ptr;
      456 
      457 	     /* checks args to see if all addresses are suitable for use
      458*	        in a constant arg list */
      459 
      460 	     if cg_stat$cur_block -> block.last_auto_loc >= 16384
      461 		then go to fail;
      462 
      463 	     /* make sure quick block contains no non-quick blocks */
      464 
      465 	     if ent_blk -> block.son ^= null
      466 	     then if ^ check_block((ent_blk -> block.son))
      467 		then go to fail;
      468 
      469 	     /* now check args for constant addresses */
      470 
      471 	     do i = 1 to n_args;
      472 		p = rand_pt(i);
      473 
      474 		if p -> reference.offset ^= null
      475 		     then go to fail;
      476 
      477 		s = p -> reference.symbol;
      478 
      479 		if p -> reference.temp_ref
      480 		then do;
      481 		     if p -> reference.address_in.storage
      482 			then go to fail;
      483 
      484 		     if p -> reference.aggregate
      485 		     then do;
      486 			do f = s repeat f -> symbol.father while(f -> symbol.father ^= null);
      487 			     end;
      488 			if f -> symbol.word_size ^= null
      489 			     then go to fail;
      490 			end;
      491 		     end;
      492 
      493 		else if p -> reference.qualifier ^= null
      494 		     then go to fail;
      495 		     else if s -> symbol.auto
      496 			then if cg_stat$cur_level ^= s -> symbol.block_node -> block.level
      497 			     then go to fail;
      498 			     else;
      499 			else if s -> symbol.constant
      500 			     then do;
      501 				if s -> symbol.equivalence ^= null
      502 				     then s = s -> symbol.equivalence;
      503 
      504 				if ^ s -> symbol.allocated
      505 				then go to fail;
      506 				else if p -> reference.units ^= 0
      507 				     then if p -> reference.units ^= word_
      508 					then go to fail;
      509 					else;
      510 				     else;
      511 				end;
      512 
      513 			     else go to fail;
      514 		end;
      515 
      516 	     return("1"b);
      517 
      518 fail:	     return("0"b);
      519 
      520 	     end;
      521 
      522 
      523 /**/
      524 check_block:   proc(pt) reducible returns(bit(1) aligned);
      525 
      526 dcl	     (p,pt) ptr;
      527 
      528 	     /* make sure all contained blocks are quick */
      529 
      530 	      do p = pt repeat p -> block.brother while(p ^= null);
      531 		if ^ p -> block.no_stack
      532 		     then go to fail;
      533 		if p -> block.son ^= null
      534 		then if ^ check_block((p -> block.son))
      535 		     then go to fail;
      536 		end;
      537 
      538 	     return("1"b);
      539 
      540 fail:	     return("0"b);
      541 
      542 	     end;
      543 /**/
      544 gen_itp_list:	proc;
      545 
      546 dcl	     iscan fixed bin;
      547 dcl	     doing_descriptors bit(1) aligned;
      548 
      549 dcl	     1 arg_list auto aligned,
      550 	     2 header aligned,
      551 	       3 arg_count fixed bin(17) unal,
      552 	       3 code bit(18) unal,
      553 	       3 desc_count fixed bin(17) unal,
      554 	       3 pad bit(18) unal,
      555 	     2 itp_list(128) like itp aligned;
      556 
      557 	     /* generates an argument list of constant addresses using
      558*	        ITP pairs and ordinary indirect words */
      559 
      560 	     doing_descriptors = "0"b;
      561 	     arg_list.code, arg_list.pad = "0"b;
      562 	     adjust = "0"b;
      563 	     iscan = 0;
      564 	     arg_list.arg_count = 2 * n_args;
      565 
      566 	     /* fill in addresses of arguments */
      567 
      568 	     call fill_list;
      569 
      570 	     /* process descriptors, if any */
      571 
      572 	     descs = sal_pt -> operand(3);
      573 	     if descs ^= null
      574 	     then do;
      575 		arg_list.desc_count = 2 * n_args;
      576 		doing_descriptors = "1"b;
      577 		call fill_list;
      578 		end;
      579 	     else arg_list.desc_count = 0;
      580 
      581 	     /* generate the constant argument list */
      582 
      583 	     arglist = generate_constant$relocatable(addr(arg_list),2 * iscan + 2,"1"b);
      584 
      585 fill_list:	proc;
      586 
      587 dcl		ind_word bit(36) aligned based;
      588 dcl		eis bit(2) aligned;
      589 dcl		p ptr;
      590 
      591 		/* fills in the arg_list */
      592 
      593 		do i = 1 to n_args;
      594 		     iscan = iscan + 1;
      595 
      596 		     if ^ doing_descriptors
      597 			then p = rand_pt(i);
      598 			else p = prepare_operand((descs -> element(i)),1,atom);
      599 
      600 		     if string(p -> reference.address_in.b)
      601 			then call state_man$flush_address(p);
      602 
      603 		     /* make the arg addressable */
      604 
      605 		     if p -> reference.units = word_
      606 			then eis = "00"b;
      607 			else eis = "11"b;
      608 
      609 		     call m_a(p,eis);
      610 
      611 		     if p -> reference.ic_ref
      612 		     then do;
      613 			p -> reference.ic_ref = "0"b;
      614 			p -> address.tag = "000000"b;
      615 			end;
      616 
      617 		     /* depending on ext_base, make an ITP pair or an indirect word */
      618 
      619 		     string(itp_list(iscan)) = (72)"0"b;
      620 
      621 		     if p -> address.ext_base
      622 		     then do;
      623 			itp_list(iscan).pr_no = p -> address.base;
      624 			itp_list(iscan).itp_mod = "100001"b;	/* 41(8) - ITP */
      625 			itp_list(iscan).offset = bit(fixed(p -> address.offset,18),18);
      626 			if p -> reference.c_f_offset ^= 0
      627 			then if p -> reference.units = bit_
      628 			     then itp_list(iscan).bit_offset = bit(p -> reference.c_f_offset,6);
      629 			     else if p -> reference.units = character_
      630 				then itp_list(iscan).bit_offset = bit(fixed(bits_per_char * p -> reference.c_f_offset,6),6);
      631 				else itp_list(iscan).bit_offset = bit(fixed(bits_per_char
      632 					* divide(p -> reference.c_f_offset,packed_digits_per_char,6),6),6);
      633 			end;
      634 
      635 		     else addr(itp_list(iscan)) -> ind_word = string(p -> reference.address);
      636 
      637 		     /* adjust the reference count for this use of the argument */
      638 
      639 		     if ^ p -> reference.shared
      640 		     then if p -> reference.temp_ref & ^ doing_descriptors
      641 			then substr(adjust,i,1) = "1"b;
      642 			else call adjust_ref_count(p,-1);
      643 		     end;
      644 
      645 		end;
      646 
      647 	     end;
      648 
      649 
      650              end; /* begin block */
      651 
      652 
      653 	end;
	SOURCE FILES USED IN THIS COMPILATION.

LINE      NUMBER  DATE MODIFIED     NAME			PATHNAME
             0    10/03/83  1007.9  call_op.pl1                       >spec>on>pl128d>call_op.pl1
87           1    07/21/80  1546.3  cg_reference.incl.pl1             >ldd>include>cg_reference.incl.pl1
88           2    07/21/80  1546.3  operator.incl.pl1                 >ldd>include>operator.incl.pl1
89           3    08/13/81  2211.5  list.incl.pl1                     >ldd>include>list.incl.pl1
90           4    10/02/83  0828.4  symbol.incl.pl1                   >spec>on>pl128d>symbol.incl.pl1
91           5    08/13/81  2043.5  block.incl.pl1                    >ldd>include>block.incl.pl1
92           6    11/30/78  1227.4  temporary.incl.pl1                >ldd>include>temporary.incl.pl1
93           7    05/03/76  1320.4  data_types.incl.pl1               >ldd>include>data_types.incl.pl1
94           8    04/07/83  1635.0  op_codes.incl.pl1                 >ldd>include>op_codes.incl.pl1
95           9    07/21/80  1546.3  nodes.incl.pl1                    >ldd>include>nodes.incl.pl1
96          10    10/25/79  1645.8  boundary.incl.pl1                 >ldd>include>boundary.incl.pl1
97          11    10/25/79  1645.8  cgsystem.incl.pl1                 >ldd>include>cgsystem.incl.pl1
98          12    11/26/79  1320.6  its.incl.pl1                      >ldd>include>its.incl.pl1
	NAMES DECLARED IN THIS COMPILATION.

IDENTIFIER	     OFFSET    LOC STORAGE CLASS   DATA TYPE		ATTRIBUTES AND REFERENCES
								(* indicates a set context)

NAMES DECLARED BY DECLARE STATEMENT.
addr                                                   builtin function         dcl 74 ref 417 417 419 419 425 425 427 427 583 583
                                                                                  635
address                  10            based           structure                level 2 packed unaligned dcl 1-3 set ref 327* 327
                                                                                  635
address_in               11            based           structure                level 3 packed unaligned dcl 1-3
adjust                          000100 automatic       bit                      unaligned dcl 133 set ref 337* 345* 433 436 562*
                                                                                  639*
adjust_ref_count                000056 constant        entry                    external dcl 54 ref 243 404 439 642
aggregate                12(19)        based           bit(1)                   level 3 packed unaligned dcl 1-3 ref 484
allocate                 12(14)        based           bit(1)                   level 3 packed unaligned dcl 1-3 ref 286 312
allocated                 1(18)        based           bit(1)                   level 2 in structure "symbol" packed unaligned
                                                                                  dcl 4-3 in procedure "call_op" ref 504
allocated                12(15)        based           bit(1)                   level 3 in structure "reference" packed unaligned
                                                                                  dcl 1-3 in procedure "call_op" ref 282 310
already                         000100 automatic       bit                      unaligned dcl 133 set ref 360* 363 376*
ap                              000116 automatic       pointer                  dcl 37 set ref 320* 323* 325 327 339 348* 365 367*
                                                                                  374 375*
arg                             000124 automatic       pointer                  array dcl 37 set ref 382* 387* 389* 417 417 419 419
                                                                                  425 425 427 427
arg_count                       000150 automatic       fixed bin(17,0)          level 3 packed unaligned dcl 549 set ref 564*
arg_list                        000150 automatic       structure                level 1 dcl 549 set ref 583 583
arg_list_extent                 000152 automatic       fixed bin(35,0)          dcl 37 set ref 127* 129* 132 133 133
arg_pos                         000147 automatic       fixed bin(17,0)          dcl 37 set ref 318* 320 320* 324* 326* 339 365 374
arglist                         000114 automatic       pointer                  dcl 37 set ref 150* 158* 159 160 161 163 310 312
                                                                                  312* 312* 313* 316 318 327 328 382 413* 414* 583*
args                            000132 automatic       pointer                  dcl 37 set ref 167* 168 179
assign                                 constant        bit(9)                   initial dcl 8-8 ref 185
assign_size_ck                         constant        bit(9)                   initial dcl 8-8 ref 185
atom                            000153 automatic       bit(1)                   dcl 37 set ref 107* 108 180* 182 206* 225 366* 598*
attributes               31            based           structure                level 2 dcl 4-3
auto                     32(09)        based           bit(1)                   level 4 packed unaligned dcl 4-3 ref 495
b                        11            based           bit(1)                   array level 4 packed unaligned dcl 1-3 ref 600
base                     10            based           bit(3)                   level 3 packed unaligned dcl 1-3 set ref 623
base_man$load_var               000050 constant        entry                    external dcl 54 ref 413 428
base_man$store_ptr_to           000044 constant        entry                    external dcl 54 ref 367 375
bit                                                    builtin function         dcl 74 ref 339 365 374 625 626 629 631
bit_                                   constant        fixed bin(3,0)           initial dcl 10-5 ref 626
bit_offset                3(21) 000150 automatic       bit(6)                   array level 3 packed unaligned dcl 549 set ref 626*
                                                                                  629* 631*
bit_string                             constant        fixed bin(15,0)          initial dcl 7-1 ref 252
bits                     12(06)        based           structure                level 2 packed unaligned dcl 1-3
bits_per_char                          constant        fixed bin(8,0)           initial dcl 11-5 ref 629 631
block                                  based           structure                level 1 dcl 5-5
block_node                4            based           pointer                  level 2 packed unaligned dcl 4-3 ref 393 495
brother                   2            based           pointer                  level 2 packed unaligned dcl 5-5 ref 536
c_a                             000052 constant        entry                    external dcl 54 ref 320 323 387 389
c_f_offset                7            based           fixed bin(6,0)           level 2 dcl 1-3 ref 626 626 629 631
c_length                  2            based           fixed bin(24,0)          level 2 dcl 1-3 ref 252
c_offset                  1            based           fixed bin(24,0)          level 2 dcl 1-3 set ref 266* 266 269* 269
call_ent_var                           constant        fixed bin(15,0)          initial dcl 76 ref 430
cg_error                        000102 constant        entry                    external dcl 54 ref 172
cg_stat$cur_block               000016 external static pointer                  dcl 32 ref 460
cg_stat$cur_level               000020 external static fixed bin(17,0)          dcl 32 ref 393 495
cg_stat$cur_node                000014 external static pointer                  dcl 32 set ref 100 101* 445*
cg_stat$cur_tree                000010 external static pointer                  dcl 32 ref 404
cg_stat$double_temp             000012 external static pointer                  dcl 32 ref 150
char_string                            constant        fixed bin(15,0)          initial dcl 7-1 ref 239 252
character_                             constant        fixed bin(3,0)           initial dcl 10-5 ref 629
code                      0(18) 000150 automatic       bit(18)                  level 3 packed unaligned dcl 549 set ref 561*
compare_expression              000040 constant        entry                    external dcl 53 ref 213
compile_exp                     000036 constant        entry                    external dcl 46 ref 240
compile_exp$save                000032 constant        entry                    external dcl 46 ref 108 235
compile_exp$save_exp            000034 constant        entry                    external dcl 46 ref 249 252
constant                 32(16)        based           bit(1)                   level 4 packed unaligned dcl 4-3 ref 499
copy_temp                       000026 constant        entry                    external dcl 46 ref 288 312
data_type                12            based           fixed bin(5,0)           level 2 packed unaligned dcl 1-3 set ref 110 204 225
                                                                                  225 233* 239 252 252
desc_count                1     000150 automatic       fixed bin(17,0)          level 3 packed unaligned dcl 549 set ref 575* 579*
descs                           000134 automatic       pointer                  dcl 37 set ref 151* 355* 356 366 372 414 430 572*
                                                                                  573 598
doing_descriptors               000147 automatic       bit(1)                   dcl 547 set ref 560* 576* 596 639
dt                              000150 automatic       fixed bin(17,0)          dcl 37 set ref 204* 233 239* 241
eis                             000560 automatic       bit(2)                   dcl 588 set ref 605* 607* 609*
element                   1            based           pointer                  array level 2 packed unaligned dcl 3-6 ref 179 366
                                                                                  372 598
ent_blk                         000136 automatic       pointer                  dcl 37 set ref 113* 114 465 465
ent_pt                          000110 automatic       pointer                  dcl 37 set ref 107* 108* 110 113 144* 393 422* 428*
                                                                                  443
ent_type                        000145 automatic       fixed bin(17,0)          dcl 37 set ref 110* 111 353 353 391 399* 430
entry_variable                         constant        fixed bin(15,0)          initial dcl 7-1 ref 353 430
equivalence              14            based           pointer                  level 2 packed unaligned dcl 4-3 ref 113 501 501
evaluated                12(13)        based           bit(1)                   level 3 packed unaligned dcl 1-3 set ref 161 447*
expmac                          000024 constant        entry                    external dcl 46 ref 144 268 414 422
expmac$many                     000074 constant        entry                    external dcl 54 ref 417 419 425 427
expmac$zero                     000072 constant        entry                    external dcl 54 ref 430
ext_base                 10(29)        based           bit(1)                   level 3 packed unaligned dcl 1-3 set ref 621
f                               000130 automatic       pointer                  dcl 455 set ref 486* 486* 487 488
father                   17            based           pointer                  level 2 packed unaligned dcl 4-3 ref 486 487
fixed                                                  builtin function         dcl 74 ref 339 353 365 374 430 625 629 631
generate_constant$relocatable   000104 constant        entry                    external dcl 54 ref 583
header                          000150 automatic       structure                level 2 dcl 549
i                               000142 automatic       fixed bin(17,0)          dcl 37 set ref 178* 179 274* 338* 339 340 345* 361*
                                                                                  363 365 366 371* 435* 436 438* 471* 472* 593* 596
                                                                                  598 639*
ic_ref                   12(10)        based           bit(1)                   level 3 packed unaligned dcl 1-3 set ref 611 613*
ind_word                               based           bit(36)                  dcl 587 set ref 635*
info                     11            based           structure                level 2 packed unaligned dcl 1-3
int_entry                              constant        fixed bin(15,0)          initial dcl 7-1 ref 111 353 391
int_entry_other                        constant        fixed bin(15,0)          initial dcl 7-1 ref 399
iscan                           000146 automatic       fixed bin(17,0)          dcl 546 set ref 563* 583 594* 594 619 623 624 625
                                                                                  626 629 631 635
itp                                    based           structure                level 1 dcl 12-18
itp_list                  2     000150 automatic       structure                array level 2 dcl 549 set ref 619* 635
itp_mod                   2(30) 000150 automatic       bit(6)                   array level 3 packed unaligned dcl 549 set ref 624*
j                               000143 automatic       fixed bin(17,0)          dcl 37 set ref 371* 372 374 376* 393* 395 397*
last_auto_loc            46            based           fixed bin(17,0)          level 2 dcl 5-5 ref 460
last_freed                      000151 automatic       fixed bin(18,0)          dcl 37 in procedure "call_op" set ref 316* 348*
last_freed                7            based           fixed bin(18,0)          level 2 in structure "temporary" dcl 6-3
                                                                                  in procedure "call_op" ref 316
lda                                    constant        fixed bin(15,0)          initial dcl 76 ref 414
length                    6            based           pointer                  level 2 packed unaligned dcl 1-3 set ref 188 207 211
                                                                                  213 221* 275
level                    45            based           fixed bin(17,0)          level 2 dcl 5-5 ref 393 495
list                                   based           structure                level 1 dcl 3-6
location                  4            based           fixed bin(18,0)          level 2 dcl 6-3 ref 318
long_op$extend_stack            000054 constant        entry                    external dcl 54 ref 241
long_ref                 12(08)        based           bit(1)                   level 3 packed unaligned dcl 1-3 ref 249
m_a                             000070 constant        entry                    external dcl 54 ref 609
max_list_elements               000000 constant        fixed bin(17,0)          initial dcl 3-12 set ref 170 172* 173
n_args                          000146 automatic       fixed bin(17,0)          dcl 37 set ref 152* 168* 170 173* 178 288 320 338
                                                                                  353 361 371 387 387 389 417 425 435 471 564 575
                                                                                  593
need_temp                       000062 constant        entry                    external dcl 54 ref 275
no_address               10(27)        based           bit(1)                   level 3 packed unaligned dcl 1-3 set ref 163*
no_stack                 24(22)        based           bit(1)                   level 2 packed unaligned dcl 5-5 ref 114 531
node                                   based           structure                level 1 dcl 9-27
node_pt                         000104 automatic       pointer                  dcl 37 set ref 101* 102 106 119 404
null                                                   builtin function         dcl 74 ref 127 136 151 188 275 356 404 414 430 447
                                                                                  465 474 486 488 493 501 530 533 573
number                    0(21)        based           fixed bin(14,0)          level 2 packed unaligned dcl 3-6 ref 129 168
offset                    3     000150 automatic       bit(18)                  array level 3 in structure "arg_list" packed
                                                                                  unaligned dcl 549 in procedure "gen_itp_list" set
                                                                                  ref 625*
offset                    5            based           pointer                  level 2 in structure "reference" packed unaligned
                                                                                  dcl 1-3 in procedure "call_op" ref 474
offset                   10(03)        based           bit(15)                  level 3 in structure "reference" packed unaligned
                                                                                  dcl 1-3 in procedure "call_op" set ref 339* 365*
                                                                                  374* 625
op_code                   0(09)        based           bit(9)                   level 2 packed unaligned dcl 2-6 ref 185 185
operand                   1            based           pointer                  array level 2 packed unaligned dcl 2-6 ref 102 106
                                                                                  119 129 158 167 201 202 206 240 243 260 355 572
operator                               based           structure                level 1 dcl 2-6
operator_node                          constant        bit(9)                   initial dcl 9-5 ref 183 202
p                               000100 automatic       pointer                  dcl 37 in procedure "call_op" set ref 180* 188 211
                                                                                  213 221 225 235* 238 238 239 241* 242* 249 249*
                                                                                  252 252 252 252* 260* 262* 264 266 266 267 267
                                                                                  268* 269 269 274 275 275 275* 282 282 286 288*
                                                                                  288* 289 292* 293 340* 342 344 344 348* 366* 367*
                                                                                  372 375* 438* 439*
p                               000132 automatic       pointer                  dcl 455 in procedure "check_arg_addrs" set ref 472*
                                                                                  474 477 479 481 484 493 506 506
p                               000100 automatic       pointer                  dcl 526 in procedure "check_block" set ref 530* 530*
                                                                                  531 533 533* 536
p                               000562 automatic       pointer                  dcl 589 in procedure "fill_list" set ref 596* 598*
                                                                                  600 600* 605 609* 611 613 614 621 623 625 626 626
                                                                                  626 629 629 631 635 639 639 642*
p2                              000120 automatic       pointer                  dcl 37 set ref 201* 202 202* 202 204 206* 207 225
                                                                                  233
p2s                             000122 automatic       pointer                  dcl 37 set ref 207* 211 213* 218* 218* 219 219* 219*
                                                                                  221
packed_digits_per_char                 constant        fixed bin(8,0)           initial dcl 11-5 ref 631
pad                       1(18) 000150 automatic       bit(18)                  level 3 packed unaligned dcl 549 set ref 561*
perm_address             12(18)        based           bit(1)                   level 3 packed unaligned dcl 1-3 set ref 160* 328*
                                                                                  443*
pr_no                     2     000150 automatic       bit(3)                   array level 3 packed unaligned dcl 549 set ref 623*
prepare_call                           constant        fixed bin(15,0)          initial dcl 76 ref 427
prepare_call_long                      constant        fixed bin(15,0)          initial dcl 76 ref 425
prepare_operand                 000022 constant        entry                    external dcl 46 ref 107 180 206 219 366 598
prepare_quick_call                     constant        fixed bin(15,0)          initial dcl 76 ref 419
prepare_quick_call_long                constant        fixed bin(15,0)          initial dcl 76 ref 417
pt                                     parameter       pointer                  dcl 30 in procedure "call_op" ref 28 101
pt                                     parameter       pointer                  dcl 526 in procedure "check_block" ref 524 530
q                               000102 automatic       pointer                  dcl 37 set ref 106* 107* 108* 179* 180* 183 185 185
                                                                                  201 206 235* 240 243 249* 252* 260
qualifier                 4            based           pointer                  level 2 packed unaligned dcl 1-3 ref 316 318 493
quick                           000155 automatic       bit(1)                   dcl 37 set ref 111* 114* 141 298 353 391 409
quick_call                             constant        fixed bin(15,0)          initial dcl 76 ref 144 422
rand_pt                         000100 automatic       pointer                  array dcl 132 set ref 274* 288* 340 438 472 596
realloc_char_temp                      constant        fixed bin(15,0)          initial dcl 76 ref 241
ref_count                 0(18)        based           fixed bin(17,0)          level 2 packed unaligned dcl 1-3 set ref 238* 238
                                                                                  267* 267 275 289* 344* 344
reference                              based           structure                level 1 dcl 1-3
reference_node                         constant        bit(9)                   initial dcl 9-5 ref 219
reset                           000156 automatic       bit(1)                   dcl 37 set ref 209* 223* 233
ret_pt                          000106 automatic       pointer                  dcl 37 set ref 102* 288* 404 404 404* 447 447 447
                                                                                  451
s                               000134 automatic       pointer                  dcl 455 set ref 477* 486 495 495 499 501 501* 501
                                                                                  504
sal_pt                          000112 automatic       pointer                  dcl 37 set ref 119* 127 129 136 158 167 355 572
save_cur_node                   000140 automatic       pointer                  dcl 37 set ref 100* 445
share_expression                000042 constant        entry                    external dcl 54 ref 218
shared                    0(11)        based           bit(1)                   level 2 packed unaligned dcl 1-3 ref 404 447 639
skip                            000144 automatic       fixed bin(17,0)          dcl 37 set ref 353* 365 374
son                       3            based           pointer                  level 2 packed unaligned dcl 5-5 ref 465 465 533 533
stack_temp$assign_temp          000030 constant        entry                    external dcl 46 ref 262 292 313
state_man$flush                 000076 constant        entry                    external dcl 54 ref 143 421 429
state_man$flush_address         000100 constant        entry                    external dcl 54 ref 600
storage                  11(23)        based           bit(1)                   level 4 in structure "reference" packed unaligned
                                                                                  dcl 1-3 in procedure "call_op" set ref 293*
storage                  11(08)        based           bit(1)                   level 4 in structure "reference" packed unaligned
                                                                                  dcl 1-3 in procedure "call_op" ref 481
storage_class            32(09)        based           structure                level 3 packed unaligned dcl 4-3
store$save_string_temp          000060 constant        entry                    external dcl 54 ref 242
store_bit_address               000046 constant        entry                    external dcl 54 ref 348
substr                                                 builtin function         dcl 74 set ref 345* 363 376* 436 639*
symbol                                 based           structure                level 1 dcl 4-3 in procedure "call_op"
symbol                    3            based           pointer                  level 2 in structure "reference" packed unaligned
                                                                                  dcl 1-3 in procedure "call_op" ref 113 393 477
tag                      10(30)        based           bit(6)                   level 3 packed unaligned dcl 1-3 set ref 325* 614*
temp_ref                 12(11)        based           bit(1)                   level 3 packed unaligned dcl 1-3 ref 282 342 479 639
temporary                              based           structure                level 1 unaligned dcl 6-3
type                                   based           bit(9)                   level 2 packed unaligned dcl 9-27 ref 183 202 219
units                     0(14)        based           fixed bin(3,0)           level 2 packed unaligned dcl 1-3 set ref 159* 506
                                                                                  506 605 626 629
use_itp                         000157 automatic       bit(1)                   dcl 37 set ref 300* 301 411
useless                         000154 automatic       bit(1)                   dcl 37 set ref 219*
value_in                 11(09)        based           structure                level 3 packed unaligned dcl 1-3
varying_ref               0(10)        based           bit(1)                   level 2 packed unaligned dcl 1-3 ref 264
word_                                  constant        fixed bin(3,0)           initial dcl 10-5 ref 159 506 605
word_size                22            based           pointer                  level 2 packed unaligned dcl 4-3 ref 488
xr_man$load_const               000064 constant        entry                    external dcl 54 ref 324 397
xr_man$super_lock               000066 constant        entry                    external dcl 54 ref 398
zero_mac                               constant        fixed bin(15,0)          initial dcl 76 ref 268

NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED.
ITP_MODIFIER                           internal static bit(6)                   initial unaligned dcl 12-56
ITS_MODIFIER                           internal static bit(6)                   initial unaligned dcl 12-55
a_format                               internal static bit(9)                   initial dcl 8-8
abs_fun                                internal static bit(9)                   initial dcl 8-8
acos_fun                               internal static bit(9)                   initial dcl 8-8
acosd_fun                              internal static bit(9)                   initial dcl 8-8
add                                    internal static bit(9)                   initial dcl 8-8
addbitno_fun                           internal static bit(9)                   initial dcl 8-8
addcharno_fun                          internal static bit(9)                   initial dcl 8-8
addr_fun                               internal static bit(9)                   initial dcl 8-8
addr_fun_bits                          internal static bit(9)                   initial dcl 8-8
addrel_fun                             internal static bit(9)                   initial dcl 8-8
alloc_char_temp                        internal static fixed bin(15,0)          initial dcl 76
allocation_fun                         internal static bit(9)                   initial dcl 8-8
allot_auto                             internal static bit(9)                   initial dcl 8-8
allot_based                            internal static bit(9)                   initial dcl 8-8
allot_ctl                              internal static bit(9)                   initial dcl 8-8
allot_var                              internal static bit(9)                   initial dcl 8-8
and_bits                               internal static bit(9)                   initial dcl 8-8
array_node                             internal static bit(9)                   initial dcl 9-5
asin_fun                               internal static bit(9)                   initial dcl 8-8
asind_fun                              internal static bit(9)                   initial dcl 8-8
assign_by_name                         internal static bit(9)                   initial dcl 8-8
assign_round                           internal static bit(9)                   initial dcl 8-8
assign_zero                            internal static bit(9)                   initial dcl 8-8
atan_fun                               internal static bit(9)                   initial dcl 8-8
atand_fun                              internal static bit(9)                   initial dcl 8-8
b_format                               internal static bit(9)                   initial dcl 8-8
baseno_fun                             internal static bit(9)                   initial dcl 8-8
baseptr_fun                            internal static bit(9)                   initial dcl 8-8
bit_pointer                            internal static bit(9)                   initial dcl 8-8
bit_to_char                            internal static bit(9)                   initial dcl 8-8
bit_to_word                            internal static bit(9)                   initial dcl 8-8
bitno_fun                              internal static bit(9)                   initial dcl 8-8
bits_per_four_words                    internal static fixed bin(8,0)           initial dcl 11-5
bits_per_half                          internal static fixed bin(8,0)           initial dcl 11-5
bits_per_packed_digit                  internal static fixed bin(8,1)           initial dcl 11-35
bits_per_two_words                     internal static fixed bin(8,0)           initial dcl 11-5
bits_per_word                          internal static fixed bin(8,0)           initial dcl 11-5
bits_per_words                         internal static fixed bin(8,0)           initial array dcl 11-5
block_node                             internal static bit(9)                   initial dcl 9-5
bn_format                              internal static bit(9)                   initial dcl 8-8
bool_fun                               internal static bit(9)                   initial dcl 8-8
bound_ck                               internal static bit(9)                   initial dcl 8-8
bound_node                             internal static bit(9)                   initial dcl 9-5
break_even_bits                        internal static fixed bin(8,0)           initial dcl 11-5
break_even_words                       internal static fixed bin(8,0)           initial dcl 11-5
by_name_agg_node                       internal static bit(9)                   initial dcl 9-5
byte_fun                               internal static bit(9)                   initial dcl 8-8
c_format                               internal static bit(9)                   initial dcl 8-8
cat_string                             internal static bit(9)                   initial dcl 8-8
ceil_fun                               internal static bit(9)                   initial dcl 8-8
cg_stat$temp_ref                       external static pointer                  dcl 32
cg_stat$text_pos                       external static fixed bin(18,0)          dcl 32
char_to_word                           internal static bit(9)                   initial dcl 8-8
charno_fun                             internal static bit(9)                   initial dcl 8-8
chars_per_word                         internal static fixed bin(8,0)           initial dcl 11-5
clock_fun                              internal static bit(9)                   initial dcl 8-8
close_file                             internal static bit(9)                   initial dcl 8-8
codeptr_fun                            internal static bit(9)                   initial dcl 8-8
column_format                          internal static bit(9)                   initial dcl 8-8
complex_fix_bin_1                      internal static fixed bin(15,0)          initial dcl 7-1
complex_fix_bin_2                      internal static fixed bin(15,0)          initial dcl 7-1
complex_fix_dec                        internal static fixed bin(15,0)          initial dcl 7-1
complex_flt_bin_1                      internal static fixed bin(15,0)          initial dcl 7-1
complex_flt_bin_2                      internal static fixed bin(15,0)          initial dcl 7-1
complex_flt_dec                        internal static fixed bin(15,0)          initial dcl 7-1
complex_fun                            internal static bit(9)                   initial dcl 8-8
conjg_fun                              internal static bit(9)                   initial dcl 8-8
context_node                           internal static bit(9)                   initial dcl 9-5
convert_offset                         internal static fixed bin(8,1)           initial array dcl 11-35
convert_size                           internal static fixed bin(8,0)           initial array dcl 11-5
copy_string                            internal static bit(9)                   initial dcl 8-8
copy_words                             internal static bit(9)                   initial dcl 8-8
cos_fun                                internal static bit(9)                   initial dcl 8-8
cosd_fun                               internal static bit(9)                   initial dcl 8-8
cross_reference_node                   internal static bit(9)                   initial dcl 9-5
default_fix_bin_p                      internal static fixed bin(8,0)           initial dcl 11-5
default_node                           internal static bit(9)                   initial dcl 9-5
delete_file                            internal static bit(9)                   initial dcl 8-8
desc_size                              internal static bit(9)                   initial dcl 8-8
digit_                                 internal static fixed bin(3,0)           initial dcl 10-5
digit_to_bit                           internal static bit(9)                   initial dcl 8-8
div                                    internal static bit(9)                   initial dcl 8-8
do_fun                                 internal static bit(9)                   initial dcl 8-8
do_spec                                internal static bit(9)                   initial dcl 8-8
e_format                               internal static bit(9)                   initial dcl 8-8
empty_area                             internal static bit(9)                   initial dcl 8-8
enable_on                              internal static bit(9)                   initial dcl 8-8
environmentptr_fun                     internal static bit(9)                   initial dcl 8-8
equal                                  internal static bit(9)                   initial dcl 8-8
ex_prologue                            internal static bit(9)                   initial dcl 8-8
exp                                    internal static bit(9)                   initial dcl 8-8
exp_fun                                internal static bit(9)                   initial dcl 8-8
ext_entry_in                           internal static fixed bin(15,0)          initial dcl 7-1
ext_entry_out                          internal static fixed bin(15,0)          initial dcl 7-1
f_format                               internal static bit(9)                   initial dcl 8-8
floor_fun                              internal static bit(9)                   initial dcl 8-8
format_value_node                      internal static bit(9)                   initial dcl 9-5
fortran_read                           internal static bit(9)                   initial dcl 8-8
fortran_write                          internal static bit(9)                   initial dcl 8-8
free_based                             internal static bit(9)                   initial dcl 8-8
free_ctl                               internal static bit(9)                   initial dcl 8-8
free_var                               internal static bit(9)                   initial dcl 8-8
ftn_file_manip                         internal static bit(9)                   initial dcl 8-8
ftn_trans_loop                         internal static bit(9)                   initial dcl 8-8
get_data_trans                         internal static bit(9)                   initial dcl 8-8
get_edit_trans                         internal static bit(9)                   initial dcl 8-8
get_file                               internal static bit(9)                   initial dcl 8-8
get_list_trans                         internal static bit(9)                   initial dcl 8-8
get_string                             internal static bit(9)                   initial dcl 8-8
greater_or_equal                       internal static bit(9)                   initial dcl 8-8
greater_than                           internal static bit(9)                   initial dcl 8-8
half_                                  internal static fixed bin(3,0)           initial dcl 10-5
half_to_word                           internal static bit(9)                   initial dcl 8-8
hbound                                                 builtin function         dcl 74
imag_fun                               internal static bit(9)                   initial dcl 8-8
index_after_fun                        internal static bit(9)                   initial dcl 8-8
index_before_fun                       internal static bit(9)                   initial dcl 8-8
index_fun                              internal static bit(9)                   initial dcl 8-8
index_rev_fun                          internal static bit(9)                   initial dcl 8-8
itp_unsigned                           based           structure                level 1 dcl 12-43
its                                    based           structure                level 1 dcl 12-5
its_unsigned                           based           structure                level 1 dcl 12-30
join                                   internal static bit(9)                   initial dcl 8-8
jump                                   internal static bit(9)                   initial dcl 8-8
jump_false                             internal static bit(9)                   initial dcl 8-8
jump_if_eq                             internal static bit(9)                   initial dcl 8-8
jump_if_ge                             internal static bit(9)                   initial dcl 8-8
jump_if_gt                             internal static bit(9)                   initial dcl 8-8
jump_if_le                             internal static bit(9)                   initial dcl 8-8
jump_if_lt                             internal static bit(9)                   initial dcl 8-8
jump_if_ne                             internal static bit(9)                   initial dcl 8-8
jump_true                              internal static bit(9)                   initial dcl 8-8
l_parn                                 internal static bit(9)                   initial dcl 8-8
label_array_element_node               internal static bit(9)                   initial dcl 9-5
label_constant                         internal static fixed bin(15,0)          initial dcl 7-1
label_node                             internal static bit(9)                   initial dcl 9-5
label_size                             internal static fixed bin(8,0)           initial dcl 11-5
label_variable                         internal static fixed bin(15,0)          initial dcl 7-1
length_fun                             internal static bit(9)                   initial dcl 8-8
less_or_equal                          internal static bit(9)                   initial dcl 8-8
less_than                              internal static bit(9)                   initial dcl 8-8
line_format                            internal static bit(9)                   initial dcl 8-8
list_node                              internal static bit(9)                   initial dcl 9-5
load_size                       000000 constant        entry                    external dcl 46
local_label_variable                   internal static fixed bin(15,0)          initial dcl 7-1
locate_file                            internal static bit(9)                   initial dcl 8-8
lock_file                              internal static bit(9)                   initial dcl 8-8
lock_fun                               internal static bit(9)                   initial dcl 8-8
log10_fun                              internal static bit(9)                   initial dcl 8-8
log2_fun                               internal static bit(9)                   initial dcl 8-8
log_fun                                internal static bit(9)                   initial dcl 8-8
long_op$c_or_b                  000000 constant        entry                    external dcl 54
loop                                   internal static bit(9)                   initial dcl 8-8
machine_state_node                     internal static bit(9)                   initial dcl 9-5
macro1                                 automatic       fixed bin(15,0)          dcl 37
macro2                                 automatic       fixed bin(15,0)          dcl 37
make_desc                              internal static bit(9)                   initial dcl 8-8
max_block_number                       internal static fixed bin(17,0)          initial dcl 5-74
max_dec_scale                          internal static fixed bin(8,0)           initial dcl 11-5
max_fun                                internal static bit(9)                   initial dcl 8-8
max_index_register_value               internal static fixed bin(31,0)          initial dcl 11-38
max_length_p                           internal static fixed bin(8,0)           initial dcl 11-5
max_number_of_operands                 internal static fixed bin(15,0)          initial dcl 2-15
max_offset                             internal static fixed bin(8,0)           initial array dcl 11-5
max_p_fix_bin_1                        internal static fixed bin(8,0)           initial dcl 11-5
max_p_fix_dec                          internal static fixed bin(8,0)           initial dcl 11-5
max_p_flt_bin_1                        internal static fixed bin(8,0)           initial dcl 11-5
max_p_xreg                             internal static fixed bin(8,0)           initial dcl 11-5
max_short_size                         internal static fixed bin(8,0)           initial array dcl 11-5
min_dec_scale                          internal static fixed bin(8,0)           initial dcl 11-5
min_fun                                internal static bit(9)                   initial dcl 8-8
mod2_                                  internal static fixed bin(3,0)           initial dcl 10-5
mod4_                                  internal static fixed bin(3,0)           initial dcl 10-5
mod_bit                                internal static bit(9)                   initial dcl 8-8
mod_byte                               internal static bit(9)                   initial dcl 8-8
mod_fun                                internal static bit(9)                   initial dcl 8-8
mod_half                               internal static bit(9)                   initial dcl 8-8
mod_word                               internal static bit(9)                   initial dcl 8-8
mult                                   internal static bit(9)                   initial dcl 8-8
n                                      automatic       fixed bin(17,0)          dcl 37
negate                                 internal static bit(9)                   initial dcl 8-8
nop                                    internal static bit(9)                   initial dcl 8-8
not_bits                               internal static bit(9)                   initial dcl 8-8
not_equal                              internal static bit(9)                   initial dcl 8-8
off_fun                                internal static bit(9)                   initial dcl 8-8
open_file                              internal static bit(9)                   initial dcl 8-8
or_bits                                internal static bit(9)                   initial dcl 8-8
p3                                     automatic       pointer                  dcl 37
pack                                   internal static bit(9)                   initial dcl 8-8
packed_digits_per_word                 internal static fixed bin(8,0)           initial dcl 11-5
packed_ptr                             internal static fixed bin(15,0)          initial dcl 7-1
page_format                            internal static bit(9)                   initial dcl 8-8
param_desc_ptr                         internal static bit(9)                   initial dcl 8-8
param_ptr                              internal static bit(9)                   initial dcl 8-8
picture_format                         internal static bit(9)                   initial dcl 8-8
pl1_mod_fun                            internal static bit(9)                   initial dcl 8-8
prefix_plus                            internal static bit(9)                   initial dcl 8-8
ptr_fun                                internal static bit(9)                   initial dcl 8-8
put_control                            internal static bit(9)                   initial dcl 8-8
put_data_trans                         internal static bit(9)                   initial dcl 8-8
put_edit_trans                         internal static bit(9)                   initial dcl 8-8
put_field                              internal static bit(9)                   initial dcl 8-8
put_field_chk                          internal static bit(9)                   initial dcl 8-8
put_file                               internal static bit(9)                   initial dcl 8-8
put_list_trans                         internal static bit(9)                   initial dcl 8-8
put_string                             internal static bit(9)                   initial dcl 8-8
r_format                               internal static bit(9)                   initial dcl 8-8
r_parn                                 internal static bit(9)                   initial dcl 8-8
range_ck                               internal static bit(9)                   initial dcl 8-8
rank_fun                               internal static bit(9)                   initial dcl 8-8
read_file                              internal static bit(9)                   initial dcl 8-8
real_fix_bin_1                         internal static fixed bin(15,0)          initial dcl 7-1
real_fix_bin_2                         internal static fixed bin(15,0)          initial dcl 7-1
real_fix_dec                           internal static fixed bin(15,0)          initial dcl 7-1
real_flt_bin_1                         internal static fixed bin(15,0)          initial dcl 7-1
real_flt_bin_2                         internal static fixed bin(15,0)          initial dcl 7-1
real_flt_dec                           internal static fixed bin(15,0)          initial dcl 7-1
real_fun                               internal static bit(9)                   initial dcl 8-8
record_io                              internal static bit(9)                   initial dcl 8-8
refer                                  internal static bit(9)                   initial dcl 8-8
rel_fun                                internal static bit(9)                   initial dcl 8-8
repeat_fun                             internal static bit(9)                   initial dcl 8-8
return_bits                            internal static bit(9)                   initial dcl 8-8
return_string                          internal static bit(9)                   initial dcl 8-8
return_value                           internal static bit(9)                   initial dcl 8-8
return_words                           internal static bit(9)                   initial dcl 8-8
reverse_fun                            internal static bit(9)                   initial dcl 8-8
revert_on                              internal static bit(9)                   initial dcl 8-8
rewrite_file                           internal static bit(9)                   initial dcl 8-8
round_fun                              internal static bit(9)                   initial dcl 8-8
search_fun                             internal static bit(9)                   initial dcl 8-8
search_rev_fun                         internal static bit(9)                   initial dcl 8-8
segno_fun                              internal static bit(9)                   initial dcl 8-8
setbitno_fun                           internal static bit(9)                   initial dcl 8-8
setcharno_fun                          internal static bit(9)                   initial dcl 8-8
sf_par_node                            internal static bit(9)                   initial dcl 9-5
sign_fun                               internal static bit(9)                   initial dcl 8-8
signal_on                              internal static bit(9)                   initial dcl 8-8
sin_fun                                internal static bit(9)                   initial dcl 8-8
sind_fun                               internal static bit(9)                   initial dcl 8-8
skip_format                            internal static bit(9)                   initial dcl 8-8
source_node                            internal static bit(9)                   initial dcl 9-5
sqrt_fun                               internal static bit(9)                   initial dcl 8-8
stack_ptr                              internal static bit(9)                   initial dcl 8-8
stack_temp$free_temp            000000 constant        entry                    external dcl 46
stackbaseptr_fun                       internal static bit(9)                   initial dcl 8-8
stackframeptr_fun                      internal static bit(9)                   initial dcl 8-8
stacq_fun                              internal static bit(9)                   initial dcl 8-8
statement_node                         internal static bit(9)                   initial dcl 9-5
std_arg_list                           internal static bit(9)                   initial dcl 8-8
std_call                               internal static bit(9)                   initial dcl 8-8
std_entry                              internal static bit(9)                   initial dcl 8-8
std_return                             internal static bit(9)                   initial dcl 8-8
stop                                   internal static bit(9)                   initial dcl 8-8
stream_prep                            internal static bit(9)                   initial dcl 8-8
sub                                    internal static bit(9)                   initial dcl 8-8
symbol_node                            internal static bit(9)                   initial dcl 9-5
tan_fun                                internal static bit(9)                   initial dcl 8-8
tand_fun                               internal static bit(9)                   initial dcl 8-8
temporary_node                         internal static bit(9)                   initial dcl 9-5
terminate_trans                        internal static bit(9)                   initial dcl 8-8
token_node                             internal static bit(9)                   initial dcl 9-5
translate_fun                          internal static bit(9)                   initial dcl 8-8
trunc_fun                              internal static bit(9)                   initial dcl 8-8
units_per_word                         internal static fixed bin(8,0)           initial array dcl 11-5
unlock_file                            internal static bit(9)                   initial dcl 8-8
unpack                                 internal static bit(9)                   initial dcl 8-8
unpacked_ptr                           internal static fixed bin(15,0)          initial dcl 7-1
vclock_fun                             internal static bit(9)                   initial dcl 8-8
verify_fun                             internal static bit(9)                   initial dcl 8-8
verify_ltrim_fun                       internal static bit(9)                   initial dcl 8-8
verify_rev_fun                         internal static bit(9)                   initial dcl 8-8
verify_rtrim_fun                       internal static bit(9)                   initial dcl 8-8
word_to_mod2                           internal static bit(9)                   initial dcl 8-8
word_to_mod4                           internal static bit(9)                   initial dcl 8-8
word_to_mod8                           internal static bit(9)                   initial dcl 8-8
wordno_fun                             internal static bit(9)                   initial dcl 8-8
write_file                             internal static bit(9)                   initial dcl 8-8
x_format                               internal static bit(9)                   initial dcl 8-8
xor_bits                               internal static bit(9)                   initial dcl 8-8
xr                                     automatic       fixed bin(3,0)           dcl 37
xr_man$load_any_const           000000 constant        entry                    external dcl 54

NAMES DECLARED BY EXPLICIT CONTEXT.
call_op                         000022 constant        entry                    external dcl 28
check_arg_addrs                 002224 constant        entry                    internal dcl 453 ref 300
check_block                     002401 constant        entry                    internal dcl 524 ref 465 533
done                            002175 constant        label                    dcl 443 ref 145 433
fail                            002375 constant        label                    dcl 518 in procedure "check_arg_addrs" ref 460 465
                                                                                  474 481 488 493 495 499 504 506
fail                            002453 constant        label                    dcl 540 in procedure "check_block" ref 531 533
fill_list                       002553 constant        entry                    internal dcl 585 ref 568 577
gen_itp_list                    002456 constant        entry                    internal dcl 544 ref 303
l1                              000651 constant        label                    dcl 252 ref 188
l2                              001511 constant        label                    dcl 382 ref 164 304 356
l3                              001511 constant        label                    dcl 382 ref 153
next                            001507 constant        label                    dcl 380 ref 363
step                            000741 constant        label                    dcl 274 ref 182 183 246

NAMES DECLARED BY CONTEXT OR IMPLICATION.
divide                                                 builtin function         ref 631
string                                                 builtin function         set ref 327 327 600 619* 635

STORAGE REQUIREMENTS FOR THIS PROGRAM.

	Object	Text	Link	Symbol	Defs	Static
Start          0       0      3422        3530    3043        3432
Length      4206    3043       106         442     356           0

BLOCK NAME	         STACK SIZE     TYPE		WHY NONQUICK/WHO SHARES STACK FRAME
call_op                             126 external procedure  is an external procedure.  
begin block on line 131             437 begin block         uses auto adjustable storage.  
check_arg_addrs                         internal procedure  shares stack frame of begin block on line 131.  
check_block                          78 internal procedure  calls itself recursively.  
gen_itp_list                            internal procedure  shares stack frame of begin block on line 131.  
fill_list                               internal procedure  shares stack frame of begin block on line 131.  

STORAGE FOR AUTOMATIC VARIABLES.

STACK FRAME                 LOC IDENTIFIER                  BLOCK NAME
begin block on line 131  000100 adjust                      begin block on line 131
                         000100 already                     begin block on line 131
                         000100 rand_pt                     begin block on line 131
                         000130 f                           check_arg_addrs
                         000132 p                           check_arg_addrs
                         000134 s                           check_arg_addrs
                         000146 iscan                       gen_itp_list
                         000147 doing_descriptors           gen_itp_list
                         000150 arg_list                    gen_itp_list
                         000560 eis                         fill_list
                         000562 p                           fill_list
call_op                  000100 p                           call_op
                         000102 q                           call_op
                         000104 node_pt                     call_op
                         000106 ret_pt                      call_op
                         000110 ent_pt                      call_op
                         000112 sal_pt                      call_op
                         000114 arglist                     call_op
                         000116 ap                          call_op
                         000120 p2                          call_op
                         000122 p2s                         call_op
                         000124 arg                         call_op
                         000132 args                        call_op
                         000134 descs                       call_op
                         000136 ent_blk                     call_op
                         000140 save_cur_node               call_op
                         000142 i                           call_op
                         000143 j                           call_op
                         000144 skip                        call_op
                         000145 ent_type                    call_op
                         000146 n_args                      call_op
                         000147 arg_pos                     call_op
                         000150 dt                          call_op
                         000151 last_freed                  call_op
                         000152 arg_list_extent             call_op
                         000153 atom                        call_op
                         000154 useless                     call_op
                         000155 quick                       call_op
                         000156 reset                       call_op
                         000157 use_itp                     call_op
check_block              000100 p                           check_block

THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM.
r_e_as              r_ne_as             unpk_to_pk          enter_begin         call_ext_out        call_int_this
call_int_other      begin_return        return              alloc_auto_adj      signal              ext_entry
int_entry

THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM.
adjust_ref_count              base_man$load_var             base_man$store_ptr_to         c_a
cg_error                      compare_expression            compile_exp                   compile_exp$save
compile_exp$save_exp          copy_temp                     expmac                        expmac$many
expmac$zero                   generate_constant$relocatable long_op$extend_stack          m_a
need_temp                     prepare_operand               share_expression              stack_temp$assign_temp
state_man$flush               state_man$flush_address       store$save_string_temp        store_bit_address
xr_man$load_const             xr_man$super_lock

THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM.
cg_stat$cur_block             cg_stat$cur_level             cg_stat$cur_node              cg_stat$cur_tree
cg_stat$double_temp




   LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC   
     28 000016       100 000027       101 000032       102 000037       106 000042       107 000045       108 000063
    110 000077       111 000103       113 000107       114 000112       119 000116       127 000121       129 000130
    131 000135       132 000140       133 000147       136 000165       141 000171       143 000173       144 000200
    145 000214       150 000215       151 000221       152 000223       153 000224       158 000225       159 000230
    160 000234       161 000236       163 000241       164 000243       167 000244       168 000247       170 000253
    172 000255       173 000270       178 000273       179 000302       180 000304       182 000323       183 000327
    185 000333       188 000343       201 000347       202 000352       204 000360       206 000364       207 000406
    209 000413       211 000414       213 000422       218 000442       219 000453       221 000477       222 000504
    223 000505       225 000510       233 000525       235 000532       236 000543       238 000544       239 000551
    240 000554       241 000566       242 000603       243 000613       246 000632       249 000633       252 000651
    260 000675       262 000700       264 000707       266 000713       267 000716       268 000723       269 000736
    274 000741       275 000747       278 000772       282 000775       286 001004       288 001007       289 001030
    292 001033       293 001043       298 001047       300 001051       301 001057       303 001063       304 001064
    310 001065       312 001071       313 001104       316 001114       318 001122       320 001124       323 001150
    324 001166       325 001202       326 001206       327 001207       328 001212       337 001214       338 001223
    339 001234       340 001247       342 001254       344 001257       345 001264       348 001271       349 001304
    353 001307       355 001325       356 001330       360 001334       361 001343       363 001354       365 001361
    366 001375       367 001417       371 001431       372 001444       374 001451       375 001466       376 001477
    378 001505       380 001507       382 001511       387 001515       389 001540       391 001557       393 001565
    395 001574       397 001575       398 001607       399 001620       404 001623       409 001651       411 001654
    413 001657       414 001676       416 001716       417 001717       419 001744       421 001765       422 001772
    423 002006       425 002007       427 002034       428 002055       429 002075       430 002102       433 002126
    435 002134       436 002146       438 002153       439 002157       441 002172       443 002175       445 002201
    447 002204       451 002216       650 002223       453 002224       460 002226       465 002234       471 002256
    472 002270       474 002274       477 002277       479 002301       481 002304       484 002307       486 002312
    487 002320       488 002323       491 002326       493 002327       495 002332       498 002342       499 002343
    501 002346       504 002353       506 002357       514 002366       516 002371       518 002375       524 002400
    530 002406       531 002416       533 002422       536 002443       538 002447       540 002453       544 002456
    560 002457       561 002460       562 002463       563 002472       564 002473       568 002500       572 002501
    573 002506       575 002512       576 002516       577 002520       578 002521       579 002522       583 002524
    647 002552       585 002553       593 002554       594 002566       596 002567       598 002600       600 002621
    605 002634       607 002643       609 002645       611 002656       613 002662       614 002664       619 002666
    621 002674       623 002700       624 002704       625 002707       626 002721       629 002742       631 002757
    633 002772       635 002773       639 002775       642 003014       643 003027       645 003032       653 003033


                                          -----------------------------------------------------------


Historical Background

This edition of the Multics software materials and documentation is provided and donated
to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. 
as a contribution to computer science knowledge.  
This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology,
Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL
and BULL HN Information Systems Inc. to the development of this operating system. 
Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970),
renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership
of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture 
for managing computer hardware properly and for executing programs. Many subsequent operating systems 
incorporated Multics principles.
Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., 
as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. .

                                          -----------------------------------------------------------

Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without
fee is hereby granted,provided that the below copyright notice and historical background appear in all copies
and that both the copyright notice and historical background and this permission notice appear in supporting
documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining
to distribution of the programs without specific prior written permission.
    Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.
    Copyright 2006 by BULL HN Information Systems Inc.
    Copyright 2006 by Bull SAS
    All Rights Reserved