COMPILATION LISTING OF SEGMENT jump_op
	Compiled by: Multics PL/I Compiler, Release 32e, of September 22, 1989
	Compiled at: Bull HN, Phoenix AZ, System-M   
	Compiled on: 09/29/89  1335.9 mst Fri
	    Options: optimize map

        1 /****^  ***********************************************************
        2*        *                                                         *
        3*        * Copyright, (C) BULL HN Information Systems Inc., 1989   *
        4*        *                                                         *
        5*        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        6*        *                                                         *
        7*        * Copyright (c) 1972 by Massachusetts Institute of        *
        8*        * Technology and Honeywell Information Systems, Inc.      *
        9*        *                                                         *
       10*        *********************************************************** */
       11 
       12 
       13 
       14 
       15 /****^  HISTORY COMMENTS:
       16*  1) change(89-07-28,JRGray), approve(89-07-28,MCR8123), audit(89-09-12,Vu),
       17*     install(89-09-22,MR12.3-1073):
       18*     Called state_man$save_regs to save temps before conditionals are
       19*     evaluated (pl1 2091 2177).
       20*  2) change(89-09-26,JRGray), approve(89-09-26,MCR8123), audit(89-09-27,Vu),
       21*     install(89-09-29,MR12.3-1076):
       22*     Fixed so that saving registers for label arrays no longer causes side
       23*     effects.
       24*                                                   END HISTORY COMMENTS */
       25 
       26 
       27 /* procedure to compile jumps and conditional jumps
       28*
       29*   Initial Version: 29 March 1971 by BLW for Version II
       30*	Modified:  9 January 1973 by BLW
       31*	Modified:	12 June 1973 by RAB for EIS
       32*	Modified:	7 May 1974 by RAB to fix bug 941 by providing eval_primaries
       33*	Modified:	23 October 1974 by RAB to fix bug 1242
       34*	Modified:	2 November 1975 by RAB to allow outside access to eval_prim
       35*	Modified:	16 May 1976 by RAB to fix 1497
       36*	Modified:	23 June 1976 by RAB to centralize use of cg_stat$last_call
       37*	Modified:	1 July 1976 by RAB for label array improvements
       38*	Modified:	29 July 1976 by RAB to fix minor bug in label array stuff
       39*	Modified:	5 November 1976 by RAB to take advantage of fix to bugs 1542 & 1546
       40*		in operator_semantics
       41*	Modified:	9 March 1977 by RAB to remove some dead code caused by previous change
       42*	Modified 790703 by PG to fix 1844 (using a decimal expression in an if statement and the then or else clause
       43*		sometimes generated bad code), and to remove old_fortran jump_three_way.
       44*	Modified 790824 by PG to tension goto's only if -optimize was specified.
       45**/
       46 
       47 jump_op:	proc(pt);
       48 
       49 /* parameters */
       50 
       51 dcl	pt ptr;		/* points at an operator node */
       52 
       53 /* automatic */
       54 
       55 dcl	(pb,p,arg(3),q,s1,save_p1) ptr,
       56 	(atomic,p2_atomic,p3_atomic,conditional,is_return,load_index) bit(1) aligned,
       57 	(dt,i,j,k,n,macro,code,hard,size,count,start,finish) fixed bin(15);
       58 
       59 /* based */
       60 
       61 dcl	based_bit_string bit(size) aligned based;
       62 
       63 /* builtins */
       64 
       65 dcl	(fixed,null,substr) builtin;
       66 
       67 /* defined */
       68 
       69 dcl	p1 ptr defined(arg(1)),
       70 	p2 ptr defined(arg(2)),
       71 	p3 ptr defined(arg(3));
       72 
       73 /* entries */
       74 
       75 dcl	expmac entry(fixed bin(15),ptr),
       76 	expmac$fill_usage entry(fixed bin(18),fixed bin(17)),
       77 	expmac$zero entry(fixed bin(15)),
       78 	error entry(fixed bin,ptr,ptr),
       79 	base_man$load_var entry(fixed bin,ptr,fixed bin),
       80 	xr_man$load_any_var entry(ptr,fixed bin(15),fixed bin),
       81 	xr_man$load_const entry(fixed bin(15),fixed bin),
       82 	c_a entry(fixed bin(15),fixed bin) returns(ptr);
       83 dcl	m_a entry(ptr,bit(2) aligned);
       84 dcl	compile_exp$save entry(ptr) returns(ptr),
       85 	need_temp entry(ptr,bit(2) aligned),
       86 	prepare_operand entry(ptr,fixed bin,bit(1) aligned) returns(ptr),
       87 	state_man$flush entry,
       88 	state_man$create_ms entry returns(ptr),
       89 	state_man$save_regs entry(ptr),
       90 	state_man$save_ms entry(ptr,bit(1) aligned),
       91 	state_man$discard_ms entry,
       92 	set_indicators entry(ptr,ptr,ptr,fixed bin(15)) returns(fixed bin(15));
       93 
       94 /* external static */
       95 
       96 dcl	(cg_stat$cur_block,cg_stat$cur_statement,cg_stat$jump_label,cg_stat$m_s_p) ptr ext,
       97 	cg_stat$text_pos fixed bin(18) ext,
       98 	cg_stat$skip_to_label bit(1) ext,
       99 	cg_stat$cur_level fixed bin ext,
      100 	cg_stat$optimize bit (1) aligned external static;
      101 
      102 /* internal static */
      103 
      104 dcl (	tra		init(169),
      105 	tra_ext_1		init(170),
      106 	tra_ext_2		init(171)) fixed bin (15) int static;
      107 
      108 dcl	reverse(8) fixed bin(15) int static
      109 	init(2,1,8,7,6,5,4,3);
      110 
      111 dcl	jump_table(8 /* operator */, 0:1 /* string? */, 0:1 /* reversed? */) fixed bin(15) int static
      112 	init(	/* true	*/ 181, 181, 181, 181,
      113 		/* false	*/ 180, 180, 180, 180,
      114 		/*  <	*/ 176, 178, 177, 179,
      115 		/*  >	*/ 178, 176, 179, 177,
      116 		/*  =	*/ 180, 180, 180, 180,
      117 		/*  ^=	*/ 181, 181, 181, 181,
      118 		/*  <=	*/ 182, 184, 183, 185,
      119 		/*  >=	*/ 184, 182, 185, 183);
      120 
      121 /* include files */
      122 
  1     1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */
  1     2 
  1     3 dcl	1 reference		based aligned,
  1     4 	2 node_type		bit(9) unaligned,
  1     5 	2 array_ref		bit(1) unaligned,
  1     6 	2 varying_ref		bit(1) unaligned,
  1     7 	2 shared			bit(1) unaligned,
  1     8 	2 put_data_sw		bit(1) unaligned,
  1     9 	2 processed		bit(1) unaligned,
  1    10 	2 units			fixed(3) unaligned,
  1    11 	2 ref_count		fixed(17) unaligned,
  1    12 	2 c_offset		fixed(24),
  1    13 	2 c_length		fixed(24),
  1    14 	2 symbol			ptr unaligned,
  1    15 	2 qualifier		ptr unaligned,
  1    16 	2 offset			ptr unaligned,
  1    17 	2 length			ptr unaligned,
  1    18 	2 subscript_list		ptr unaligned,
  1    19 						/* these fields are used by the 645 code generator */
  1    20 	2 address			structure unaligned,
  1    21 	  3 base			bit(3),
  1    22 	  3 offset		bit(15),
  1    23 	  3 op			bit(9),
  1    24 	  3 no_address		bit(1),
  1    25 	  3 inhibit		bit(1),
  1    26 	  3 ext_base		bit(1),
  1    27 	  3 tag			bit(6),
  1    28 	2 info			structure unaligned,
  1    29 	  3 address_in		structure,
  1    30 	    4 b			dimension(0:7) bit(1),
  1    31 	    4 storage		bit(1),
  1    32 	  3 value_in		structure,
  1    33 	    4 a			bit(1),
  1    34 	    4 q			bit(1),
  1    35 	    4 aq			bit(1),
  1    36 	    4 string_aq		bit(1),
  1    37 	    4 complex_aq		bit(1),
  1    38 	    4 decimal_aq		bit(1),
  1    39 	    4 b			dimension(0:7) bit(1),
  1    40 	    4 storage		bit(1),
  1    41 	    4 indicators		bit(1),
  1    42 	    4 x			dimension(0:7) bit(1),
  1    43 	  3 other			structure,
  1    44 	    4 big_offset		bit(1),
  1    45 	    4 big_length		bit(1),
  1    46 	    4 modword_in_offset	bit(1),
  1    47 	2 data_type		fixed(5) unaligned,
  1    48 	2 bits			structure unaligned,
  1    49 	  3 padded_ref		bit(1),
  1    50 	  3 aligned_ref		bit(1),
  1    51 	  3 long_ref		bit(1),
  1    52 	  3 forward_ref		bit(1),
  1    53 	  3 ic_ref		bit(1),
  1    54 	  3 temp_ref		bit(1),
  1    55 	  3 defined_ref		bit(1),
  1    56 	  3 evaluated		bit(1),
  1    57 	  3 allocate		bit(1),
  1    58 	  3 allocated		bit(1),
  1    59 	  3 aliasable		bit(1),
  1    60 	  3 even			bit(1),
  1    61 	  3 perm_address		bit(1),
  1    62 	  3 aggregate		bit(1),
  1    63 	  3 hit_zero		bit(1),
  1    64 	  3 dont_save		bit(1),
  1    65 	  3 fo_in_qual		bit(1),
  1    66 	  3 hard_to_load		bit(1),
  1    67 	2 relocation		bit(12) unaligned,
  1    68 	2 more_bits		structure unaligned,
  1    69 	  3 substr		bit(1),
  1    70 	  3 padded_for_store_ref	bit(1),
  1    71 	  3 aligned_for_store_ref	bit(1),
  1    72 	  3 mbz			bit(15),
  1    73 	2 store_ins		bit(18) unaligned;
  1    74 
  1    75 /* END INCLUDE FILE ... reference.incl.pl1 */
      123 
  2     1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */
  2     2 
  2     3 /*	Modified: 2 Apr 1980 by PCK to add max_number_of_operands */
  2     4 
  2     5 /* format: style3 */
  2     6 dcl	1 operator	based aligned,
  2     7 	  2 node_type	bit (9) unaligned,
  2     8 	  2 op_code	bit (9) unaligned,
  2     9 	  2 shared	bit (1) unaligned,
  2    10 	  2 processed	bit (1) unaligned,
  2    11 	  2 optimized	bit (1) unaligned,
  2    12 	  2 number	fixed (14) unaligned,
  2    13 	  2 operand	dimension (n refer (operator.number)) ptr unaligned;
  2    14 
  2    15 dcl	max_number_of_operands
  2    16 			fixed bin (15) int static options (constant) initial (32767);
  2    17 
  2    18 /* END INCLUDE FILE ... operator.incl.pl1 */
      124 
  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 */
      125 
  4     1 dcl	1 label			based aligned,
  4     2 	2 node_type		bit(9) unaligned,
  4     3 	2 source_id		structure unaligned,
  4     4 	  3 file_number		bit(8),
  4     5 	  3 line_number		bit(14),
  4     6 	  3 statement_number	bit(5),
  4     7 	2 location		fixed(17) unaligned,
  4     8 	2 allocated		bit(1) unaligned,
  4     9 	2 dcl_type		bit(3) unaligned,
  4    10 	2 reserved		bit(29) unaligned,
  4    11 	2 array			bit(1) unaligned,
  4    12 	2 used_as_format		bit(1) unaligned,
  4    13 	2 used_in_goto		bit(1) unaligned,
  4    14 	2 symbol_table		bit(18) unaligned,
  4    15 	2 low_bound		fixed(17) unaligned,
  4    16 	2 high_bound		fixed(17) unaligned,
  4    17 	2 block_node		ptr unaligned,
  4    18 	2 token			ptr unaligned,
  4    19 	2 next			ptr unaligned,
  4    20 	2 multi_use		ptr unaligned,
  4    21 	2 cross_reference		ptr unaligned,
  4    22 	2 statement		ptr unaligned;
      126 
  5     1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */
  5     2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */
  5     3 /* format: style3,idind30 */
  5     4 
  5     5 declare	1 block			aligned based,
  5     6 	  2 node_type		bit (9) unaligned,
  5     7 	  2 source_id		structure unaligned,
  5     8 	    3 file_number		bit (8),
  5     9 	    3 line_number		bit (14),
  5    10 	    3 statement_number	bit (5),
  5    11 	  2 father		ptr unaligned,
  5    12 	  2 brother		ptr unaligned,
  5    13 	  2 son			ptr unaligned,
  5    14 	  2 declaration		ptr unaligned,
  5    15 	  2 end_declaration		ptr unaligned,
  5    16 	  2 default		ptr unaligned,
  5    17 	  2 end_default		ptr unaligned,
  5    18 	  2 context		ptr unaligned,
  5    19 	  2 prologue		ptr unaligned,
  5    20 	  2 end_prologue		ptr unaligned,
  5    21 	  2 main			ptr unaligned,
  5    22 	  2 end_main		ptr unaligned,
  5    23 	  2 return_values		ptr unaligned,
  5    24 	  2 return_count		ptr unaligned,
  5    25 	  2 plio_ps		ptr unaligned,
  5    26 	  2 plio_fa		ptr unaligned,
  5    27 	  2 plio_ffsb		ptr unaligned,
  5    28 	  2 plio_ssl		ptr unaligned,
  5    29 	  2 plio_fab2		ptr unaligned,
  5    30 	  2 block_type		bit (9) unaligned,
  5    31 	  2 prefix		bit (12) unaligned,
  5    32 	  2 like_attribute		bit (1) unaligned,
  5    33 	  2 no_stack		bit (1) unaligned,
  5    34 	  2 get_data		bit (1) unaligned,
  5    35 	  2 flush_at_call		bit (1) unaligned,
  5    36 	  2 processed		bit (1) unaligned,
  5    37 	  2 text_displayed		bit (1) unaligned,
  5    38 	  2 number		fixed bin (9) unsigned unaligned,
  5    39 	  2 free_temps		dimension (3) ptr,	/* these fields are used by the code generator */
  5    40 	  2 temp_list		ptr,
  5    41 	  2 entry_list		ptr,
  5    42 	  2 o_and_s		ptr,
  5    43 	  2 why_nonquick		aligned,
  5    44 	    3 auto_adjustable_storage bit (1) unaligned,
  5    45 	    3 returns_star_extents	bit (1) unaligned,
  5    46 	    3 stack_extended_by_args	bit (1) unaligned,
  5    47 	    3 invoked_by_format	bit (1) unaligned,
  5    48 	    3 format_statement	bit (1) unaligned,
  5    49 	    3 io_statements		bit (1) unaligned,
  5    50 	    3 assigned_to_entry_var	bit (1) unaligned,
  5    51 	    3 condition_statements	bit (1) unaligned,
  5    52 	    3 no_owner		bit (1) unaligned,
  5    53 	    3 recursive_call	bit (1) unaligned,
  5    54 	    3 options_non_quick	bit (1) unaligned,
  5    55 	    3 options_variable	bit (1) unaligned,
  5    56 	    3 never_referenced	bit (1) unaligned,
  5    57 	    3 pad_nonquick		bit (5) unaligned,
  5    58 	  2 prologue_flag		bit (1) unaligned,
  5    59 	  2 options_main		bit (1) unaligned,
  5    60 	  2 pad			bit (16) unaligned,
  5    61 	  2 number_of_entries	fixed bin (17),
  5    62 	  2 level			fixed bin (17),
  5    63 	  2 last_auto_loc		fixed bin (17),
  5    64 	  2 symbol_block		fixed bin (17),
  5    65 	  2 entry_info		fixed bin (18),
  5    66 	  2 enter			structure unaligned,
  5    67 	    3 start		fixed bin (17),
  5    68 	    3 end			fixed bin (17),
  5    69 	  2 leave			structure unaligned,
  5    70 	    3 start		fixed bin (17),
  5    71 	    3 end			fixed bin (17),
  5    72 	  2 owner			ptr;
  5    73 
  5    74 declare	max_block_number		fixed bin internal static options (constant) initial (511);
  5    75 
  5    76 /* END INCLUDE FILE ... block.incl.pl1 */
      127 
  6     1 /* ***********************************************************
  6     2*   *                                                         *
  6     3*   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
  6     4*   *                                                         *
  6     5*   *********************************************************** */
  6     6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */
  6     7 /* Internal interface of the PL/I compiler */
  6     8 
  6     9 dcl	1 statement		based aligned,
  6    10 	2 node_type		bit(9) unaligned,
  6    11 	2 source_id		structure unaligned,
  6    12 	  3 file_number		bit(8),
  6    13 	  3 line_number		bit(14),
  6    14 	  3 statement_number	bit(5),
  6    15 	2 next			ptr unaligned,
  6    16 	2 back			ptr unaligned,
  6    17 	2 root			ptr unaligned,
  6    18 	2 labels			ptr unaligned,
  6    19 	2 reference_list		ptr unaligned,
  6    20 	2 state_list		ptr unaligned,
  6    21 	2 reference_count		fixed(17) unaligned,
  6    22 	2 ref_count_copy		fixed(17) unaligned,
  6    23 	2 object			structure unaligned,
  6    24 	  3 start			fixed(17),
  6    25 	  3 finish		fixed(17),
  6    26 	2 source			structure unaligned,
  6    27 	  3 segment		fixed(11),
  6    28 	  3 start			fixed(23),
  6    29 	  3 length		fixed(11),
  6    30 	2 prefix			bit(12) unaligned,
  6    31 	2 optimized		bit(1) unaligned,
  6    32 	2 free_temps		bit(1) unaligned,
  6    33 	2 LHS_in_RHS		bit(1) unaligned,
  6    34 	2 statement_type		bit(9) unaligned,
  6    35 	2 bits			structure unaligned,
  6    36 	  3 processed		bit(1) unaligned,
  6    37 	  3 put_in_profile		bit(1) unaligned,
  6    38 	  3 generated		bit(1) unaligned,
  6    39 	  3 snap			bit(1) unaligned,
  6    40 	  3 system		bit(1) unaligned,
  6    41 	  3 irreducible		bit(1) unaligned,
  6    42 	  3 checked		bit(1) unaligned,
  6    43 	  3 save_temps		bit(1) unaligned,
  6    44 	  3 suppress_warnings	bit(1) unaligned,
  6    45 	  3 force_nonquick		bit(1) unaligned,
  6    46 	  3 expanded_by_name	bit(1) unaligned,
  6    47 	  3 begins_loop		bit(1) unaligned,
  6    48 	  3 pad			bit(24) unaligned;
  6    49 
  6    50 /* END INCLUDE FILE ... statement.incl.pl1 */
      128 
  7     1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */
  7     2 
  7     3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */
  7     4 
  7     5 dcl (	block_node		initial("000000001"b),
  7     6 	statement_node		initial("000000010"b),
  7     7 	operator_node		initial("000000011"b),
  7     8 	reference_node		initial("000000100"b),
  7     9 	token_node		initial("000000101"b),
  7    10 	symbol_node		initial("000000110"b),
  7    11 	context_node		initial("000000111"b),
  7    12 	array_node		initial("000001000"b),
  7    13 	bound_node		initial("000001001"b),
  7    14 	format_value_node		initial("000001010"b),
  7    15 	list_node			initial("000001011"b),
  7    16 	default_node		initial("000001100"b),
  7    17 	machine_state_node		initial("000001101"b),
  7    18 	source_node		initial("000001110"b),
  7    19 	label_node		initial("000001111"b),
  7    20 	cross_reference_node	initial("000010000"b),
  7    21 	sf_par_node		initial("000010001"b),
  7    22 	temporary_node		initial("000010010"b),
  7    23 	label_array_element_node	initial("000010011"b),
  7    24 	by_name_agg_node		initial("000010100"b))
  7    25 				bit(9) internal static aligned options(constant);
  7    26 
  7    27 dcl	1 node			based aligned,
  7    28 	2 type			unal bit(9),
  7    29 	2 source_id		unal structure,
  7    30 	  3 file_number		bit(8),
  7    31 	  3 line_number		bit(14),
  7    32 	  3 statement_number	bit(5);
  7    33 
  7    34 /* END INCLUDE FILE ... nodes.incl.pl1 */
      129 
  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 */
      130 
  9     1 dcl (	real_fix_bin_1		init(1),
  9     2 	real_fix_bin_2		init(2),
  9     3 	real_flt_bin_1		init(3),
  9     4 	real_flt_bin_2		init(4),
  9     5 	complex_fix_bin_1		init(5),
  9     6 	complex_fix_bin_2		init(6),
  9     7 	complex_flt_bin_1		init(7),
  9     8 	complex_flt_bin_2		init(8),
  9     9 	real_fix_dec		init(9),
  9    10 	real_flt_dec		init(10),
  9    11 	complex_fix_dec		init(11),
  9    12 	complex_flt_dec		init(12),
  9    13 	char_string		init(13),
  9    14 	bit_string		init(14),
  9    15 	label_constant		init(15),
  9    16 	local_label_variable	init(16),
  9    17 	label_variable		init(17),
  9    18 	entry_variable		init(18),
  9    19 	ext_entry_in		init(19),
  9    20 	ext_entry_out		init(20),
  9    21 	int_entry			init(21),
  9    22 	int_entry_other		init(22),
  9    23 	unpacked_ptr		init(23),
  9    24 	packed_ptr		init(24)) fixed bin(15) int static options(constant);
      131 
 10     1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */
 10     2 
 10     3 /* Modified 26 June 81 by EBush to add max_list_elements */
 10     4 
 10     5 
 10     6 dcl	1 list		based aligned,
 10     7 	2 node_type	bit(9) unaligned,
 10     8 	2 reserved	bit(12) unaligned,
 10     9 	2 number		fixed(14) unaligned,
 10    10 	2 element		dimension(n refer(list.number)) ptr unaligned;
 10    11 
 10    12 dcl       max_list_elements   fixed bin(17) internal static options (constant)
 10    13 	                    init(16383);
 10    14 
 10    15 /* END INCLUDE FILE ... list.incl.pl1 */
      132 
      133 
      134 /* program */
      135 
      136 	pb = cg_stat$cur_block;
      137 
      138 	p = pt;
      139 	s1, p1 = p -> operand(1);
      140 
      141 	/* if the destination of this transfer is another transfer,
      142*	   go directly to destination of other transfer */
      143 
      144 	if p1 -> node.type = label_node & cg_stat$optimize
      145 	then do;
      146 		do count = 1 to 10;			/* limit number of attempts */
      147 		     p3 = p1 -> label.statement;
      148 		     q = p3 -> statement.root;
      149 
      150 		     do while(q = null);
      151 			p3 = p3 -> statement.next;
      152 			if p3 = null then goto prep;
      153 			q = p3 -> statement.root;
      154 		     end;
      155 
      156 		     if q -> operator.op_code ^= jump then goto prep;
      157 
      158 		     if p3 = cg_stat$cur_statement
      159 		     then do;
      160 			call error(325,p3,null);	/* infinite loop */
      161 			goto prep;
      162 			end;
      163 
      164 		     p2 = q -> operand(1);
      165 		     if p2 -> node.type ^= label_node then goto prep;
      166 		     if p1 -> label.block_node ^= p2 -> label.block_node then goto prep;
      167 
      168 		     p1 = p2;
      169 		end;
      170 
      171 prep:	     if s1 ^= p1
      172 	     then do;
      173 
      174 		/* if we actually skipped over a transfer, we have to correct the
      175*		   reference counts on the statements involved */
      176 
      177 		q = s1 -> label.statement;
      178 		q -> statement.reference_count = q -> statement.reference_count - 1;
      179 
      180 		q = p1 -> label.statement;
      181 		q -> statement.reference_count = q -> statement.reference_count + 1;
      182 
      183 		end;
      184 
      185 	     end;
      186 
      187 	else if p1 -> node.type = reference_node
      188 	     then if p1 -> reference.symbol = null
      189 		then do;
      190 
      191 		     /* a reference node with no symbol would have been created
      192*		        by a call to c_a.  This is used to indicate a conditional
      193*		        return statement	     */
      194 
      195 		     is_return = "1"b;
      196 		     goto sh;
      197 		     end;
      198 		else if p1 -> reference.symbol -> node.type = label_node
      199 		     then call init_label_array_info;
      200 
      201 	is_return = "0"b;
      202 
      203 	/* operator_semantics ensures that operand(1) of a conditional jump
      204*	   operator will not be an operator node nor a reference node with
      205*	   expressions hanging off.  This used to arise in the case of
      206*	   if <expr> then goto <lab>; when <lab> was other than a simple
      207*	   reference to a label constant */
      208 
      209 	p1 = prepare_operand(p1,1,atomic);
      210 	dt = p1 -> reference.data_type;
      211 	s1 = p1 -> reference.symbol;
      212 
      213 sh:	hard = 0;
      214 
      215 	/* get integer giving op_code going from 0 to 8 */
      216 
      217 	i, n = fixed(p -> operator.op_code,9) - fixed(jump,9);
      218 
      219 	if n >= 3 then n = 3;
      220 
      221 	if n > 0
      222 	then do;
      223 
      224 	     /* have conditional jump */
      225 
      226 	     if is_return then goto cond_ok;
      227 
      228 	     if dt = label_constant
      229 	     then if cg_stat$cur_level = s1 -> label.block_node -> block.level
      230 		then do;
      231 		     if ^ cg_stat$cur_statement -> statement.checked
      232 		     then if ^ s1 -> label.allocated
      233 			then call eval_primaries((s1 -> label.statement));
      234 			else if s1 -> label.array
      235 			     then call eval_all_primaries;
      236 		     go to cond_ok;
      237 		     end;
      238 
      239 	     /* special action needed for conditional transfer to something
      240*	        other than a label constant */
      241 
      242 	     hard = 1;
      243 	     i = reverse(i);
      244 	     save_p1 = p1;
      245 
      246 	     s1 = cg_stat$jump_label;
      247 	     s1 -> label.allocated = "0"b;
      248 	     s1 -> label.location = 0;
      249 	     p1 = prepare_operand(s1,1,atomic);
      250 
      251 cond_ok:	     conditional = "1"b;
      252 	     p2 = p -> operand(2);
      253 	     goto switch(n);
      254 	     end;
      255 
      256 	if dt = label_constant
      257 	then if s1 -> label.array
      258 	then if p1 -> reference.offset ^= null
      259 	then if ^ cg_stat$cur_statement -> statement.checked
      260 	then if cg_stat$cur_block = s1 -> label.block_node
      261 	then call eval_all_primaries;
      262 
      263 	/* have unconditional jump */
      264 
      265 uncond:	conditional = "0"b;
      266 
      267 	if dt = local_label_variable
      268 	then do;
      269 
      270 	     q = s1 -> symbol.block_node;
      271 
      272 	     if q = pb
      273 	     then do;
      274 
      275 		/* the local label variable is declared in current block,
      276*		   can transfer indirectly thru the pointer */
      277 
      278 jump_ind:		call m_a(p1,"1"b);			/* no indirection allowed */
      279 		p1 -> reference.perm_address = "1"b;
      280 		substr(p1 -> address.tag,2,1) = "1"b;	/* r mod -> r* mod */
      281 		goto put_tra;
      282 		end;
      283 
      284 	     /* if none of the blocks between this one and the block in
      285*	        which the local label variable is declared have stack frames,
      286*	        we also can jump indirectly */
      287 
      288 	     do while(pb -> block.no_stack);
      289 		pb = pb -> block.father;
      290 		end;
      291 
      292 	     if q = pb then goto jump_ind;
      293 
      294 	     /* must use an unwinder to do the transfer */
      295 
      296 unwind:	     macro = tra_ext_2;
      297 	     load_index = "0"b;
      298 	     goto load_bp;
      299 	     end;
      300 
      301 	/* if operand(1) is a pointer, we have jump to a do block */
      302 
      303 	if dt = unpacked_ptr then goto jump_ind;
      304 
      305 	if dt = real_fix_bin_1
      306 	then do;
      307 
      308 	     /* have transfer resulting from Fortran assigned goto */
      309 
      310 	     call xr_man$load_any_var(p1,k,0);
      311 	     p1 = c_a(k,8);			/* 0,xr */
      312 	     goto put_tra;
      313 	     end;
      314 
      315 	if dt ^= label_constant then goto unwind;
      316 
      317 	/* get number of blocks between current block and block in
      318*	   which the constant appears */
      319 
      320 	k = cg_stat$cur_level - s1 -> label.block_node -> block.level;
      321 
      322 	if k ^= 0
      323 	then do;
      324 
      325 	     /* must use an unwinder since label is in an outer block */
      326 
      327 	     load_index = "1"b;
      328 	     macro = tra_ext_1;
      329 
      330 load_bp:	     call base_man$load_var(2,p1,1);	/* load ptr into bp */
      331 
      332 	     if load_index
      333 		then call xr_man$load_const(k,7);	/* load x7 with number of frames to walk */
      334 
      335 	     call state_man$discard_ms;
      336 
      337 	     call expmac$zero(macro);
      338 	     goto done;
      339 	     end;
      340 
      341 put_tra:	macro = tra;
      342 
      343 	goto put;
      344 
      345 	/* opcode is jump_true */
      346 
      347 switch(1):
      348 	if hard = 1 then goto sw_2;
      349 
      350 sw_1:	if p2 -> node.type ^= operator_node then goto jump_tf;
      351 
      352 	/* look for case "if ^ bit(1) then ..." */
      353 
      354 	if p2 -> operator.op_code ^= not_bits then goto jump_tf;
      355 	if p2 -> operand(1) -> reference.c_length ^= 1 then goto jump_tf;
      356 	if ^ p2 -> operand(1) -> reference.shared then go to jump_tf;
      357 
      358 	/* have case "if ^ bit(1)", remove the not and change to jump_false */
      359 
      360 	pt -> operand(2), p2 = p2 -> operand(2);
      361 	i = i + 1;
      362 	goto jump_tf;
      363 
      364 	/* opcode is jump_false */
      365 
      366 switch(2):
      367 	if hard = 1 then goto sw_1;
      368 
      369 sw_2:	if p2 -> node.type ^= operator_node then goto chk_const;
      370 
      371 	/* look for case of form "if ^ bit(1) then return;" */
      372 
      373 	if p2 -> operator.op_code ^= not_bits then goto jump_tf;
      374 	if p2 -> operand(1) -> reference.c_length ^= 1 then goto jump_tf;
      375 	if ^ p2 -> operand(1) -> reference.shared then go to jump_tf;
      376 
      377 	/* remove the node and change to jump_true */
      378 
      379 	pt -> operand(2), p2 = p2 -> operand(2);
      380 	i = i - 1;
      381 	goto jump_tf;
      382 
      383 	/* look for jump produces by construct
      384*		do while("1"b);
      385*	   and eliminate the test	*/
      386 
      387 chk_const:
      388 	if p2 -> reference.offset ^= null then goto jump_tf;
      389 	if p2 -> reference.c_offset ^= 0 then goto jump_tf;
      390 	if p2 -> reference.length ^= null then goto jump_tf;
      391 
      392 	q = p2 -> reference.symbol;
      393 	if ^ q -> symbol.constant then goto jump_tf;
      394 	if ^ q -> symbol.bit then goto jump_tf;
      395 	if q -> symbol.varying then goto jump_tf;
      396 	if q -> symbol.dimensioned then goto jump_tf;
      397 
      398 	if hard > 0 then goto jump_tf;
      399 
      400 	size = q -> symbol.c_dcl_size;
      401 	if q -> symbol.initial -> based_bit_string then return;
      402 
      403 jump_tf:	code = 5;
      404 	p3 = null;
      405 	goto jump_rel;
      406 
      407 	/* have conditional jump */
      408 
      409 switch(3):
      410 	code = 0;
      411 
      412 jump_rel:	p2 = prepare_operand(p2,1,p2_atomic);
      413 
      414 	if code = 0
      415 	then do;
      416 	     p3 = prepare_operand((p -> operand(3)),1,p3_atomic);
      417 	     code = fixed(p2_atomic || p3_atomic,2);
      418 	     end;
      419 
      420 	if ^is_return & hard = 0 & dt = label_constant then	/* save useful registers now to avoid clobbering indicators later */
      421 	     if s1 -> label.array then call label_array_save_regs;
      422 	     else if ^s1 -> label.allocated then call state_man$save_regs((s1 -> label.statement));
      423 
      424 	k = set_indicators(pt,p2,p3,code);
      425 
      426 	if p2 -> reference.data_type <= real_flt_bin_2 then j = 0;
      427 	else do;
      428 	     q = p2 -> reference.symbol;
      429 	     j = fixed(q -> symbol.bit | q -> symbol.char,1);
      430 	     end;
      431 
      432 	macro = jump_table(i,j,k);
      433 
      434 put:	if is_return then goto putx;
      435 
      436 	call m_a(p1,"0"b);
      437 	p1 -> reference.perm_address = "1"b;
      438 
      439 	if p1 -> reference.ref_count = 1
      440 	then if p1 -> reference.offset ^= null | p1 -> reference.qualifier ^= null
      441 	     then call need_temp(p1,"10"b);
      442 
      443 	if dt = label_constant
      444 	then if hard ^= 0
      445 	     then call state_man$flush;
      446 	     else if s1 -> label.array
      447 		then call process_label_array;
      448 		else if ^ s1 -> label.allocated
      449 		     then call state_man$save_ms((s1 -> label.statement),conditional);
      450 		     else if ^ conditional
      451 			then call state_man$discard_ms;
      452 			else;
      453 	else if hard ^= 0
      454 	     then call state_man$flush;
      455 
      456 putx:	call expmac(macro,p1);
      457 
      458 	if hard = 1
      459 	then do;
      460 
      461 	     /* just finished first part of conditional transfer to jump_label,
      462*	        how go unconditional transfer to the real label */
      463 
      464 	     p1 = save_p1;
      465 
      466 	     s1 = p1 -> reference.symbol;
      467 	     hard = 2;
      468 	     goto uncond;
      469 	     end;
      470 
      471 done:	if hard = 2
      472 	then do;
      473 	     call expmac$fill_usage(cg_stat$text_pos,(cg_stat$jump_label -> label.location));
      474 	     if cg_stat$m_s_p = null then cg_stat$m_s_p = state_man$create_ms();
      475 	     else call state_man$flush;
      476 	     cg_stat$skip_to_label = "0"b;
      477 	     end;
      478 	else cg_stat$skip_to_label = ^ conditional;
      479 
      480 	return;
      481 
      482 jump_op$eval_primaries:	entry(pt);
      483 
      484 	p1 = pt;
      485 	if p1 -> node.type = label_node
      486 	then call eval_primaries((p1 -> label.statement));
      487 	else do;
      488 	     call init_label_array_info;
      489 	     call eval_all_primaries;
      490 	     end;
      491 	return;
      492 
      493 
      494 
      495 eval_primaries:	proc(stm);
      496 
      497 	     /* eval_primaries is called before an easy conditional forward
      498*	     jump to ensure that all expressions known now and known
      499*	     at the label are fully evaluated.  It searches the primary list
      500*	     at the label.  This routine is necessary because the code generator
      501*	     does not usually evaluate the addr_fun operator as an optimization,
      502*	     and because short unaligned strings are most often not converted
      503*	     to aligned temporaries when they are stored, but rather when they
      504*	     are loaded again later.  Thus, an anomalous situation would
      505*	     arise, if an expr, like those mentioned above, was encountered
      506*	     before a conditional forward jump without its being evaluated,
      507*	     was evaluated along one branch of execution, thus making the
      508*	     code generator think it was already evaluated when it encountered
      509*	     the expr yet again along the other branch of execution.  */
      510 
      511 dcl	     (prim,q,r,stm) ptr;
      512 
      513 	     do prim = stm -> statement.reference_list
      514 		repeat prim -> element(4) while(prim ^= null);
      515 		q = prim -> element(1);
      516 		if q -> node.type = operator_node
      517 		then do;
      518 		     r = q -> operand(1);
      519 	 	     if ^ r -> reference.evaluated
      520 		     then if r -> reference.ref_count > 1
      521 			then if q -> operator.op_code = addr_fun
      522 			     then call evaluate;
      523 		     end;
      524 		else if ^ q -> reference.aligned_ref
      525 		     then if q -> reference.ref_count > 1
      526 			then if ^q -> reference.symbol -> symbol.decimal
      527 			     then call evaluate;
      528 		end;
      529 
      530 evaluate:		proc;
      531 
      532 		/* evaluate q */
      533 
      534 dcl		atomic bit(1) aligned;
      535 
      536 		r = prepare_operand(q,1,atomic);
      537 
      538 		if ^ atomic
      539 		then if ^ r -> reference.aggregate
      540 		     then r = compile_exp$save(q);
      541 
      542 		end;
      543 
      544 	     end;
      545 
      546 
      547 init_label_array_info: proc;
      548 
      549 /* initializes start, finish for further use */
      550 
      551 	     if p1 -> reference.offset = null
      552 	     then start, finish = p1 -> reference.c_offset + 1;
      553 
      554 	     else do;
      555 		start = 1;
      556 		finish = p1 ->reference.symbol -> label.statement -> list.number;
      557 		end;
      558 
      559 	     end;
      560 
      561 
      562 eval_all_primaries:	proc;
      563 
      564 	     /* finds all statements for which eval_primaries must be called.
      565*	        called only for label array in same block */
      566 
      567 dcl	     (q,vector) ptr;
      568 dcl	     i fixed bin;
      569 
      570 	     vector = p1 -> reference.symbol -> label.statement;
      571 
      572 	     do i = start to finish;
      573 		if vector -> list.element(i) ^= null
      574 		then do;
      575 		     q = vector -> element(i);
      576 		     if q -> statement.object.start = 0
      577 			then call eval_primaries(q);
      578 		     end;
      579 		end;
      580 
      581 	     end;
      582 
      583 
      584 process_label_array: proc;
      585 
      586 	     /* handle machine state for local jumps to label array target */
      587 
      588 dcl	     (vector,q) ptr;
      589 dcl	     i fixed bin;
      590 dcl	     cond bit(1) aligned;
      591 
      592 	     cond = conditional | start ^= finish;
      593 	     vector = s1 -> label.statement;
      594 
      595 	     do i = start to finish;
      596 		if vector -> element(i) ^= null
      597 		then do;
      598 		     q = vector -> element(i);
      599 		     if q -> statement.object.start = 0
      600 		     then call state_man$save_ms(q,cond);
      601 		     else if ^ cond
      602 			then call state_man$discard_ms;
      603 		     end;
      604 		end;
      605 
      606 	     if start ^= finish
      607 		then call state_man$discard_ms;
      608 
      609 	     end;
      610 
      611 label_array_save_regs:	proc;
      612 
      613 	/* saves temp-values before local jumps to label array target */
      614 
      615 dcl	i fixed bin;
      616 dcl	q ptr;
      617 
      618 	do i =  start to finish;
      619 	     q = s1 -> label.statement -> element(i);
      620 	     if q ^= null then
      621 		if q -> statement.object.start = 0 then call state_man$save_regs(q);
      622 	  end;
      623      end label_array_save_regs;
      624 
      625 end jump_op;
	SOURCE FILES USED IN THIS COMPILATION.

