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

        1 /* ***********************************************************
        2*   *                                                         *
        3*   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        4*   *                                                         *
        5*   * Copyright (c) 1972 by Massachusetts Institute of        *
        6*   * Technology and Honeywell Information Systems, Inc.      *
        7*   *                                                         *
        8*   *********************************************************** */
        9 
       10 
       11 /* procedure to compile I/O operators
       12*
       13*   Initial Version: 19 October 1971 by BLW
       14*	Modified:  3 October 1972 by BLW
       15*	Modified:	28 February 1973 by RAB
       16*	Modified:	18 June 1973 by RAB	
       17*	Modified:	30 December 1974 by RAB to fix 1282
       18*	Modified:	25 February 1975 by RAB for quick put list
       19*	Modified:	12 January 1976 by RAB to fix 1455
       20*	Modified:	10 January 1978 by RAB to fix 1697
       21*	Modified: 1 May 1979 by PCK to implement 4-bit decimal */
       22 
       23 io_op:	proc(pt);
       24 
       25 dcl	pt ptr;		/* points at operator node */
       26 
       27 dcl	(cg_stat$cur_block,cg_stat$cur_statement,cg_stat$text_base) ptr ext,
       28 	cg_stat$generate_symtab bit(1) ext,
       29 	cg_stat$star_symbol_up_zero bit(18) ext;
       30 
       31 dcl	(p,psp,psr,sslp,q,p2,p3,p4,arg(3),rand(3)) ptr,
       32 	(psloc,i,n,macro,ok) fixed bin(15),
       33 	quick_stream_op bit(1) aligned init("0"b),
       34 	(atomic,useless) bit(1) aligned;
       35 
       36 dcl	odd_bases bit(19) int static aligned init("0000000000000001111"b);
       37 
       38 dcl	(addr,bit,fixed,null,substr) builtin;
       39 
       40 dcl	expmac entry(fixed bin(15),ptr),
       41 	expmac$many entry(fixed bin(15),ptr,fixed bin),
       42 	long_op$io entry(ptr,fixed bin(15)),
       43 	generate_constant$real_fix_bin_1 entry(fixed bin) returns(ptr),
       44 	load entry(ptr,fixed bin),
       45 	base_man$load_var entry(fixed bin,ptr,fixed bin);
       46 dcl	base_man$load_linkage entry returns(bit(3) aligned);
       47 dcl	(compile_exp, fortran_$fortran_io_op) entry(ptr),
       48 	compile_exp$save_exp entry(ptr) returns(ptr),
       49 	prepare_operand entry(ptr,fixed bin,bit(1) aligned) returns(ptr),
       50 	xr_man$load_var entry(ptr,fixed bin(17)),
       51 	xr_man$super_lock entry(fixed bin(17)),
       52 	c_a entry(fixed bin(18),fixed bin) returns(ptr),
       53 	base_man$store_ptr_to entry(ptr,ptr),
       54 	state_man$erase_reg entry(bit(19) aligned),
       55 	state_man$flush_ref entry(ptr),
       56 	state_man$flush entry();
       57 dcl	m_a entry(ptr,bit(2) aligned);
       58 dcl	expmac$zero entry(fixed bin(15)),
       59 	aq_man$lock entry(ptr,fixed bin);
       60 dcl	copy_temp entry(ptr) returns(ptr);
       61 dcl	stack_temp$assign_temp entry(ptr),
       62 	declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),ptr) returns(ptr);
       63 
       64 dcl (	get_term_mac	init(313),
       65 	put_data_mac	init(328),
       66 	lda		init(1),
       67 	ldfx1		init(7),
       68 	stfx1		init(15),
       69 	zero_mac		init(308),
       70 	symtab_mac	init(320),
       71 	init_ps_mac	init(339),
       72 	init_sslp		init(340),
       73 	io_macro(0:15)	init(495,499,0,503,507,(8)0,587,498,506),
       74 	put_field_mac		init(502),
       75 	stream_prep_mac	init(396),
       76 	recio_mac		init(485),
       77 	form_desc		init(513),
       78 	load_pt		init(60)) fixed bin(15) int static;
       79 
       80 dcl	fixbin fixed bin based aligned;
       81 
  1     1 
  1     2 			/* ps_map.incl.pl1 for PLIO2 */
  1     3 dcl (	ps_stack		init(0),
  1     4 	ps_symbol_top	init(2),
  1     5 	ps_symbol_block	init(4),
  1     6 	ps_format_area	init(6),
  1     7 	ps_ssl		init(8),
  1     8 	ps_label		init(10),
  1     9 	ps_source		init(16),
  1    10 	ps_special_list	init(18),
  1    11 	ps_set_p		init(18),
  1    12 	ps_copy		init(20),
  1    13 	ps_var_bitlen	init(21),
  1    14 	ps_job		init(22),
  1    15 	ps_number		init(23),
  1    16 	ps_value		init(24),
  1    17 	ps_var_p		init(24),
  1    18 	ps_descriptor	init(26),
  1    19 	ps_offset		init(28),
  1    20 	ps_prep		init(29),
  1    21 	ps_lock_sw	init(29),
  1    22 	ps_new_format	init(30),
  1    23 	ps_key		init(48) )  fixed bin(15) static internal options(constant);
  1    24 
       82 
  2     1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */
  2     2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */
  2     3 /* format: style3,idind30 */
  2     4 
  2     5 declare	1 block			aligned based,
  2     6 	  2 node_type		bit (9) unaligned,
  2     7 	  2 source_id		structure unaligned,
  2     8 	    3 file_number		bit (8),
  2     9 	    3 line_number		bit (14),
  2    10 	    3 statement_number	bit (5),
  2    11 	  2 father		ptr unaligned,
  2    12 	  2 brother		ptr unaligned,
  2    13 	  2 son			ptr unaligned,
  2    14 	  2 declaration		ptr unaligned,
  2    15 	  2 end_declaration		ptr unaligned,
  2    16 	  2 default		ptr unaligned,
  2    17 	  2 end_default		ptr unaligned,
  2    18 	  2 context		ptr unaligned,
  2    19 	  2 prologue		ptr unaligned,
  2    20 	  2 end_prologue		ptr unaligned,
  2    21 	  2 main			ptr unaligned,
  2    22 	  2 end_main		ptr unaligned,
  2    23 	  2 return_values		ptr unaligned,
  2    24 	  2 return_count		ptr unaligned,
  2    25 	  2 plio_ps		ptr unaligned,
  2    26 	  2 plio_fa		ptr unaligned,
  2    27 	  2 plio_ffsb		ptr unaligned,
  2    28 	  2 plio_ssl		ptr unaligned,
  2    29 	  2 plio_fab2		ptr unaligned,
  2    30 	  2 block_type		bit (9) unaligned,
  2    31 	  2 prefix		bit (12) unaligned,
  2    32 	  2 like_attribute		bit (1) unaligned,
  2    33 	  2 no_stack		bit (1) unaligned,
  2    34 	  2 get_data		bit (1) unaligned,
  2    35 	  2 flush_at_call		bit (1) unaligned,
  2    36 	  2 processed		bit (1) unaligned,
  2    37 	  2 text_displayed		bit (1) unaligned,
  2    38 	  2 number		fixed bin (9) unsigned unaligned,
  2    39 	  2 free_temps		dimension (3) ptr,	/* these fields are used by the code generator */
  2    40 	  2 temp_list		ptr,
  2    41 	  2 entry_list		ptr,
  2    42 	  2 o_and_s		ptr,
  2    43 	  2 why_nonquick		aligned,
  2    44 	    3 auto_adjustable_storage bit (1) unaligned,
  2    45 	    3 returns_star_extents	bit (1) unaligned,
  2    46 	    3 stack_extended_by_args	bit (1) unaligned,
  2    47 	    3 invoked_by_format	bit (1) unaligned,
  2    48 	    3 format_statement	bit (1) unaligned,
  2    49 	    3 io_statements		bit (1) unaligned,
  2    50 	    3 assigned_to_entry_var	bit (1) unaligned,
  2    51 	    3 condition_statements	bit (1) unaligned,
  2    52 	    3 no_owner		bit (1) unaligned,
  2    53 	    3 recursive_call	bit (1) unaligned,
  2    54 	    3 options_non_quick	bit (1) unaligned,
  2    55 	    3 options_variable	bit (1) unaligned,
  2    56 	    3 never_referenced	bit (1) unaligned,
  2    57 	    3 pad_nonquick		bit (5) unaligned,
  2    58 	  2 prologue_flag		bit (1) unaligned,
  2    59 	  2 options_main		bit (1) unaligned,
  2    60 	  2 pad			bit (16) unaligned,
  2    61 	  2 number_of_entries	fixed bin (17),
  2    62 	  2 level			fixed bin (17),
  2    63 	  2 last_auto_loc		fixed bin (17),
  2    64 	  2 symbol_block		fixed bin (17),
  2    65 	  2 entry_info		fixed bin (18),
  2    66 	  2 enter			structure unaligned,
  2    67 	    3 start		fixed bin (17),
  2    68 	    3 end			fixed bin (17),
  2    69 	  2 leave			structure unaligned,
  2    70 	    3 start		fixed bin (17),
  2    71 	    3 end			fixed bin (17),
  2    72 	  2 owner			ptr;
  2    73 
  2    74 declare	max_block_number		fixed bin internal static options (constant) initial (511);
  2    75 
  2    76 /* END INCLUDE FILE ... block.incl.pl1 */
       83 
  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 */
       84 
  4     1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */
  4     2 
  4     3 dcl	1 reference		based aligned,
  4     4 	2 node_type		bit(9) unaligned,
  4     5 	2 array_ref		bit(1) unaligned,
  4     6 	2 varying_ref		bit(1) unaligned,
  4     7 	2 shared			bit(1) unaligned,
  4     8 	2 put_data_sw		bit(1) unaligned,
  4     9 	2 processed		bit(1) unaligned,
  4    10 	2 units			fixed(3) unaligned,
  4    11 	2 ref_count		fixed(17) unaligned,
  4    12 	2 c_offset		fixed(24),
  4    13 	2 c_length		fixed(24),
  4    14 	2 symbol			ptr unaligned,
  4    15 	2 qualifier		ptr unaligned,
  4    16 	2 offset			ptr unaligned,
  4    17 	2 length			ptr unaligned,
  4    18 	2 subscript_list		ptr unaligned,
  4    19 						/* these fields are used by the 645 code generator */
  4    20 	2 address			structure unaligned,
  4    21 	  3 base			bit(3),
  4    22 	  3 offset		bit(15),
  4    23 	  3 op			bit(9),
  4    24 	  3 no_address		bit(1),
  4    25 	  3 inhibit		bit(1),
  4    26 	  3 ext_base		bit(1),
  4    27 	  3 tag			bit(6),
  4    28 	2 info			structure unaligned,
  4    29 	  3 address_in		structure,
  4    30 	    4 b			dimension(0:7) bit(1),
  4    31 	    4 storage		bit(1),
  4    32 	  3 value_in		structure,
  4    33 	    4 a			bit(1),
  4    34 	    4 q			bit(1),
  4    35 	    4 aq			bit(1),
  4    36 	    4 string_aq		bit(1),
  4    37 	    4 complex_aq		bit(1),
  4    38 	    4 decimal_aq		bit(1),
  4    39 	    4 b			dimension(0:7) bit(1),
  4    40 	    4 storage		bit(1),
  4    41 	    4 indicators		bit(1),
  4    42 	    4 x			dimension(0:7) bit(1),
  4    43 	  3 other			structure,
  4    44 	    4 big_offset		bit(1),
  4    45 	    4 big_length		bit(1),
  4    46 	    4 modword_in_offset	bit(1),
  4    47 	2 data_type		fixed(5) unaligned,
  4    48 	2 bits			structure unaligned,
  4    49 	  3 padded_ref		bit(1),
  4    50 	  3 aligned_ref		bit(1),
  4    51 	  3 long_ref		bit(1),
  4    52 	  3 forward_ref		bit(1),
  4    53 	  3 ic_ref		bit(1),
  4    54 	  3 temp_ref		bit(1),
  4    55 	  3 defined_ref		bit(1),
  4    56 	  3 evaluated		bit(1),
  4    57 	  3 allocate		bit(1),
  4    58 	  3 allocated		bit(1),
  4    59 	  3 aliasable		bit(1),
  4    60 	  3 even			bit(1),
  4    61 	  3 perm_address		bit(1),
  4    62 	  3 aggregate		bit(1),
  4    63 	  3 hit_zero		bit(1),
  4    64 	  3 dont_save		bit(1),
  4    65 	  3 fo_in_qual		bit(1),
  4    66 	  3 hard_to_load		bit(1),
  4    67 	2 relocation		bit(12) unaligned,
  4    68 	2 more_bits		structure unaligned,
  4    69 	  3 substr		bit(1),
  4    70 	  3 padded_for_store_ref	bit(1),
  4    71 	  3 aligned_for_store_ref	bit(1),
  4    72 	  3 mbz			bit(15),
  4    73 	2 store_ins		bit(18) unaligned;
  4    74 
  4    75 /* END INCLUDE FILE ... reference.incl.pl1 */
       85 
  5     1 /* ***********************************************************
  5     2*   *                                                         *
  5     3*   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
  5     4*   *                                                         *
  5     5*   *********************************************************** */
  5     6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */
  5     7 /* Internal interface of the PL/I compiler */
  5     8 
  5     9 dcl	1 statement		based aligned,
  5    10 	2 node_type		bit(9) unaligned,
  5    11 	2 source_id		structure unaligned,
  5    12 	  3 file_number		bit(8),
  5    13 	  3 line_number		bit(14),
  5    14 	  3 statement_number	bit(5),
  5    15 	2 next			ptr unaligned,
  5    16 	2 back			ptr unaligned,
  5    17 	2 root			ptr unaligned,
  5    18 	2 labels			ptr unaligned,
  5    19 	2 reference_list		ptr unaligned,
  5    20 	2 state_list		ptr unaligned,
  5    21 	2 reference_count		fixed(17) unaligned,
  5    22 	2 ref_count_copy		fixed(17) unaligned,
  5    23 	2 object			structure unaligned,
  5    24 	  3 start			fixed(17),
  5    25 	  3 finish		fixed(17),
  5    26 	2 source			structure unaligned,
  5    27 	  3 segment		fixed(11),
  5    28 	  3 start			fixed(23),
  5    29 	  3 length		fixed(11),
  5    30 	2 prefix			bit(12) unaligned,
  5    31 	2 optimized		bit(1) unaligned,
  5    32 	2 free_temps		bit(1) unaligned,
  5    33 	2 LHS_in_RHS		bit(1) unaligned,
  5    34 	2 statement_type		bit(9) unaligned,
  5    35 	2 bits			structure unaligned,
  5    36 	  3 processed		bit(1) unaligned,
  5    37 	  3 put_in_profile		bit(1) unaligned,
  5    38 	  3 generated		bit(1) unaligned,
  5    39 	  3 snap			bit(1) unaligned,
  5    40 	  3 system		bit(1) unaligned,
  5    41 	  3 irreducible		bit(1) unaligned,
  5    42 	  3 checked		bit(1) unaligned,
  5    43 	  3 save_temps		bit(1) unaligned,
  5    44 	  3 suppress_warnings	bit(1) unaligned,
  5    45 	  3 force_nonquick		bit(1) unaligned,
  5    46 	  3 expanded_by_name	bit(1) unaligned,
  5    47 	  3 begins_loop		bit(1) unaligned,
  5    48 	  3 pad			bit(24) unaligned;
  5    49 
  5    50 /* END INCLUDE FILE ... statement.incl.pl1 */
       86 
  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 */
       87 
  7     1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */
  7     2 
  7     3 /* Modified 26 June 81 by EBush to add max_list_elements */
  7     4 
  7     5 
  7     6 dcl	1 list		based aligned,
  7     7 	2 node_type	bit(9) unaligned,
  7     8 	2 reserved	bit(12) unaligned,
  7     9 	2 number		fixed(14) unaligned,
  7    10 	2 element		dimension(n refer(list.number)) ptr unaligned;
  7    11 
  7    12 dcl       max_list_elements   fixed bin(17) internal static options (constant)
  7    13 	                    init(16383);
  7    14 
  7    15 /* END INCLUDE FILE ... list.incl.pl1 */
       88 
  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 */
       89 
  9     1 	/* statement types */
  9     2 
  9     3 dcl (	unknown_statement		initial("000000000"b),
  9     4 	allocate_statement		initial("000000001"b),
  9     5 	assignment_statement	initial("000000010"b),
  9     6 	begin_statement		initial("000000011"b),
  9     7 	call_statement		initial("000000100"b),
  9     8 	close_statement		initial("000000101"b),
  9     9 	declare_statement		initial("000000110"b),
  9    10 	lock_statement		initial("000000111"b),
  9    11 	delete_statement		initial("000001000"b),
  9    12 	display_statement		initial("000001001"b),
  9    13 	do_statement		initial("000001010"b),
  9    14 	else_clause		initial("000001011"b),
  9    15 	end_statement		initial("000001100"b),
  9    16 	entry_statement		initial("000001101"b),
  9    17 	exit_statement		initial("000001110"b),
  9    18 	format_statement		initial("000001111"b),
  9    19 	free_statement		initial("000010000"b),
  9    20 	get_statement		initial("000010001"b),
  9    21 	goto_statement		initial("000010010"b),
  9    22 	if_statement		initial("000010011"b),
  9    23 	locate_statement		initial("000010100"b),
  9    24 	null_statement		initial("000010101"b),
  9    25 	on_statement		initial("000010110"b),
  9    26 	open_statement		initial("000010111"b),
  9    27 	procedure_statement 	initial("000011000"b),
  9    28 	put_statement		initial("000011001"b),
  9    29 	read_statement		initial("000011010"b),
  9    30 	return_statement		initial("000011011"b),
  9    31 	revert_statement		initial("000011100"b),
  9    32 	rewrite_statement		initial("000011101"b),
  9    33 	signal_statement		initial("000011110"b),
  9    34 	stop_statement		initial("000011111"b),
  9    35 	system_on_unit		initial("000100000"b),
  9    36 	unlock_statement		initial("000100001"b),
  9    37 	wait_statement		initial("000100010"b),
  9    38 	write_statement		initial("000100011"b),
  9    39 	default_statement		initial("000100100"b),
  9    40 	continue_statement		initial("000100101"b)) bit(9) internal static aligned options(constant);
       90 
 10     1 dcl	bases(0:7) bit(3) aligned int static init("000"b, "010"b, "100"b,  "001"b, "011"b, "101"b, "111"b,"110"b)
 10     2 	options(constant);
 10     3 
 10     4 dcl (	ap	defined(bases(0)),
 10     5 	bp	defined(bases(1)),
 10     6 	lp	defined(bases(2)),
 10     7 	sp	defined(bases(7))) bit(3) aligned;
 10     8 
 10     9 dcl (	ab	defined(bases(3)),
 10    10 	bb	defined(bases(4)),
 10    11 	lb	defined(bases(5)),
 10    12 	sb	defined(bases(6))) bit(3) aligned;
 10    13 
 10    14 dcl	which_base(0:7) fixed bin int static init(0,3,1,4,2,5,7,6) options(constant);
       91 
 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 */
       92 
 12     1 /* BEGIN INCLUDE FILE relocation_bits.incl.pl1 */
 12     2 
 12     3 /* This include file defines the relocation bits as bit (6) entities.  See
 12     4*   also relbts.incl.pl1 and reloc_lower.incl.pl1. */
 12     5 
 12     6 dcl (	rc_a	initial("000000"b),		/* absolute */
 12     7 	rc_t	initial("010000"b),		/* text */
 12     8 	rc_nt	initial("010001"b),		/* negative text */
 12     9 	rc_lp18	initial("010010"b),		/* linkage, 18 bit */
 12    10 	rc_nlp18	initial("010011"b),		/* negative link, 18 bit */
 12    11 	rc_lp15	initial("010100"b),		/* linkage, 15 bit */
 12    12 	rc_dp	initial("010101"b),		/* def section */
 12    13 	rc_s	initial("010110"b),		/* symbol segment */
 12    14 	rc_ns	initial("010111"b),		/* negative symbol */
 12    15 	rc_is18	initial("011000"b),		/* internal static 18 */
 12    16 	rc_is15	initial("011001"b),		/* internal static 15 */
 12    17 	rc_lb	initial("011000"b),		/* link block */
 12    18 	rc_nlb	initial("011001"b),		/* negative link block */
 12    19 	rc_sr	initial("011010"b),		/* self relative */
 12    20 	rc_e	initial("011111"b))		/* escape */
 12    21 	bit(6) int static options(constant);
 12    22 
 12    23 /* END INCLUDE FILE relocation_bits.incl.pl1 */
       93 
 13     1 dcl (	real_fix_bin_1		init(1),
 13     2 	real_fix_bin_2		init(2),
 13     3 	real_flt_bin_1		init(3),
 13     4 	real_flt_bin_2		init(4),
 13     5 	complex_fix_bin_1		init(5),
 13     6 	complex_fix_bin_2		init(6),
 13     7 	complex_flt_bin_1		init(7),
 13     8 	complex_flt_bin_2		init(8),
 13     9 	real_fix_dec		init(9),
 13    10 	real_flt_dec		init(10),
 13    11 	complex_fix_dec		init(11),
 13    12 	complex_flt_dec		init(12),
 13    13 	char_string		init(13),
 13    14 	bit_string		init(14),
 13    15 	label_constant		init(15),
 13    16 	local_label_variable	init(16),
 13    17 	label_variable		init(17),
 13    18 	entry_variable		init(18),
 13    19 	ext_entry_in		init(19),
 13    20 	ext_entry_out		init(20),
 13    21 	int_entry			init(21),
 13    22 	int_entry_other		init(22),
 13    23 	unpacked_ptr		init(23),
 13    24 	packed_ptr		init(24)) fixed bin(15) int static options(constant);
       94 
 14     1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */
 14     2 
 14     3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */
 14     4 
 14     5 dcl (	bit_		init(1),
 14     6 	digit_		init(2),
 14     7 	character_	init(3),
 14     8 	half_		init(4),
 14     9 	word_		init(5),
 14    10 	mod2_		init(6),
 14    11 	mod4_		init(7)) fixed bin(3) int static options(constant);
 14    12 
 14    13 /* END INCLUDE FILE ... boundary.incl.pl1 */
       95 
 15     1 /* BEGIN INCLUDE FILE ... mask.incl.pl1 */
 15     2 
 15     3 dcl (	structure_mask		init("100000000000000000000000000000000000"b),
 15     4 	fixed_mask		init("010000000000000000000000000000000000"b),
 15     5 	float_mask		init("001000000000000000000000000000000000"b),
 15     6 	bit_mask			init("000100000000000000000000000000000000"b),
 15     7 	char_mask			init("000010000000000000000000000000000000"b),
 15     8 	ptr_mask			init("000001000000000000000000000000000000"b),
 15     9 	offset_mask		init("000000100000000000000000000000000000"b),
 15    10 	area_mask			init("000000010000000000000000000000000000"b),
 15    11 	label_mask		init("000000001000000000000000000000000000"b),
 15    12 	entry_mask		init("000000000100000000000000000000000000"b),
 15    13 	file_mask			init("000000000010000000000000000000000000"b),
 15    14 	arg_descriptor_mask		init("000000000001000000000000000000000000"b),
 15    15 	storage_block_mask		init("000000000000100000000000000000000000"b),
 15    16 	lock_mask			init("000000000000010000000000000000000000"b),
 15    17 	condition_mask		init("000000000000001000000000000000000000"b),
 15    18 	format_mask		init("000000000000000100000000000000000000"b),
 15    19 	builtin_mask		init("000000000000000010000000000000000000"b),
 15    20 	generic_mask		init("000000000000000001000000000000000000"b),
 15    21 	picture_mask		init("000000000000000000100000000000000000"b),
 15    22 	dimensioned_mask		init("000000000000000000010000000000000000"b),
 15    23 	initialed_mask		init("000000000000000000001000000000000000"b),
 15    24 	aligned_mask		init("000000000000000000000100000000000000"b),
 15    25 	unaligned_mask		init("000000000000000000000010000000000000"b),
 15    26 	signed_mask		init("000000000000000000000001000000000000"b),
 15    27 	unsigned_mask		init("000000000000000000000000100000000000"b),
 15    28 	precision_mask		init("000000000000000000000000010000000000"b),
 15    29 	varying_mask		init("000000000000000000000000001000000000"b),
 15    30 	local_mask		init("000000000000000000000000000100000000"b),
 15    31 	decimal_mask		init("000000000000000000000000000010000000"b),
 15    32 	binary_mask		init("000000000000000000000000000001000000"b),
 15    33 	real_mask			init("000000000000000000000000000000100000"b),
 15    34 	complex_mask		init("000000000000000000000000000000010000"b),
 15    35 	variable_mask		init("000000000000000000000000000000001000"b),
 15    36 	reducible_mask		init("000000000000000000000000000000000100"b),
 15    37 	irreducible_mask		init("000000000000000000000000000000000010"b),
 15    38 	returns_mask		init("000000000000000000000000000000000001"b)) bit(36) aligned int static
 15    39 				options(constant);
 15    40 
 15    41 dcl (	arithmetic_mask		init("011000000000000000000000000011110000"b),
 15    42 	computational_mask		init("011110000000000000100000000011110000"b),
 15    43 	fixed_binary_real_mask	init("010000000000000000000000000001100000"b),
 15    44 	fixed_decimal_real_mask	init("010000000000000000000000000010100000"b),
 15    45 	float_decimal_real_mask	init("001000000000000000000000000010100000"b),
 15    46 	fixed_decimal_complex_mask	init("010000000000000000000000000010010000"b),
 15    47 	float_decimal_complex_mask	init("001000000000000000000000000010010000"b),
 15    48 	string_mask		init("000110000000000000000000000000000000"b),
 15    49 	undesirable_mask		init("111111111111111111100111110111110111"b),
 15    50 	convert_mask		init("011111111111111111100111110111111110"b),
 15    51 	declare_constant_mask	init("111111111111111111100000000011110000"b)
 15    52 								     ) bit(36) aligned int static
 15    53 									options(constant);
 15    54 
 15    55 /* END INCLUDE FILE ... mask.incl.pl1 */
       96 
       97 
       98 	p = pt;
       99 
      100 	if p -> operator.op_code > record_io
      101 	then if p -> operator.op_code < put_control
      102 	     then do;
      103 	          call fortran_$fortran_io_op(p);
      104 	          return;
      105 	          end;
      106 	     else quick_stream_op = "1"b;
      107 
      108 	psp = cg_stat$cur_block -> block.plio_ps -> element(1);
      109 	psr = psp -> symbol.reference;
      110 
      111 	rand(1) = p -> operand(1);
      112 	rand(2) = p -> operand(2);
      113 	rand(3) = p -> operand(3);
      114 	if p -> op_code = stream_prep
      115 	then do;
      116 	     arg(1) = rand(1);
      117 	     arg(2) = prepare_operand(rand(2),-1,atomic);
      118 	     call ma_and_flush(2);
      119 	     call expmac$many((stream_prep_mac),addr(arg),2);
      120 	     arg(1) -> reference.perm_address = "0"b;
      121 	     arg(2) -> reference.perm_address = "0"b;
      122 	     return;
      123 	     end;
      124 
      125 	if p -> op_code = record_io
      126 	then do;
      127 	     arg(1) = rand(1);
      128 	     call ma_and_flush(1);
      129 
      130 	     if p -> operator.number = 2
      131 	     then do;
      132 		arg(2) = prepare_operand(rand(2),-1,atomic);
      133 		call base_man$load_var(2,arg(2),1);
      134 		end;
      135 
      136 	     call expmac((recio_mac),arg(1));
      137 	     arg(1) -> reference.perm_address = "0"b;
      138 	     return;
      139 	     end;
      140 
      141 	if p -> op_code = terminate_trans
      142 	then do;
      143 	     call ma_and_flush(0);
      144 	     call expmac$zero(get_term_mac + fixed(cg_stat$cur_statement -> statement_type = put_statement,1));
      145 	     return;
      146 	     end;
      147 
      148 	psloc = psp -> symbol.location;
      149 
      150 	if p -> op_code = get_data_trans
      151 	then do;
      152 
      153 	     /* set ptr to OK list */
      154 
      155 	     if rand(1) -> operator.number = 0
      156 	     then do;
      157 		q = generate_constant$real_fix_bin_1(0);
      158 		call state_man$flush;
      159 		end;
      160 	     else do;
      161 		ok = rand(1) -> operator.number;
      162 		q = c_a((ok),10);
      163 		do i = 1 to addrel(cg_stat$text_base,ok) -> fixbin;	/* KLUDGE to find out original number of operands */
      164 		     call state_man$flush_ref((rand(1) -> operand(i)));
      165 		end;
      166 		end;
      167 
      168 	     call base_man$store_ptr_to(q,c_a(psloc + ps_special_list,4));
      169 	     return;
      170 	     end;
      171 
      172 	if p -> op_code = put_data_trans
      173 	then do;
      174 
      175 	     /* process subscript list */
      176 
      177 	     sslp = cg_stat$cur_block -> block.plio_ssl;
      178 	     n = sslp -> symbol.location;
      179 	     sslp = sslp -> symbol.reference;
      180 
      181 	     sslp -> reference.perm_address = "0"b;
      182 
      183 	     if rand(1) = null then call expmac((zero_mac),sslp);
      184 	     else do;
      185 		call expmac((ldfx1),c_a((rand(1) -> list.number),2));
      186 		call expmac((stfx1),sslp);
      187 		sslp -> reference.perm_address = "1"b;
      188 
      189 		do i = 1 to rand(1) -> list.number;
      190 		     sslp -> address.offset = bit(fixed(n+i,15),15);
      191 
      192 		     p2 = rand(1) -> element(i);
      193 		     p3 = prepare_operand(p2,1,atomic);
      194 		     if atomic then call load(p3,0); else call compile_exp(p2);
      195 
      196 		     call expmac((stfx1),sslp);
      197 		     end;
      198 		end;
      199 
      200 	     p2 = prepare_operand(rand(2),-1,atomic);
      201 
      202 	     /* put symtab offset into ps */
      203 
      204 	     call protect_areg;
      205 	     q = c_a(fixed(rand(2) -> reference.symbol -> symbol.runtime,18),2);
      206 	     q -> reference.relocation = rc_s;
      207 	     call expmac((lda),q);
      208 
      209 	     macro = put_data_mac;
      210 	     goto l2;
      211 	     end;
      212 
      213 	if p->op_code = put_control
      214 	then do;
      215 	     p2 = prepare_operand(rand(2),-1,atomic);
      216 
      217 	     p3 = prepare_operand(rand(1),-1,atomic);
      218 	     call compile_exp(rand(2));
      219 	     call xr_man$load_var(rand(1),6);
      220 
      221 	     call expmac$zero((io_macro(13)));
      222 	     return;
      223 	     end;
      224 
      225 	/* get|put list|edit */
      226 
      227 	p2 = prepare_operand(rand(2),-1,atomic);
      228 
      229 	if ^ atomic then p2 = compile_exp$save_exp(rand(2));
      230 
      231 	if rand(1) ^= null
      232 	then p3 = prepare_operand(rand(1),-1,atomic);
      233 	else do;
      234 	     p3 = c_a(0,2);
      235 	     p3 -> reference.data_type = real_fix_bin_1;
      236 	     atomic = "1"b;
      237 	     end;
      238 
      239 	if p->op_code = put_field_chk 
      240 	then do;
      241 	     p4 =prepare_operand(rand(3),-1,useless);
      242 	     call xr_man$load_var(rand(3),6);
      243 	     call xr_man$super_lock(6);
      244 	     end;
      245 
      246 	if atomic 
      247 	then call load(p3,0);
      248 	else if quick_stream_op
      249 	     then call compile_exp(rand(1));
      250 	     else do;
      251 		q = rand(1) -> operand(3);
      252 		p3 = prepare_operand(q,1,atomic);
      253 		if atomic then call load(p3,0); else call compile_exp(q);
      254 		call expmac((form_desc),prepare_operand((rand(1) -> operand(2)),-1,atomic));
      255 		end;
      256 
      257 	macro = io_macro(fixed(substr(p -> op_code,6,4),4));
      258 
      259 	p3 = p2 -> reference.symbol;
      260 	if p3 -> symbol.picture
      261 	then if ^quick_stream_op
      262 	then do;
      263 	     p3 = c_a((p3 -> symbol.general -> reference.symbol -> symbol.location),3);
      264 	     p3 -> reference.relocation = rc_t;
      265 	     call protect_areg;
      266 	     call expmac((lda),p3);
      267 	     end;
      268 
      269 l2:	call long_op$io(p2,macro);
      270 	if p -> op_code = get_list_trans | p -> op_code = get_edit_trans
      271 	     then call state_man$flush_ref(p2);
      272 	return;
      273 
      274 io_op$init_ps: entry;
      275 
      276 	/* This entry is called to initialize the ps space */
      277 
      278 	psp = cg_stat$cur_block -> block.plio_ps -> element(1);
      279 	arg(1) = psp -> symbol.reference;
      280 	arg(1) -> reference.units = word_;
      281 
      282 	call expmac((init_ps_mac),arg(1));
      283 	arg(1) -> reference.perm_address = "0"b;
      284 
      285 	base_regs(1).type = 0;
      286 	arg(1) -> reference.address_in.b(1) = "0"b;
      287 
      288 	if cg_stat$generate_symtab
      289 	then do;
      290 	     arg(2) = c_a(fixed(cg_stat$star_symbol_up_zero,18),9);
      291 	     arg(2) -> address.base = base_man$load_linkage();
      292 
      293 	     arg(3) = c_a((cg_stat$cur_block -> block.symbol_block),3);
      294 	     arg(3) -> reference.relocation = rc_s;
      295 
      296 	     call expmac$many((symtab_mac),addr(arg),3);
      297 	     end;
      298 
      299 	sslp = cg_stat$cur_block -> block.plio_ssl;
      300 	if sslp ^= null
      301 	then do;
      302 	     arg(2) = sslp -> symbol.reference;
      303 	     arg(2) -> reference.units = word_;
      304 	     call expmac$many((init_sslp),addr(arg),2);
      305 	     end;
      306 
      307 	sslp = cg_stat$cur_block -> block.plio_fa;
      308 	if sslp ^= null
      309 	then do;
      310 	     sslp -> symbol.reference -> reference.units = word_;
      311 	     call base_man$store_ptr_to((sslp -> symbol.reference),
      312 	       c_a(psp -> symbol.location + ps_format_area,4));
      313 	     end;
      314 
      315 
      316 
      317 ma_and_flush:	proc(n);
      318 dcl	(i,n) fixed bin;
      319 
      320 	do i = 1 to n;
      321 	     call m_a(arg(i),"0"b);
      322 	     arg(i) -> reference.perm_address = "1"b;
      323 	end;
      324 
      325 	call state_man$erase_reg((odd_bases));
      326 
      327 	end;
      328 
      329 /*	NOT PRESENTLY USED
      330*
      331*get_temp:	proc() returns(ptr);
      332*
      333*dcl	r ptr;
      334*
      335*     */	/* returns reference to a char(256) varying temporary */	/*
      336*
      337*	r = declare_temporary(char_mask | varying_mask | aligned_mask,256,0,null);
      338*	r = copy_temp(r);
      339*	r -> reference.c_length = r -> reference.symbol -> symbol.c_dcl_size;
      340*	r = prepare_operand(r,1,atomic);
      341*	call stack_temp$assign_temp(r);
      342*	return(r);
      343*
      344*	end;
      345*
      346*	MAYBE SOMEDAY AGAIN	*/
      347 
      348 protect_areg:  proc;
      349 
      350 	/* makes sure that long_op does not clobber the a_register by 
      351*	   calling base_man (fixes bug 1282) */
      352 
      353 	if p2 -> reference.units < word_ | p2 -> reference.big_offset
      354 	then do;
      355 	     call aq_man$lock(null,2);
      356 	     if ^ p2 -> reference.shared
      357 		then p2 -> reference.ref_count = p2 -> reference.ref_count + 1;
      358 	     call base_man$load_var(2,p2,1);
      359 	     end;
      360 
      361 	end;
      362 
      363 end;
	SOURCE FILES USED IN THIS COMPILATION.

