THIS FILE IS DAMAGED

	COMPILATION LISTING OF SEGMENT prepare_operand
	Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983
	Compiled at: Honeywell LCPD Phoenix, System M
	Compiled on: 10/03/83  1654.9 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 /* program to process operand of an operator node
       12*
       13*	Modified:  21 May 1973 by RAB for multiple base regs
       14*	Modified:	19 June 1973 by RAB for EIS
       15*	Modified:	8 August 1974 by RAB to fix 1206
       16*	Modified:	18 November 1974 by RAB to fix 1257, 1258
       17*	Modified:	22 November 1974 by RAB to remove setting of passed_as_arg
       18*	Modified:	26 June 1976 by RAB to fix 1503 (changed handling of
       19*		qualifier for defined_ref)
       20*	Modified:	5 Oct 1976 by RAB to improve unspec(char_expr)
       21*	Modified:	24 Nov 1976 by RAB to fix 1555
       22*	Modified:	14 Sept 1977 by RAB to fix 1662
       23*	Modified:	15 Dec 1977 by RAB to fix 1694
       24*	Modified:	9 March 1978 by RAB to fix 1714 (setting of aligned_ref for packed decimal)
       25*	Modified:	22 Jan 1979 by RAB to fix 1814 (ERROR 313 for multiple occurrences of
       26*		packed based qualifiers in if stmt)
       27*		pointer_chain now sets reference.evaluated after call to
       28*		base_man$load_packed
       29*	Modified: 25 Apr 1979 by PCK to implement 4-bit decimal
       30*	Modified: 4 Mar 1980 by PCK to fix 1910 and 1911
       31*	Modified:	30 Mar 1980 by RAB to add reference.(padded aligned)_for_store_ref
       32*		as a partial fix to bug 1186, the famous PADDED REFERENCE BUG.
       33*          Modified 830118 BIM to copy_temp on all pointers.
       34*	Modified 830427 BIM to support ptr options (packed);
       35**/
       36 
       37 /* format: style3,^indnoniterdo,indend */
       38 prepare_operand:
       39      proc (pt, evaluate, atomic) returns (ptr);
       40 
       41 dcl	pt		ptr,			/* points at reference|operator node */
       42 	evaluate		fixed bin,		/* < 0 means evaluate offset but not size,
       43*				   = 0 means don't evaluate size or offset,
       44*				   > 0 means evaluate size and offset */
       45 	atomic		bit (1) aligned;		/* set "1"b if operand is atomic */
       46 
       47 dcl	(p, p1, p2, q, s)	ptr,
       48 	(cfo, eval, n, bit_length)
       49 			fixed bin,
       50 	(str, useless, here_before, padded_bit)
       51 			bit (1) aligned,
       52 	op_code		bit (9) aligned;
       53 
       54 dcl	(
       55 	cg_stat$long_string_temp,
       56 	cg_stat$cur_block,
       57 	cg_stat$cur_statement,
       58 	cg_stat$cur_node
       59 	)		ptr ext;
       60 
       61 dcl	(
       62 	assign_op,
       63 	compile_exp,
       64 	stack_temp$assign_aggregate,
       65 	state_man$update_ref
       66 	)		entry (ptr),
       67 	adjust_ref_count	entry (ptr, fixed bin),
       68 	state_man$update_reg
       69 			entry (ptr, bit (19) aligned),
       70 	state_man$erase_reg entry (bit (19) aligned),
       71 	(
       72 	compile_exp$save,
       73 	compile_exp$save_exp
       74 	)		entry (ptr) returns (ptr),
       75 	eval_exp		entry (ptr, bit (1) aligned) returns (ptr),
       76 	get_reference	entry returns (ptr),
       77 	prepare_operand	entry (ptr, fixed bin, bit (1) aligned) returns (ptr),
       78 	copy_temp		entry (ptr) returns (ptr),
       79 	generate_constant$real_fix_bin_1
       80 			entry (fixed bin) returns (ptr),
       81 	check_o_and_s	entry (ptr) returns (ptr),
       82 	load		entry (ptr, fixed bin),
       83 	call_op		entry (ptr) returns (ptr),
       84 	base_man$load_packed
       85 			entry (ptr, fixed bin),
       86 	pointer_builtins	entry (ptr, bit (1) aligned),
       87 	length_op		entry (ptr) returns (ptr),
       88 	assign_desc_op	entry (ptr) returns (ptr),
       89 	decimal_op$change_target
       90 			entry (ptr) returns (bit (1) aligned),
       91 	decimal_op$get_float_temp
       92 			entry (fixed bin (24), bit (1) aligned) returns (ptr),
       93 	assign_op$to_dec_scaled
       94 			entry (ptr, ptr);
       95 
       96 dcl	(addrel, divide, fixed, max, mod, null, string, substr)
       97 			builtin;
       98 
       99 dcl	fix_bin		(0:1) fixed bin based;
      100 
      101 dcl	io_class		init ("10000"b) bit (5) int static;
      102 
  1     1 /* BEGIN INCLUDE FILE ... cgsystem.incl.pl1 */
  1     2 
  1     3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */
  1     4 
  1     5 dcl (	bits_per_char		init(9),
  1     6 	bits_per_half		init(18),
  1     7 	bits_per_word		init(36),
  1     8 	bits_per_two_words		init(72),
  1     9 	bits_per_four_words		init(144),
  1    10 	bits_per_words(2)		init(36,72),
  1    11 	packed_digits_per_char	init(2),
  1    12 	chars_per_word		init(4),
  1    13 	packed_digits_per_word	init(8),
  1    14 
  1    15 	break_even_bits		init(216),
  1    16 	break_even_words		init(6),
  1    17 
  1    18 	label_size		init(4),
  1    19 
  1    20 	convert_size(13:14)		init(9,1),
  1    21 	max_offset(13:14)		init(27,35),
  1    22 	max_short_size(13:14)	init(8,72),
  1    23 
  1    24 	units_per_word(0:5)		init(1,36,8,4,2,1),
  1    25 
  1    26 	max_dec_scale		init(32),
  1    27 	min_dec_scale		init(-31),
  1    28 	max_p_xreg		init(18),
  1    29 	max_p_fix_bin_1		init(35),
  1    30 	max_p_flt_bin_1		init(27),
  1    31 	max_p_fix_dec		init(59),
  1    32 	max_length_p		init(24),
  1    33 	default_fix_bin_p		init(17)) fixed bin(8) int static options(constant);
  1    34 
  1    35 dcl      (convert_offset(0:5)		init(36,1,4.5,9,18,36),
  1    36 	bits_per_packed_digit	init(4.5)) fixed bin(8,1) int static options(constant);
  1    37 
  1    38 dcl	max_index_register_value	init(262143) fixed bin(31) int static options(constant);
  1    39 
  1    40 /* END INCLUDE FILE ... cgsystem.incl.pl1 */
  1    41 
      103 
  2     1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */
  2     2 
  2     3 dcl	1 reference		based aligned,
  2     4 	2 node_type		bit(9) unaligned,
  2     5 	2 array_ref		bit(1) unaligned,
  2     6 	2 varying_ref		bit(1) unaligned,
  2     7 	2 shared			bit(1) unaligned,
  2     8 	2 put_data_sw		bit(1) unaligned,
  2     9 	2 processed		bit(1) unaligned,
  2    10 	2 units			fixed(3) unaligned,
  2    11 	2 ref_count		fixed(17) unaligned,
  2    12 	2 c_offset		fixed(24),
  2    13 	2 c_length		fixed(24),
  2    14 	2 symbol			ptr unaligned,
  2    15 	2 qualifier		ptr unaligned,
  2    16 	2 offset			ptr unaligned,
  2    17 	2 length			ptr unaligned,
  2    18 	2 subscript_list		ptr unaligned,
  2    19 						/* these fields are used by the 645 code generator */
  2    20 	2 address			structure unaligned,
  2    21 	  3 base			bit(3),
  2    22 	  3 offset		bit(15),
  2    23 	  3 op			bit(9),
  2    24 	  3 no_address		bit(1),
  2    25 	  3 inhibit		bit(1),
  2    26 	  3 ext_base		bit(1),
  2    27 	  3 tag			bit(6),
  2    28 	2 info			structure unaligned,
  2    29 	  3 address_in		structure,
  2    30 	    4 b			dimension(0:7) bit(1),
  2    31 	    4 storage		bit(1),
  2    32 	  3 value_in		structure,
  2    33 	    4 a			bit(1),
  2    34 	    4 q			bit(1),
  2    35 	    4 aq			bit(1),
  2    36 	    4 string_aq		bit(1),
  2    37 	    4 complex_aq		bit(1),
  2    38 	    4 decimal_aq		bit(1),
  2    39 	    4 b			dimension(0:7) bit(1),
  2    40 	    4 storage		bit(1),
  2    41 	    4 indicators		bit(1),
  2    42 	    4 x			dimension(0:7) bit(1),
  2    43 	  3 other			structure,
  2    44 	    4 big_offset		bit(1),
  2    45 	    4 big_length		bit(1),
  2    46 	    4 modword_in_offset	bit(1),
  2    47 	2 data_type		fixed(5) unaligned,
  2    48 	2 bits			structure unaligned,
  2    49 	  3 padded_ref		bit(1),
  2    50 	  3 aligned_ref		bit(1),
  2    51 	  3 long_ref		bit(1),
  2    52 	  3 forward_ref		bit(1),
  2    53 	  3 ic_ref		bit(1),
  2    54 	  3 temp_ref		bit(1),
  2    55 	  3 defined_ref		bit(1),
  2    56 	  3 evaluated		bit(1),
  2    57 	  3 allocate		bit(1),
  2    58 	  3 allocated		bit(1),
  2    59 	  3 aliasable		bit(1),
  2    60 	  3 even			bit(1),
  2    61 	  3 perm_address		bit(1),
  2    62 	  3 aggregate		bit(1),
  2    63 	  3 hit_zero		bit(1),
  2    64 	  3 dont_save		bit(1),
  2    65 	  3 fo_in_qual		bit(1),
  2    66 	  3 hard_to_load		bit(1),
  2    67 	2 relocation		bit(12) unaligned,
  2    68 	2 more_bits		structure unaligned,
  2    69 	  3 substr		bit(1),
  2    70 	  3 padded_for_store_ref	bit(1),
  2    71 	  3 aligned_for_store_ref	bit(1),
  2    72 	  3 mbz			bit(15),
  2    73 	2 store_ins		bit(18) unaligned;
  2    74 
  2    75 /* END INCLUDE FILE ... reference.incl.pl1 */
      104 
  3     1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */
  3     2 
  3     3 dcl	1 symbol			based aligned,
  3     4 	2 node_type		bit(9) unal,
  3     5 	2 source_id		structure unal,
  3     6 	  3 file_number		bit(8),
  3     7 	  3 line_number		bit(14),
  3     8 	  3 statement_number	bit(5),
  3     9 	2 location		fixed(18) unal unsigned,
  3    10 	2 allocated		bit(1) unal,
  3    11 	2 dcl_type		bit(3) unal,
  3    12 	2 reserved		bit(6) unal,
  3    13 	2 pix			unal,
  3    14 	  3 pic_fixed		bit(1) unal,
  3    15 	  3 pic_float		bit(1) unal,
  3    16 	  3 pic_char		bit(1) unal,
  3    17 	  3 pic_scale		fixed(7) unal,
  3    18 	  3 pic_size		fixed(7) unal,
  3    19 	2 level			fixed(8) unal,
  3    20 	2 boundary		fixed(3) unal,
  3    21 	2 size_units		fixed(3) unal,
  3    22 	2 scale			fixed(7) unal,
  3    23 	2 runtime			bit(18) unal,
  3    24 	2 runtime_offset		bit(18) unal,
  3    25 	2 block_node		ptr unal,
  3    26 	2 token			ptr unal,
  3    27 	2 next			ptr unal,
  3    28 	2 multi_use		ptr unal,
  3    29 	2 cross_references		ptr unal,
  3    30 	2 initial			ptr unal,
  3    31 	2 array			ptr unal,
  3    32 	2 descriptor		ptr unal,
  3    33 	2 equivalence		ptr unal,
  3    34 	2 reference		ptr unal,
  3    35 	2 general			ptr unal,
  3    36 	2 father			ptr unal,
  3    37 	2 brother			ptr unal,
  3    38 	2 son			ptr unal,
  3    39 	2 word_size		ptr unal,
  3    40 	2 bit_size		ptr unal,
  3    41 	2 dcl_size		ptr unal,
  3    42 	2 symtab_size		ptr unal,
  3    43 	2 c_word_size		fixed(24),
  3    44 	2 c_bit_size		fixed(24),
  3    45 	2 c_dcl_size		fixed(24),
  3    46 
  3    47 	2 attributes		structure aligned,
  3    48 	  3 data_type		structure unal,
  3    49 	    4 structure		bit(1) ,
  3    50 	    4 fixed		bit(1),
  3    51 	    4 float		bit(1),
  3    52 	    4 bit			bit(1),
  3    53 	    4 char		bit(1),
  3    54 	    4 ptr			bit(1),
  3    55 	    4 offset		bit(1),
  3    56 	    4 area		bit(1),
  3    57 	    4 label		bit(1),
  3    58 	    4 entry		bit(1),
  3    59 	    4 file		bit(1),
  3    60 	    4 arg_descriptor	bit(1),
  3    61 	    4 storage_block		bit(1),
  3    62 	    4 explicit_packed	bit(1), /* options(packed) */
  3    63 	    4 condition		bit(1),
  3    64 	    4 format		bit(1),
  3    65 	    4 builtin		bit(1),
  3    66 	    4 generic		bit(1),
  3    67 	    4 picture		bit(1),
  3    68 
  3    69 	  3 misc_attributes		structure unal,
  3    70 	    4 dimensioned		bit(1),
  3    71 	    4 initialed		bit(1),
  3    72 	    4 aligned		bit(1),
  3    73 	    4 unaligned		bit(1),
  3    74 	    4 signed		bit(1),
  3    75 	    4 unsigned		bit(1),
  3    76 	    4 precision		bit(1),
  3    77 	    4 varying		bit(1),
  3    78 	    4 local		bit(1),
  3    79 	    4 decimal		bit(1),
  3    80 	    4 binary		bit(1),
  3    81 	    4 real		bit(1),
  3    82 	    4 complex		bit(1),
  3    83 	    4 variable		bit(1),
  3    84 	    4 reducible		bit(1),
  3    85 	    4 irreducible		bit(1),
  3    86 	    4 returns		bit(1),
  3    87 	    4 position		bit(1),
  3    88 	    4 internal		bit(1),
  3    89 	    4 external		bit(1),
  3    90 	    4 like		bit(1),
  3    91 	    4 member		bit(1),
  3    92 	    4 non_varying		bit(1),
  3    93 	    4 options		bit(1),
  3    94 	    4 variable_arg_list 	bit(1),		/* options(variable) */
  3    95 	    4 alloc_in_text		bit(1),		/* options(constant) */
  3    96 
  3    97 	  3 storage_class		structure unal,
  3    98 	    4 auto		bit(1),
  3    99 	    4 based		bit(1),
  3   100 	    4 static		bit(1),
  3   101 	    4 controlled		bit(1),
  3   102 	    4 defined		bit(1),
  3   103 	    4 parameter		bit(1),
  3   104 	    4 param_desc		bit(1),
  3   105 	    4 constant		bit(1),
  3   106 	    4 temporary		bit(1),
  3   107 	    4 return_value		bit(1),
  3   108 
  3   109 	  3 file_attributes		structure unal,
  3   110 	    4 print		bit(1),
  3   111 	    4 input		bit(1),
  3   112 	    4 output		bit(1),
  3   113 	    4 update		bit(1),
  3   114 	    4 stream		bit(1),
  3   115 	    4 reserved_1		bit(1),
  3   116 	    4 record		bit(1),
  3   117 	    4 sequential		bit(1),
  3   118 	    4 direct		bit(1),
  3   119 	    4 interactive		bit(1),		/* env(interactive) */
  3   120 	    4 reserved_2		bit(1),
  3   121 	    4 reserved_3		bit(1),
  3   122 	    4 stringvalue		bit(1),		/* env(stringvalue) */
  3   123 	    4 keyed		bit(1),
  3   124 	    4 reserved_4		bit(1),
  3   125 	    4 environment		bit(1),
  3   126 
  3   127 	  3 compiler_developed	structure unal,
  3   128 	    4 aliasable		bit(1),
  3   129 	    4 packed		bit(1),
  3   130 	    4 passed_as_arg		bit(1),
  3   131 	    4 allocate		bit(1),
  3   132 	    4 set			bit(1),
  3   133 	    4 exp_extents		bit(1),
  3   134 	    4 refer_extents		bit(1),
  3   135 	    4 star_extents		bit(1),
  3   136 	    4 isub		bit(1),
  3   137 	    4 put_in_symtab		bit(1),
  3   138 	    4 contiguous		bit(1),
  3   139 	    4 put_data		bit(1),
  3   140 	    4 overlayed		bit(1),
  3   141 	    4 error		bit(1),
  3   142 	    4 symtab_processed	bit(1),
  3   143 	    4 overlayed_by_builtin	bit(1),
  3   144 	    4 defaulted		bit(1),
  3   145 	    4 connected		bit(1);
  3   146 
  3   147 /* END INCLUDE FILE ... symbol.incl.pl1 */
      105 
  4     1 dcl	1 array			based aligned,
  4     2 	2 node_type		bit(9) unaligned,
  4     3 	2 reserved		bit(34) unaligned,
  4     4 	2 number_of_dimensions	fixed(7) unaligned,
  4     5 	2 own_number_of_dimensions	fixed(7) unaligned,
  4     6 	2 element_boundary		fixed(3) unaligned,
  4     7 	2 size_units		fixed(3) unaligned,
  4     8 	2 offset_units		fixed(3) unaligned,
  4     9 	2 interleaved		bit(1) unaligned,
  4    10 	2 c_element_size		fixed(24),
  4    11 	2 c_element_size_bits	fixed(24),
  4    12 	2 c_virtual_origin		fixed(24),
  4    13 	2 element_size		ptr unaligned,
  4    14 	2 element_size_bits		ptr unaligned,
  4    15 	2 virtual_origin		ptr unaligned,
  4    16 	2 symtab_virtual_origin	ptr unaligned,
  4    17 	2 symtab_element_size	ptr unaligned,
  4    18 	2 bounds			ptr unaligned,
  4    19 	2 element_descriptor	ptr unaligned;
  4    20 
  4    21 dcl	1 bound			based aligned,
  4    22 	2 node_type		bit(9),
  4    23 	2 c_lower			fixed(24),
  4    24 	2 c_upper			fixed(24),
  4    25 	2 c_multiplier		fixed(24),
  4    26 	2 c_desc_multiplier		fixed(24),
  4    27 	2 lower			ptr unaligned,
  4    28 	2 upper			ptr unaligned,
  4    29 	2 multiplier		ptr unaligned,
  4    30 	2 desc_multiplier		ptr unaligned,
  4    31 	2 symtab_lower		ptr unaligned,
  4    32 	2 symtab_upper		ptr unaligned,
  4    33 	2 symtab_multiplier		ptr unaligned,
  4    34 	2 next			ptr unaligned;
      106 
  5     1 dcl	1 label			based aligned,
  5     2 	2 node_type		bit(9) unaligned,
  5     3 	2 source_id		structure unaligned,
  5     4 	  3 file_number		bit(8),
  5     5 	  3 line_number		bit(14),
  5     6 	  3 statement_number	bit(5),
  5     7 	2 location		fixed(17) unaligned,
  5     8 	2 allocated		bit(1) unaligned,
  5     9 	2 dcl_type		bit(3) unaligned,
  5    10 	2 reserved		bit(29) unaligned,
  5    11 	2 array			bit(1) unaligned,
  5    12 	2 used_as_format		bit(1) unaligned,
  5    13 	2 used_in_goto		bit(1) unaligned,
  5    14 	2 symbol_table		bit(18) unaligned,
  5    15 	2 low_bound		fixed(17) unaligned,
  5    16 	2 high_bound		fixed(17) unaligned,
  5    17 	2 block_node		ptr unaligned,
  5    18 	2 token			ptr unaligned,
  5    19 	2 next			ptr unaligned,
  5    20 	2 multi_use		ptr unaligned,
  5    21 	2 cross_reference		ptr unaligned,
  5    22 	2 statement		ptr unaligned;
      107 
  6     1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */
  6     2 
  6     3 /*	Modified: 2 Apr 1980 by PCK to add max_number_of_operands */
  6     4 
  6     5 /* format: style3 */
  6     6 dcl	1 operator	based aligned,
  6     7 	  2 node_type	bit (9) unaligned,
  6     8 	  2 op_code	bit (9) unaligned,
  6     9 	  2 shared	bit (1) unaligned,
  6    10 	  2 processed	bit (1) unaligned,
  6    11 	  2 optimized	bit (1) unaligned,
  6    12 	  2 number	fixed (14) unaligned,
  6    13 	  2 operand	dimension (n refer (operator.number)) ptr unaligned;
  6    14 
  6    15 dcl	max_number_of_operands
  6    16 			fixed bin (15) int static options (constant) initial (32767);
  6    17 
  6    18 /* END INCLUDE FILE ... operator.incl.pl1 */
      108 
  7     1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */
  7     2 
  7     3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */
  7     4 
  7     5 dcl (	block_node		initial("000000001"b),
  7     6 	statement_node		initial("000000010"b),
  7     7 	operator_node		initial("000000011"b),
  7     8 	reference_node		initial("000000100"b),
  7     9 	token_node		initial("000000101"b),
  7    10 	symbol_node		initial("000000110"b),
  7    11 	context_node		initial("000000111"b),
  7    12 	array_node		initial("000001000"b),
  7    13 	bound_node		initial("000001001"b),
  7    14 	format_value_node		initial("000001010"b),
  7    15 	list_node			initial("000001011"b),
  7    16 	default_node		initial("000001100"b),
  7    17 	machine_state_node		initial("000001101"b),
  7    18 	source_node		initial("000001110"b),
  7    19 	label_node		initial("000001111"b),
  7    20 	cross_reference_node	initial("000010000"b),
  7    21 	sf_par_node		initial("000010001"b),
  7    22 	temporary_node		initial("000010010"b),
  7    23 	label_array_element_node	initial("000010011"b),
  7    24 	by_name_agg_node		initial("000010100"b))
  7    25 				bit(9) internal static aligned options(constant);
  7    26 
  7    27 dcl	1 node			based aligned,
  7    28 	2 type			unal bit(9),
  7    29 	2 source_id		unal structure,
  7    30 	  3 file_number		bit(8),
  7    31 	  3 line_number		bit(14),
  7    32 	  3 statement_number	bit(5);
  7    33 
  7    34 /* END INCLUDE FILE ... nodes.incl.pl1 */
      109 
  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 */
      110 
  9     1 dcl (	real_fix_bin_1		init(1),
  9     2 	real_fix_bin_2		init(2),
  9     3 	real_flt_bin_1		init(3),
  9     4 	real_flt_bin_2		init(4),
  9     5 	complex_fix_bin_1		init(5),
  9     6 	complex_fix_bin_2		init(6),
  9     7 	complex_flt_bin_1		init(7),
  9     8 	complex_flt_bin_2		init(8),
  9     9 	real_fix_dec		init(9),
  9    10 	real_flt_dec		init(10),
  9    11 	complex_fix_dec		init(11),
  9    12 	complex_flt_dec		init(12),
  9    13 	char_string		init(13),
  9    14 	bit_string		init(14),
  9    15 	label_constant		init(15),
  9    16 	local_label_variable	init(16),
  9    17 	label_variable		init(17),
  9    18 	entry_variable		init(18),
  9    19 	ext_entry_in		init(19),
  9    20 	ext_entry_out		init(20),
  9    21 	int_entry			init(21),
  9    22 	int_entry_other		init(22),
  9    23 	unpacked_ptr		init(23),
  9    24 	packed_ptr		init(24)) fixed bin(15) int static options(constant);
      111 
 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 */
      112 
 11     1 /* BEGIN INCLUDE FILE ... machine_state.incl.pl1 */
 11     2 
 11     3 dcl	cg_static_$m_s_p ptr ext static,
 11     4 	m_s_p ptr init(cg_static_$m_s_p);
 11     5 
 11     6 dcl	1 machine_state	aligned based(m_s_p),
 11     7 	2 node_type	bit(9),
 11     8 	2 indicators	fixed bin,
 11     9 	2 next		ptr unal,
 11    10 	2 a_reg,
 11    11 	  3 variable(10)	ptr unal,
 11    12 	  3 number	fixed bin(17),
 11    13 	  3 size		fixed bin(8),
 11    14 	  3 length	fixed bin(8),
 11    15 	  3 offset	fixed bin(8),
 11    16 	  3 constant	fixed bin(24),
 11    17 	  3 changed	fixed bin(18),
 11    18 	  3 instruction	bit(36),
 11    19 	  3 locked	bit(1) aligned,
 11    20 	  3 number_h_o	fixed bin,
 11    21 	  3 has_offset(3)	ptr unal,
 11    22 	2 q_reg,
 11    23 	  3 variable(10)	ptr unal,
 11    24 	  3 number	fixed bin(17),
 11    25 	  3 size		fixed bin(8),
 11    26 	  3 length	fixed bin(8),
 11    27 	  3 offset	fixed bin(8),
 11    28 	  3 constant	fixed bin(24),
 11    29 	  3 changed	fixed bin(18),
 11    30 	  3 instruction	bit(36),
 11    31 	  3 locked	bit(1) aligned,
 11    32 	  3 number_h_o	fixed bin,
 11    33 	  3 has_offset(3)	ptr unal,
 11    34 	2 string_reg,
 11    35 	  3 variable	ptr unal,
 11    36 	  3 size		fixed bin(8),
 11    37 	  3 offset	fixed bin(8),
 11    38 	2 complex_reg,
 11    39 	  3 variable	ptr unal,
 11    40 	  3 size		fixed bin(8),
 11    41 	  3 scale		fixed bin(8),
 11    42 	2 decimal_reg,
 11    43 	  3 variable	ptr unal,
 11    44 	  3 size		fixed bin(8),
 11    45 	  3 scale		fixed bin(8),
 11    46 	2 index_regs(0:7),
 11    47 	  3 variable	ptr unal,
 11    48 	  3 constant	fixed bin,
 11    49 	  3 type		fixed bin(8),
 11    50 	  3 used		fixed bin(18),
 11    51 	  3 changed	fixed bin(18),
 11    52 	  3 instruction	bit(36),
 11    53 	  3 filler	fixed bin,
 11    54 	2 base_regs(0:7),
 11    55 	  3 variable	ptr unal,
 11    56 	  3 constant	fixed bin,
 11    57 	  3 type		fixed bin(8),
 11    58 	  3 pad (12)	fixed bin,	/* future...room to make 5 element array for variable, constant, type */
 11    59 	  3 number	fixed bin (17),	/* future...number of valid elements in array */
 11    60 	  3 used		fixed bin(18),
 11    61 	  3 changed	fixed bin(18),
 11    62 	  3 instruction	bit(36),
 11    63 	  3 locked	fixed bin(2),
 11    64 	2 indicators_ref(2:3) ptr unal;
 11    65 
 11    66 /* Permissible values for machine_state.indicators. */
 11    67 
 11    68 dcl (	ind_known_refs	init (-2),		/* set by comparison of known, nonzero, references */
 11    69 	ind_invalid	init (-1),
 11    70 	ind_string_aq	init (0),			/* logical value in storage */
 11    71 	ind_logical	init (1),			/* logical value in A or AQ */
 11    72 	ind_arithmetic	init (2),			/* arith value in Q, AQ, or EAQ */
 11    73 	ind_x (0:7)	init (6, 7, 8, 9, 10, 11, 12, 13),
 11    74 	ind_decimal_reg	init (14)
 11    75 	) fixed bin internal static options (constant);
 11    76 
 11    77 /* END INCLUDE FILE ... machine_state.incl.pl1 */
      113 
      114 
      115 	p, q = pt;
      116 	atomic = "1"b;
      117 
      118 	eval = evaluate;
      119 
      120 	if p -> node.type = label_node
      121 	then do;
      122 
      123 	     q = get_reference ();
      124 	     q -> reference.symbol = p;
      125 
      126 l1:
      127 	     q -> reference.data_type = label_constant;
      128 	     q -> reference.allocated = p -> label.allocated;
      129 	     q -> reference.aliasable, q -> reference.temp_ref, q -> reference.defined_ref, q -> reference.allocate = "0"b;
      130 	     goto l3;
      131 	     end;
      132 
      133 	if p -> node.type = operator_node
      134 	then do;
      135 
      136 	     if p -> operator.op_code = desc_size
      137 	     then do;
      138 		q = check_o_and_s (p);
      139 		if q ^= null
      140 		then goto go;
      141 		end;
      142 
      143 	     q = p -> operand (1);
      144 
      145 /* check for expression already done */
      146 
      147 	     if q -> reference.evaluated
      148 	     then if q -> reference.data_type = 0
      149 		then goto l8a;
      150 		else do;
      151 		     if eval > 0
      152 		     then if q -> reference.symbol -> node.type = symbol_node
      153 			then if q -> reference.symbol -> symbol.return_value
      154 			     then q -> reference.length = eval_exp ((q -> reference.length), "1"b);
      155 		     if ^q -> reference.aligned_ref
      156 		     then atomic = "0"b;
      157 		     goto done;
      158 		     end;
      159 
      160 	     if p -> operator.op_code = assign
      161 	     then do;
      162 		s = p -> operand (2);
      163 		if s -> node.type ^= reference_node
      164 		then goto l8;
      165 		if s -> reference.symbol -> node.type ^= symbol_node
      166 		then goto l8;
      167 		if ^s -> reference.symbol -> symbol.arg_descriptor
      168 		then goto l8;
      169 		if ^q -> reference.symbol -> symbol.temporary
      170 		then goto l8;
      171 
      172 /* have assignment of element of arg_descriptor to a temporary,
      173*		   eliminate the unnecessary assignment */
      174 
      175 		if q -> reference.shared
      176 		then do;
      177 		     q = s;
      178 		     goto go;
      179 		     end;
      180 		else do;
      181 		     q = assign_desc_op (p);
      182 		     go to exit;
      183 		     end;
      184 		end;
      185 
      186 	     if p -> operator.op_code = length_fun
      187 	     then do;
      188 		q = length_op (p);
      189 		go to exit;
      190 		end;
      191 
      192 	     if p -> operator.op_code = std_call
      193 	     then do;
      194 		q = call_op (p);
      195 		if ^q -> reference.aligned_ref
      196 		then atomic = "0"b;
      197 		goto done;
      198 		end;
      199 
      200 l8:
      201 	     eval = 0;
      202 l8a:
      203 	     atomic = "0"b;
      204 	     end;
      205 
      206 /* set fields not yet set by declaration processor */
      207 
      208 go:
      209 	p1 = q -> reference.qualifier;
      210 	s = q -> reference.symbol;
      211 
      212 	here_before = q -> reference.data_type ^= 0 & ^q -> reference.shared;
      213 
      214 	if s -> node.type = label_node
      215 	then do;
      216 	     p = s;
      217 	     goto l1;
      218 	     end;
      219 
      220 	q -> reference.aggregate =
      221 	     q -> reference.array_ref | s -> symbol.structure | s -> symbol.arg_descriptor | s -> symbol.storage_block
      222 	     | ((s -> symbol.dimensioned | s -> symbol.member) & s -> symbol.temporary);
      223 
      224 	q -> reference.aliasable =
      225 	     s -> symbol.aliasable
      226 	     | (s -> symbol.auto & (cg_stat$cur_block ^= s -> symbol.block_node) & s -> symbol.passed_as_arg);
      227 	q -> reference.temp_ref = q -> reference.temp_ref | 4s