LINE      NUMBER  DATE MODIFIED     NAME			PATHNAME
             0    09/29/89  1335.9  jump_op.pl1                       >spec>install>1076>jump_op.pl1
123          1    07/21/80  1546.3  reference.incl.pl1                >ldd>include>reference.incl.pl1
124          2    07/21/80  1546.3  operator.incl.pl1                 >ldd>include>operator.incl.pl1
125          3    12/07/83  1701.7  symbol.incl.pl1                   >ldd>include>symbol.incl.pl1
126          4    05/06/74  1742.1  label.incl.pl1                    >ldd>include>label.incl.pl1
127          5    08/13/81  2043.5  block.incl.pl1                    >ldd>include>block.incl.pl1
128          6    04/07/83  1635.0  statement.incl.pl1                >ldd>include>statement.incl.pl1
129          7    07/21/80  1546.3  nodes.incl.pl1                    >ldd>include>nodes.incl.pl1
130          8    04/07/83  1635.0  op_codes.incl.pl1                 >ldd>include>op_codes.incl.pl1
131          9    05/03/76  1320.4  data_types.incl.pl1               >ldd>include>data_types.incl.pl1
132         10    08/13/81  2211.5  list.incl.pl1                     >ldd>include>list.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_fun                               constant        bit(9)                   initial dcl 8-8 ref 519
address                  10            based           structure                level 2 packed packed unaligned dcl 1-3
aggregate                12(19)        based           bit(1)                   level 3 packed packed unaligned dcl 1-3 ref 538
aligned_ref              12(07)        based           bit(1)                   level 3 packed packed unaligned dcl 1-3 ref 524
allocated                 1(18)        based           bit(1)                   level 2 packed packed unaligned dcl 4-1 set ref 231
                                                                                  247* 422 448