LINE      NUMBER  DATE MODIFIED     NAME			PATHNAME
             0    10/03/83  1008.6  io_op.pl1                         >spec>on>pl128d>io_op.pl1
82           1    05/03/76  1320.4  ps_map.incl.pl1                   >ldd>include>ps_map.incl.pl1
83           2    08/13/81  2043.5  block.incl.pl1                    >ldd>include>block.incl.pl1
84           3    10/02/83  0828.4  symbol.incl.pl1                   >spec>on>pl128d>symbol.incl.pl1
85           4    07/21/80  1546.3  reference.incl.pl1                >ldd>include>reference.incl.pl1
86           5    04/07/83  1635.0  statement.incl.pl1                >ldd>include>statement.incl.pl1
87           6    07/21/80  1546.3  operator.incl.pl1                 >ldd>include>operator.incl.pl1
88           7    08/13/81  2211.5  list.incl.pl1                     >ldd>include>list.incl.pl1
89           8    04/07/83  1635.0  op_codes.incl.pl1                 >ldd>include>op_codes.incl.pl1
90           9    05/03/76  1320.4  statement_types.incl.pl1          >ldd>include>statement_types.incl.pl1
91          10    05/03/76  1320.8  bases.incl.pl1                    >ldd>include>bases.incl.pl1
92          11    11/13/79  1015.8  machine_state.incl.pl1            >ldd>include>machine_state.incl.pl1
93          12    10/30/80  1648.7  relocation_bits.incl.pl1          >ldd>include>relocation_bits.incl.pl1
94          13    05/03/76  1320.4  data_types.incl.pl1               >ldd>include>data_types.incl.pl1
95          14    10/25/79  1645.8  boundary.incl.pl1                 >ldd>include>boundary.incl.pl1
96          15    11/30/78  1227.5  mask.incl.pl1                     >ldd>include>mask.incl.pl1
	NAMES DECLARED IN THIS COMPILATION.

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