��vC3���'�IA"�}��}6�W&�o!

$���bK3�1,�P��Q�b���#�F
{	��@��eOr
����,������
X�( ��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ��q������Q��0�Q��"Q�����������������������������������������V�#jXB#B#��@0����
�ɠ�*��'#L�
���pB#

�
@
~VB�����[?�����
9�ki����G�j@e~"O+����x h�LS
_
�%i
Q� �MR12.5  Q�H�o��        gV��dK���I}E��c�+|.T
pZI}S�^tSJ~��k�8��V���Q� �^
O��,�
.��0~�'�*
��V�-.}3�������

�s
�f�+��;��^��I=�?y
?�

3�-_G�{0}�M/,�%��z]z��.�

Q�-Dr���D�

4s
��vC3���'�IA"�}��}6�W&�o!

$���%j� �,����b���#��W
(	��@��eOr
����,������
X�((��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ�!U������Q��@�Q�R0aQ�)"-��������������������������������������V�#jXB#B#��@0����
�ɠ�*��'#L�
���pB#

�
@
~VB�����[?�����
9�vi����G�j@e~"O+���x h�LS
_
�%i
Q� �Z�MR12.5  Q�H�o��        gu���dK���J���f
,9�
p[J�S��t�Pn��k�8�%���Q� �l
O��4�
5N�0����

��V�-.}F|�����

��
�f�+��;��^���=�?y
?�

3�-_G�{0}�M/,�%��z]z��.�
n
nQ� �=r�����

4s
��vC3���'�IA"�}��}6�W&�o!

%)�Fr&B��,�����b���#��C
�	��@��eOr
����,������
X�((��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ� �:v�����Q� ���Q� �Y)Q� �� ��������������������������������������V�#jXB#B#��@0����
�ɠ�*��'#L�
���pB#

�
@
~VB�����[?�����
9��i����G�j@e~"
      284 
      285 	q -> reference.padded_for_store_ref = q -> reference.padded_ref;
      286 
      287 	if ^s -> symbol.packed
      288 	then do;
      289 	     padded_bit,
      290 		q -> reference.padded_for_store_ref =
      291 		^q -> reference.substr | q -> reference.c_length = s -> symbol.c_dcl_size;
      292 
      293 	     if ^(s -> symbol.parameter | (s -> symbol.defined & s -> symbol.overlayed))
      294 	     then q -> reference.padded_ref = padded_bit;
      295 	     end;
      296 
      297 /* The following is a bad remnant of the old padded reference scheme
      298*	   that we hope to drop, eventually.  Note that reference.padded_for_store_ref
      299*	   is not affected. */
      300 
      301 	if s -> symbol.passed_as_arg
      302 	then if ^s -> symbol.constant
      303 	     then q -> reference.padded_ref = "0"b;
      304 
      305 	/* end of code that we eventually hope to drop */
      306 
      307 	if p1 ^= null
      308 	then if p1 -> node.type ^= temporary_node
      309 	     then if eval ^= 0
      310 		then if ^q -> reference.defined_ref
      311 		     then call pointer_chain (q);
      312 		     else call defined_chain (q);
      313 
      314 /* encode data type of reference */
      315 
      316 	if s -> symbol.binary
      317 	then do;
      318 	     if s -> symbol.fixed
      319 	     then if s -> symbol.c_dcl_size > max_p_fix_bin_1
      320 		then n = real_fix_bin_2;
      321 		else n = real_fix_bin_1;
      322 	     else if s -> symbol.c_dcl_size > max_p_flt_bin_1
      323 	     then n = real_flt_bin_2;
      324 	     else n = real_flt_bin_1;
      325 
      326 	     if s -> symbol.complex
      327 	     then n = n + 4;
      328 	     goto set;
      329 	     end;
      330 
      331 	if s -> symbol.decimal
      332 	then do;
      333 	     n = real_fix_dec + fixed (s -> symbol.float, 1);
      334 	     if s -> symbol.complex
      335 	     then n = n + 2;
      336 
      337 set:
      338 	     q -> reference.data_type = n;
      339 	     goto l2;
      340 	     end;
      341 
      342 	if s -> symbol.char | s -> symbol.picture
      343 	then do;
      344 	     q -> reference.data_type = char_string;
      345 	     goto l2;
      346 	     end;
      347 
      348 	if s -> symbol.bit
      349 	then do;
      350 	     q -> reference.data_type = bit_string;
      351 	     goto l2;
      352 	     end;
      353 
      354 	if s -> symbol.offset
      355 	then do;
      356 	     q -> reference.data_type = real_fix_bin_1;
      357 	     goto l2;
      358 	     end;
      359 
      360 	if s -> symbol.ptr
      361 	then do;
      362 	     if q -> reference.temp_ref      /* temp ptr operands are copied */
      363 	     then if q -> reference.shared   /* so they can be in the machine state correctly */
      364 	     then do;
      365 		     q = copy_temp (q);
      366 		     q -> reference.ref_count = 2; /* create, then use */
      367 		     if p -> node.type = operator_node
      368 		     then p -> operator.operand (1) = q;
      369 		end;
      370 	     q -> reference.data_type = unpacked_ptr + fixed (s -> symbol.packed | s -> symbol.unaligned | s -> symbol.explicit_packed, 1);
      371 	     goto l2;
      372 	     end;
      373 
      374 	if s -> symbol.label
      375 	then do;
      376 	     q -> reference.data_type = label_variable - fixed (s -> symbol.local, 1);
      377 	     goto l2;
      378 	     end;
      379 
      380 	if s -> symbol.arg_descriptor
      381 	then do;
      382 	     q -> reference.data_type = real_fix_bin_1;
      383 	     goto l2;
      384 	     end;
      385 
      386 	if s -> symbol.file
      387 	then do;
      388 	     q -> reference.data_type = local_label_variable;
      389 	     goto l2;
      390 	     end;
      391 
      392 	if s -> symbol.format
      393 	then do;
      394 	     q -> reference.data_type = local_label_variable - fixed (s -> symbol.constant, 1);
      395 	     goto l2;
      396 	     end;
      397 
      398 	if s -> symbol.area
      399 	then do;
      400 	     q -> reference.data_type = real_fix_bin_2;
      401 	     go to l2;
      402 	     end;
      403 
      404 	if s -> symbol.entry
      405 	then if s -> symbol.variable | s -> symbol.temporary
      406 	     then q -> reference.data_type = entry_variable;
      407 	     else if s -> symbol.external
      408 	     then q -> reference.data_type = ext_entry_in + fixed (s -> symbol.initial = null);
      409 	     else q -> reference.data_type = int_entry;
      410 
      411 l2:
      412 	str = s -> symbol.char | s -> symbol.bit | s -> symbol.picture;
      413 
      414 	if here_before
      415 	then do;
      416 	     if (s -> symbol.packed & ^(str | s -> symbol.decimal))
      417 		| (str & ^(q -> reference.long_ref | q -> reference.varying_ref))
      418 	     then if ^q -> reference.aligned_ref
      419 		then atomic = "0"b;
      420 
      421 	     goto done;
      422 	     end;
      423 
      424 	n = q -> reference.units;
      425 	if n = 0
      426 	then n, q -> reference.units = word_;
      427 
      428 	else if n ^= word_ & q -> reference.offset = null
      429 	then if mod (q -> reference.c_offset, units_per_word (n)) = 0
      430 	     then do;
      431 		q -> reference.c_offset = divide (q -> reference.c_offset, units_per_word (n), 17, 0);
      432 		n, q -> reference.units = word_;
      433 		end;
      434 
      435 	q -> reference.aligned_for_store_ref, q -> reference.aligned_ref = n = word_ & ^q -> reference.fo_in_qual;
      436 
      437 	if n < word_
      438 	then if q -> reference.data_type > 0
      439 	     then if q -> reference.data_type = char_string | (s -> symbol.decimal & ^s -> symbol.unaligned)
      440 		then if n ^= character_
      441 		     then call bad;
      442 		     else ;
      443 		else if s -> symbol.decimal & s -> symbol.unaligned
      444 		then if n ^= digit_
      445 		     then call bad;
      446 		     else ;
      447 		else if n ^= bit_
      448 		then call bad;
      449 
      450 	if str
      451 	then do;
      452 
      453 	     bit_length = q -> reference.c_length * convert_size (q -> reference.data_type);
      454 	     if q -> reference.c_length = 0 & q -> reference.length = null
      455 	     then q -> reference.aligned_for_store_ref, q -> reference.aligned_ref = "1"b;
      456 
      457 	     if q -> reference.length ^= null
      458 	     then do;
      459 		q -> reference.long_ref = "1"b;
      460 		if q -> reference.shared
      461 		then go to l3;			/* This catches call from mst for symbol.reference */
      462 		q -> reference.big_length = is_big ((q -> reference.length));
      463 		go to l3;
      464 		end;
      465 
      466 	     if q -> reference.c_length > max_short_size (q -> reference.data_type)
      467 	     then do;
      468 		q -> reference.big_length = q -> reference.c_length > max_index_register_value;
      469 		q -> reference.long_ref = "1"b;
      470 		if q -> reference.temp_ref
      471 		then call check_assign;
      472 		go to l3;
      473 		end;
      474 
      475 	     if q -> reference.varying_ref
      476 	     then do;
      477 		q -> reference.big_length = "1"b;
      478 		if q -> reference.symbol -> symbol.dcl_size = null
      479 		then if q -> reference.symbol -> symbol.c_dcl_size <= max_index_register_value
      480 		     then q -> reference.big_length = "0"b;
      481 		go to l3;
      482 		end;
      483 
      484 	     q -> reference.aligned_ref =
      485 		q -> reference.aligned_ref & (q -> reference.padded_ref | mod (bit_length, bits_per_word) = 0);
      486 
      487 	     q -> reference.aligned_for_store_ref =
      488 		q -> reference.aligned_for_store_ref
      489 		& (q -> reference.padded_for_store_ref | mod (bit_length, bits_per_word) = 0);
      490 	     goto l5b;
      491 	     end;
      492 
      493 	bit_length = q -> reference.c_length;
      494 
      495 	if bit_length = 0
      496 	then do;
      497 	     if s -> symbol.array = null
      498 	     then bit_length = s -> symbol.c_bit_size;
      499 	     else bit_length = s -> symbol.array -> array.c_element_size_bits;
      500 
      501 	     if s -> symbol.decimal
      502 	     then if s -> symbol.unaligned
      503 		then do;
      504 		     if s -> symbol.float
      505 		     then q -> reference.c_length = s -> symbol.c_dcl_size + 3;
      506 		     else q -> reference.c_length = s -> symbol.c_dcl_size + 1;
      507 
      508 		     if s -> symbol.complex
      509 		     then q -> reference.c_length = 2 * q -> reference.c_length;
      510 		     end;
      511 		else q -> reference.c_length = divide (bit_length, bits_per_char, 24, 0);
      512 	     else q -> reference.c_length = bit_length;
      513 	     end;
      514 
      515 	if s -> symbol.decimal
      516 	then do;
      517 	     call prepare_decimal;
      518 	     if s -> symbol.packed
      519 	     then do;
      520 		q -> reference.aligned_ref =
      521 		     q -> reference.aligned_ref & (q -> reference.padded_ref | mod (bit_length, bits_per_word) = 0);
      522 		q -> reference.aligned_for_store_ref =
      523 		     q -> reference.aligned_for_store_ref
      524 		     & (q -> reference.padded_for_store_ref | mod (bit_length, bits_per_word) = 0);
      525 		end;
      526 	     go to l5b;
      527 	     end;
      528 
      529 	if s -> symbol.packed
      530 	then do;
      531 	     if s -> symbol.binary
      532 		& ^(q -> reference.data_type = real_fix_bin_1 | q -> reference.data_type = real_flt_bin_1)
      533 	     then do;
      534 		q -> reference.aligned_ref =
      535 		     q -> reference.aligned_ref
      536 		     & (s -> symbol.boundary > word_ & mod (bit_length, bits_per_two_words) = 0);
      537 		q -> reference.aligned_for_store_ref =
      538 		     q -> reference.aligned_for_store_ref
      539 		     & (s -> symbol.boundary > word_ & mod (bit_length, bits_per_two_words) = 0);
      540 		end;
      541 
      542 	     else if ^s -> symbol.ptr
      543 	     then do;
      544 		if s -> symbol.structure
      545 		then do;
      546 		     q -> reference.aligned_ref = q -> reference.aligned_ref & q -> reference.padded_ref;
      547 		     q -> reference.aligned_for_store_ref =
      548 			q -> reference.aligned_for_store_ref & q -> reference.padded_for_store_ref;
      549 		     end;
      550 		q -> reference.aligned_ref = q -> reference.aligned_ref & (mod (bit_length, bits_per_word) = 0);
      551 		q -> reference.aligned_for_store_ref =
      552 		     q -> reference.aligned_for_store_ref & (mod (bit_length, bits_per_word) = 0);
      553 		end;
      554 l5b:
      555 	     if ^q -> reference.aligned_ref
      556 	     then atomic = "0"b;
      557 	     end;
      558 
      559 l3:
      560 	if q -> reference.aggregate & q -> reference.temp_ref
      561 	then do;
      562 
      563 /* this is an aggregate temp, walk back to level 1 ancestor and
      564*		assign storage if non-already assigned */
      565 
      566 	     do p2 = s repeat (p2 -> symbol.father) while (p2 -> symbol.father ^= null);
      567 	     end;
      568 
      569 	     if p2 -> symbol.initial = null
      570 	     then call stack_temp$assign_aggregate (p2);
      571 	     end;
      572 
      573 /* develop hard_to_load bit */
      574 
      575 	if ^q -> reference.aligned_ref
      576 	then if q -> reference.fo_in_qual
      577 	     then q -> reference.hard_to_load = "1"b;
      578 	     else do;
      579 		n = q -> reference.units;
      580 		if n < word_
      581 		then if q -> reference.offset ^= null & ^q -> reference.modword_in_offset
      582 		     then q -> reference.hard_to_load = "1"b;
      583 		     else if ^q -> reference.long_ref
      584 		     then do;
      585 			cfo = mod (q -> reference.c_offset * convert_offset (n), bits_per_word);
      586 			if cfo < 0
      587 			then cfo = cfo + bits_per_word;
      588 			q -> reference.hard_to_load = cfo + bit_length > bits_per_two_words;
      589 			end;
      590 		end;
      591 
      592 	if eval = 0
      593 	then goto done;
      594 
      595 	if eval > 0
      596 	then if q -> reference.length ^= null
      597 	     then q -> reference.length = eval_exp ((q -> reference.length), (q -> reference.big_length));
      598 
      599 	if q -> reference.offset ^= null
      600 	then do;
      601 	     if n < word_ & ^q -> reference.modword_in_offset
      602 	     then do;
      603 		q -> reference.big_offset = q -> reference.big_offset | is_big ((q -> reference.offset));
      604 		end;
      605 
      606 	     q -> reference.offset = eval_exp ((q -> reference.offset), (q -> reference.big_offset));
      607 	     end;
      608 
      609 done:
      610 	q -> reference.no_address = "1"b;
      611 	q -> reference.perm_address = "0"b;
      612 
      613 	if q -> reference.defined_ref
      614 	then do;
      615 	     if p1 = null
      616 	     then goto exit;
      617 
      618 	     if p1 -> node.type = operator_node
      619 	     then p1 = p1 -> operand (1);
      620 
      621 	     if p1 -> reference.temp_ref
      622 	     then do;
      623 
      624 		if substr (string (p1 -> reference.value_in), 1, 2) = "00"b
      625 		then goto def_done;
      626 
      627 		if q -> reference.hard_to_load
      628 		then go to erase_no_update;
      629 
      630 /* the defined base is in A or Q register */
      631 
      632 		if q -> reference.data_type ^= bit_string
      633 		then do;
      634 		     if q -> reference.data_type ^= p1 -> reference.data_type
      635 		     then go to erase_no_update;
      636 
      637 same:
      638 		     string (q -> reference.value_in) =
      639 			string (q -> reference.value_in) | string (p1 -> reference.value_in);
      640 		     call state_man$erase_reg (substr (string (p1 -> reference.value_in), 1, 2));
      641 		     call state_man$update_reg (q, string (q -> reference.value_in));
      642 		     if q -> reference.value_in.a
      643 		     then if p1 -> reference.data_type = char_string
      644 			then if a_reg.size < p1 -> reference.c_length * bits_per_char
      645 			     then a_reg.length = a_reg.size + a_reg.offset;
      646 		     goto exit;
      647 		     end;
      648 
      649 /* the defined temporary is a bit string (possibly from unspec or substr) */
      650 
      651 		if p1 -> reference.data_type ^= bit_string
      652 		then do;
      653 		     if p1 -> reference.data_type = real_fix_bin_1
      654 		     then goto same;
      655 		     if p1 -> reference.data_type = packed_ptr
      656 		     then goto same;
      657 		     if p1 -> reference.data_type = char_string
      658 		     then goto same;
      659 
      660 		     if p1 -> reference.data_type = real_fix_bin_2 | p1 -> reference.data_type = unpacked_ptr
      661 		     then do;
      662 			q -> reference.value_in.a = "1"b;
      663 			call state_man$update_reg (q, "1"b);
      664 			goto exit;
      665 			end;
      666 
      667 erase_no_update:
      668 		     call state_man$erase_reg (substr (string (p1 -> reference.value_in), 1, 2));
      669 		     end;
      670 		else do;
      671 		     call state_man$erase_reg (substr (string (p1 -> reference.value_in), 1, 2));
      672 		     call state_man$update_ref (q);
      673 		     if a_reg.size < p1 -> reference.c_length
      674 		     then a_reg.length = a_reg.size + a_reg.offset;
      675 		     end;
      676 
      677 def_done:
      678 		end;
      679 	     else do;
      680 		q -> reference.allocate, q -> reference.allocated = "1"b;
      681 		q -> reference.temp_ref = "0"b;
      682 		end;
      683 
      684 	     end;
      685 
      686 exit:
      687 	return (q);
      688 
      689 pointer_chain:
      690      proc (pt);
      691 
      692 dcl	(pt, qp, tp, sp, rp)
      693 			ptr,
      694 	dummy		fixed bin,
      695 	useless		bit (1) aligned,
      696 	op_code		bit (9) aligned;
      697 
      698 	qp = pt -> reference.qualifier;
      699 	if qp -> node.type = reference_node
      700 	then do;
      701 	     qp = prepare_operand (qp, 1, useless);
      702 	     return;
      703 	     end;
      704 
      705 	tp = qp -> operand (1);
      706 	if tp -> reference.evaluated
      707 	then return;
      708 
      709 	op_code = qp -> operator.op_code;
      710 	if op_code = std_call
      711 	then do;
      712 	     pt -> reference.qualifier = call_op (qp);
      713 	     return;
      714 	     end;
      715 
      716 	if op_code = addr_fun
      717 	then do;
      718 	     qp -> operand (2) = prepare_operand ((qp -> operand (2)), 1, useless);
      719 	     return;
      720 	     end;
      721 
      722 	sp = tp -> reference.symbol;
      723 
      724 	if op_code = assign /* must be (unpacked temp) <- (packed) */
      725 	then do;
      726 	     if qp -> operator.operand (1) -> reference.temp_ref
      727 	     then if qp -> operator.operand (1) -> reference.shared
      728 	     then qp -> operator.operand (1) = copy_temp ((qp -> operator.operand (1)));
      729 	     call base_man$load_packed (qp, dummy);
      730 	     qp -> operand (1) -> reference.evaluated = "1"b;
      731 	     return;
      732 	     end;
      733 
      734 	if op_code = param_ptr
      735 	then return;
      736 	if op_code = param_desc_ptr
      737 	then return;
      738 
      739 /* must be a pointer valued builtin function */
      740 
      741 	if sp -> symbol.temporary
      742 	then if tp -> reference.shared
      743 	     then qp -> operand (1) = copy_temp (tp);
      744 
      745 	call pointer_builtins (qp, "0"b);
      746 	qp -> operand (1) -> reference.evaluated = "1"b;
      747 
      748      end;
      749 
      750 
      751 defined_chain:
      752      proc (pt);
      753 
      754 dcl	(pt, qp, rp)	ptr;
      755 dcl	atomic		bit (1) aligned;
      756 
      757 	qp = pt -> reference.qualifier;
      758 
      759 	if qp -> node.type = reference_node
      760 	then qp = prepare_operand (qp, 1, atomic);
      761 	else if ^qp -> operand (1) -> reference.evaluated
      762 	then do;
      763 	     rp = prepare_operand (qp, 1, atomic);
      764 	     if ^atomic
      765 	     then rp = compile_exp$save_exp (qp);
      766 	     end;
      767 
      768      end;
      769 
      770 
      771 is_big:
      772      proc (pt) reducible returns (bit (1) aligned);
      773 
      774 /* is_big determines if the precision of an offset or length expression is
      775*   too big to fit in an index register */
      776 
      777 dcl	(p, pt)		ptr;
      778 dcl	result		bit (1) aligned;
      779 
      780 	p = pt;
      781 
      782 	if p -> node.type = operator_node
      783 	then if p -> operator.op_code = length_fun
      784 	     then do;
      785 		p = p -> operand (2);
      786 		if p -> node.type = operator_node
      787 		then p = p -> operand (1);
      788 		p = p -> reference.symbol;
      789 		result = "1"b;
      790 		if p -> symbol.dcl_size = null
      791 		then if p -> symbol.c_dcl_size <= max_index_register_value
      792 		     then result = "0"b;
      793 		return (result);
      794 		end;
      795 	     else p = p -> operand (1);
      796 
      797 	return (p -> reference.symbol -> symbol.c_dcl_size > max_p_xreg);
      798 
      799      end;
      800 
      801 
      802 check_assign:
      803      proc;
      804 
      805 /* This code is necessary because assign_op cannot have a shared temporary
      806*   as the target of a conversion to long string */
      807 
      808 dcl	p2		ptr;
      809 
      810 	if q -> reference.shared
      811 	then if p -> node.type = operator_node
      812 	     then if substr (p -> operator.op_code, 1, 5) = "00011"b
      813 						/* assign class */
      814 		then do;
      815 		     p2 = p -> operand (2);
      816 		     if p2 -> node.type = operator_node
      817 		     then p2 = p2 -> operand (1);
      818 		     if (string (p2 -> reference.symbol -> symbol.data_type) & "0111111111111111111"b)
      819 			^= (string (s -> symbol.data_type) & "0111111111111111111"b)
      820 		     then q, p -> operand (1) = copy_temp (q);
      821 		     end;
      822 
      823      end;
      824 
      825 
      826 prepare_decimal:
      827      proc;
      828 
      829 /* prepare_decimal is needed to make up for a disagreement between the hardware and
      830*   the language.  PL/I allows scales from -128 to 127 while the hardware will only take
      831*   decimal scales from -31 to +32.  In order to get around this restriction, we must,
      832*   in most cases, replace any fixed decimal temporaries whose scale is outside the
      833*   hardware limits to floating temporaries of the same precision.  */
      834 
      835 dcl	r		ptr;
      836 dcl	(
      837 	i,
      838 	scale		(3)
      839 	)		fixed bin;
      840 
      841 	if s -> symbol.temporary
      842 	then if s -> symbol.fixed
      843 	     then if s -> symbol.scale < min_dec_scale | s -> symbol.scale > max_dec_scale
      844 		then if p -> node.type = operator_node
      845 		     then if p -> operator.number >= 3
      846 			then if p -> operator.op_code ^= complex_fun
      847 			     then if p -> operator.op_code ^= round_fun
      848 				then do;
      849 				     if decimal_op$change_target (p)
      850 				     then do;
      851 					r = decimal_op$get_float_temp (s -> symbol.c_dcl_size,
      852 					     (s -> symbol.complex));
      853 
      854 					if cg_stat$cur_node ^= null
      855 					then if cg_stat$cur_node -> operator.op_code = std_call
      856 					     then go to keep_fixed;
      857 					     else if substr (cg_stat$cur_node -> operator.op_code, 1, 5) = io_class
      858 					     then go to keep_fixed;
      859 
      860 					if s -> symbol.c_dcl_size < max_p_fix_dec
      861 					then do;
      862 					     if ^q -> reference.shared
      863 					     then r -> reference.ref_count = q -> reference.ref_count;
      864 					     q, p -> operand (1) = r;
      865 					     s = r -> reference.symbol;
      866 					     end;
      867 					else do;
      868 keep_fixed:
      869 					     p -> operand (1) = r;
      870 					     r = compile_exp$save (p);
      871 					     if q -> reference.shared
      872 					     then q = copy_temp (q);
      873 					     call assign_op$to_dec_scaled (q, r);
      874 					     p -> operand (1) = q;
      875 					     atomic = "1"b;
      876 					     end;
      877 					end;
      878 				     end;
      879 
      880      end;
      881 
      882 
      883 
      884 
      885 bad:
      886      proc;
      887 
      888 dcl	error		entry (fixed bin, ptr, ptr);
      889 
      890 	if q -> reference.offset = null
      891 	then if q -> reference.temp_ref
      892 	     then if q -> reference.data_type = real_fix_bin_1
      893 		then return;
      894 
      895 	call error (332, cg_stat$cur_statement, q);
      896 
      897      end;
      898 
      899      end;
	SOURCE FILES USED IN THIS COMPILATION.

LINE      NUMBER  DATE MODIFIED     NAME			PATHNAME
             0    10/03/83  1009.1  prepare_operand.pl1               >spec>on>pl128d>prepare_operand.pl1
103          1    10/25/79  1645.8  cgsystem.incl.pl1                 >ldd>include>cgsystem.incl.pl1
104          2    07/21/80  1546.3  reference.incl.pl1                >ldd>include>reference.incl.pl1
105          3    10/02/83  0828.4  symbol.incl.pl1                   >spec>on>pl128d>symbol.incl.pl1
106          4    05/06/74  1741.6  array.incl.pl1                    >ldd>include>array.incl.pl1
107          5    05/06/74  1742.1  label.incl.pl1                    >ldd>include>label.incl.pl1
108          6    07/21/80  1546.3  operator.incl.pl1                 >ldd>include>operator.incl.pl1
109          7    07/21/80  1546.3  nodes.incl.pl1                    >ldd>include>nodes.incl.pl1
110          8    04/07/83  1635.0  op_codes.incl.pl1                 >ldd>include>op_codes.incl.pl1
111          9    05/03/76  1320.4  data_types.incl.pl1               >ldd>include>data_types.incl.pl1
112         10    10/25/79  1645.8  boundary.incl.pl1                 >ldd>include>boundary.incl.pl1
113         11    11/13/79  1015.8  machine_state.incl.pl1            >ldd>include>machine_state.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.
a                        11(09)        based           bit(1)                   level 4 packed unaligned dcl 2-3 set ref 642 662*
a_reg                     3            based           structure                level 2 dcl 11-6
addr_fun                               constant        bit(9)                   initial dcl 8-8 ref 716
address                  10            based           structure                level 2 packed unaligned dcl 2-3
aggregate                12(19)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 220* 231
                                                                                  559
aliasable                32(35)        based           bit(1)                   level 4 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedure "prepare_operand" ref 224
aliasable                12(16)        based           bit(1)                   level 3 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" set ref
                                                                                  129* 224*
aligned_for_store_ref
                         13(02)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 435* 454*
                                                                                  487* 487 522* 522 537* 537 547* 547 551* 551
aligned_ref              12(07)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 155 195 416
                                                                                  435* 454* 484* 484 520* 520 534* 534 546* 546 550*
                                                                                  550 554 575
allocate                 33(02)        based           bit(1)                   level 4 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedure "prepare_operand" ref 231
allocate                 12(14)        based           bit(1)                   level 3 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" set ref
                                                                                  129* 231* 231 680*
allocated                12(15)        based           bit(1)                   level 3 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" set ref
                                                                                  128* 228* 228 680*
allocated                 1(18)        based           bit(1)                   level 2 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedure "prepare_operand" ref 228
allocated                 1(18)        based           bit(1)                   level 2 in structure "label" packed unaligned
                                                                                  dcl 5-1 in procedure "prepare_operand" ref 128
area                     31(07)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 398
arg_descriptor           31(11)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 167 220 380
array                    12            based           pointer                  level 2 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedur�V�#jXB#B#��@0����
�ɠ�*��'#��
���pB#

�
@
~VB�����[?����
9��iY���G�j@e~"O+����x h�LS
_
�%i
Q���@MR12.5  Q�H�o��        e�8c�dKM��k?�r��Q� 4A�
pB?SSTs��Ck�8���VW=�Q���3
O��69
����0Z.�]
��U�-.}��C�����

��
�f�+��;��]?k6=�?y
?�

3�-_G�{0}�M/,�%��z]z��.�	�	�Q��Gq�r��亀