arg                             000104 automatic       pointer                  array dcl 55 set ref 139* 139 144 144 147* 147 147
                                                                                  147 148 148 151* 151 151 151 152 152 153 153 158
                                                                                  158 160 160 164* 164 165 165 166 166 166 166 168*
                                                                                  168 168 168 171 171 180 180 187 187 187 187 198
                                                                                  198 209* 209 209 209 210 210 211 211 244 244 249*
                                                                                  249 252* 252 256 256 278 278 279 279 280 280 310
                                                                                  310 311* 311 330 330 350 350 354 354 355 355 356
                                                                                  356 360 360 360* 360 369 369 373 373 374 374 375
                                                                                  375 379 379 379* 379 387 387 389 389 390 390 392
                                                                                  392 404* 404 412* 412 412 412 416* 416 424 424 424
                                                                                  424 426 426 428 428 436 436 437 437 439 439 439
                                                                                  439 439 439 439 439 456 456 464* 464 466 466 484*
                                                                                  484 485 485 485 485 551 551 551 551 556 556 570
                                                                                  570
array                     2(15)        based           bit(1)                   level 2 packed packed unaligned dcl 4-1 ref 234 256
                                                                                  420 446
atomic                          000120 automatic       bit(1)                   dcl 55 in procedure "jump_op" set ref 209* 249*
atomic                          000164 automatic       bit(1)                   dcl 534 in procedure "evaluate" set ref 536* 538
attributes               31            based           structure                level 2 dcl 3-3
base_man$load_var               000020 constant        entry                    external dcl 75 ref 330
based_bit_string                       based           bit                      dcl 61 ref 401
bit                      31(03)        based           bit(1)                   level 4 packed packed unaligned dcl 3-3 ref 394 429
bits                     12(06)        based           structure                level 2 in structure "reference" packed packed
                                                                                  unaligned dcl 1-3 in procedure "jump_op"