NAMES DECLARED BY DECLARE STATEMENT.
addr                                                   builtin function         dcl 38 ref 119 119 296 296 304 304
address                  10            based           structure                level 2 packed unaligned dcl 4-3
address_in               11            based           structure                level 3 packed unaligned dcl 4-3
aq_man$lock                     000072 constant        entry                    external dcl 58 ref 355
arg                             000120 automatic       pointer                  array dcl 31 set ref 116* 117* 119 119 120 121 127*
                                                                                  132* 133* 136* 137 279* 280 282* 283 286 290* 291
                                                                                  293* 294 296 296 302* 303 304 304 321* 322
atomic                          000142 automatic       bit(1)                   dcl 31 set ref 117* 132* 193* 194 200* 215* 217*
                                                                                  227* 229 231* 236* 246 252* 253 254* 254*
attributes               31            based           structure                level 2 dcl 3-3
b                        11            based           bit(1)                   array level 4 packed unaligned dcl 4-3 set ref 286*
base                     10            based           bit(3)                   level 3 packed unaligned dcl 4-3 set ref 291*
base_man$load_linkage           000036 constant        entry                    external dcl 46 ref 291
base_man$load_var               000034 constant        entry                    external dcl 40 ref 133 358
base_man$store_ptr_to           000056 constant        entry                    external dcl 47 ref 168 311
base_regs               160            based           structure                array level 2 dcl 11-6
big_offset               11(33)        based           bit(1)                   level 4 packed unaligned dcl 4-3 ref 353
bit                                                    builtin function         dcl 38 ref 190
bits                     12(06)        based           structure                level 2 packed unaligned dcl 4-3
block                                  based           structure                level 1 dcl 2-5
c_a                             000054 constant        entry                    external dcl 47 ref 162 168 168 185 185 205 234 263
                                                                                  290 293 311 311