4s
��vC3���'�IA"�}��}6�W&�o!

$x.��,�{M�,��
�~�a���#u�:
�	��@��eOr
����,������
X�((��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ���7Z�����Q��.x�Q���6CQ������������������������������������������V�#jXB#B#��@0����
�ɠ�*��'#��
���pB#

�
@
~VB�����[?����#
9��ik���G�j@e~"O+����x h�LS
_
�%i
Q��@��MR12.5  Q�H�o��        eL���dKW���@i�G��TW!�A
pC@iS[�sz�K�k�8�ǐ\J�Q��@y3
O��2�
n�0^�E�3
��U/-.}�'������

�D
�f�+��;��]�Q=�?y
?�

3�-_G�{0}�M/,�%��z]z��.�	�]	�]Q��@�)r����

4s
��vC3���'�IA"�}��}6�W&�o!

$�h��4TW�,��U���a���#z�y
	�	��@��eOr
����,������
X�(��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ��@������Q��N��Q��Ui�Q��h[��������������������������������������V�#jXB#B#��@0����
�ɠ�*��'#��
���pB#

�
@
~VB�����[?��(�D
9��it���G�j@e~"O+���x h�LS
_
�%i
Q��,{MR12.5  Q�H�o��        e�x��dK`��5A��"��V�# 8
pHA�ScFs�#ّ�k�8�apc:N�Q���1
O��$
m�0eC��
��U�-.}��$�����

��
�f�+��;��]o=�?y
?�

3�-_G�{0}��f�B�j?qy4OT�+��x h���
^
�i
Q���KMR12.5  Q�H�o��        b���dK���R)@����0�	98
nU)@M�p���Qk�8�
�PVNQ��~o
O��06
�Cs�/�+�
��SZ-.|61`�����

X�
�.�+��;��Y�cU=��
?�

3�-_G�{0}�I,�%��z]z��.�	� 	� Q��ث�r���ĥ�

0J
���C&��f'�IA"�}��}6�W&�o!

�����4U��,d�&���W���">:�?	��@��eO
����,������
X�(0��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ����{�����Q��̜YQ����ZQ�������������������������������������������V�#jxB#B#��@3����
��H�/@�'#��
��ǏB#

�
@
~Tt�H�+��?�}��V�xe���C�j@�y�O��z��x h���
_
�7i
Q����oMR12.5  Q�H�o��        b��dKǞפ+��`��3�E�
n�+�M�p#�dAk�8�B�	�1Q����
O��A�
���@0B�R
��S�-.|Z������

\�
�7�+��;��Y���=��a
?�

3�-_G�{0}�I+,�%��z]z��.�	��	��Q��C�:r������

0u
�ɯC&��f'�IA"�}��}6�W&�o!

v��I��Ǟ,m^����Z���"C��		��@��eO@
����,������
X�((��

@������?�#
?�#
Q�G���àà�P��������������@�1ZQ���d�����Q���'�Q���.�Q��%5^��������������������������������������V�#q�B#B#��@4���$
����/@�'#(�
��ǏB#

�
@
~T��i�3�?�(���x�e��D�j@�y�O�����x hĩ
_
�Ci
Q��QmMR12.5  Q�H�o��        b�y��dKӫ٠-��W�
7n
�S
o-�O��p���E�k�8��"wgQ��Qhw
O��Q�
�]�0�U��
��S�-.|�u�����

a�
�?�+��;��Z���=��`
?�

3�-_G�{0}�IC,�%��z]z��.�	�J	�JQ�����r���c�

0�
��oC&��f'�IA"�}��}6�W&�o!

o���Ƞӫ,w�I���]���"K��	��@��eO`
����,������
X�( ��

@������?�#
?�#
Q�G���àà�P����������������1ZQ��Ws�����Q���7\Q�����Q��e����������������������������������������V�#oB#B#��@R����
����/@�'#<�
�.ǻB#

�
@
~U/߁�7�-?�������yxf��F�j@�zO����x h�n
_
�ci
Q�����MR12.5  Q�H�o��        cQM
�dK����/���:�wC
o\/R�5p��g�Nk�8�&���Q���w�
O��=Z
�l40#��)
��SQ-.|�y�����

em
�G�+��;��Za�j=�"
?�

3�-_G�{0}�IK,�%��z]z��.�	��	��Q��#�r���|�

0�
��rC&��f'�IA"�}��}6�W&�o!

�Y�e�L���,~����]P��"Pf-
	��@��eOo
����,������
X�(��

@������?�#
?�#
Q�G���àà�P���������������@�1ZQ���j������Q��G$Q���	�Q����o��������������������������������������V�#d`B#B#��@3����
��H�/@�'#��
�.ǻB#

�
@
~U�ߋ�9�<?������y�f���G�j@�zO��^��x h�ۊ
_
�i
Q��$�2MR12.5  Q�H�o��        cO�*�dK�z�U3�����=�O>}
o�3�Rgqa܏��k�8�7�:Q��$�
O��8+
��Û03�7Ƭ
��S�-.|�)`�����

o�
�_�+��;��[tׇ=�k5
?�

3�-_G�{0}�L�,�%��z]z�@�.�	�y	�yQ���'r����


4
�o>C3���'�IA"�}��}6�W&�o!

#Ve�}��z,�#���a��#T(

�	��@��eOr
����,������
X�(h
��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ��&e7�����Q��=��Q��Cq�Q��&e7��������������������������������������V�#w�B#B#��@3���$
��x�/@�'#�
�H�pB#

�
@
~V6�����:?��8�
9�h����G�j@V}�O'����x h�8�
_
�"i
Q����~MR12.5  Q�H�o�� 7-5 ref 120 214
label_variable                         constant        fixed bin(15,0)          initial dcl 9-1 ref 376
length                   17            based           fixed bin(8,0)           level 3 in structure "machine_state" dcl 11-6
                                                                                  in procedure "prepare_operand" set ref 642* 673*
length                    6            based           pointer                  level 2 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" set ref
                                                                                  151* 151 454 457 462 595 595* 595
length_fun                             constant        bit(9)                   initial dcl 8-8 ref 186 782
length_op                       000052 constant        entry                    external dcl 61 ref 188
local                    31(27)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 376
local_label_variable                   constant        fixed bin(15,0)          initial dcl 9-1 ref 388 394
long_ref                 12(08)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 416 459*
                                                                                  469* 583
m_s_p                           000122 automatic       pointer                  initial dcl 11-3 set ref 642 642 642 642 673 673 673
                                                                                  673 11-3*
machine_state                          based           structure                level 1 dcl 11-6
max_dec_scale                          constant        fixed bin(8,0)           initial dcl 1-5 ref 841
max_index_register_value               constant        fixed bin(31,0)          initial dcl 1-38 ref 468 478 790
max_p_fix_bin_1                        constant        fixed bin(8,0)           initial dcl 1-5 ref 318
max_p_fix_dec                          constant        fixed bin(8,0)           initial dcl 1-5 ref 860
max_p_flt_bin_1                        constant        fixed bin(8,0)           initial dcl 1-5 ref 322
max_p_xreg                             constant        fixed bin(8,0)           initial dcl 1-5 ref 797
max_short_size                  000014 constant        fixed bin(8,0)           initial array dcl 1-5 ref 466
member                   32(04)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 220
min_dec_scale                   003433 constant        fixed bin(8,0)           initial dcl 1-5 ref 841
misc_attributes          31(19)        based           structure                level 3 packed unaligned dcl 3-3
mod                                                    builtin function         dcl 96 ref 428 484 487 520 522 534 537 550 551 585
modword_in_offset        11(35)        based           bit(1)                   level 4 packed unaligned dcl 2-3 ref 580 601
more_bits                13            based           structure                level 2 packed unaligned dcl 2-3
n                               000114 automatic       fixed bin(17,0)          dcl 47 set ref 318* 321* 322* 324* 326* 326 333*
                                                                                  334* 334 337 424* 425 425* 428 428 431 432* 435
                                                                                  437 437 443 447 579* 580 585 601
no_address               10(27)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 609*
node                                   based           structure                level 1 dcl 7-27
null                                                   builtin function         dcl 96 ref 139 307 407 428 454 457 478 497 566 569
                                                                                  580 595 599 615 790 854 890
number                    0(21)        based           fixed bin(14,0)          level 2 packed unaligned dcl 6-6 ref 841
offset                   20            based           fixed bin(8,0)           level 3 in structure "machine_state" dcl 11-6
                                                                                  in procedure "prepare_operand" ref 642 673
offset                   31(06)        based           bit(1)                   level 4 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedure "prepare_operand" ref 354
offset                    5            based           pointer                  level 2 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" set ref 428
                                                                                  580 599 603 606* 606 890
op_code                         000142 automatic       bit(9)                   dcl 692 in procedure "pointer_chain" set ref 709*
                                                                                  710 716 724 734 736
op_code                   0(09)        based           bit(9)                   level 2 in structure "operator" packed unaligned
                                                                                  dcl 6-6 in procedure "prepare_operand" ref 136 160
                                                                                  186 192 709 782 810 841 841 854 857
operand                   1            based           pointer                  array level 2 packed unaligned dcl 6-6 set ref 143
                                                                                  162 367* 618 705 718* 718 726 726 726* 726 730
                                                                                  741* 746 761 785 786 795 815 816 818* 864* 868*
                                                                                  874*
operator                               based           structure                level 1 dcl 6-6
operator_node                          constant        bit(9)                   initial dcl 7-5 ref 133 367 618 782 786 810 816 841
other                    11(33)        based           structure                level 3 packed unaligned dcl 2-3
overlayed                33(11)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 293
p                               000100 automatic       pointer                  dcl 47 in procedure "prepare_operand" set ref 115*
                                                                                  120 124 128 133 136 138* 143 160 162 181* 186 188*
                                                                                  192 194* 216* 367 367 810 810 815 818 841 841 841
                                                                                  841 849* 864 868 870* 874
p                               000166 automatic       pointer                  dcl 777 in procedure "is_big" set ref 780* 782 782
                                                                                  785* 785 786 786* 786 788* 788 790 790 795* 795
                                                                                  797
p1                              000102 automatic       pointer                  dcl 47 set ref 208* 307 307 615 618 618* 618 621 624
                                                                                  634 637 640 640 642 642 651 653 655 657 660 660
                                                                                  667 667 671 671 673
p2                              000104 automatic       pointer                  dcl 47 in procedure "prepare_operand" set ref 566*
                                                                                  566* 567 569 569*
p2                              000200 automatic       pointer                  dcl 808 in procedure "check_assign" set ref 815* 816
                                                                                  816* 816 818
packed                   33            based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 287 370 416 518
                                                                                  529
packed_ptr                             constant        fixed bin(15,0)          initial dcl 9-1 ref 655
padded_bit                      000120 automatic       bit(1)                   dcl 47 set ref 289* 293
padded_for_store_ref     13(01)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 285* 289*
                                                                                  487 522 547
padded_ref               12(06)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 285 293*
                                                                                  301* 484 520 546
param_desc_ptr                         constant        bit(9)                   initial dcl 8-8 ref 736
param_ptr                              constant        bit(9)                   initial dcl 8-8 ref 734
parameter                32(14)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 293
passed_as_arg            33(01)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 224 301
perm_address             12(18)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 611*
picture                  31(18)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 342 411
pointer_builtins                000050 constant        entry                    external dcl 61 ref 745
prepare_operand                 000036 constant        entry                    external dcl 61 ref 701 718 759 763
pt                                     parameter       pointer                  dcl 692 in procedure "pointer_chain" ref 689 698 712
pt                                     parameter       pointer                  dcl 777 in procedure "is_big" ref 771 780
pt                                     parameter       pointer                  dcl 41 in procedure "prepare_operand" ref 38 115
pt                                     parameter       pointer                  dcl 754 in procedure "defined_chain" ref 751 757
ptr                      31(05)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 360 542
q                               000106 automatic       pointer                  dcl 47 set ref 115* 123* 124 126 128 129 129 129 129
                                                                                  138* 139 143* 147 147 151 151 151 151 155 169 175
                                                                                  177* 181* 188* 194* 195 208 210 212 212 220 220
                                                                                  224 227 227 228 228 228 230 230 231 231 231 231
                                                                                  231 285 285 289 289 289 293 301 307 307* 312* 337
                                                                                  344 350 356 362 362 365* 365* 366 367 370 376 382
                                                                                  388 394 400 404 407 409 416 416 416 424 425 428
                                                                                  428 431 431 432 435 435 435 437 437 453 453 454
                                                                                  454 454 454 457 459 460 462 462 466 466 468 468
                                                                                  469 470 475 477 478 478 478 484 484 484 487 487
                                                                                  487 493 504 506 508 508 511 512 520 520 520 522
                                                                                  522 522 531 531 534 534 537 537 546 546 546 547
                                                                                  547 547 550 550 551 551 554 559 559 575 575 575
                                                                                  579 580 580 580 583 585 588 595 595 595 595 599
                                                                                  601 603 603 603 606 606 606 609 611 613 627 632
                                                                                  634 637 637 641* 641 641 642 662 663* 672* 680 680
                                                                                  681 686 810 818* 818* 862 862 864* 871 871* 871*
                                                                                  873* 874 890 890 890 895*
qp                              000132 automatic       pointer                  dcl 692 in procedure "pointer_chain" set ref 698*
                                                                                  699 701* 701* 705 709 712* 718 718 726 726 726 726
                                                                                  729* 730 741 745* 746
qp                              000152 automatic       pointer                  dcl 754 in procedure "defined_chain" set ref 757*
                                                                                  759 759* 759* 761 763* 764*
qualifier                 4            based           pointer                  level 2 packed unaligned dcl 2-3 set ref 208 698
                                                                                  712* 757
r                               000210 automatic       pointer                  dcl 835 set ref 851* 862 864 865 868 870* 873*
real_fix_bin_1                         constant        fixed bin(15,0)          initial dcl 9-1 ref 321 356 382 531 653 890
real_fix_bin_2                         constant        fixed bin(15,0)          initial dcl 9-1 ref 318 400 660
real_fix_dec                           constant        fixed bin(15,0)          initial dcl 9-1 ref 333
real_flt_bin_1                         constant        fixed bin(15,0)          initial dcl 9-1 ref 324 531
real_flt_bin_2                         constant        fixed bin(15,0)          initial dcl 9-1 ref 322
ref_count                 0(18)        based           fixed bin(17,0)          level 2 packed unaligned dcl 2-3 set ref 231 366*
                                                                                  862* 862
reference                              based           structure                level 1 dcl 2-3
reference_node                         constant        bit(9)                   initial dcl 7-5 ref 163 699 759
result                          000170 automatic       bit(1)                   dcl 778 set ref 789* 790* 793
return_value             32(18)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 151
round_fun                              constant        bit(9)                   initial dcl 8-8 ref 841
rp                              000154 automatic       pointer                  dcl 754 set ref 763* 764*
s                               000110 automatic       pointer                  dcl 47 set ref 162* 163 165 167 177 210* 214 216 220
                                                                                  220 220 220 220 220 224 224 224 224 227 228 228
                                                                                  230 231 287 289 293 293 293 301 301 316 318 318
                                                                                  322 326 331 333 334 342 342 348 354 360 370 370
                                                                                  370 374 376 380 386 392 394 398 404 404 404 407
                                                                                  407 411 411 411 416 416 437 437 443 443 497 497
                                                                                  499 501 501 504 504 506 508 515 518 529 531 534
                                                                                  537 542 544 566 818 841 841 841 841 851 851 860
                                                                                  865*
scale                     2(28)        based           fixed bin(7,0)           level 2 packed unaligned dcl 3-3 ref 841 841
shared                    0(11)        based           bit(1)                   level 2 packed unaligned dcl 2-3 ref 175 212 362 460
                                                                                  726 741 810 862 871
size                     16            based           fixed bin(8,0)           level 3 dcl 11-6 ref 642 642 673 673
sp                              000136 automatic       pointer                  dcl 692 set ref 722* 741
stack_temp$assign_aggregate     000016 constant        entry                    external dcl 61 ref 569
state_man$erase_reg             000024 constant        entry                    external dcl 61 ref 640 667 671
state_man$update_ref            000020 constant        entry                    external dcl 61 ref 672
state_man$update_reg            000022 constant        entry                    external dcl 61 ref 641 663
std_call                               constant        bit(9)                   initial dcl 8-8 ref 192 710 854
storage_block            31(12)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 220
storage_class            32(09)        based           structure                level 3 packed unaligned dcl 3-3
str                             000116 automatic       bit(1)                   dcl 47 set ref 411* 416 416 450
string                                                 builtin function         dcl 96 set ref 624 637* 637 637 640 640 641 641 667
                                                                                  667 671 671 818 818
structure                31            based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 220 544
substr                   13            based           bit(1)                   level 3 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" ref 289
substr                                                 builtin function         dcl 96 in procedure "prepare_operand" ref 624 640
                                                                                  640 667 667 671 671 810 857
symbol                                 based           structure                level 1 dcl 3-3 in procedure "prepare_operand"
symbol                    3            based           pointer                  level 2 in structure "reference" packed unaligned
                                                                                  dcl 2-3 in procedure "prepare_operand" set ref
                                                                                  124* 151 151 165 167 169 210 478 478 722 788 797
                                                                                  818 865
symbol_node                            constant        bit(9)                   initial dcl 7-5 ref 151 165
temp_ref                 12(11)        based           bit(1)                   level 3 packed unaligned dcl 2-3 set ref 129* 227*
                                                                                  227 228 230 231 362 470 559 621 681* 726 890
temporary                32(17)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 169 220 227 228
                                                                                  404 741 841
temporary_node                         constant        bit(9)                   initial dcl 7-5 ref 307
tp                              000134 automatic       pointer                  dcl 692 set ref 705* 706 722 741 741*
type                                   based           bit(9)                   level 2 packed unaligned dcl 7-27 ref 120 133 151
                                                                                  163 165 214 307 367 618 699 759 782 786 810 816
                                                                                  841
unaligned                31(22)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 370 437 443 501
units                     0(14)        based           fixed bin(3,0)           level 2 packed unaligned dcl 2-3 set ref 424 425*
                                                                                  432* 579
units_per_word                  000006 constant        fixed bin(8,0)           initial array dcl 1-5 ref 428 431
unpacked_ptr                           constant        fixed bin(15,0)          initial dcl 9-1 ref 370 660
useless                         000141 automatic       bit(1)                   dcl 692 set ref 701* 718*
value_in                 11(09)        based           structure                level 3 packed unaligned dcl 2-3 set ref 624 637*
                                                                                  637 637 640 640 641 641 667 667 671 671
variable                 31(32)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 404
varying_ref               0(10)        based           bit(1)                   level 2 packed unaligned dcl 2-3 ref 416 475
word_                                  constant        fixed bin(3,0)           initial dcl 10-5 ref 425 428 432 435 437 534 537 580
                                                                                  601

NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED.
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_bits                          internal static bit(9)                   initial dcl 8-8
addrel                                                 builtin function         dcl 96
addrel_fun                             internal static bit(9)                   initial dcl 8-8
adjust_ref_count                000000 constant        entry                    external dcl 61
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 7-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_op                       000000 constant        entry                    external dcl 61
assign_round                           internal static bit(9)                   initial dcl 8-8
assign_size_ck                         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 1-5
bits_per_half                          internal static fixed bin(8,0)           initial dcl 1-5
bits_per_packed_digit                  internal static fixed bin(8,1)           initial dcl 1-35
bits_per_words                         internal static fixed bin(8,0)           initial array dcl 1-5
block_node                             internal static bit(9)                   initial dcl 7-5
bn_format                              internal static bit(9)                   initial dcl 8-8
bool_fun                               internal static bit(9)                   initial dcl 8-8
bound                                  based           structure                level 1 dcl 4-21
bound_ck                               internal static bit(9)                   initial dcl 8-8
bound_node                             internal static bit(9)                   initial dcl 7-5
break_even_bits                        internal static fixed bin(8,0)           initial dcl 1-5
break_even_words                       internal static fixed bin(8,0)           initial dcl 1-5
by_name_agg_node                       internal static bit(9)                   initial dcl 7-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$long_string_temp               external static pointer                  dcl 54
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 1-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
compile_exp                     000000 constant        entry                    external dcl 61
complex_fix_bin_1                      internal static fixed bin(15,0)          initial dcl 9-1
complex_fix_bin_2                      internal static fixed bin(15,0)          initial dcl 9-1
complex_fix_dec                        internal static fixed bin(15,0)          initial dcl 9-1
complex_flt_bin_1                      internal static fixed bin(15,0)          initial dcl 9-1
complex_flt_bin_2                      internal static fixed bin(15,0)          initial dcl 9-1
complex_flt_dec                        internal static fixed bin(15,0)          initial dcl 9-1
conjg_fun                              internal static bit(9)                   initial dcl 8-8
context_node                           internal static bit(9)                   initial dcl 7-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 7-5
default_fix_bin_p                      internal static fixed bin(8,0)           initial dcl 1-5
default_node                           internal static bit(9)                   initial dcl 7-5
delete_file                            internal static bit(9)                   initial dcl 8-8
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_out                          internal static fixed bin(15,0)          initial dcl 9-1
f_format                               internal static bit(9)                   initial dcl 8-8
fix_bin                                based           fixed bin(17,0)          array dcl 99
floor_fun                              internal static bit(9)                   initial dcl 8-8
format_value_node                      internal static bit(9)                   initial dcl 7-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
generate_constant$real_fix_bin_1
                                000000 constant        entry                    external dcl 61
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
i                                      automatic       fixed bin(17,0)          dcl 836
imag_fun                               internal static bit(9)                   initial dcl 8-8
ind_arithmetic                         internal static fixed bin(17,0)          initial dcl 11-68
ind_decimal_reg                        internal static fixed bin(17,0)          initial dcl 11-68
ind_invalid                            internal static fixed bin(17,0)          initial dcl 11-68
ind_known_refs                         internal static fixed bin(17,0)          initial dcl 11-68
ind_logical                            internal static fixed bin(17,0)          initial dcl 11-68
ind_string_aq                          internal static fixed bin(17,0)          initial dcl 11-68
ind_x                                  internal static fixed bin(17,0)          initial array dcl 11-68
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
int_entry_other                        internal static fixed bin(15,0)          initial dcl 9-1
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 7-5
label_size                             internal static fixed bin(8,0)           initial dcl 1-5
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 7-5
load                            000000 constant        entry                    external dcl 61
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
loop                                   internal static bit(9)                   initial dcl 8-8
machine_state_node                     internal static bit(9)                   initial dcl 7-5
make_desc                              internal static bit(9)                   initial dcl 8-8
max                                                    builtin function         dcl 96
max_fun                                internal static bit(9)                   initial dcl 8-8
max_length_p                           internal static fixed bin(8,0)           initial dcl 1-5
max_number_of_operands                 internal static fixed bin(15,0)          initial dcl 6-15
max_offset                             internal static fixed bin(8,0)           initial array dcl 1-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
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
op_code                                automatic       bit(9)                   dcl 47
open_file                              internal static bit(9)                   initial dcl 8-8
or_bits                                internal static bit(9)                   initial dcl 8-8
pack                                   internal static bit(9)                   initial dcl 8-8
packed_digits_per_char                 internal static fixed bin(8,0)           initial dcl 1-5
packed_digits_per_word                 internal static fixed bin(8,0)           initial dcl 1-5
page_format                            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_flt_dec                           internal static fixed bin(15,0)          initial dcl 9-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
rp                                     automatic       pointer                  dcl 692
scale                                  automatic       fixed bin(17,0)          array dcl 836
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 7-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 7-5
sqrt_fun                               internal static bit(9)                   initial dcl 8-8
stack_ptr                              internal static bit(9)                   initial dcl 8-8
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 7-5
std_arg_list                           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
tan_fun                                internal static bit(9)                   initial dcl 8-8
tand_fun                               internal static bit(9)                   initial dcl 8-8
terminate_trans                        internal static bit(9)                   initial dcl 8-8
token_node                             internal static bit(9)                   initial dcl 7-5
translate_fun                          internal static bit(9)                   initial dcl 8-8
trunc_fun                              internal static bit(9)                   initial dcl 8-8
unlock_file     ��#���
�	��@��eOt
����,������
X�((��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ�4�	������Q�4�<�Q�4�gnQ�4�a��������������������������������������V�#m�B#B#��@0����
�ɠ�*��'#��
���pB#

�
@
~VT����f?����W
:��i����G�j@l~KO+����x h�Ƅ
_
�7i
Q�;/*�MR12.5  Q�H�o��        hcr�dK��BO,	O�-n�1D/7
pmO,S��uj6��k�8�Q����3Q�;.�
O��(!
P��0���/
��W$-.}�_U�����

�)
�g�+��;��_�3�=�L�
?�

3�-_G�{0}�M^,�%��z]z��.�
�
�Q�;C��r��C
��

4�
��C3���'�IA"�}��}6�W&�o!

%&���;�,�+�Ɋ�b���#�/�
5	��@��eOt
����,������
X�((��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ�;Cƙ�����Q�;��QQ�;[��Q�;j/
��������������������������������������V�#m�B#B#��@0����
�ɠ�*��'#��
���pB#

�
@
~VT����f?��)�x
:�i���G�j@l~KO+����x h�Ƅ
_
�7i
Q�A���MR12.5  Q�H�o��        haY%�dKѺ��P~
�-qn2�.�
prP~S�utq0�k�8������Q�A�c�
O��%�
W\X0�v���
��Wo-.}��%�����

�]
�g�+��;��`
�=�L�
?�

3�-_G�{0}�M^,�%��z]z��.�



Q�A�l�r��C�

4�
��C3���'�IA"�}��}6�W&�o!

%88���c'Ѻ,��<���b���#�N
�	��@��eOt
����,������
X�( ��

@������?�#
?�#
Q�G���àà�P�����������������1ZQ�A�������Q�A��Q�A��KQ�A����������������������������������������V�#m�B#B#��@0����
�ɠ�*��'#��
���pB#

�
@
~VT����f?��O��
:�#i���G�j@l~KO+����x h�Ƅ
_
�7i
Q�H
cMR12.5  Q�H�o��        h��dK����in                           internal procedure  shares stack frame of external procedure prepare_operand.  
defined_chain                           internal procedure  shares stack frame of external procedure prepare_operand.  
is_big                                  internal procedure  shares stack frame of external procedure prepare_operand.  
check_assign                            internal procedure  shares stack frame of external procedure prepare_operand.  
prepare_decimal                         internal procedure  shares stack frame of external procedure prepare_operand.  
bad                                     internal procedure  shares stack frame of external procedure prepare_operand.  

STORAGE FOR AUTOMATIC VARIABLES.

STACK FRAME                 LOC IDENTIFIER                  BLOCK NAME
prepare_operand          000100 p                           prepare_operand
                         000102 p1                          prepare_operand
                         000104 p2                          prepare_operand
                         000106 q                           prepare_operand
                         000110 s                           prepare_operand
                         000112 cfo                         prepare_operand
                         000113 eval                        prepare_operand
                         000114 n                           prepare_operand
                         000115 bit_length                  prepare_operand
                         000116 str                         prepare_operand
                         000117 here_before                 prepare_operand
                         000120 padded_bit                  prepare_operand
                         000122 m_s_p                       prepare_operand
                         000132 qp                          pointer_chain
                         000134 tp                          pointer_chain
                         000136 sp                          pointer_chain
                         000140 dummy                       pointer_chain
                         000141 useless                     pointer_chain
                         000142 op_code                     pointer_chain
                         000152 qp                          defined_chain
                         000154 rp                          defined_chain
                         000156 atomic                      defined_chain
                         000166 p                           is_big
                         000170 result                      is_big
                         000200 p2                          check_assign
                         000210 r                           prepare_decimal

THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM.
r_g_a               r_e_as              r_ne_as             unpk_to_pk          call_ext_out        return
mod_fx1             ext_entry           trunc_fx1           scaled_mod_fx1

THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM.
assign_desc_op                assign_op$to_dec_scaled       base_man$load_packed          call_op
check_o_and_s                 compile_exp$save              compile_exp$save_exp          copy_temp
decimal_op$change_target      decimal_op$get_float_temp     error                         eval_exp
get_reference                 length_op                     pointer_builtins              prepare_operand
stack_temp$assign_aggregate   state_man$erase_reg           state_man$update_ref          state_man$update_reg

THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM.
cg_stat$cur_block             cg_stat$cur_node              cg_stat$cur_statement         cg_static_$m_s_p




   LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC   
     38 000026   11    3 000040       115 000043       116 000050       118 000052       120 000054       123 000061
    124 000067       126 000072       128 000075       129 000103       130 000113       133 000114       136 000116
    138 000123       139 000133       143 000137       147 000142       151 000150       155 000204       157 000212
    160 000213       162 000221       163 000224       165 000230       167 000235       169 000240       175 000244
    177 000247       178 000250       181 000251       182 000262       186 000263       188 000265       189 000276
    192 000277       194 000301       195 000312       197 000320       200 000321       202 000322       208 000324
    210 000327       212 000332       214 000345       216 000351       217 000352       220 000353       224 000417
    227 000446       228 000453       230 000473       231 000510       285 000545       287 000552       289 000555
    293 000572       301 000610       307 000620       312 000640       316 000642       318 000646       321 000657
    322 000662       324 000670       326 000672       328 000677       331 000700       333 000703       334 000710
    337 000715       339 000721       342 000722       344 000725       345 000730       348 000731       350 000734
    351 000737       354 000740       356 000743       357 000746       360 000747       362 000752       365 000761
    366 000771       367 000774       370 001003       371 001025       374 001026       376 001031       377 001042
    380 001043       382 001046       383 001051       386 001052       388 001055       389 001060       392 001061
    394 001064       395 001075       398 001076       400 001101       401 001104       404 001105       407 001122
    409 001136       411 001141       414 001157       416 001161       421 001210       424 001211       425 001215
    428 001225       431 001240       432 001243       435 001251       437 001275       442 001326       443 001327
    446 001337       447 001340       450 001344       453 001346       454 001355       457 001367       459 001372
    460 001374       462 001377       463 001412       466 001413       468 001416       469 001424       470 001426
    472 001432       475 001433       477 001436       478 001440       481 001451       484 001452       487 001474
    490 001511       493 001512       495 001515       497 001516       499 001525       501 001530       504 001536
    506 001545       508 001550       510 001556       511 001557       512 001562       515 001563       517 001567
    518 001570       520 001574       522 001617       526 001634       529 001635       531 001640       534 001652
    537 001676       540 001706       542 001707       544 001712       546 001715       547 001731       550 001745
    551 001762       554 001772       559 002000       566 002005       567 002014       569 002017       575 002031
    579 002043       580 002047       583 002062       585 002065       586 002077       588 002102       592 002112
    595 002114       599 002144       601 002150       603 002156       606 002167       609 002213       611 002216
    613 002220       615 002223       618 002227       621 002236       624 002242       627 002246       632 002252
    634 002257       637 002263       640 002272       641 002305       642 002323       646 002344       651 002345
    653 002352       655 002354       657 002356       660 002360       662 002364       663 002366       664 002401
    667 002402       669 002413       671 002414       672 002425       673 002434       677 002443       680 002444
    681 002450       686 002452       689 002456       698 002460       699 002464       701 002470       702 002507
    705 002510       706 002512       709 002516       710 002522       712 002524       713 002542       716 002543
    718 002545       719 002571       722 002572       724 002574       726 002576       729 002623       730 002634
    731 002640       734 002641       736 002644       741 002647       745 002671       746 002704       748 002710
    751 002711       757 002713       759 002717       761 002743       763 002747       764 002766       768 003002
    771 003003       780 003005       782 003010       785 003021       786 003023       788 003031       789 003034
    790 003036       793 003045       795 003050       797 003052       802 003061       810 003062       815 003076
    816 003101       818 003107       823 003140       826 003141       841 003142       849 003201       851 003215
    854 003235       857 003250       860 003255       862 003261       864 003267       865 003273       866 003276
    868 003277       870 003302       871 003312       873 003325       874 003336       875 003341       880 003344
    885 003345       890 003346       895 003362       897 003377


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


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