bits                     13            based           structure                level 2 in structure "statement" packed packed
                                                                                  unaligned dcl 6-9 in procedure "jump_op"
block                                  based           structure                level 1 dcl 5-5
block_node                4            based           pointer                  level 2 in structure "label" packed packed unaligned
                                                                                  dcl 4-1 in procedure "jump_op" ref 166 166 228 256
                                                                                  320
block_node                4            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 3-3 in procedure "jump_op" ref 270
c_a                             000026 constant        entry                    external dcl 75 ref 311
c_dcl_size               30            based           fixed bin(24,0)          level 2 dcl 3-3 ref 400
c_length                  2            based           fixed bin(24,0)          level 2 dcl 1-3 ref 355 374
c_offset                  1            based           fixed bin(24,0)          level 2 dcl 1-3 ref 389 551
cg_stat$cur_block               000054 external static pointer                  dcl 96 ref 136 256
cg_stat$cur_level               000070 external static fixed bin(17,0)          dcl 96 ref 228 320
cg_stat$cur_statement           000056 external static pointer                  dcl 96 ref 158 231 256
cg_stat$jump_label              000060 external static pointer                  dcl 96 ref 246 473
cg_stat$m_s_p                   000062 external static pointer                  dcl 96 set ref 474 474*
cg_stat$optimize                000072 external static bit(1)                   dcl 96 ref 144
cg_stat$skip_to_label           000066 external static bit(1)                   packed unaligned dcl 96 set ref 476* 478*
cg_stat$text_pos                000064 external static fixed bin(18,0)          dcl 96 set ref 473*
char                     31(04)        based           bit(1)                   level 4 packed packed unaligned dcl 3-3 ref 429
checked                  13(06)        based           bit(1)                   level 3 packed packed unaligned dcl 6-9 ref 231 256
code                            000134 automatic       fixed bin(15,0)          dcl 55 set ref 403* 409* 414 417* 424*
compile_exp$save                000032 constant        entry                    external dcl 84 ref 538
cond                            000223 automatic       bit(1)                   dcl 590 set ref 592* 599* 601
conditional                     000123 automatic       bit(1)                   dcl 55 set ref 251* 265* 448* 450 478 592
constant                 32(16)        based           bit(1)                   level 4 packed packed unaligned dcl 3-3 ref 393
count                           000137 automatic       fixed bin(15,0)          dcl 55 set ref 146*
data_type                31            based           structure                level 3 in structure "symbol" packed packed
                                                                                  unaligned dcl 3-3 in procedure "jump_op"