cg_stat$cur_block               000010 external static pointer                  dcl 27 ref 108 177 278 293 299 307
cg_stat$cur_statement           000012 external static pointer                  dcl 27 ref 144
cg_stat$generate_symtab         000016 external static bit(1)                   unaligned dcl 27 ref 288
cg_stat$star_symbol_up_zero     000020 external static bit(18)                  unaligned dcl 27 ref 290 290
cg_stat$text_base               000014 external static pointer                  dcl 27 ref 163
cg_static_$m_s_p                000074 external static pointer                  dcl 11-3 ref 11-3
compile_exp                     000040 constant        entry                    external dcl 47 ref 194 218 248 253
compile_exp$save_exp            000044 constant        entry                    external dcl 47 ref 229
data_type                12            based           fixed bin(5,0)           level 2 in structure "reference" packed unaligned
                                                                                  dcl 4-3 in procedure "io_op" set ref 235*
data_type                31            based           structure                level 3 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedure "io_op"
element                   1            based           pointer                  array level 2 packed unaligned dcl 7-6 ref 108 192
                                                                                  278
expmac                          000022 constant        entry                    external dcl 40 ref 136 183 185 186 196 207 254 266
                                                                                  282
expmac$many                     000024 constant        entry                    external dcl 40 ref 119 296 304
expmac$zero                     000070 constant        entry                    external dcl 58 ref 144 221
fixbin                                 based           fixed bin(17,0)          dcl 80 ref 163
fixed                                                  builtin function         dcl 38 ref 144 190 205 205 257 290 290
form_desc                              constant        fixed bin(15,0)          initial dcl 64 ref 254
fortran_$fortran_io_op          000042 constant        entry                    external dcl 47 ref 103
general                  16            based           pointer                  level 2 packed unaligned dcl 3-3 ref 263
generate_constant$real_fix_bin_1
                                000030 constant        entry                    external dcl 40 ref 157