data_type                12            based           fixed bin(5,0)           level 2 in structure "reference" packed packed
                                                                                  unaligned dcl 1-3 in procedure "jump_op" ref 210
                                                                                  426
decimal                  31(28)        based           bit(1)                   level 4 packed packed unaligned dcl 3-3 ref 524
dimensioned              31(19)        based           bit(1)                   level 4 packed packed unaligned dcl 3-3 ref 396
dt                              000126 automatic       fixed bin(15,0)          dcl 55 set ref 210* 228 256 267 303 305 315 420 443
element                   1            based           pointer                  array level 2 packed packed unaligned dcl 10-6 ref
                                                                                  515 528 573 575 596 598 619
error                           000016 constant        entry                    external dcl 75 ref 160
evaluated                12(13)        based           bit(1)                   level 3 packed packed unaligned dcl 1-3 ref 519
expmac                          000010 constant        entry                    external dcl 75 ref 456
expmac$fill_usage               000012 constant        entry                    external dcl 75 ref 473
expmac$zero                     000014 constant        entry                    external dcl 75 ref 337
father                    1            based           pointer                  level 2 packed packed unaligned dcl 5-5 ref 289
finish                          000141 automatic       fixed bin(15,0)          dcl 55 set ref 551* 556* 572 592 595 606 618
fixed                                                  builtin function         dcl 65 ref 217 217 417 429
hard                            000135 automatic       fixed bin(15,0)          dcl 55 set ref 213* 242* 347 366 398 420 443 453 458
                                                                                  467* 471
i                               000206 automatic       fixed bin(17,0)          dcl 568 in procedure "eval_all_primaries" set ref
                                                                                  572* 573 575*
i                               000222 automatic       fixed bin(17,0)          dcl 589 in procedure "process_label_array" set ref
                                                                                  595* 596 598*
i                               000127 automatic       fixed bin(15,0)          dcl 55 in procedure "jump_op" set ref 217* 243* 243
                                                                                  361* 361 380* 380 432
i                               000234 automatic       fixed bin(17,0)          dcl 615 in procedure "label_array_save_regs" set ref
                                                                                  618* 619*
initial                  11            based           pointer                  level 2 packed packed unaligned dcl 3-3 ref 401
is_return                       000124 automatic       bit(1)                   dcl 55 set ref 195* 201* 226 420 434
j                               000130 automatic       fixed bin(15,0)          dcl 55 set ref 426* 429* 432
jump                                   constant        bit(9)                   initial dcl 8-8 ref 156 217
jump_table                      000003 constant        fixed bin(15,0)          initial array dcl 111 ref 432
k                               000131 automatic       fixed bin(15,0)          dcl 55 set ref 310* 311* 320* 322 332* 424* 432
label                                  based           structure                level 1 dcl 4-1
label_constant                         constant        fixed bin(15,0)          initial dcl 9-1 ref 228 256 315 420 443
label_node                             constant        bit(9)                   initial dcl 7-5 ref 144 165 198 485
length                    6            based           pointer                  level 2 packed packed unaligned dcl 1-3 ref 390
level                    45            based           fixed bin(17,0)          level 2 dcl 5-5 ref 228 320
list                                   based           structure                level 1 dcl 10-6
load_index                      000125 automatic       bit(1)                   dcl 55 set ref 297* 327* 332
local_label_variable                   constant        fixed bin(15,0)          initial dcl 9-1 ref 267
location                  1            based           fixed bin(17,0)          level 2 packed packed unaligned dcl 4-1 set ref 248*
                                                                                  473