get_data_trans                         constant        bit(9)                   initial dcl 8-8 ref 150
get_edit_trans                         constant        bit(9)                   initial dcl 8-8 ref 270
get_list_trans                         constant        bit(9)                   initial dcl 8-8 ref 270
get_term_mac                           constant        fixed bin(15,0)          initial dcl 64 ref 144
i                               000135 automatic       fixed bin(15,0)          dcl 31 in procedure "io_op" set ref 163* 164* 189*
                                                                                  190 192*
i                               000174 automatic       fixed bin(17,0)          dcl 318 in procedure "ma_and_flush" set ref 320* 321
                                                                                  322*
info                     11            based           structure                level 2 packed unaligned dcl 4-3
init_ps_mac                            constant        fixed bin(15,0)          initial dcl 64 ref 282
init_sslp                              constant        fixed bin(15,0)          initial dcl 64 ref 304
io_macro                        000000 constant        fixed bin(15,0)          initial array dcl 64 ref 221 257
lda                                    constant        fixed bin(15,0)          initial dcl 64 ref 207 266
ldfx1                                  constant        fixed bin(15,0)          initial dcl 64 ref 185
list                                   based           structure                level 1 dcl 7-6
load                            000032 constant        entry                    external dcl 40 ref 194 246 253
location                  1            based           fixed bin(18,0)          level 2 packed unsigned unaligned dcl 3-3 ref 148
                                                                                  178 263 311 311
long_op$io                      000026 constant        entry                    external dcl 40 ref 269
m_a                             000066 constant        entry                    external dcl 57 ref 321
m_s_p                           000144 automatic       pointer                  initial dcl 11-3 set ref 285 11-3*
machine_state                          based           structure                level 1 dcl 11-6
macro                           000137 automatic       fixed bin(15,0)          dcl 31 set ref 209* 257* 269*
n                               000136 automatic       fixed bin(15,0)          dcl 31 in procedure "io_op" set ref 178* 190
n                                      parameter       fixed bin(17,0)          dcl 318 in procedure "ma_and_flush" ref 317 320
null                                                   builtin function         dcl 38 ref 183 231 300 308 355 355
number                    0(21)        based           fixed bin(14,0)          level 2 in structure "operator" packed unaligned
                                                                                  dcl 6-6 in procedure "io_op" ref 130 155 161
number                    0(21)        based           fixed bin(14,0)          level 2 in structure "list" packed unaligned dcl 7-6
                                                                                  in procedure "io_op" ref 185 185 189
odd_bases                       000020 constant        bit(19)                  initial dcl 36 ref 325
offset                   10(03)        based           bit(15)                  level 3 packed unaligned dcl 4-3 set ref 190*
ok                              000140 automatic       fixed bin(15,0)          dcl 31 set ref 161* 162 163
op_code                   0(09)        based           bit(9)                   level 2 packed unaligned dcl 6-6 ref 100 100 114 125
                                                                                  141 150 172 213 239 257 270 270
operand                   1            based           pointer                  array level 2 packed unaligned dcl 6-6 ref 111 112
                                                                                  113 164 251 254 254
operator                               based           structure                level 1 dcl 6-6
other                    11(33)        based           structure                level 3 packed unaligned dcl 4-3
p                               000100 automatic       pointer                  dcl 31 set ref 98* 100 100 103* 111 112 113 114 125
                                                                                  130 141 150 172 213 239 257 270 270
p2                              000112 automatic       pointer                  dcl 31 set ref 192* 193* 194* 200* 215* 227* 229*
                                                                                  259 269* 270* 353 353 356 356 356 358*
p3                              000114 automatic       pointer                  dcl 31 set ref 193* 194* 217* 231* 234* 235 246*
                                                                                  252* 253* 259* 260 263* 263 264 266*
p4                              000116 automatic       pointer                  dcl 31 set ref 241*
perm_address             12(18)        based           bit(1)                   level 3 packed unaligned dcl 4-3 set ref 120* 121*
                                                                                  137* 181* 187* 283* 322*
picture                  31(18)        based           bit(1)                   level 4 packed unaligned dcl 3-3 ref 260
plio_fa                  20            based           pointer                  level 2 packed unaligned dcl 2-5 ref 307
plio_ps                  17            based           pointer                  level 2 packed unaligned dcl 2-5 ref 108 278
plio_ssl                 22            based           pointer                  level 2 packed unaligned dcl 2-5 ref 177 299
prepare_operand                 000046 constant        entry                    external dcl 47 ref 117 132 193 200 215 217 227 231
                                                                                  241 252 254 254
ps_format_area                         constant        fixed bin(15,0)          initial dcl 1-3 ref 311 311
ps_special_list                        constant        fixed bin(15,0)          initial dcl 1-3 ref 168 168
psloc                           000134 automatic       fixed bin(15,0)          dcl 31 set ref 148* 168 168
psp                             000102 automatic       pointer                  dcl 31 set ref 108* 109 148 278* 279 311 311
psr                             000104 automatic       pointer                  dcl 31 set ref 109*
pt                                     parameter       pointer                  dcl 25 ref 23 98
put_control                            constant        bit(9)                   initial dcl 8-8 ref 100 213
put_data_mac                           constant        fixed bin(15,0)          initial dcl 64 ref 209
put_data_trans                         constant        bit(9)                   initial dcl 8-8 ref 172
put_field_chk                          constant        bit(9)                   initial dcl 8-8 ref 239
put_statement                          constant        bit(9)                   initial dcl 9-3 ref 144
q                               000110 automatic       pointer                  dcl 31 set ref 157* 162* 168* 205* 206 207* 251*
                                                                                  252* 253*
quick_stream_op                 000141 automatic       bit(1)                   initial dcl 31 set ref 31* 106* 248 260
rand                            000126 automatic       pointer                  array dcl 31 set ref 111* 112* 113* 116 117* 127
                                                                                  132* 155 161 164 183 185 185 189 192 200* 205 205
                                                                                  215* 217* 218* 219* 227* 229* 231 231* 241* 242*
                                                                                  248* 251 254 254
rc_s                                   constant        bit(6)                   initial unaligned dcl 12-6 ref 206 294
rc_t                                   constant        bit(6)                   initial unaligned dcl 12-6 ref 264
real_fix_bin_1                         constant        fixed bin(15,0)          initial dcl 13-1 ref 235
recio_mac                              constant        fixed bin(15,0)          initial dcl 64 ref 136
record_io                              constant        bit(9)                   initial dcl 8-8 ref 100 125
ref_count                 0(18)        based           fixed bin(17,0)          level 2 packed unaligned dcl 4-3 set ref 356* 356
reference                15            based           pointer                  level 2 in structure "symbol" packed unaligned
                                                                                  dcl 3-3 in procedure "io_op" ref 109 179 279 302
                                                                                  310 311
reference                              based           structure                level 1 dcl 4-3 in procedure "io_op"
relocation               12(24)        based           bit(12)                  level 2 packed unaligned dcl 4-3 set ref 206* 264*
                                                                                  294*
runtime                   3            based           bit(18)                  level 2 packed unaligned dcl 3-3 ref 205 205
shared                    0(11)        based           bit(1)                   level 2 packed unaligned dcl 4-3 ref 356
sslp                            000106 automatic       pointer                  dcl 31 set ref 177* 178 179* 179 181 183* 186* 187
                                                                                  190 196* 299* 300 302 307* 308 310 311
state_man$erase_reg             000060 constant        entry                    external dcl 47 ref 325
state_man$flush                 000064 constant        entry                    external dcl 47 ref 158
state_man$flush_ref             000062 constant        entry                    external dcl 47 ref 164 270
statement                              based           structure                level 1 dcl 5-9
statement_type           12(27)        based           bit(9)                   level 2 packed unaligned dcl 5-9 ref 144
stfx1                                  constant        fixed bin(15,0)          initial dcl 64 ref 186 196
stream_prep                            constant        bit(9)                   initial dcl 8-8 ref 114
stream_prep_mac                        constant        fixed bin(15,0)          initial dcl 64 ref 119
substr                                                 builtin function         dcl 38 ref 257
symbol                                 based           structure                level 1 dcl 3-3 in procedure "io_op"
symbol                    3            based           pointer                  level 2 in structure "reference" packed unaligned
                                                                                  dcl 4-3 in procedure "io_op" ref 205 205 259 263
symbol_block             47            based           fixed bin(17,0)          level 2 dcl 2-5 ref 293
symtab_mac                             constant        fixed bin(15,0)          initial dcl 64 ref 296
terminate_trans                        constant        bit(9)                   initial dcl 8-8 ref 141
type                    162            based           fixed bin(8,0)           array level 3 dcl 11-6 set ref 285*
units                     0(14)        based           fixed bin(3,0)           level 2 packed unaligned dcl 4-3 set ref 280* 303*
                                                                                  310* 353
useless                         000143 automatic       bit(1)                   dcl 31 set ref 241*
word_                                  constant        fixed bin(3,0)           initial dcl 14-5 ref 280 303 310 353
xr_man$load_var                 000050 constant        entry                    external dcl 47 ref 219 242
xr_man$super_lock               000052 constant        entry                    external dcl 47 ref 243
zero_mac                               constant        fixed bin(15,0)          initial dcl 64 ref 183

NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED.
a_format                               internal static bit(9)                   initial dcl 8-8
ab                                     defined         bit(3)                   dcl 10-9
abs_fun                                internal static bit(9)                   initial dcl 8-8
acos_fun                               internal static bit(9)                   initial dcl 8-8
acosd_fun                              internal static bit(9)                   initial dcl 8-8
add                                    internal static bit(9)                   initial dcl 8-8
addbitno_fun                           internal static bit(9)                   initial dcl 8-8
addcharno_fun                          internal static bit(9)                   initial dcl 8-8
addr_fun                               internal static bit(9)                   initial dcl 8-8
addr_fun_bits                          internal static bit(9)                   initial dcl 8-8
addrel_fun                             internal static bit(9)                   initial dcl 8-8
aligned_mask                           internal static bit(36)                  initial dcl 15-3
allocate_statement                     internal static bit(9)                   initial dcl 9-3
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
ap                                     defined         bit(3)                   dcl 10-4
area_mask                              internal static bit(36)                  initial dcl 15-3
arg_descriptor_mask                    internal static bit(36)                  initial dcl 15-3
arithmetic_mask                        internal static bit(36)                  initial dcl 15-41
asin_fun                               internal static bit(9)                   initial dcl 8-8
asind_fun                              internal static bit(9)                   initial dcl 8-8
assign                                 internal static bit(9)                   initial dcl 8-8
assign_by_name                         internal static bit(9)                   initial dcl 8-8
assign_round                           internal static bit(9)                   initial dcl 8-8
assign_size_ck                         internal static bit(9)                   initial dcl 8-8
assign_zero                            internal static bit(9)                   initial dcl 8-8
assignment_statement                   internal static bit(9)                   initial dcl 9-3
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
bases                                  internal static bit(3)                   initial array dcl 10-1
bb                                     defined         bit(3)                   dcl 10-9
begin_statement                        internal static bit(9)                   initial dcl 9-3
binary_mask                            internal static bit(36)                  initial dcl 15-3
bit_                                   internal static fixed bin(3,0)           initial dcl 14-5
bit_mask                               internal static bit(36)                  initial dcl 15-3
bit_pointer                            internal static bit(9)                   initial dcl 8-8
bit_string                             internal static fixed bin(15,0)          initial dcl 13-1
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
bn_format                              internal static bit(9)                   initial dcl 8-8
bool_fun                               internal static bit(9)                   initial dcl 8-8
bound_ck                               internal static bit(9)                   initial dcl 8-8
bp                                     defined         bit(3)                   dcl 10-4
builtin_mask                           internal static bit(36)                  initial dcl 15-3
byte_fun                               internal static bit(9)                   initial dcl 8-8
c_format                               internal static bit(9)                   initial dcl 8-8
call_statement                         internal static bit(9)                   initial dcl 9-3
cat_string                             internal static bit(9)                   initial dcl 8-8
ceil_fun                               internal static bit(9)                   initial dcl 8-8
char_mask                              internal static bit(36)                  initial dcl 15-3
char_string                            internal static fixed bin(15,0)          initial dcl 13-1
char_to_word                           internal static bit(9)                   initial dcl 8-8
character_                             internal static fixed bin(3,0)           initial dcl 14-5
charno_fun                             internal static bit(9)                   initial dcl 8-8
clock_fun                              internal static bit(9)                   initial dcl 8-8
close_file                             internal static bit(9)                   initial dcl 8-8
close_statement                        internal static bit(9)                   initial dcl 9-3
codeptr_fun                            internal static bit(9)                   initial dcl 8-8
column_format                          internal static bit(9)                   initial dcl 8-8
complex_fix_bin_1                      internal static fixed bin(15,0)          initial dcl 13-1
complex_fix_bin_2                      internal static fixed bin(15,0)          initial dcl 13-1
complex_fix_dec                        internal static fixed bin(15,0)          initial dcl 13-1
complex_flt_bin_1                      internal static fixed bin(15,0)          initial dcl 13-1
complex_flt_bin_2                      internal static fixed bin(15,0)          initial dcl 13-1
complex_flt_dec                        internal static fixed bin(15,0)          initial dcl 13-1
complex_fun                            internal static bit(9)                   initial dcl 8-8
complex_mask                           internal static bit(36)                  initial dcl 15-3
computational_mask                     internal static bit(36)                  initial dcl 15-41
condition_mask                         internal static bit(36)                  initial dcl 15-3
conjg_fun                              internal static bit(9)                   initial dcl 8-8
continue_statement                     internal static bit(9)                   initial dcl 9-3
convert_mask                           internal static bit(36)                  initial dcl 15-41
copy_string                            internal static bit(9)                   initial dcl 8-8
copy_temp                       000000 constant        entry                    external dcl 60
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
decimal_mask                           internal static bit(36)                  initial dcl 15-3
declare_constant_mask                  internal static bit(36)                  initial dcl 15-41
declare_statement                      internal static bit(9)                   initial dcl 9-3
declare_temporary               000000 constant        entry                    external dcl 61
default_statement                      internal static bit(9)                   initial dcl 9-3
delete_file                            internal static bit(9)                   initial dcl 8-8
delete_statement                       internal static bit(9)                   initial dcl 9-3
desc_size                              internal static bit(9)                   initial dcl 8-8
digit_                                 internal static fixed bin(3,0)           initial dcl 14-5
digit_to_bit                           internal static bit(9)                   initial dcl 8-8
dimensioned_mask                       internal static bit(36)                  initial dcl 15-3
display_statement                      internal static bit(9)                   initial dcl 9-3
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
do_statement                           internal static bit(9)                   initial dcl 9-3
e_format                               internal static bit(9)                   initial dcl 8-8
else_clause                            internal static bit(9)                   initial dcl 9-3
empty_area                             internal static bit(9)                   initial dcl 8-8
enable_on                              internal static bit(9)                   initial dcl 8-8
end_statement                          internal static bit(9)                   initial dcl 9-3
entry_mask                             internal static bit(36)                  initial dcl 15-3
entry_statement                        internal static bit(9)                   initial dcl 9-3
entry_variable                         internal static fixed bin(15,0)          initial dcl 13-1
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
exit_statement                         internal static bit(9)                   initial dcl 9-3
exp                                    internal static bit(9)                   initial dcl 8-8
exp_fun                                internal static bit(9)                   initial dcl 8-8
ext_entry_in                           internal static fixed bin(15,0)          initial dcl 13-1
ext_entry_out                          internal static fixed bin(15,0)          initial dcl 13-1
f_format                               internal static bit(9)                   initial dcl 8-8
file_mask                              internal static bit(36)                  initial dcl 15-3
fixed_binary_real_mask                 internal static bit(36)                  initial dcl 15-41
fixed_decimal_complex_mask             internal static bit(36)                  initial dcl 15-41
fixed_decimal_real_mask                internal static bit(36)                  initial dcl 15-41
fixed_mask                             internal static bit(36)                  initial dcl 15-3
float_decimal_complex_mask             internal static bit(36)                  initial dcl 15-41
float_decimal_real_mask                internal static bit(36)                  initial dcl 15-41
float_mask                             internal static bit(36)                  initial dcl 15-3
floor_fun                              internal static bit(9)                   initial dcl 8-8
format_mask                            internal static bit(36)                  initial dcl 15-3
format_statement                       internal static bit(9)                   initial dcl 9-3
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_statement                         internal static bit(9)                   initial dcl 9-3
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
generic_mask                           internal static bit(36)                  initial dcl 15-3
get_file                               internal static bit(9)                   initial dcl 8-8
get_statement                          internal static bit(9)                   initial dcl 9-3
get_string                             internal static bit(9)                   initial dcl 8-8
goto_statement                         internal static bit(9)                   initial dcl 9-3
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 14-5
half_to_word                           internal static bit(9)                   initial dcl 8-8
if_statement                           internal static bit(9)                   initial dcl 9-3
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
initialed_mask                         internal static bit(36)                  initial dcl 15-3
int_entry                              internal static fixed bin(15,0)          initial dcl 13-1
int_entry_other                        internal static fixed bin(15,0)          initial dcl 13-1
irreducible_mask                       internal static bit(36)                  initial dcl 15-3
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_constant                         internal static fixed bin(15,0)          initial dcl 13-1
label_mask                             internal static bit(36)                  initial dcl 15-3
label_variable                         internal static fixed bin(15,0)          initial dcl 13-1
lb                                     defined         bit(3)                   dcl 10-9
length_fun                             internal static bit(9)                   initial dcl 8-8
less_or_equal                          internal static bit(9)                   initial dcl 8-8
less_than                              internal static bit(9)                   initial dcl 8-8
line_format                            internal static bit(9)                   initial dcl 8-8
load_pt                                internal static fixed bin(15,0)          initial dcl 64
local_label_variable                   internal static fixed bin(15,0)          initial dcl 13-1
local_mask                             internal static bit(36)                  initial dcl 15-3
locate_file                            internal static bit(9)                   initial dcl 8-8
locate_statement                       internal static bit(9)                   initial dcl 9-3
lock_file                              internal static bit(9)                   initial dcl 8-8
lock_fun                               internal static bit(9)                   initial dcl 8-8
lock_mask                              internal static bit(36)                  initial dcl 15-3
lock_statement                         internal static bit(9)                   initial dcl 9-3
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
lp                                     defined         bit(3)                   dcl 10-4
make_desc                              internal static bit(9)                   initial dcl 8-8
max_block_number                       internal static fixed bin(17,0)          initial dcl 2-74
max_fun                                internal static bit(9)                   initial dcl 8-8
max_list_elements                      internal static fixed bin(17,0)          initial dcl 7-12
max_number_of_operands                 internal static fixed bin(15,0)          initial dcl 6-15
min_fun                                internal static bit(9)                   initial dcl 8-8
mod2_                                  internal static fixed bin(3,0)           initial dcl 14-5
mod4_                                  internal static fixed bin(3,0)           initial dcl 14-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
null_statement                         internal static bit(9)                   initial dcl 9-3
off_fun                                internal static bit(9)                   initial dcl 8-8
offset_mask                            internal static bit(36)                  initial dcl 15-3
on_statement                           internal static bit(9)                   initial dcl 9-3
open_file                              internal static bit(9)                   initial dcl 8-8
open_statement                         internal static bit(9)                   initial dcl 9-3
or_bits                                internal static bit(9)                   initial dcl 8-8
pack                                   internal static bit(9)                   initial dcl 8-8
packed_ptr                             internal static fixed bin(15,0)          initial dcl 13-1
page_format                            internal static bit(9)                   initial dcl 8-8
param_desc_ptr                         internal static bit(9)                   initial dcl 8-8
param_ptr                              internal static bit(9)                   initial dcl 8-8
picture_format                         internal static bit(9)                   initial dcl 8-8
picture_mask                           internal static bit(36)                  initial dcl 15-3
pl1_mod_fun                            internal static bit(9)                   initial dcl 8-8
precision_mask                         internal static bit(36)                  initial dcl 15-3
prefix_plus                            internal static bit(9)                   initial dcl 8-8
procedure_statement                    internal static bit(9)                   initial dcl 9-3
ps_copy                                internal static fixed bin(15,0)          initial dcl 1-3
ps_descriptor                          internal static fixed bin(15,0)          initial dcl 1-3
ps_job                                 internal static fixed bin(15,0)          initial dcl 1-3
ps_key                                 internal static fixed bin(15,0)          initial dcl 1-3
ps_label                               internal static fixed bin(15,0)          initial dcl 1-3
ps_lock_sw                             internal static fixed bin(15,0)          initial dcl 1-3
ps_new_format                          internal static fixed bin(15,0)          initial dcl 1-3
ps_number                              internal static fixed bin(15,0)          initial dcl 1-3
ps_offset                              internal static fixed bin(15,0)          initial dcl 1-3
ps_prep                                internal static fixed bin(15,0)          initial dcl 1-3
ps_set_p                               internal static fixed bin(15,0)          initial dcl 1-3
ps_source                              internal static fixed bin(15,0)          initial dcl 1-3
ps_ssl                                 internal static fixed bin(15,0)          initial dcl 1-3
ps_stack                               internal static fixed bin(15,0)          initial dcl 1-3
ps_symbol_block                        internal static fixed bin(15,0)          initial dcl 1-3
ps_symbol_top                          internal static fixed bin(15,0)          initial dcl 1-3
ps_value                               internal static fixed bin(15,0)          initial dcl 1-3
ps_var_bitlen                          internal static fixed bin(15,0)          initial dcl 1-3
ps_var_p                               internal static fixed bin(15,0)          initial dcl 1-3
ptr_fun                                internal static bit(9)                   initial dcl 8-8
ptr_mask                               internal static bit(36)                  initial dcl 15-3
put_edit_trans                         internal static bit(9)                   initial dcl 8-8
put_field                              internal static bit(9)                   initial dcl 8-8
put_field_mac                          internal static fixed bin(15,0)          initial dcl 64
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
rc_a                                   internal static bit(6)                   initial unaligned dcl 12-6
rc_dp                                  internal static bit(6)                   initial unaligned dcl 12-6
rc_e                                   internal static bit(6)                   initial unaligned dcl 12-6
rc_is15                                internal static bit(6)                   initial unaligned dcl 12-6
rc_is18                                internal static bit(6)                   initial unaligned dcl 12-6
rc_lb                                  internal static bit(6)                   initial unaligned dcl 12-6
rc_lp15                                internal static bit(6)                   initial unaligned dcl 12-6
rc_lp18                                internal static bit(6)                   initial unaligned dcl 12-6
rc_nlb                                 internal static bit(6)                   initial unaligned dcl 12-6
rc_nlp18                               internal static bit(6)                   initial unaligned dcl 12-6
rc_ns                                  internal static bit(6)                   initial unaligned dcl 12-6
rc_nt                                  internal static bit(6)                   initial unaligned dcl 12-6
rc_sr                                  internal static bit(6)                   initial unaligned dcl 12-6
read_file                              internal static bit(9)                   initial dcl 8-8
read_statement                         internal static bit(9)                   initial dcl 9-3
real_fix_bin_2                         internal static fixed bin(15,0)          initial dcl 13-1
real_fix_dec                           internal static fixed bin(15,0)          initial dcl 13-1
real_flt_bin_1                         internal static fixed bin(15,0)          initial dcl 13-1
real_flt_bin_2                         internal static fixed bin(15,0)          initial dcl 13-1
real_flt_dec                           internal static fixed bin(15,0)          initial dcl 13-1
real_fun                               internal static bit(9)                   initial dcl 8-8
real_mask                              internal static bit(36)                  initial dcl 15-3
reducible_mask                         internal static bit(36)                  initial dcl 15-3
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_statement                       internal static bit(9)                   initial dcl 9-3
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
returns_mask                           internal static bit(36)                  initial dcl 15-3
reverse_fun                            internal static bit(9)                   initial dcl 8-8
revert_on                              internal static bit(9)                   initial dcl 8-8
revert_statement                       internal static bit(9)                   initial dcl 9-3
rewrite_file                           internal static bit(9)                   initial dcl 8-8
rewrite_statement                      internal static bit(9)                   initial dcl 9-3
round_fun                              internal static bit(9)                   initial dcl 8-8
sb                                     defined         bit(3)                   dcl 10-9
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
sign_fun                               internal static bit(9)                   initial dcl 8-8
signal_on                              internal static bit(9)                   initial dcl 8-8
signal_statement                       internal static bit(9)                   initial dcl 9-3
signed_mask                            internal static bit(36)                  initial dcl 15-3
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
sp                                     defined         bit(3)                   dcl 10-4
sqrt_fun                               internal static bit(9)                   initial dcl 8-8
stack_ptr                              internal static bit(9)                   initial dcl 8-8
stack_temp$assign_temp          000000 constant        entry                    external dcl 61
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
std_arg_list                           internal static bit(9)                   initial dcl 8-8
std_call                               internal static bit(9)                   initial dcl 8-8
std_entry                              internal static bit(9)                   initial dcl 8-8
std_return                             internal static bit(9)                   initial dcl 8-8
stop                                   internal static bit(9)                   initial dcl 8-8
stop_statement                         internal static bit(9)                   initial dcl 9-3
storage_block_mask                     internal static bit(36)                  initial dcl 15-3
string_mask                            internal static bit(36)                  initial dcl 15-41
structure_mask                         internal static bit(36)                  initial dcl 15-3
sub                                    internal static bit(9)                   initial dcl 8-8
system_on_unit                         internal static bit(9)                   initial dcl 9-3
tan_fun                                internal static bit(9)                   initial dcl 8-8
tand_fun                               internal static bit(9)                   initial dcl 8-8
translate_fun                          internal static bit(9)                   initial dcl 8-8
trunc_fun                              internal static bit(9)                   initial dcl 8-8
unaligned_mask                         internal static bit(36)                  initial dcl 15-3
undesirable_mask                       internal static bit(36)                  initial dcl 15-41
unknown_statement                      internal static bit(9)                   initial dcl 9-3
unlock_file                            internal static bit(9)                   initial dcl 8-8
unlock_statement                       internal static bit(9)                   initial dcl 9-3
unpack                                 internal static bit(9)                   initial dcl 8-8
unpacked_ptr                           internal static fixed bin(15,0)          initial dcl 13-1
unsigned_mask                          internal static bit(36)                  initial dcl 15-3
variable_mask                          internal static bit(36)                  initial dcl 15-3
varying_mask                           internal static bit(36)                  initial dcl 15-3
vclock_fun                             internal static bit(9)                   initial dcl 8-8
verify_fun                             internal static bit(9)                   initial dcl 8-8
verify_ltrim_fun                       internal static bit(9)                   initial dcl 8-8
verify_rev_fun                         internal static bit(9)                   initial dcl 8-8
verify_rtrim_fun                       internal static bit(9)                   initial dcl 8-8
wait_statement                         internal static bit(9)                   initial dcl 9-3
which_base                             internal static fixed bin(17,0)          initial array dcl 10-14
word_to_mod2                           internal static bit(9)                   initial dcl 8-8
word_to_mod4                           internal static bit(9)                   initial dcl 8-8
word_to_mod8                           internal static bit(9)                   initial dcl 8-8
wordno_fun                             internal static bit(9)                   initial dcl 8-8
write_file                             internal static bit(9)                   initial dcl 8-8
write_statement                        internal static bit(9)                   initial dcl 9-3
x_format                               internal static bit(9)                   initial dcl 8-8
xor_bits                               internal static bit(9)                   initial dcl 8-8