m_a                             000030 constant        entry                    external dcl 83 ref 278 436
macro                           000133 automatic       fixed bin(15,0)          dcl 55 set ref 296* 328* 337* 341* 432* 456*
misc_attributes          31(19)        based           structure                level 3 packed packed unaligned dcl 3-3
n                               000132 automatic       fixed bin(15,0)          dcl 55 set ref 217* 219 219* 221 253
need_temp                       000034 constant        entry                    external dcl 84 ref 439
next                      1            based           pointer                  level 2 packed packed unaligned dcl 6-9 ref 151
no_stack                 24(22)        based           bit(1)                   level 2 packed packed unaligned dcl 5-5 ref 288
node                                   based           structure                level 1 dcl 7-27
not_bits                               constant        bit(9)                   initial dcl 8-8 ref 354 373
null                                                   builtin function         dcl 65 ref 150 152 160 160 187 256 387 390 404 439
                                                                                  439 474 513 551 573 596 620
number                    0(21)        based           fixed bin(14,0)          level 2 packed packed unaligned dcl 10-6 ref 556
object                   10            based           structure                level 2 packed packed unaligned dcl 6-9
offset                    5            based           pointer                  level 2 packed packed unaligned dcl 1-3 ref 256 387
                                                                                  439 551
op_code                   0(09)        based           bit(9)                   level 2 packed packed unaligned dcl 2-6 ref 156 217
                                                                                  354 373 519
operand                   1            based           pointer                  array level 2 packed packed unaligned dcl 2-6 set
                                                                                  ref 139 164 252 355 356 360 360* 374 375 379 379*
                                                                                  416 518
operator                               based           structure                level 1 dcl 2-6
operator_node                          constant        bit(9)                   initial dcl 7-5 ref 350 369 516
p                               000102 automatic       pointer                  dcl 55 set ref 138* 139 217 252 416
p1                                     defined         pointer                  dcl 69 set ref 139* 144 147 166 168* 171 180 187 187
                                                                                  198 209* 209* 210 211 244 249* 256 278* 279 280
                                                                                  310* 311* 330* 436* 437 439 439 439 439* 456* 464*
                                                                                  466 484* 485 485 551 551 556 570
p2                                     defined         pointer                  dcl 69 set ref 164* 165 166 168 252* 350 354 355 356
                                                                                  360 360* 369 373 374 375 379 379* 387 389 390 392
                                                                                  412* 412* 424* 426 428
p2_atomic                       000121 automatic       bit(1)                   dcl 55 set ref 412* 417
p3                                     defined         pointer                  dcl 69 set ref 147* 148 151* 151 152 153 158 160*
                                                                                  404* 416* 424*
p3_atomic                       000122 automatic       bit(1)                   dcl 55 set ref 416* 417
pb                              000100 automatic       pointer                  dcl 55 set ref 136* 272 288 289* 289 292
perm_address             12(18)        based           bit(1)                   level 3 packed packed unaligned dcl 1-3 set ref 279*
                                                                                  437*
prepare_operand                 000036 constant        entry                    external dcl 84 ref 209 249 412 416 536
prim                            000150 automatic       pointer                  dcl 511 set ref 513* 513* 515* 528
pt                                     parameter       pointer                  dcl 51 set ref 47 138 360 379 424* 482 484
q                               000202 automatic       pointer                  dcl 567 in procedure "eval_all_primaries" set ref
                                                                                  575* 576 576*
q                               000236 automatic       pointer                  dcl 616 in procedure "label_array_save_regs" set ref
                                                                                  619* 620 620 620*
q                               000152 automatic       pointer                  dcl 511 in procedure "eval_primaries" set ref 515*
                                                                                  516 518 519 524 524 524 536* 538*
q                               000112 automatic       pointer                  dcl 55 in procedure "jump_op" set ref 148* 150 153*
                                                                                  156 164 177* 178 178 180* 181 181 270* 272 292
                                                                                  392* 393 394 395 396 400 401 428* 429 429
q                               000220 automatic       pointer                  dcl 588 in procedure "process_label_array" set ref
                                                                                  598* 599 599*
qualifier                 4            based           pointer                  level 2 packed packed unaligned dcl 1-3 ref 439
r                               000154 automatic       pointer                  dcl 511 set ref 518* 519 519 536* 538 538*
real_fix_bin_1                         constant        fixed bin(15,0)          initial dcl 9-1 ref 305
real_flt_bin_2                         constant        fixed bin(15,0)          initial dcl 9-1 ref 426
ref_count                 0(18)        based           fixed bin(17,0)          level 2 packed packed unaligned dcl 1-3 ref 439 519
                                                                                  524
reference                              based           structure                level 1 dcl 1-3
reference_count           7            based           fixed bin(17,0)          level 2 packed packed unaligned dcl 6-9 set ref 178*
                                                                                  178 181* 181
reference_list            5            based           pointer                  level 2 packed packed unaligned dcl 6-9 ref 513
reference_node                         constant        bit(9)                   initial dcl 7-5 ref 187
reverse                         000043 constant        fixed bin(15,0)          initial array dcl 108 ref 243
root                      3            based           pointer                  level 2 packed packed unaligned dcl 6-9 ref 148 153
s1                              000114 automatic       pointer                  dcl 55 set ref 139* 171 177 211* 228 231 231 234
                                                                                  246* 247 248 249* 256 256 270 320 420 422 422 446
                                                                                  448 448 466* 593 619
save_p1                         000116 automatic       pointer                  dcl 55 set ref 244* 464
set_indicators                  000052 constant        entry                    external dcl 84 ref 424
shared                    0(11)        based           bit(1)                   level 2 packed packed unaligned dcl 1-3 ref 356 375
size                            000136 automatic       fixed bin(15,0)          dcl 55 set ref 400* 401
start                           000140 automatic       fixed bin(15,0)          dcl 55 in procedure "jump_op" set ref 551* 555* 572
                                                                                  592 595 606 618
start                    10            based           fixed bin(17,0)          level 3 in structure "statement" packed packed
                                                                                  unaligned dcl 6-9 in procedure "jump_op" ref 576
                                                                                  599 620
state_man$create_ms             000042 constant        entry                    external dcl 84 ref 474
state_man$discard_ms            000050 constant        entry                    external dcl 84 ref 335 450 601 606
state_man$flush                 000040 constant        entry                    external dcl 84 ref 443 453 475
state_man$save_ms               000046 constant        entry                    external dcl 84 ref 448 599
state_man$save_regs             000044 constant        entry                    external dcl 84 ref 422 620
statement                11            based           pointer                  level 2 in structure "label" packed packed unaligned
                                                                                  dcl 4-1 in procedure "jump_op" ref 147 177 180 231
                                                                                  422 448 485 556 570 593 619
statement                              based           structure                level 1 dcl 6-9 in procedure "jump_op"
stm                                    parameter       pointer                  dcl 511 ref 495 513
storage_class            32(09)        based           structure                level 3 packed packed unaligned dcl 3-3
substr                                                 builtin function         dcl 65 set ref 280*
symbol                    3            based           pointer                  level 2 in structure "reference" packed packed
                                                                                  unaligned dcl 1-3 in procedure "jump_op" ref 187
                                                                                  198 211 392 428 466 524 556 570
symbol                                 based           structure                level 1 dcl 3-3 in procedure "jump_op"
tag                      10(30)        based           bit(6)                   level 3 packed packed unaligned dcl 1-3 set ref 280*
tra                                    constant        fixed bin(15,0)          initial dcl 104 ref 341
tra_ext_1                              constant        fixed bin(15,0)          initial dcl 104 ref 328
tra_ext_2                              constant        fixed bin(15,0)          initial dcl 104 ref 296
type                                   based           bit(9)                   level 2 packed packed unaligned dcl 7-27 ref 144 165
                                                                                  187 198 350 369 485 516
unpacked_ptr                           constant        fixed bin(15,0)          initial dcl 9-1 ref 303
varying                  31(26)        based           bit(1)                   level 4 packed packed unaligned dcl 3-3 ref 395
vector                          000204 automatic       pointer                  dcl 567 in procedure "eval_all_primaries" set ref
                                                                                  570* 573 575
vector                          000216 automatic       pointer                  dcl 588 in procedure "process_label_array" set ref
                                                                                  593* 596 598
xr_man$load_any_var             000022 constant        entry                    external dcl 75 ref 310
xr_man$load_const               000024 constant        entry                    external dcl 75 ref 332

NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED.
a_format                               internal static bit(9)                   initial dcl 8-8
abs_fun                                internal static bit(9)                   initial dcl 8-8
acos_fun                               internal static bit(9)                   initial dcl 8-8
acosd_fun                              internal static bit(9)                   initial dcl 8-8
add                                    internal static bit(9)                   initial dcl 8-8
addbitno_fun                           internal static bit(9)                   initial dcl 8-8
addcharno_fun                          internal static bit(9)                   initial dcl 8-8
addr_fun_bits                          internal static bit(9)                   initial dcl 8-8
addrel_fun                             internal static bit(9)                   initial dcl 8-8
allocation_fun                         internal static bit(9)                   initial dcl 8-8
allot_auto                             internal static bit(9)                   initial dcl 8-8
allot_based                            internal static bit(9)                   initial dcl 8-8
allot_ctl                              internal static bit(9)                   initial dcl 8-8
allot_var                              internal static bit(9)                   initial dcl 8-8
and_bits                               internal static bit(9)                   initial dcl 8-8
array_node                             internal static bit(9)                   initial dcl 7-5
asin_fun                               internal static bit(9)                   initial dcl 8-8
asind_fun                              internal static bit(9)                   initial dcl 8-8
assign                                 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
atan_fun                               internal static bit(9)                   initial dcl 8-8
atand_fun                              internal static bit(9)                   initial dcl 8-8
b_format                               internal static bit(9)                   initial dcl 8-8
baseno_fun                             internal static bit(9)                   initial dcl 8-8
baseptr_fun                            internal static bit(9)                   initial dcl 8-8
bit_pointer                            internal static bit(9)                   initial dcl 8-8
bit_string                             internal static fixed bin(15,0)          initial dcl 9-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
block_node                             internal static bit(9)                   initial dcl 7-5
bn_format                              internal static bit(9)                   initial dcl 8-8
bool_fun                               internal static bit(9)                   initial dcl 8-8
bound_ck                               internal static bit(9)                   initial dcl 8-8
bound_node                             internal static bit(9)                   initial dcl 7-5
by_name_agg_node                       internal static bit(9)                   initial dcl 7-5
byte_fun                               internal static bit(9)                   initial dcl 8-8
c_format                               internal static bit(9)                   initial dcl 8-8
cat_string                             internal static bit(9)                   initial dcl 8-8
ceil_fun                               internal static bit(9)                   initial dcl 8-8
char_string                            internal static fixed bin(15,0)          initial dcl 9-1
char_to_word                           internal static bit(9)                   initial dcl 8-8
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
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 9-1
complex_fix_bin_2                      internal static fixed bin(15,0)          initial dcl 9-1
complex_fix_dec                        internal static fixed bin(15,0)          initial dcl 9-1
complex_flt_bin_1                      internal static fixed bin(15,0)          initial dcl 9-1
complex_flt_bin_2                      internal static fixed bin(15,0)          initial dcl 9-1
complex_flt_dec                        internal static fixed bin(15,0)          initial dcl 9-1
complex_fun                            internal static bit(9)                   initial dcl 8-8
conjg_fun                              internal static bit(9)                   initial dcl 8-8
context_node                           internal static bit(9)                   initial dcl 7-5
copy_string                            internal static bit(9)                   initial dcl 8-8
copy_words                             internal static bit(9)                   initial dcl 8-8
cos_fun                                internal static bit(9)                   initial dcl 8-8
cosd_fun                               internal static bit(9)                   initial dcl 8-8
cross_reference_node                   internal static bit(9)                   initial dcl 7-5
default_node                           internal static bit(9)                   initial dcl 7-5
delete_file                            internal static bit(9)                   initial dcl 8-8
desc_size                              internal static bit(9)                   initial dcl 8-8
digit_to_bit                           internal static bit(9)                   initial dcl 8-8
div                                    internal static bit(9)                   initial dcl 8-8
do_fun                                 internal static bit(9)                   initial dcl 8-8
do_spec                                internal static bit(9)                   initial dcl 8-8
e_format                               internal static bit(9)                   initial dcl 8-8
empty_area                             internal static bit(9)                   initial dcl 8-8
enable_on                              internal static bit(9)                   initial dcl 8-8
entry_variable                         internal static fixed bin(15,0)          initial dcl 9-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
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 9-1
ext_entry_out                          internal static fixed bin(15,0)          initial dcl 9-1
f_format                               internal static bit(9)                   initial dcl 8-8
floor_fun                              internal static bit(9)                   initial dcl 8-8
format_value_node                      internal static bit(9)                   initial dcl 7-5
fortran_read                           internal static bit(9)                   initial dcl 8-8
fortran_write                          internal static bit(9)                   initial dcl 8-8
free_based                             internal static bit(9)                   initial dcl 8-8
free_ctl                               internal static bit(9)                   initial dcl 8-8
free_var                               internal static bit(9)                   initial dcl 8-8
ftn_file_manip                         internal static bit(9)                   initial dcl 8-8
ftn_trans_loop                         internal static bit(9)                   initial dcl 8-8
get_data_trans                         internal static bit(9)                   initial dcl 8-8
get_edit_trans                         internal static bit(9)                   initial dcl 8-8
get_file                               internal static bit(9)                   initial dcl 8-8
get_list_trans                         internal static bit(9)                   initial dcl 8-8
get_string                             internal static bit(9)                   initial dcl 8-8
greater_or_equal                       internal static bit(9)                   initial dcl 8-8
greater_than                           internal static bit(9)                   initial dcl 8-8
half_to_word                           internal static bit(9)                   initial dcl 8-8
imag_fun                               internal static bit(9)                   initial dcl 8-8
index_after_fun                        internal static bit(9)                   initial dcl 8-8
index_before_fun                       internal static bit(9)                   initial dcl 8-8
index_fun                              internal static bit(9)                   initial dcl 8-8
index_rev_fun                          internal static bit(9)                   initial dcl 8-8
int_entry                              internal static fixed bin(15,0)          initial dcl 9-1
int_entry_other                        internal static fixed bin(15,0)          initial dcl 9-1
join                                   internal static bit(9)                   initial dcl 8-8
jump_false                             internal static bit(9)                   initial dcl 8-8
jump_if_eq                             internal static bit(9)                   initial dcl 8-8
jump_if_ge                             internal static bit(9)                   initial dcl 8-8
jump_if_gt                             internal static bit(9)                   initial dcl 8-8
jump_if_le                             internal static bit(9)                   initial dcl 8-8
jump_if_lt                             internal static bit(9)                   initial dcl 8-8
jump_if_ne                             internal static bit(9)                   initial dcl 8-8
jump_true                              internal static bit(9)                   initial dcl 8-8
l_parn                                 internal static bit(9)                   initial dcl 8-8
label_array_element_node               internal static bit(9)                   initial dcl 7-5
label_variable                         internal static fixed bin(15,0)          initial dcl 9-1
length_fun                             internal static bit(9)                   initial dcl 8-8
less_or_equal                          internal static bit(9)                   initial dcl 8-8
less_than                              internal static bit(9)                   initial dcl 8-8
line_format                            internal static bit(9)                   initial dcl 8-8
list_node                              internal static bit(9)                   initial dcl 7-5
locate_file                            internal static bit(9)                   initial dcl 8-8
lock_file                              internal static bit(9)                   initial dcl 8-8
lock_fun                               internal static bit(9)                   initial dcl 8-8
log10_fun                              internal static bit(9)                   initial dcl 8-8
log2_fun                               internal static bit(9)                   initial dcl 8-8
log_fun                                internal static bit(9)                   initial dcl 8-8
loop                                   internal static bit(9)                   initial dcl 8-8
machine_state_node                     internal static bit(9)                   initial dcl 7-5
make_desc                              internal static bit(9)                   initial dcl 8-8
max_block_number                       internal static fixed bin(17,0)          initial dcl 5-74
max_fun                                internal static bit(9)                   initial dcl 8-8
max_list_elements                      internal static fixed bin(17,0)          initial dcl 10-12
max_number_of_operands                 internal static fixed bin(15,0)          initial dcl 2-15
min_fun                                internal static bit(9)                   initial dcl 8-8
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_equal                              internal static bit(9)                   initial dcl 8-8
off_fun                                internal static bit(9)                   initial dcl 8-8
open_file                              internal static bit(9)                   initial dcl 8-8
or_bits                                internal static bit(9)                   initial dcl 8-8
pack                                   internal static bit(9)                   initial dcl 8-8
packed_ptr                             internal static fixed bin(15,0)          initial dcl 9-1
page_format                            internal static bit(9)                   initial dcl 8-8
param_desc_ptr                         internal static bit(9)                   initial dcl 8-8
param_ptr                              internal static bit(9)                   initial dcl 8-8
picture_format                         internal static bit(9)                   initial dcl 8-8
pl1_mod_fun                            internal static bit(9)                   initial dcl 8-8
prefix_plus                            internal static bit(9)                   initial dcl 8-8
ptr_fun                                internal static bit(9)                   initial dcl 8-8
put_control                            internal static bit(9)                   initial dcl 8-8
put_data_trans                         internal static bit(9)                   initial dcl 8-8
put_edit_trans                         internal static bit(9)                   initial dcl 8-8
put_field                              internal static bit(9)                   initial dcl 8-8
put_field_chk                          internal static bit(9)                   initial dcl 8-8
put_file                               internal static bit(9)                   initial dcl 8-8
put_list_trans                         internal static bit(9)                   initial dcl 8-8
put_string                             internal static bit(9)                   initial dcl 8-8
r_format                               internal static bit(9)                   initial dcl 8-8
r_parn                                 internal static bit(9)                   initial dcl 8-8
range_ck                               internal static bit(9)                   initial dcl 8-8
rank_fun                               internal static bit(9)                   initial dcl 8-8
read_file                              internal static bit(9)                   initial dcl 8-8
real_fix_bin_2                         internal static fixed bin(15,0)          initial dcl 9-1
real_fix_dec                           internal static fixed bin(15,0)          initial dcl 9-1
real_flt_bin_1                         internal static fixed bin(15,0)          initial dcl 9-1
real_flt_dec                           internal static fixed bin(15,0)          initial dcl 9-1
real_fun                               internal static bit(9)                   initial dcl 8-8
record_io                              internal static bit(9)                   initial dcl 8-8
refer                                  internal static bit(9)                   initial dcl 8-8
rel_fun                                internal static bit(9)                   initial dcl 8-8
repeat_fun                             internal static bit(9)                   initial dcl 8-8
return_bits                            internal static bit(9)                   initial dcl 8-8
return_string                          internal static bit(9)                   initial dcl 8-8
return_value                           internal static bit(9)                   initial dcl 8-8
return_words                           internal static bit(9)                   initial dcl 8-8
reverse_fun                            internal static bit(9)                   initial dcl 8-8
revert_on                              internal static bit(9)                   initial dcl 8-8
rewrite_file                           internal static bit(9)                   initial dcl 8-8
round_fun                              internal static bit(9)                   initial dcl 8-8
search_fun                             internal static bit(9)                   initial dcl 8-8
search_rev_fun                         internal static bit(9)                   initial dcl 8-8
segno_fun                              internal static bit(9)                   initial dcl 8-8
setbitno_fun                           internal static bit(9)                   initial dcl 8-8
setcharno_fun                          internal static bit(9)                   initial dcl 8-8
sf_par_node                            internal static bit(9)                   initial dcl 7-5
sign_fun                               internal static bit(9)                   initial dcl 8-8
signal_on                              internal static bit(9)                   initial dcl 8-8
sin_fun                                internal static bit(9)                   initial dcl 8-8
sind_fun                               internal static bit(9)                   initial dcl 8-8
skip_format                            internal static bit(9)                   initial dcl 8-8
source_node                            internal static bit(9)                   initial dcl 7-5
sqrt_fun                               internal static bit(9)                   initial dcl 8-8
stack_ptr                              internal static bit(9)                   initial dcl 8-8
stackbaseptr_fun                       internal static bit(9)                   initial dcl 8-8
stackframeptr_fun                      internal static bit(9)                   initial dcl 8-8
stacq_fun                              internal static bit(9)                   initial dcl 8-8
statement_node                         internal static bit(9)                   initial dcl 7-5
std_arg_list                           internal static bit(9)                   initial dcl 8-8
std_call                               internal static bit(9)                   initial dcl 8-8
std_entry                              internal static bit(9)                   initial dcl 8-8
std_return                             internal static bit(9)                   initial dcl 8-8
stop                                   internal static bit(9)                   initial dcl 8-8
stream_prep                            internal static bit(9)                   initial dcl 8-8
sub                                    internal static bit(9)                   initial dcl 8-8
symbol_node                            internal static bit(9)                   initial dcl 7-5
tan_fun                                internal static bit(9)                   initial dcl 8-8
tand_fun                               internal static bit(9)                   initial dcl 8-8
temporary_node                         internal static bit(9)                   initial dcl 7-5
terminate_trans                        internal static bit(9)                   initial dcl 8-8
token_node                             internal static bit(9)                   initial dcl 7-5
translate_fun                          internal static bit(9)                   initial dcl 8-8
trunc_fun                              internal static bit(9)                   initial dcl 8-8
unlock_file                            internal static bit(9)                   initial dcl 8-8
unpack                                 internal static bit(9)                   initial dcl 8-8
vclock_fun                             internal static bit(9)                   initial dcl 8-8
verify_fun                             internal static bit(9)                   initial dcl 8-8
verify_ltrim_fun                       internal static bit(9)                   initial dcl 8-8
verify_rev_fun                         internal static bit(9)                   initial dcl 8-8
verify_rtrim_fun                       internal static bit(9)                   initial dcl 8-8
word_to_mod2                           internal static bit(9)                   initial dcl 8-8
word_to_mod4                           internal static bit(9)                   initial dcl 8-8
word_to_mod8                           internal static bit(9)                   initial dcl 8-8
wordno_fun                             internal static bit(9)                   initial dcl 8-8
write_file                             internal static bit(9)                   initial dcl 8-8
x_format                               internal static bit(9)                   initial dcl 8-8
xor_bits                               internal static bit(9)                   initial dcl 8-8