NAMES DECLARED BY EXPLICIT CONTEXT.
io_op                           000041 constant        entry                    external dcl 23
io_op$init_ps                   001452 constant        entry                    external dcl 274
l2                              001420 constant        label                    dcl 269 ref 210
ma_and_flush                    001733 constant        entry                    internal dcl 317 ref 118 128 143
protect_areg                    002002 constant        entry                    internal dcl 348 ref 204 265

NAME DECLARED BY CONTEXT OR IMPLICATION.
addrel                                                 builtin function         ref 163

STORAGE REQUIREMENTS FOR THIS PROGRAM.

	Object	Text	Link	Symbol	Defs	Static
Start          0       0      2422        2520    2076        2432
Length      3246    2076        76         512     323           0

BLOCK NAME	         STACK SIZE     TYPE		WHY NONQUICK/WHO SHARES STACK FRAME
io_op                               182 external procedure  is an external procedure.  
ma_and_flush                            internal procedure  shares stack frame of external procedure io_op.  
protect_areg                            internal procedure  shares stack frame of external procedure io_op.  

STORAGE FOR AUTOMATIC VARIABLES.

STACK FRAME                 LOC IDENTIFIER                  BLOCK NAME
io_op                    000100 p                           io_op
                         000102 psp                         io_op
                         000104 psr                         io_op
                         000106 sslp                        io_op
                         000110 q                           io_op
                         000112 p2                          io_op
                         000114 p3                          io_op
                         000116 p4                          io_op
                         000120 arg                         io_op
                         000126 rand                        io_op
                         000134 psloc                       io_op
                         000135 i                           io_op
                         000136 n                           io_op
                         000137 macro                       io_op
                         000140 ok                          io_op
                         000141 quick_stream_op             io_op
                         000142 atomic                      io_op
                         000143 useless                     io_op
                         000144 m_s_p                       io_op
                         000174 i                           ma_and_flush

THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM.
r_e_as              call_ext_out        return              ext_entry

THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM.
aq_man$lock                   base_man$load_linkage         base_man$load_var             base_man$store_ptr_to
c_a                           compile_exp                   compile_exp$save_exp          expmac
expmac$many                   expmac$zero                   fortran_$fortran_io_op
generate_constant$real_fix_bin_1                            load                          long_op$io
m_a                           prepare_operand               state_man$erase_reg           state_man$flush
state_man$flush_ref           xr_man$load_var               xr_man$super_lock

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




   LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC   
     31 000027   11    3 000030        23 000036        98 000047       100 000053       103 000064       104 000073
    106 000074       108 000076       109 000104       111 000106       112 000110       113 000112       114 000114
    116 000117       117 000120       118 000136       119 000142       120 000163       121 000166       122 000170
    125 000171       127 000173       128 000174       130 000200       132 000205       133 000224       136 000243
    137 000256       138 000261       141 000262       143 000264       144 000267       145 000307       148 000310
    150 000314       155 000317       157 000324       158 000335       159 000342       161 000343       162 000344
    163 000361       164 000375       165 000406       168 000410       169 000441       172 000442       177 000444
    178 000450       179 000453       181 000455       183 000457       185 000476       186 000531       187 000544
    189 000547       190 000561       192 000573       193 000576       194 000615       194 000633       196 000642
    197 000655       200 000657       204 000676       205 000677       206 000721       207 000724       209 000737
    210 000741       213 000742       215 000744       217 000762       218 001001       219 001010       221 001023
    222 001034       227 001035       229 001053       231 001067       234 001113       235 001131       236 001134
    239 001136       241 001143       242 001162       243 001175       246 001206       248 001224       251 001236
    252 001241       253 001260       253 001276       254 001305       257 001342       259 001347       260 001352
    263 001357       264 001401       265 001404       266 001405       269 001420       270 001431       272 001450
    274 001451       278 001460       279 001466       280 001470       282 001474       283 001506       285 001511
    286 001513       288 001515       290 001520       291 001537       293 001554       294 001575       296 001600
    299 001621       300 001626       302 001632       303 001634       304 001640       307 001660       308 001665
    310 001671       311 001676       363 001732       317 001733       320 001735       321 001745       322 001762
    323 001766       325 001770       327 002001       348 002002       353 002003       355 002014       356 002031
    358 002042       361 002061


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


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