NAMES DECLARED BY EXPLICIT CONTEXT.
chk_const                       000755 constant        label                    dcl 387 ref 369
cond_ok                         000425 constant        label                    dcl 251 ref 226 236
done                            001356 constant        label                    dcl 471 ref 338
eval_all_primaries              001630 constant        entry                    internal dcl 562 ref 234 256 489
eval_primaries                  001460 constant        entry                    internal dcl 495 ref 231 485 576
evaluate                        001544 constant        entry                    internal dcl 530 ref 519 524
init_label_array_info           001605 constant        entry                    internal dcl 547 ref 198 488
jump_ind                        000475 constant        label                    dcl 278 ref 292 303
jump_op                         000063 constant        entry                    external dcl 47
jump_op$eval_primaries          001432 constant        entry                    external dcl 482
jump_rel                        001023 constant        label                    dcl 412 ref 405
jump_tf                         001015 constant        label                    dcl 403 ref 350 354 355 356 362 373 374 375 381 387
                                                                                  389 390 393 394 395 396 398
label_array_save_regs           001755 constant        entry                    internal dcl 611 ref 420
load_bp                         000610 constant        label                    dcl 330 ref 298
prep                            000215 constant        label                    dcl 171 ref 152 156 161 165 166
process_label_array             001663 constant        entry                    internal dcl 584 ref 446
put                             001204 constant        label                    dcl 434 ref 343
put_tra                         000661 constant        label                    dcl 341 ref 281 312
putx                            001332 constant        label                    dcl 456 ref 434
sh                              000310 constant        label                    dcl 213 ref 196
sw_1                            000667 constant        label                    dcl 350 ref 366
sw_2                            000723 constant        label                    dcl 369 ref 347
switch                          000000 constant        label                    array(3) dcl 347 ref 253
uncond                          000462 constant        label                    dcl 265 ref 468
unwind                          000531 constant        label                    dcl 296 ref 315

THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION.

STORAGE REQUIREMENTS FOR THIS PROGRAM.

	Object	Text	Link	Symbol	Defs	Static
Start          0       0      2334        2430    2025        2344
Length      3040    2025        74         373     306           0

BLOCK NAME	         STACK SIZE     TYPE		WHY NONQUICK/WHO SHARES STACK FRAME
jump_op                             220 external procedure  is an external procedure.  
eval_primaries                          internal procedure  shares stack frame of external procedure jump_op.  
evaluate                                internal procedure  shares stack frame of external procedure jump_op.  
init_label_array_info                   internal procedure  shares stack frame of external procedure jump_op.  
eval_all_primaries                      internal procedure  shares stack frame of external procedure jump_op.  
process_label_array                     internal procedure  shares stack frame of external procedure jump_op.  
label_array_save_regs                   internal procedure  shares stack frame of external procedure jump_op.  

STORAGE FOR AUTOMATIC VARIABLES.

STACK FRAME                 LOC IDENTIFIER                  BLOCK NAME
jump_op                  000100 pb                          jump_op
                         000102 p                           jump_op
                         000104 arg                         jump_op
                         000112 q                           jump_op
                         000114 s1                          jump_op
                         000116 save_p1                     jump_op
                         000120 atomic                      jump_op
                         000121 p2_atomic                   jump_op
                         000122 p3_atomic                   jump_op
                         000123 conditional                 jump_op
                         000124 is_return                   jump_op
                         000125 load_index                  jump_op
                         000126 dt                          jump_op
                         000127 i                           jump_op
                         000130 j                           jump_op
                         000131 k                           jump_op
                         000132 n                           jump_op
                         000133 macro                       jump_op
                         000134 code                        jump_op
                         000135 hard                        jump_op
                         000136 size                        jump_op
                         000137 count                       jump_op
                         000140 start                       jump_op
                         000141 finish                      jump_op
                         000150 prim                        eval_primaries
                         000152 q                           eval_primaries
                         000154 r                           eval_primaries
                         000164 atomic                      evaluate
                         000202 q                           eval_all_primaries
                         000204 vector                      eval_all_primaries
                         000206 i                           eval_all_primaries
                         000216 vector                      process_label_array
                         000220 q                           process_label_array
                         000222 i                           process_label_array
                         000223 cond                        process_label_array
                         000234 i                           label_array_save_regs
                         000236 q                           label_array_save_regs

THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM.
r_ne_as             unpk_to_pk          call_ext_out        return_mac          ext_entry

THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM.
base_man$load_var             c_a                           compile_exp$save              error
expmac                        expmac$fill_usage             expmac$zero                   m_a
need_temp                     prepare_operand               set_indicators                state_man$create_ms
state_man$discard_ms          state_man$flush               state_man$save_ms             state_man$save_regs
xr_man$load_any_var           xr_man$load_const

THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM.
cg_stat$cur_block             cg_stat$cur_level             cg_stat$cur_statement         cg_stat$jump_label
cg_stat$m_s_p                 cg_stat$optimize              cg_stat$skip_to_label         cg_stat$text_pos




   LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC   
     47 000060       136 000070       138 000073       139 000077       144 000102       146 000111       147 000117
    148 000122       150 000125       151 000132       152 000135       153 000141       154 000144       156 000145
    158 000152       160 000157       161 000175       164 000176       165 000201       166 000205       168 000212
    169 000213       171 000215       177 000221       178 000224       180 000231       181 000234       185 000241
    187 000242       195 000251       196 000253       198 000254       201 000262       209 000263       210 000302
    211 000306       213 000310       217 000311       219 000322       221 000326       226 000330       228 000332
    231 000344       234 000362       236 000366       242 000367       243 000371       244 000374       246 000376
    247 000402       248 000405       249 000407       251 000425       252 000427       253 000432       256 000434
    265 000462       267 000463       270 000466       272 000471       278 000475       279 000510       280 000513
    281 000515       288 000516       289 000522       290 000524       292 000525       296 000531       297 000533
    298 000534       303 000535       305 000537       310 000541       311 000555       312 000572       315 000573
    320 000575       322 000603       327 000604       328 000606       330 000610       332 000627       335 000644
    337 000651       338 000660       341 000661       343 000663       347 000664       350 000667       354 000673
    355 000700       356 000705       360 000710       361 000716       362 000717       366 000720       369 000723
    373 000727       374 000734       375 000741       379 000744       380 000752       381 000754       387 000755
    389 000761       390 000763       392 000766       393 000770       394 000773       395 000776       396 001001
    398 001004       400 001006       401 001010       403 001015       404 001017       405 001021       409 001022
    412 001023       414 001042       416 001044       417 001066       420 001077       422 001114       424 001130
    426 001150       428 001157       429 001161       432 001173       434 001204       436 001206       437 001221
    439 001224       443 001252       446 001265       448 001273       450 001312       452 001322       453 001323
    456 001332       458 001343       464 001346       466 001350       467 001353       468 001355       471 001356
    473 001361       474 001377       475 001413       476 001417       477 001421       478 001422       480 001427
    482 001430       484 001437       485 001443       488 001455       489 001456       491 001457       495 001460
    513 001462       515 001472       516 001475       518 001501       519 001503       523 001521       524 001522
    528 001537       544 001543       530 001544       536 001545       538 001564       542 001604       547 001605
    551 001606       555 001617       556 001621       559 001627       562 001630       570 001631       572 001635
    573 001645       575 001650       576 001653       579 001660       581 001662       584 001663       592 001664
    593 001674       595 001677       596 001707       598 001712       599 001715       601 001732       604 001742
    606 001744       609 001754       611 001755       618 001756       619 001765       620 001771       622 002007
    623 002011


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


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