COMPILATION LISTING OF SEGMENT prepare_symbol_table
	Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992
	Compiled at: CGI                             
	Compiled on: 2000-04-18_1131.65_Tue_mdt
	    Options: optimize map

        1 /* ***********************************************************
        2*   *                                                         *
        3*   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        4*   *                                                         *
        5*   * Copyright (c) 1972 by Massachusetts Institute of        *
        6*   * Technology and Honeywell Information Systems, Inc.      *
        7*   *                                                         *
        8*   *********************************************************** */
        9 
       10 
       11 /* Program to prepare symbol table by semantically translating any expressions
       12*   associated with a symbol node.
       13*
       14*   Initial Version:  1 July 1972 by BLW
       15*	Modified:	5 April 1978 by RAB to fix 1720
       16*	Modified: 23 January by DS to fix bug 1817
       17*	Modified: 7 October 1980 by M. N. Davidoff to fix bug 1971.
       18**/
       19 /* format: style3 */
       20 prepare_symbol_table:
       21      procedure (root);
       22 
       23 dcl	root		ptr;
       24 
       25 /* automatic */
       26 
       27 dcl	ev_based_var	ptr;
       28 dcl	ev_qual		ptr;
       29 dcl	ev_ref		ptr;
       30 dcl	ev_temp		ptr;
       31 dcl	s1		ptr;
       32 dcl	s2		ptr;
       33 dcl	scan_again	bit (1) aligned;
       34 
       35 /* builtin */
       36 
       37 dcl	(null, string)	builtin;
       38 
       39 /* external static */
       40 
       41 dcl	pl1_stat_$cur_statement
       42 			ptr external static;
       43 dcl	pl1_stat_$dummy_block
       44 			ptr external static;
       45 dcl	pl1_stat_$index	fixed bin external static;
       46 dcl	pl1_stat_$locator	(128) ptr external static;
       47 dcl	1 pl1_stat_$statement_id
       48 			external static,
       49 	  2 file_number	bit (8),
       50 	  2 line_number	bit (14),
       51 	  2 statement_number
       52 			bit (5);
       53 dcl	pl1_stat_$table	bit (1) aligned external static;
       54 
  1     1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */
  1     2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */
  1     3 /* format: style3,idind30 */
  1     4 
  1     5 declare	1 block			aligned based,
  1     6 	  2 node_type		bit (9) unaligned,
  1     7 	  2 source_id		structure unaligned,
  1     8 	    3 file_number		bit (8),
  1     9 	    3 line_number		bit (14),
  1    10 	    3 statement_number	bit (5),
  1    11 	  2 father		ptr unaligned,
  1    12 	  2 brother		ptr unaligned,
  1    13 	  2 son			ptr unaligned,
  1    14 	  2 declaration		ptr unaligned,
  1    15 	  2 end_declaration		ptr unaligned,
  1    16 	  2 default		ptr unaligned,
  1    17 	  2 end_default		ptr unaligned,
  1    18 	  2 context		ptr unaligned,
  1    19 	  2 prologue		ptr unaligned,
  1    20 	  2 end_prologue		ptr unaligned,
  1    21 	  2 main			ptr unaligned,
  1    22 	  2 end_main		ptr unaligned,
  1    23 	  2 return_values		ptr unaligned,
  1    24 	  2 return_count		ptr unaligned,
  1    25 	  2 plio_ps		ptr unaligned,
  1    26 	  2 plio_fa		ptr unaligned,
  1    27 	  2 plio_ffsb		ptr unaligned,
  1    28 	  2 plio_ssl		ptr unaligned,
  1    29 	  2 plio_fab2		ptr unaligned,
  1    30 	  2 block_type		bit (9) unaligned,
  1    31 	  2 prefix		bit (12) unaligned,
  1    32 	  2 like_attribute		bit (1) unaligned,
  1    33 	  2 no_stack		bit (1) unaligned,
  1    34 	  2 get_data		bit (1) unaligned,
  1    35 	  2 flush_at_call		bit (1) unaligned,
  1    36 	  2 processed		bit (1) unaligned,
  1    37 	  2 text_displayed		bit (1) unaligned,
  1    38 	  2 number		fixed bin (9) unsigned unaligned,
  1    39 	  2 free_temps		dimension (3) ptr,	/* these fields are used by the code generator */
  1    40 	  2 temp_list		ptr,
  1    41 	  2 entry_list		ptr,
  1    42 	  2 o_and_s		ptr,
  1    43 	  2 why_nonquick		aligned,
  1    44 	    3 auto_adjustable_storage bit (1) unaligned,
  1    45 	    3 returns_star_extents	bit (1) unaligned,
  1    46 	    3 stack_extended_by_args	bit (1) unaligned,
  1    47 	    3 invoked_by_format	bit (1) unaligned,
  1    48 	    3 format_statement	bit (1) unaligned,
  1    49 	    3 io_statements		bit (1) unaligned,
  1    50 	    3 assigned_to_entry_var	bit (1) unaligned,
  1    51 	    3 condition_statements	bit (1) unaligned,
  1    52 	    3 no_owner		bit (1) unaligned,
  1    53 	    3 recursive_call	bit (1) unaligned,
  1    54 	    3 options_non_quick	bit (1) unaligned,
  1    55 	    3 options_variable	bit (1) unaligned,
  1    56 	    3 never_referenced	bit (1) unaligned,
  1    57 	    3 pad_nonquick		bit (5) unaligned,
  1    58 	  2 prologue_flag		bit (1) unaligned,
  1    59 	  2 options_main		bit (1) unaligned,
  1    60 	  2 pad			bit (16) unaligned,
  1    61 	  2 number_of_entries	fixed bin (17),
  1    62 	  2 level			fixed bin (17),
  1    63 	  2 last_auto_loc		fixed bin (17),
  1    64 	  2 symbol_block		fixed bin (17),
  1    65 	  2 entry_info		fixed bin (18),
  1    66 	  2 enter			structure unaligned,
  1    67 	    3 start		fixed bin (17),
  1    68 	    3 end			fixed bin (17),
  1    69 	  2 leave			structure unaligned,
  1    70 	    3 start		fixed bin (17),
  1    71 	    3 end			fixed bin (17),
  1    72 	  2 owner			ptr;
  1    73 
  1    74 declare	max_block_number		fixed bin internal static options (constant) initial (511);
  1    75 
  1    76 /* END INCLUDE FILE ... block.incl.pl1 */
       55 
  2     1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */
  2     2 
  2     3 dcl	1 symbol			based aligned,
  2     4 	2 node_type		bit(9) unal,
  2     5 	2 source_id		structure unal,
  2     6 	  3 file_number		bit(8),
  2     7 	  3 line_number		bit(14),
  2     8 	  3 statement_number	bit(5),
  2     9 	2 location		fixed(18) unal unsigned,
  2    10 	2 allocated		bit(1) unal,
  2    11 	2 dcl_type		bit(3) unal,
  2    12 	2 reserved		bit(6) unal,
  2    13 	2 pix			unal,
  2    14 	  3 pic_fixed		bit(1) unal,
  2    15 	  3 pic_float		bit(1) unal,
  2    16 	  3 pic_char		bit(1) unal,
  2    17 	  3 pic_scale		fixed(7) unal,
  2    18 	  3 pic_size		fixed(7) unal,
  2    19 	2 level			fixed(8) unal,
  2    20 	2 boundary		fixed(3) unal,
  2    21 	2 size_units		fixed(3) unal,
  2    22 	2 scale			fixed(7) unal,
  2    23 	2 runtime			bit(18) unal,
  2    24 	2 runtime_offset		bit(18) unal,
  2    25 	2 block_node		ptr unal,
  2    26 	2 token			ptr unal,
  2    27 	2 next			ptr unal,
  2    28 	2 multi_use		ptr unal,
  2    29 	2 cross_references		ptr unal,
  2    30 	2 initial			ptr unal,
  2    31 	2 array			ptr unal,
  2    32 	2 descriptor		ptr unal,
  2    33 	2 equivalence		ptr unal,
  2    34 	2 reference		ptr unal,
  2    35 	2 general			ptr unal,
  2    36 	2 father			ptr unal,
  2    37 	2 brother			ptr unal,
  2    38 	2 son			ptr unal,
  2    39 	2 word_size		ptr unal,
  2    40 	2 bit_size		ptr unal,
  2    41 	2 dcl_size		ptr unal,
  2    42 	2 symtab_size		ptr unal,
  2    43 	2 c_word_size		fixed(24),
  2    44 	2 c_bit_size		fixed(24),
  2    45 	2 c_dcl_size		fixed(24),
  2    46 
  2    47 	2 attributes		structure aligned,
  2    48 	  3 data_type		structure unal,
  2    49 	    4 structure		bit(1) ,
  2    50 	    4 fixed		bit(1),
  2    51 	    4 float		bit(1),
  2    52 	    4 bit			bit(1),
  2    53 	    4 char		bit(1),
  2    54 	    4 ptr			bit(1),
  2    55 	    4 offset		bit(1),
  2    56 	    4 area		bit(1),
  2    57 	    4 label		bit(1),
  2    58 	    4 entry		bit(1),
  2    59 	    4 file		bit(1),
  2    60 	    4 arg_descriptor	bit(1),
  2    61 	    4 storage_block		bit(1),
  2    62 	    4 explicit_packed	bit(1), /* options(packed) */
  2    63 	    4 condition		bit(1),
  2    64 	    4 format		bit(1),
  2    65 	    4 builtin		bit(1),
  2    66 	    4 generic		bit(1),
  2    67 	    4 picture		bit(1),
  2    68 
  2    69 	  3 misc_attributes		structure unal,
  2    70 	    4 dimensioned		bit(1),
  2    71 	    4 initialed		bit(1),
  2    72 	    4 aligned		bit(1),
  2    73 	    4 unaligned		bit(1),
  2    74 	    4 signed		bit(1),
  2    75 	    4 unsigned		bit(1),
  2    76 	    4 precision		bit(1),
  2    77 	    4 varying		bit(1),
  2    78 	    4 local		bit(1),
  2    79 	    4 decimal		bit(1),
  2    80 	    4 binary		bit(1),
  2    81 	    4 real		bit(1),
  2    82 	    4 complex		bit(1),
  2    83 	    4 variable		bit(1),
  2    84 	    4 reducible		bit(1),
  2    85 	    4 irreducible		bit(1),
  2    86 	    4 returns		bit(1),
  2    87 	    4 position		bit(1),
  2    88 	    4 internal		bit(1),
  2    89 	    4 external		bit(1),
  2    90 	    4 like		bit(1),
  2    91 	    4 member		bit(1),
  2    92 	    4 non_varying		bit(1),
  2    93 	    4 options		bit(1),
  2    94 	    4 variable_arg_list 	bit(1),		/* options(variable) */
  2    95 	    4 alloc_in_text		bit(1),		/* options(constant) */
  2    96 
  2    97 	  3 storage_class		structure unal,
  2    98 	    4 auto		bit(1),
  2    99 	    4 based		bit(1),
  2   100 	    4 static		bit(1),
  2   101 	    4 controlled		bit(1),
  2   102 	    4 defined		bit(1),
  2   103 	    4 parameter		bit(1),
  2   104 	    4 param_desc		bit(1),
  2   105 	    4 constant		bit(1),
  2   106 	    4 temporary		bit(1),
  2   107 	    4 return_value		bit(1),
  2   108 
  2   109 	  3 file_attributes		structure unal,
  2   110 	    4 print		bit(1),
  2   111 	    4 input		bit(1),
  2   112 	    4 output		bit(1),
  2   113 	    4 update		bit(1),
  2   114 	    4 stream		bit(1),
  2   115 	    4 reserved_1		bit(1),
  2   116 	    4 record		bit(1),
  2   117 	    4 sequential		bit(1),
  2   118 	    4 direct		bit(1),
  2   119 	    4 interactive		bit(1),		/* env(interactive) */
  2   120 	    4 reserved_2		bit(1),
  2   121 	    4 reserved_3		bit(1),
  2   122 	    4 stringvalue		bit(1),		/* env(stringvalue) */
  2   123 	    4 keyed		bit(1),
  2   124 	    4 reserved_4		bit(1),
  2   125 	    4 environment		bit(1),
  2   126 
  2   127 	  3 compiler_developed	structure unal,
  2   128 	    4 aliasable		bit(1),
  2   129 	    4 packed		bit(1),
  2   130 	    4 passed_as_arg		bit(1),
  2   131 	    4 allocate		bit(1),
  2   132 	    4 set			bit(1),
  2   133 	    4 exp_extents		bit(1),
  2   134 	    4 refer_extents		bit(1),
  2   135 	    4 star_extents		bit(1),
  2   136 	    4 isub		bit(1),
  2   137 	    4 put_in_symtab		bit(1),
  2   138 	    4 contiguous		bit(1),
  2   139 	    4 put_data		bit(1),
  2   140 	    4 overlayed		bit(1),
  2   141 	    4 error		bit(1),
  2   142 	    4 symtab_processed	bit(1),
  2   143 	    4 overlayed_by_builtin	bit(1),
  2   144 	    4 defaulted		bit(1),
  2   145 	    4 connected		bit(1);
  2   146 
  2   147 /* END INCLUDE FILE ... symbol.incl.pl1 */
       56 
  3     1 dcl	1 array			based aligned,
  3     2 	2 node_type		bit(9) unaligned,
  3     3 	2 reserved		bit(34) unaligned,
  3     4 	2 number_of_dimensions	fixed(7) unaligned,
  3     5 	2 own_number_of_dimensions	fixed(7) unaligned,
  3     6 	2 element_boundary		fixed(3) unaligned,
  3     7 	2 size_units		fixed(3) unaligned,
  3     8 	2 offset_units		fixed(3) unaligned,
  3     9 	2 interleaved		bit(1) unaligned,
  3    10 	2 c_element_size		fixed(24),
  3    11 	2 c_element_size_bits	fixed(24),
  3    12 	2 c_virtual_origin		fixed(24),
  3    13 	2 element_size		ptr unaligned,
  3    14 	2 element_size_bits		ptr unaligned,
  3    15 	2 virtual_origin		ptr unaligned,
  3    16 	2 symtab_virtual_origin	ptr unaligned,
  3    17 	2 symtab_element_size	ptr unaligned,
  3    18 	2 bounds			ptr unaligned,
  3    19 	2 element_descriptor	ptr unaligned;
  3    20 
  3    21 dcl	1 bound			based aligned,
  3    22 	2 node_type		bit(9),
  3    23 	2 c_lower			fixed(24),
  3    24 	2 c_upper			fixed(24),
  3    25 	2 c_multiplier		fixed(24),
  3    26 	2 c_desc_multiplier		fixed(24),
  3    27 	2 lower			ptr unaligned,
  3    28 	2 upper			ptr unaligned,
  3    29 	2 multiplier		ptr unaligned,
  3    30 	2 desc_multiplier		ptr unaligned,
  3    31 	2 symtab_lower		ptr unaligned,
  3    32 	2 symtab_upper		ptr unaligned,
  3    33 	2 symtab_multiplier		ptr unaligned,
  3    34 	2 next			ptr unaligned;
       57 
  4     1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */
  4     2 
  4     3 dcl	1 reference		based aligned,
  4     4 	2 node_type		bit(9) unaligned,
  4     5 	2 array_ref		bit(1) unaligned,
  4     6 	2 varying_ref		bit(1) unaligned,
  4     7 	2 shared			bit(1) unaligned,
  4     8 	2 put_data_sw		bit(1) unaligned,
  4     9 	2 processed		bit(1) unaligned,
  4    10 	2 units			fixed(3) unaligned,
  4    11 	2 ref_count		fixed(17) unaligned,
  4    12 	2 c_offset		fixed(24),
  4    13 	2 c_length		fixed(24),
  4    14 	2 symbol			ptr unaligned,
  4    15 	2 qualifier		ptr unaligned,
  4    16 	2 offset			ptr unaligned,
  4    17 	2 length			ptr unaligned,
  4    18 	2 subscript_list		ptr unaligned,
  4    19 						/* these fields are used by the 645 code generator */
  4    20 	2 address			structure unaligned,
  4    21 	  3 base			bit(3),
  4    22 	  3 offset		bit(15),
  4    23 	  3 op			bit(9),
  4    24 	  3 no_address		bit(1),
  4    25 	  3 inhibit		bit(1),
  4    26 	  3 ext_base		bit(1),
  4    27 	  3 tag			bit(6),
  4    28 	2 info			structure unaligned,
  4    29 	  3 address_in		structure,
  4    30 	    4 b			dimension(0:7) bit(1),
  4    31 	    4 storage		bit(1),
  4    32 	  3 value_in		structure,
  4    33 	    4 a			bit(1),
  4    34 	    4 q			bit(1),
  4    35 	    4 aq			bit(1),
  4    36 	    4 string_aq		bit(1),
  4    37 	    4 complex_aq		bit(1),
  4    38 	    4 decimal_aq		bit(1),
  4    39 	    4 b			dimension(0:7) bit(1),
  4    40 	    4 storage		bit(1),
  4    41 	    4 indicators		bit(1),
  4    42 	    4 x			dimension(0:7) bit(1),
  4    43 	  3 other			structure,
  4    44 	    4 big_offset		bit(1),
  4    45 	    4 big_length		bit(1),
  4    46 	    4 modword_in_offset	bit(1),
  4    47 	2 data_type		fixed(5) unaligned,
  4    48 	2 bits			structure unaligned,
  4    49 	  3 padded_ref		bit(1),
  4    50 	  3 aligned_ref		bit(1),
  4    51 	  3 long_ref		bit(1),
  4    52 	  3 forward_ref		bit(1),
  4    53 	  3 ic_ref		bit(1),
  4    54 	  3 temp_ref		bit(1),
  4    55 	  3 defined_ref		bit(1),
  4    56 	  3 evaluated		bit(1),
  4    57 	  3 allocate		bit(1),
  4    58 	  3 allocated		bit(1),
  4    59 	  3 aliasable		bit(1),
  4    60 	  3 even			bit(1),
  4    61 	  3 perm_address		bit(1),
  4    62 	  3 aggregate		bit(1),
  4    63 	  3 hit_zero		bit(1),
  4    64 	  3 dont_save		bit(1),
  4    65 	  3 fo_in_qual		bit(1),
  4    66 	  3 hard_to_load		bit(1),
  4    67 	2 relocation		bit(12) unaligned,
  4    68 	2 more_bits		structure unaligned,
  4    69 	  3 substr		bit(1),
  4    70 	  3 padded_for_store_ref	bit(1),
  4    71 	  3 aligned_for_store_ref	bit(1),
  4    72 	  3 mbz			bit(15),
  4    73 	2 store_ins		bit(18) unaligned;
  4    74 
  4    75 /* END INCLUDE FILE ... reference.incl.pl1 */
       58 
  5     1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */
  5     2 
  5     3 /*	Modified: 2 Apr 1980 by PCK to add max_number_of_operands */
  5     4 
  5     5 /* format: style3 */
  5     6 dcl	1 operator	based aligned,
  5     7 	  2 node_type	bit (9) unaligned,
  5     8 	  2 op_code	bit (9) unaligned,
  5     9 	  2 shared	bit (1) unaligned,
  5    10 	  2 processed	bit (1) unaligned,
  5    11 	  2 optimized	bit (1) unaligned,
  5    12 	  2 number	fixed (14) unaligned,
  5    13 	  2 operand	dimension (n refer (operator.number)) ptr unaligned;
  5    14 
  5    15 dcl	max_number_of_operands
  5    16 			fixed bin (15) int static options (constant) initial (32767);
  5    17 
  5    18 /* END INCLUDE FILE ... operator.incl.pl1 */
       59 
  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 */
       60 
  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 */
       61 
  8     1 dcl (	root_block		initial("000000001"b),
  8     2 	external_procedure		initial("000000010"b),
  8     3 	internal_procedure		initial("000000011"b),
  8     4 	begin_block		initial("000000100"b),
  8     5 	on_unit			initial("000000101"b))  internal static bit(9) aligned options(constant);
       62 
  9     1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */
  9     2 
  9     3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */
  9     4 
  9     5 dcl  (	by_declare	initial("001"b),
  9     6 	by_explicit_context initial("010"b),
  9     7 	by_context	initial("011"b),
  9     8 	by_implication	initial("100"b),
  9     9 	by_compiler	initial("101"b)) int static bit(3) aligned options(constant);
  9    10 
  9    11 /* END INCLUDE FILE ... declare_type.incl.pl1 */
       63 
 10     1 	/* statement types */
 10     2 
 10     3 dcl (	unknown_statement		initial("000000000"b),
 10     4 	allocate_statement		initial("000000001"b),
 10     5 	assignment_statement	initial("000000010"b),
 10     6 	begin_statement		initial("000000011"b),
 10     7 	call_statement		initial("000000100"b),
 10     8 	close_statement		initial("000000101"b),
 10     9 	declare_statement		initial("000000110"b),
 10    10 	lock_statement		initial("000000111"b),
 10    11 	delete_statement		initial("000001000"b),
 10    12 	display_statement		initial("000001001"b),
 10    13 	do_statement		initial("000001010"b),
 10    14 	else_clause		initial("000001011"b),
 10    15 	end_statement		initial("000001100"b),
 10    16 	entry_statement		initial("000001101"b),
 10    17 	exit_statement		initial("000001110"b),
 10    18 	format_statement		initial("000001111"b),
 10    19 	free_statement		initial("000010000"b),
 10    20 	get_statement		initial("000010001"b),
 10    21 	goto_statement		initial("000010010"b),
 10    22 	if_statement		initial("000010011"b),
 10    23 	locate_statement		initial("000010100"b),
 10    24 	null_statement		initial("000010101"b),
 10    25 	on_statement		initial("000010110"b),
 10    26 	open_statement		initial("000010111"b),
 10    27 	procedure_statement 	initial("000011000"b),
 10    28 	put_statement		initial("000011001"b),
 10    29 	read_statement		initial("000011010"b),
 10    30 	return_statement		initial("000011011"b),
 10    31 	revert_statement		initial("000011100"b),
 10    32 	rewrite_statement		initial("000011101"b),
 10    33 	signal_statement		initial("000011110"b),
 10    34 	stop_statement		initial("000011111"b),
 10    35 	system_on_unit		initial("000100000"b),
 10    36 	unlock_statement		initial("000100001"b),
 10    37 	wait_statement		initial("000100010"b),
 10    38 	write_statement		initial("000100011"b),
 10    39 	default_statement		initial("000100100"b),
 10    40 	continue_statement		initial("000100101"b)) bit(9) internal static aligned options(constant);
       64 
 11     1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */
 11     2 
 11     3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */
 11     4 /* Modified: 6 Jun 1979 by PG to add rank and byte */
 11     5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */
 11     6 /* Modified: 26 July 82 BIM wordno, segno */
 11     7 
 11     8 dcl (	add		initial("000010001"b),	/* opnd(1) <- opnd(2)+opnd(3)		*/
 11     9 	sub		initial("000010010"b),	/* opnd(1) <- opnd(2)-opnd(3)		*/
 11    10 	mult		initial("000010011"b),	/* opnd(1) <- opnd(2)*opnd(3)		*/
 11    11 	div		initial("000010100"b),	/* opnd(1) <- opnd(2)/opnd(3)		*/
 11    12 	negate		initial("000010101"b),	/* opnd(1) <- -opnd(2)  		*/
 11    13 	exp		initial("000010110"b),	/* opnd(1) <- opnd(2) ** opnd(3)	*/
 11    14 
 11    15 	and_bits		initial("000100001"b),	/* opnd(1) <- opnd(2) & opnd(3)	*/
 11    16 	or_bits		initial("000100010"b),	/* opnd(1) <- opnd(2)|opnd(3)		*/
 11    17 	xor_bits		initial("000100011"b),	/* opnd(1) <- opnd(2) xor opnd(3)	*/
 11    18 	not_bits		initial("000100100"b),	/* opnd(1) <- ^opnd(2)		*/
 11    19 	cat_string	initial("000100101"b),	/* opnd(1) <- opnd(2)||opnd(3)	*/
 11    20 	bool_fun		initial("000100110"b),	/* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */
 11    21 
 11    22 	assign		initial("000110001"b),	/* opnd(1) <- opnd(2)		*/
 11    23 	assign_size_ck	initial("000110010"b),	/* opnd(1) <- opnd(2)		*/
 11    24 	assign_zero	initial("000110011"b),	/* opnd(1) <- 0			*/
 11    25 	copy_words	initial("000110100"b),	/* move opnd(2) to opnd(1) by opnd(3) words */
 11    26 	copy_string	initial("000110101"b),	/* move opnd(2) to opnd(1) by opnd(3) units */
 11    27 	make_desc		initial("000110110"b),	/* opnd(1) <- descriptor(opnd(2),opnd(3)) */
 11    28 	assign_round	initial("000110111"b),	/* opnd(1) <- opnd(2) rounded		*/
 11    29 	pack		initial("000111000"b),	/* opnd(1) <- encode to picture opnd(2) */
 11    30 	unpack		initial("000111001"b),	/* opnd(1) <- decode from picture opnd(2) */
 11    31 
 11    32 	less_than		initial("001000100"b),	/* opnd(1) <- opnd(2) < opnd(3)	*/
 11    33 	greater_than	initial("001000101"b),	/* opnd(1) <- opnd(2) > opnd(3)	*/
 11    34 	equal		initial("001000110"b),	/* opnd(1) <- opnd(2) = opnd(3)	*/
 11    35 	not_equal		initial("001000111"b),	/* opnd(1) <- opnd(2) ^= opnd(3)	*/
 11    36 	less_or_equal	initial("001001000"b),	/* opnd(1) <- opnd(2) <= opnd(3)	*/
 11    37 	greater_or_equal	initial("001001001"b),	/* opnd(1) <- opnd(2) >= opnd(3)	*/
 11    38 
 11    39 	jump		initial("001010001"b),	/* go to opnd(1) unconditionally	*/
 11    40 	jump_true		initial("001010010"b),	/* go to opnd(1) if opnd(2) is not 0	*/
 11    41 	jump_false	initial("001010011"b),	/* go to opnd(1) if opnd(2) is all 0	*/
 11    42 	jump_if_lt	initial("001010100"b),	/* go to opnd(1) if opnd(2) < opnd(3)	*/
 11    43 	jump_if_gt	initial("001010101"b),	/* go to opnd(1) if opnd(2) > opnd(3)	*/
 11    44 	jump_if_eq	initial("001010110"b),	/* go to opnd(1) if opnd(2) = opnd(3)	*/
 11    45 	jump_if_ne	initial("001010111"b),	/* go to opnd(1) if opnd(2) ^= opnd(3)	*/
 11    46 	jump_if_le	initial("001011000"b),	/* go to opnd(1) if opnd(2) <= opnd(3)	*/
 11    47 	jump_if_ge	initial("001011001"b),	/* go to opnd(1) if opnd(2) >= opnd(3)	*/
 11    48 
 11    49 	std_arg_list	initial("001100001"b),	/* opnd(1) <- arglist(opnd(2) desclist(opnd(3)))	*/
 11    50 	return_words	initial("001100010"b),	/* return aggregate opnd(1), opnd(2) is length in words */
 11    51 	std_call		initial("001100011"b),	/* opnd(1) <- call opnd(2) with opnd(3)		*/
 11    52 	return_bits	initial("001100100"b),	/* return aggregate opnd(1), opnd(2) is length in bits */
 11    53 	std_entry		initial("001100101"b),	/* entry(opnd(1)... opnd(n))			*/
 11    54 	return_string	initial("001100110"b),	/* return string opnd(1) */
 11    55 	ex_prologue	initial("001100111"b),	/* execute the prologue -no operands-		*/
 11    56 	allot_auto	initial("001101000"b),	/* opnd(1) <- addrel(stack,opnd(2))		*/
 11    57 	param_ptr		initial("001101001"b),	/* opnd(1) <- ptr to opnd(2) in  block opnd(3)	*/
 11    58 	param_desc_ptr	initial("001101010"b),	/* opnd(1) <- ptr to opnd(2) in block opnd(3)	*/
 11    59 	std_return	initial("001101011"b),	/* return -no arguments-			*/
 11    60 	allot_ctl		initial("001101100"b),	/* allocate opnd(1) , length in words is opnd(2) 	*/
 11    61 	free_ctl		initial("001101101"b),	/* free opnd(1)				*/
 11    62 	stop		initial("001101110"b),	/* stop - terminate run unit			*/
 11    63 
 11    64 	mod_bit		initial("001110000"b),	/* opnd(1) <- mod(opnd(3),36),
 11    65*						   opnd(2) <- opnd(3) / 36		*/
 11    66 	mod_byte		initial("001110001"b),	/* opnd(1) <- mod(opnd(3),4),
 11    67*						   opnd(2) <- opnd(3) / 4		*/
 11    68 	mod_half		initial("001110010"b),	/* opnd(1) <- mod(opnd(3),2),
 11    69*						   opnd(2) <- opnd(3) / 2		*/
 11    70 	mod_word		initial("001110011"b),	/* TO BE DEFINED BY BLW			*/
 11    71 
 11    72 	bit_to_char	initial("010000000"b),	/* opnd(1) <- (opnd(2)+8)/9		*/
 11    73 	bit_to_word	initial("010000001"b),	/* opnd(1) <- (opnd(2)+35)/36		*/
 11    74 	char_to_word	initial("010000010"b),	/* opnd(1) <- (opnd(2)+3)/4		*/
 11    75 	half_to_word	initial("010000011"b),	/* opnd(1) <- (opnd(2)+1)/2		*/
 11    76 	word_to_mod2	initial("010000100"b),	/* opnd(1) <- (opnd(2)+1)/2*2		*/
 11    77 	word_to_mod4	initial("010000101"b),	/* opnd(1) <- (opnd(2)+3)/4*4		*/
 11    78 	word_to_mod8	initial("010000110"b),	/* opnd(1) <- (opnd(2)+7)/8*8		*/
 11    79 	rel_fun		initial("010000111"b),	/* opnd(1) <- rel(opnd(2))		*/
 11    80 	baseno_fun	initial("010001000"b),	/* opnd(1) <- baseno(opnd(2))		*/
 11    81 	desc_size		initial("010001001"b),	/* opnd(1) <- substr(opnd(2),13,24)	*/
 11    82 	bit_pointer	initial("010001010"b),	/* opnd(1) <- bit offset of opnd(2)	*/
 11    83 	index_before_fun	initial("010001011"b),	/* opnd(1) <- length of before(opnd(2),opnd(3)) */
 11    84 	index_after_fun	initial("010001100"b),	/* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */
 11    85 	verify_ltrim_fun	initial("010001101"b),	/* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */
 11    86 	verify_rtrim_fun	initial("010001110"b),	/* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */
 11    87 	digit_to_bit	initial("010001111"b),	/* opnd(1) <- 9*opnd(2)/2		*/
 11    88 
 11    89 	ceil_fun		initial("010010000"b),	/* opnd(1) <- ceil(opnd(2))		*/
 11    90 	floor_fun		initial("010010001"b),	/* opnd(1) <- floor(opnd(2))		*/
 11    91 	round_fun		initial("010010010"b),	/* opnd(1) <- round(opnd(2))		*/
 11    92 	sign_fun		initial("010010011"b),	/* opnd(1) <- sign(opnd(2))		*/
 11    93 	abs_fun		initial("010010100"b),	/* opnd(1) <- abs(opnd(2))		*/
 11    94 	trunc_fun		initial("010010101"b),	/* opnd(1) <- trunc(opnd(2))		*/
 11    95 	byte_fun		initial("010010110"b),	/* opnd(1) <- byte(opnd(2))		*/
 11    96 	rank_fun		initial("010010111"b),	/* opnd(1) <- rank(opnd(2))		*/
 11    97 	index_rev_fun	initial("010011000"b),	/* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */
 11    98 	search_rev_fun	initial("010011001"b),	/* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */
 11    99 	verify_rev_fun	initial("010011010"b),	/* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */
 11   100 	wordno_fun	initial("010011011"b),        /* opnd(1) <- wordno (opnd(2)) */
 11   101 	segno_fun		initial("010011100"b),        /* opnd(1) <- segno (opnd(2)) */
 11   102 	bitno_fun           initial("010011101"b),        /* opnd(1) <- bitno (opnd(2)) */
 11   103 	charno_fun	initial("010011110"b),        /* opnd(1) <- charno (opnd(2)) */
 11   104 
 11   105 	index_fun		initial("010100000"b),	/* opnd(1) <- index(opnd(2),opnd(3))	*/
 11   106 	off_fun		initial("010100001"b),	/* opnd(1) <- offset(opnd(2),opnd(3))	*/
 11   107 	complex_fun	initial("010100010"b),	/* opnd(1) <- complex(opnd(2),opnd(3))	*/
 11   108 	conjg_fun		initial("010100011"b),	/* opnd(1) <- conjg(opnd(2),opnd(3))	*/
 11   109 	mod_fun		initial("010100100"b),	/* opnd(1) <- mod(opnd(2),opnd(3))	*/
 11   110 	repeat_fun	initial("010100101"b),	/* opnd(1) <- repeat(opnd(2),opnd(3))	*/
 11   111 	verify_fun	initial("010100110"b),	/* opnd(1) <- verify(opnd(2),opnd(3))	*/
 11   112 	translate_fun	initial("010100111"b),	/* opnd(1) <- translate(opnd(2),opnd(3))*/
 11   113 	real_fun   	initial("010101001"b),	/* opnd(1) <- real(opnd(2))		*/
 11   114 	imag_fun   	initial("010101010"b),	/* opnd(1) <- imag(opnd(2))		*/
 11   115 	length_fun	initial("010101011"b),	/* opnd(1) <- length(opnd(2))	*/
 11   116 	pl1_mod_fun	initial("010101100"b),	/* opnd(1) <- mod(opnd(2)) */
 11   117 	search_fun	initial("010101101"b),	/* opnd(1) <- search(opnd(2),opnd(3)) */
 11   118 	allocation_fun	initial("010101110"b),	/* opnd(1) <- allocation(opnd(2)) */
 11   119 	reverse_fun	initial("010101111"b),	/* opnd(1) <- reverse(opnd(2)) */
 11   120 
 11   121 	addr_fun		initial("010110000"b),	/* opnd(1) <- addr(opnd(2))		*/
 11   122 	addr_fun_bits	initial("010110001"b),	/* opnd(1) <- addr(opnd(2))		*/
 11   123 	ptr_fun		initial("010110010"b),	/* opnd(1) <- ptr(opnd(2),opnd(3))	*/
 11   124 	baseptr_fun	initial("010110011"b),	/* opnd(1) <- baseptr(opnd(2))	*/
 11   125 	addrel_fun	initial("010110100"b),	/* opnd(1) <- addrel(opnd(2),opnd(3))	*/
 11   126 	codeptr_fun	initial("010110101"b),	/* opnd(1) <- codeptr(opnd(2))	*/
 11   127 	environmentptr_fun	initial("010110110"b),	/* opnd(1) <- environmentptr(opnd(2))	*/
 11   128 	stackbaseptr_fun	initial("010110111"b),	/* opnd(1) is ptr to base of current stack	*/
 11   129 	stackframeptr_fun	initial("010111000"b),	/* opnd(1) is ptr to current block's stack frame	*/
 11   130 	setcharno_fun	initial("010111001"b),	/* opnd(1) <- opnd(2) with charno opnd(3) */
 11   131 	addcharno_fun	initial("010111010"b),	/* opnd(1) <- opnd(2) with charno = charno + opnd(3) */
 11   132 	setbitno_fun	initial("010111011"b),	/* setcharno for bitsno */
 11   133 	addbitno_fun	initial("010111100"b),	/* addcharno for bitno */
 11   134 
 11   135 	min_fun		initial("011000000"b),	/* opnd(1) <- min(opnd(1),opnd(2),...)	*/
 11   136 	max_fun		initial("011000001"b),	/* opnd(1) <- max(opnd(1),opnd(2),...)	*/
 11   137 
 11   138 	stack_ptr		initial("011010001"b),	/* opnd(1) <- stack frame ptr		*/
 11   139 	empty_area	initial("011010010"b),	/* empty opnd(1), length in words is opnd(2) */
 11   140 	enable_on		initial("011010100"b),	/* opnd(1) is the cond name
 11   141*						   opnd(2) is the file name
 11   142*						   opnd(3) is the block	*/
 11   143 	revert_on		initial("011010101"b),	/* opnd(1) is the cond name,
 11   144*						   opnd(2) is the file name	*/
 11   145 	signal_on		initial("011010110"b),	/* opnd(1) is the cond name
 11   146*						   opnd(2) is the file name */
 11   147 
 11   148 	lock_fun		initial("011010111"b),	/* opnd(1) <- stac(opnd(2),opnd(3))	*/
 11   149 	stacq_fun		initial("011011000"b),	/* opnd(1) is result, opnd(2) is ptr to lock word,
 11   150*						   opnd(3) is old value, (4) is new value. */
 11   151 	clock_fun		initial("011011001"b),	/* opnd(1) is the clock time		*/
 11   152 	vclock_fun	initial("011011010"b),	/* opnd(1) is the virtual clock time	*/
 11   153 
 11   154 	bound_ck		initial("011100000"b),	/* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */
 11   155 	range_ck		initial("011100001"b),	/* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */
 11   156 	loop		initial("011100010"b),	/* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1,
 11   157*						   opnd(5) is the list */
 11   158 	join		initial("011100011"b),	/* do opnd(1), opnd(2) ... opnd(n)	*/
 11   159 	allot_based	initial("011100100"b),	/* allocate opnd(2) words in opnd(3), set opnd(1) */
 11   160 	free_based	initial("011100101"b),	/* free opnd(1) in opnd(3), length is opnd(2) words */
 11   161 
 11   162 	r_parn		initial("011110001"b),	/* format op code			*/
 11   163 	l_parn		initial("011110010"b),
 11   164 	r_format		initial("011110011"b),
 11   165 	c_format		initial("011110100"b),
 11   166 	f_format		initial("011110101"b),
 11   167 	e_format		initial("011110110"b),
 11   168 	b_format		initial("011110111"b),
 11   169 	a_format		initial("011111000"b),
 11   170 	x_format		initial("011111001"b),
 11   171 	skip_format	initial("011111010"b),
 11   172 	column_format	initial("011111011"b),
 11   173 	page_format	initial("011111100"b),
 11   174 	line_format	initial("011111101"b),
 11   175 	picture_format	initial("011111110"b),
 11   176 	bn_format		initial("011111111"b),	/* bit format, length(opnd(2)), radix factor(opnd(3)) */
 11   177 
 11   178 	get_list_trans	initial("100000000"b),	/* getlist(opnd(2) with desc(opnd(1)))	*/
 11   179 	get_edit_trans	initial("100000001"b),	/* getedit(opnd(2) with desc(opnd(1)))	*/
 11   180 	get_data_trans	initial("100000010"b),	/* getdata(opnd(1) to opnd(n))	*/
 11   181 	put_list_trans	initial("100000011"b),	/* putlist(opnd(2) with desc(opnd(1)))	*/
 11   182 	put_edit_trans	initial("100000100"b),	/* putedit(opnd(2) with desc(opnd(1)))	*/
 11   183 	put_data_trans	initial("100000101"b),	/* putdata(opnd(2)) with subscript-list opnd(1) */
 11   184 	terminate_trans	initial("100000110"b),	/* terminate stream transmission	*/
 11   185 	stream_prep	initial("100000111"b),	/* initiate stream transmission	*/
 11   186 	record_io		initial("100001000"b),	/* perform record io operation	*/
 11   187 	fortran_read	initial("100001001"b),	/* A complete read statement		*/
 11   188 	fortran_write	initial("100001010"b),	/* A complete write statement		*/
 11   189 	ftn_file_manip	initial("100001011"b),	/* endfile,backspace,rewind,etc.	*/
 11   190 	ftn_trans_loop	initial("100001100"b),	/* An implied do in i/o list		*/
 11   191 	put_control	initial("100001101"b),	/* put control opnd(1) opnd(2) times	*/
 11   192 	put_field		initial("100001110"b),	/* putlist(opnd(2)) of length(opnd(1))	*/
 11   193 	put_field_chk	initial("100001111"b),	/* putlist(op(2)) of len(op(1)) check char index(op(3)) */
 11   194 
 11   195 /* These operators are produced by the parse but are not used as input to the code generator.	*/
 11   196 /* They are processed by the semantic translator.						*/
 11   197 
 11   198 	return_value	initial("100010010"b),	/* return(opnd(1))			*/
 11   199 	allot_var		initial("100010011"b),	/* allot opnd(1) in opnd(2)		*/
 11   200 	free_var		initial("100010100"b),	/* free opnd(1) out of opnd(2)	*/
 11   201 	get_file		initial("100010101"b),	/* opnd(1) is filename,opnd(2) is copy	*/
 11   202 						/* opnd(3) is skip, opnd(4) is list	*/
 11   203 	get_string	initial("100010110"b),	/* opnd(1) is string,opnd(2) is list	*/
 11   204 	put_file		initial("100010111"b),	/* opnd(1) is filename,opnd(2) is page	*/
 11   205 						/* opnd(3) is skip,opnd(4) is line	*/
 11   206 	put_string	initial("100011000"b),	/* opnd(1) is string,opnd(2) is list	*/
 11   207 	open_file		initial("100011001"b),
 11   208 	close_file	initial("100011010"b),
 11   209 	read_file		initial("100011011"b),
 11   210 	write_file	initial("100011100"b),
 11   211 	locate_file	initial("100011101"b),
 11   212 	do_fun		initial("100011110"b),	/* opnd(1) is join of a list		*/
 11   213 						/* opnd(2) is control variable ref	*/
 11   214 						/* opnd(3) is specification operator	*/
 11   215 	do_spec		initial("100011111"b),	/* opnd(1) to opnd(2) by opnd(3) 	*/
 11   216 						/* repeat opnd(4) while opnd(5)	*/
 11   217 						/* opnd(6) is next specification	*/
 11   218 
 11   219 	rewrite_file	initial("100100000"b),
 11   220 	delete_file	initial("100100001"b),
 11   221 	unlock_file	initial("100100010"b),
 11   222 	lock_file		initial("100100011"b),
 11   223 	refer		initial("100100101"b),	/* opnd(1) refer(opnd(2))		*/
 11   224 	prefix_plus	initial("100100110"b),	/* opnd(1) <- +opnd(2)		*/
 11   225 	nop		initial("100100111"b),	/* no-op */
 11   226 	assign_by_name	initial("100101000"b),	/* opnd(1) <- opnd(2),by name		*/
 11   227 
 11   228 /* These operators are produced by the semantic translator in processing the math
 11   229*   builtin functions and are used as input to the code generator			*/
 11   230 
 11   231 	sqrt_fun		initial("100110000"b),	/* opnd(1) <- sqrt(opnd(2))	*/
 11   232 	sin_fun		initial("100110001"b),	/* opnd(1) <- sin(opnd(2))	*/
 11   233 	sind_fun		initial("100110010"b),	/* opnd(1) <- sind(opnd(2))	*/
 11   234 	cos_fun		initial("100110011"b),	/* opnd(1) <- cos(opnd(2))	*/
 11   235 	cosd_fun		initial("100110100"b),	/* opnd(1) <- cosd(opnd(2))	*/
 11   236 	tan_fun		initial("100110101"b),	/* opnd(1) <- tan(opnd(2))	*/
 11   237 	tand_fun		initial("100110110"b),	/* opnd(1) <- tand(opnd(2))	*/
 11   238 	asin_fun		initial("100110111"b),	/* opnd(1) <- asin(opnd(2))	*/
 11   239 	asind_fun		initial("100111000"b),	/* opnd(1) <- asind(opnd(2))	*/
 11   240 	acos_fun		initial("100111001"b),	/* opnd(1) <- acos(opnd(2))	*/
 11   241 	acosd_fun		initial("100111010"b),	/* opnd(1) <- acosd(opnd(2))	*/
 11   242 	atan_fun		initial("100111011"b),	/* opnd(1) <- atan(opnd(2)[,opnd(3)])	*/
 11   243 	atand_fun		initial("100111100"b),	/* opnd(1) <- atand(opnd(2)[,opnd(3)])	*/
 11   244 	log2_fun		initial("100111101"b),	/* opnd(1) <- log2(opnd(2))	*/
 11   245 	log_fun		initial("100111110"b),	/* opnd(1) <- log(opnd(2))	*/
 11   246 	log10_fun		initial("100111111"b),	/* opnd(1) <- log10(opnd(2))	*/
 11   247 
 11   248 	exp_fun		initial("101000000"b))	/* opnd(1) <- exp(opnd(2))	*/
 11   249 
 11   250 			bit(9) aligned internal static options(constant);
 11   251 
 11   252 /* END INCLUDE FILE ... op_codes.incl.pl1 */
       65 
 12     1 /* BEGIN INCLUDE FILE ... system.incl.pl1 */
 12     2 
 12     3 /* Modified: 25 Apr 1979 by PCK to implemnt 4-bit decimal */
 12     4 
 12     5 dcl (	max_p_flt_bin_1			initial(27),
 12     6 	max_p_flt_bin_2			initial(63),
 12     7 	max_p_fix_bin_1			initial(35),
 12     8 	max_p_fix_bin_2			initial(71),
 12     9 
 12    10 	max_p_dec				initial(59),
 12    11 	max_p_bin_or_dec			initial (71),	/* max (max_p_fix_bin_2, max_p_dec) */
 12    12 
 12    13 	min_scale				initial(-128),
 12    14 	max_scale				initial(+127),
 12    15 	max_bit_string			initial(9437184),
 12    16 	max_char_string			initial(1048576),
 12    17 	max_area_size			initial(262144),
 12    18 	min_area_size			initial(28),
 12    19 
 12    20 	max_bit_string_constant		initial (253),	/* max length of bit literals */
 12    21 	max_char_string_constant		initial (254),	/* max length of character literals */
 12    22 	max_identifier_length		initial (256),
 12    23 	max_number_of_dimensions		initial (127),
 12    24 
 12    25 	max_length_precision		initial(24),
 12    26 	max_offset_precision		initial(24),	/* 18 bits for word offset + 6 bits for bit offset */
 12    27 
 12    28 	max_words_per_variable		initial (262144),
 12    29 
 12    30 	bits_per_word			initial(36),
 12    31 	bits_per_double			initial(72),
 12    32 	packed_digits_per_character		initial(2),
 12    33 	characters_per_half			initial(2),
 12    34 	characters_per_word			initial(4),
 12    35 	characters_per_double		initial(8),
 12    36 
 12    37 	bits_per_character			initial(9),
 12    38 	bits_per_half			initial(18),
 12    39 	bits_per_decimal_digit		initial(9),
 12    40 	bits_per_binary_exponent		initial(8),
 12    41 	bits_per_packed_ptr			initial(36),
 12    42 	words_per_packed_pointer		initial(1),
 12    43 
 12    44 	words_per_fix_bin_1			initial(1),
 12    45 	words_per_fix_bin_2			initial(2),
 12    46 	words_per_flt_bin_1			initial(1),
 12    47 	words_per_flt_bin_2			initial(2),
 12    48 	words_per_varying_string_header	initial(1),
 12    49 	words_per_offset			initial(1),
 12    50 	words_per_pointer			initial(2),
 12    51 	words_per_label_var			initial(4),
 12    52 	words_per_entry_var			initial(4),
 12    53 	words_per_file_var			initial(4),
 12    54 	words_per_format			initial(4),
 12    55 	words_per_condition_var		initial(6),
 12    56 
 12    57 	max_index_register_value		initial(262143),
 12    58 	max_signed_index_register_value	initial(131071),
 12    59 
 12    60 	max_signed_xreg_precision		initial(17),
 12    61 	max_uns_xreg_precision		initial(18),
 12    62 
 12    63 	default_area_size			initial(1024),
 12    64 	default_flt_bin_p			initial(27),
 12    65 	default_fix_bin_p			initial(17),
 12    66 	default_flt_dec_p			initial(10),
 12    67           default_fix_dec_p   		initial(7)) fixed bin(31) internal static options(constant);
 12    68 
 12    69 dcl	bits_per_digit			initial(4.5)  fixed bin(31,1) internal static options(constant);
 12    70 
 12    71 dcl (	integer_type		initial("010000000000000000000100000001100000"b),
 12    72 	dec_integer_type		initial("010000000000000000000100000010100000"b),
 12    73 	pointer_type		initial("000001000000000000000100000000000000"b),
 12    74 	real_type			initial("001000000000000000000100000001100000"b),
 12    75 	complex_type		initial("001000000000000000000100000001010000"b),
 12    76 	builtin_type		initial("000000000000000010000000000000000000"b),
 12    77 	storage_block_type		initial("000000000000100000000000000000000000"b),
 12    78 	arg_desc_type		initial("000000000001000000000000000000000000"b),
 12    79 	local_label_var_type	initial("000000001000000000000100000100001000"b),
 12    80 	entry_var_type		initial("000000000100000000000000000000001000"b),
 12    81 	bit_type			initial("000100000000000000000000000000000000"b),
 12    82 	char_type			initial("000010000000000000000000000000000000"b)) bit(36) aligned int static
 12    83 									options(constant);
 12    84 
 12    85 /* END INCLUDE FILE ... system.incl.pl1 */
       66 
 13     1 /* BEGIN INCLUDE FILE ... semant.incl.pl1 */
 13     2 
 13     3 /* Modified: 30 Aug 1979 by PCK to fix 1804 and 1823 */
 13     4 /* Modified: 26 Aug 1979 by PCK to implement by name assignment */
 13     5 
 13     6 
 13     7 declare	alloc_semantics	entry(pointer,pointer,pointer);
 13     8 			/* parameter 1:	(input)	block node pointer		*/
 13     9 			/* parameter 2:	(input)	statement node pointer	*/
 13    10 			/* parameter 3:	(in/out)	tree pointer		*/
 13    11 
 13    12 declare	alloc_semantics$init_only entry(pointer,pointer,pointer);
 13    13 			/* parameter 1:	(input)	qualifier pointer		*/
 13    14 			/* parameter 2:	(input)	statement node pointer	*/
 13    15 			/* parameter 3:	(input)	symbol node pointer		*/
 13    16 
 13    17 declare	builtin		entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned)
 13    18 			returns(pointer);
 13    19 			/* parameter 1:	(input)	block node pointer		*/
 13    20 			/* parameter 2:	(input)	statement node pointer	*/
 13    21 			/* parameter 3:	(input)	tree pointer		*/
 13    22 			/* parameter 4:	(input)	subscript pointer		*/
 13    23 			/* parameter 5:	(input)	builtin symbol node pointer	*/
 13    24 			/* parameter 6:	(in/out)	context			*/
 13    25 			/* return:	(output)	tree pointer		*/
 13    26 
 13    27 declare	check_star_extents	entry(pointer,pointer);
 13    28 			/* parameter 1:	(input) symbol node of procedure	*/
 13    29 			/* parameter 2:	(input) argument list pointer		*/
 13    30 
 13    31 declare	compare_declaration	entry(pointer,pointer,bit(1) aligned) reducible
 13    32 			returns(bit(1) aligned);
 13    33 			/* parameter 1:	(input)	reference or symbol node ptr	*/
 13    34 			/* parameter 2:	(input)	symbol node ptr	*/
 13    35 			/* parameter 3:	(input)	"1"b if aligned attribute ignored for string	*/
 13    36 			/* return:	(output)	compare bit		*/
 13    37 
 13    38 declare	context_processor	entry(pointer,label);
 13    39 			/* parameter 1:	(input)	root block node pointer	*/
 13    40 
 13    41 declare	declare		entry(pointer);
 13    42 			/* parameter 1:	(input)	symbol node pointer		*/
 13    43 
 13    44 declare	declare_structure	entry(pointer);
 13    45 			/* parameter 1:	(input)	symbol node pointer		*/
 13    46 
 13    47 declare	defined_reference	entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned)
 13    48 			returns(pointer);
 13    49 			/* parameter 1:	(input)	block node pointer		*/
 13    50 			/* parameter 2:	(input)	statement node pointer	*/
 13    51 			/* parameter 3:	(input)	tree pointer		*/
 13    52 			/* parameter 4:	(input)	subscript list pointer or null*/
 13    53 			/* parameter 5:	(input)	symbol node pointer		*/
 13    54 			/* parameter 6:	(in/out)	context			*/
 13    55 			/* return:	(output)	tree pointer		*/
 13    56 
 13    57 declare	do_semantics	entry(pointer,pointer,pointer);
 13    58 			/* parameter 1:	(input)	block node pointer		*/
 13    59 			/* parameter 2:	(input)	statement node pointer	*/
 13    60 			/* parameter 3:	(input)	tree pointer		*/
 13    61 
 13    62 declare	expand_assign	entry(pointer,pointer,pointer,bit(36) aligned,pointer)
 13    63 			returns(pointer);
 13    64 			/* parameter 1:	(input)	block node pointer		*/
 13    65 			/* parameter 2:	(input)	statement node pointer	*/
 13    66 			/* parameter 3:	(input)	tree pointer		*/
 13    67 			/* parameter 4:	(in/out)	context			*/
 13    68 			/* parameter 5:	(input)	aggregate reference node ptr	*/
 13    69 			/* return:	(output)	tree pointer		*/
 13    70 
 13    71 declare	expand_by_name	entry(pointer,pointer,pointer);
 13    72 			/* parameter 1:	(input)	block node pointer		*/
 13    73 			/* parameter 2:	(input)	statement node pointer	*/
 13    74 			/* parameter 3:	(input/output)	tree pointer		*/
 13    75 
 13    76 declare	expand_infix	entry(pointer,pointer,pointer,bit(36) aligned)
 13    77 			returns(pointer);
 13    78 			/* parameter 1:	(input)	block node pointer		*/
 13    79 			/* parameter 2:	(input)	statement node pointer	*/
 13    80 			/* parameter 3:	(input)	tree pointer		*/
 13    81 			/* parameter 4:	(in/out)	context			*/
 13    82 			/* return:	(output)	tree pointer		*/
 13    83 
 13    84 declare	expand_initial	entry(pointer,pointer,pointer);
 13    85 			/* parameter 1:	(input)	symbol node pointer		*/
 13    86 			/* parameter 2:	(input)	statement node pointer	*/
 13    87 			/* parameter 3:	(input)	locator			*/
 13    88 
 13    89 declare	expand_prefix	entry(pointer,pointer,pointer,bit(36) aligned)
 13    90 			returns(pointer);
 13    91 			/* parameter 1:	(input)	block node pointer		*/
 13    92 			/* parameter 2:	(input)	statement node pointer	*/
 13    93 			/* parameter 3:	(input)	tree pointer		*/
 13    94 			/* parameter 4:	(in/out)	context			*/
 13    95 			/* return:	(output)	tree pointer		*/
 13    96 
 13    97 declare	expand_primitive	entry(pointer,pointer,pointer,bit(36) aligned)
 13    98 			returns(pointer);
 13    99 			/* parameter 1:	(input)	block node pointer		*/
 13   100 			/* parameter 2:	(input)	statement node pointer	*/
 13   101 			/* parameter 3:	(input)	tree pointer		*/
 13   102 			/* parameter 4:	(input)	context			*/
 13   103 			/* return:	(output)	tree pointer		*/
 13   104 
 13   105 declare	expression_semantics entry(pointer,pointer,pointer,bit(36) aligned)
 13   106 			returns(pointer);
 13   107 			/* parameter 1:	(input)	block node pointer		*/
 13   108 			/* parameter 2:	(input)	statement node pointer	*/
 13   109 			/* parameter 3:	(input)	tree pointer		*/
 13   110 			/* parameter 4:	(in/out)	context			*/
 13   111 			/* return:	(output)	tree pointer		*/
 13   112 
 13   113 declare	fill_refer	entry(pointer,pointer,bit(1) aligned)
 13   114 			returns(pointer);
 13   115 			/* parameter 1:	(input)	null,ref node,op node ptr */
 13   116 			/* parameter 2:	(input)	null,ref node,op node ptr */
 13   117 			/* parameter 3:	(input)	copy switch for param 2 */
 13   118 			/* return:	(output)	ptr to processed tree */
 13   119 
 13   120 declare	io_data_list_semantics$format_list_semantics entry(pointer,pointer,pointer);
 13   121 			/* parameter 1:	(input)	block node pointer		*/
 13   122 			/* parameter 2:	(input)	statement node pointer	*/
 13   123 			/* parameter 3:	(in/out)	tree pointer		*/
 13   124 
 13   125 declare	function		entry(pointer,pointer,pointer,pointer,bit(36) aligned)
 13   126 			returns(pointer);
 13   127 			/* parameter 1:	(input)	block node pointer		*/
 13   128 			/* parameter 2:	(input)	statement node pointer	*/
 13   129 			/* parameter 3:	(input)	tree pointer		*/
 13   130 			/* parameter 4:	(input)	symbol node pointer		*/
 13   131 			/* parameter 5:	(in/out)	context			*/
 13   132 			/* return:	(output)	tree pointer		*/
 13   133 
 13   134 declare	generic_selector	entry(pointer,pointer,pointer,pointer,bit(36) aligned)
 13   135 			returns(pointer);
 13   136 			/* parameter 1:	(input)	block node pointer	*/
 13   137 			/* parameter 2:	(input)	statement node pointer	*/
 13   138 			/* parameter 3:	(input)	tree pointer	*/
 13   139 			/* parameter 4:	(input)	pointer to argument list	*/
 13   140 			/* parameter 5:	(in/out)	context		*/
 13   141 			/* return:	(output)	tree pointer	*/
 13   142 
 13   143 declare	io_data_list_semantics entry(pointer,pointer,pointer);
 13   144 			/* parameter 1:	(input)	block node pointer		*/
 13   145 			/* parameter 2:	(input)	statement node pointer	*/
 13   146 			/* parameter 3:	(input)	operator node pointer	*/
 13   147 
 13   148 declare	io_semantics	entry(pointer,pointer,pointer);
 13   149 			/* parameter 1:	(input)	block node pointer		*/
 13   150 			/* parameter 2:	(input)	statement node pointer	*/
 13   151 			/* parameter 3:	(input)	tree pointer		*/
 13   152 
 13   153 declare	lookup		entry(pointer,pointer,pointer,pointer,bit(36) aligned)
 13   154 			returns(bit(1) aligned);
 13   155 			/* parameter 1:	(input)	block node pointer		*/
 13   156 			/* parameter 2:	(input)	stmnt|symbol node pointer	*/
 13   157 			/* parameter 3:	(input)	token or reference node ptr	*/
 13   158 			/* parameter 4:	(output)	symbol node pointer		*/
 13   159 			/* parameter 5:	(in/out)	context			*/
 13   160 			/* return:	(output)	symbol found bit		*/
 13   161 
 13   162 declare	make_non_quick	entry(pointer, bit (36) aligned);
 13   163 			/* parameter 1:	(input)	tree pointer	*/
 13   164 			/* parameter 2:	(input)	reason why being made nonquick */
 13   165 
 13   166 declare	match_arguments	entry(pointer,pointer) reducible
 13   167 			returns(bit(1) aligned);
 13   168 			/* parameter 1:	(input)	reference or symbol node ptr	*/
 13   169 			/* parameter 2:	(input)	reference or symbol node ptr	*/
 13   170 			/* return:	(output)	compare bit		*/
 13   171 
 13   172 declare	offset_adder	entry(pointer,fixed binary(31),fixed binary(3),bit(1) aligned,
 13   173 			      pointer,fixed binary(31),fixed binary(3),bit(1) aligned,bit(1));
 13   174 			/* parameter 1:	(in/out)	tree pointer		*/
 13   175 			/* parameter 2:	(in/out)	constant size		*/
 13   176 			/* parameter 3:	(in/out)	units			*/
 13   177 			/* parameter 4:	(in/out) 	ON if units ^= word_, but tree in words	*/
 13   178 			/* parameter 5:	(input)	tree pointer		*/
 13   179 			/* parameter 6:	(input)	constant size		*/
 13   180 			/* parameter 7:	(input)	units			*/
 13   181 			/* parameter 8:	(input)	ON if units ^= word_, but tree in words	*/
 13   182 			/* parameter 9:	(input)	ON if should not improve units	*/
 13   183 
 13   184 declare	operator_semantics	entry(pointer,pointer,pointer,bit(36) aligned)
 13   185 			returns(pointer);
 13   186 			/* parameter 1:	(input)	block node pointer		*/
 13   187 			/* parameter 2:	(input)	statement node pointer	*/
 13   188 			/* parameter 3:	(input)	tree pointer		*/
 13   189 			/* parameter 4:	(in/out)	context			*/
 13   190 			/* return:	(output)	tree pointer		*/
 13   191 
 13   192 declare	propagate_bit	entry(pointer,fixed binary(15));
 13   193 			/* parameter 1:	(input)	symbol node pointer		*/
 13   194 			/* parameter 2:	(input)	attribute number		*/
 13   195 
 13   196 declare	semantic_translator$call_es entry(pointer,pointer,pointer,label,bit(1) aligned)
 13   197 			returns(pointer);
 13   198 			/* parameter 1:	(input)	block ptr	*/
 13   199 			/* parameter 2:	(input)	statement ptr	*/
 13   200 			/* parameter 3:	(input)	tree ptr	*/
 13   201 			/* parameter 4:	(input)	failure label	*/
 13   202 			/* parameter 5:	(input)	"1"b -- convert to integer	*/
 13   203 			/* return:	(output)	tree ptr		*/
 13   204 
 13   205 declare	simplify_expression	entry(pointer,fixed bin,bit(1)aligned);
 13   206 			/* parameter 1:	(in/out)	tree pointer		*/
 13   207 			/* parameter 2:	(output)	value of constant, if the entire tree
 13   208*						is simplified		*/
 13   209 			/* parameter 3:	(output)	bit indicating if the tree has
 13   210*						been simplified		*/
 13   211 
 13   212 declare	simplify_offset	entry(pointer,bit(36) aligned);
 13   213 			/* parameter 1:	(input)	reference node pointer	*/
 13   214 			/* parameter 2:	(input)	context			*/
 13   215 
 13   216 declare	subscripter	entry(pointer,pointer,pointer,pointer,pointer)
 13   217 			returns(pointer);
 13   218 			/* parameter 1:	(input)	block node pointer		*/
 13   219 			/* parameter 2:	(input)	statement node pointer	*/
 13   220 			/* parameter 3:	(input)	tree pointer		*/
 13   221 			/* parameter 4:	(in/out)	subscript list pointer	*/
 13   222 			/* parameter 5:	(input)	symbol node pointer		*/
 13   223 			/* return:	(output)	reference node pointer	*/
 13   224 
 13   225 declare	validate		entry(pointer);
 13   226 			/* parameter 1:	(input)	symbol node pointer		*/
 13   227 
 14     1 /****^  *********************************************************
 14     2*        *                                                       *
 14     3*        * Copyright, (C) BULL HN Information Systems Inc., 1989 *
 14     4*        *                                                       *
 14     5*        ********************************************************* */
 14     6 
 14     7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */
 14     8 
 14     9 
 14    10 /****^  HISTORY COMMENTS:
 14    11*  1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu),
 14    12*     install(89-07-31,MR12.3-1066):	
 14    13*     Removed the obsolete parameter source_line from the dcl of error_().
 14    14*                                                   END HISTORY COMMENTS */
 14    15 
 14    16 /* Modified: 6 Jun 1979 by PG to add rank and byte
 14    17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 
 14    18* */
 14    19 
 14    20 declare	adjust_count	entry(pointer);
 14    21 			/* parameter 1:	(input)	any node pointer		*/
 14    22 
 14    23 declare	bindec		entry(fixed bin(31)) reducible
 14    24 			returns(character(12) aligned);
 14    25 			/* parameter 1:	(input)	bin value			*/
 14    26 			/* return:	(output)	character value with blanks	*/
 14    27 
 14    28 declare	bindec$vs		entry(fixed bin(31)) reducible
 14    29 			returns(character(12) aligned varying);
 14    30 			/* parameter 1:	(input)	binary value		*/
 14    31 			/* return:	(output)	char value without blanks	*/
 14    32 
 14    33 declare	binoct		entry(fixed bin(31)) reducible
 14    34 			returns(char(12) aligned);
 14    35 			/* parameter 1:	(input)	binary value		*/
 14    36 			/* return:	(output)	char value with blanks	*/
 14    37 
 14    38 declare	binary_to_octal_string	entry(fixed bin(31)) reducible
 14    39 			returns(char(12) aligned);
 14    40 			/* parameter 1:	(input)	binary value		*/
 14    41 			/* return:	(output)	right-aligned char value	*/
 14    42 
 14    43 declare	binary_to_octal_var_string	entry(fixed bin(31)) reducible
 14    44 			returns(char(12) varying aligned);
 14    45 			/* parameter 1:	(input)	binary value		*/
 14    46 			/* returns:	(output)	char value without blanks	*/
 14    47 
 14    48 declare	compare_expression	entry(pointer,pointer) reducible
 14    49 			returns(bit(1) aligned);
 14    50 			/* parameter 1:	(input)	any node pointer		*/
 14    51 			/* parameter 2:	(input)	any node pointer		*/
 14    52 			/* return:	(output)	compare bit		*/
 14    53 
 14    54 declare	constant_length	entry (pointer, fixed bin (71))
 14    55 			returns (bit (1) aligned);
 14    56 			/* parameter 1:	(input)	reference node pointer	*/
 14    57 			/* parameter 2:	(input)	value of constant length	*/
 14    58 			/* return:	(output)	"1"b if constant length	*/
 14    59 
 14    60 declare	convert		entry(pointer,bit(36) aligned)
 14    61 			returns(pointer);
 14    62 			/* parameter 1:	(input)	any node pointer		*/
 14    63 			/* parameter 2:	(input)	target type		*/
 14    64 			/* return:	(output)	target value tree pointer	*/
 14    65 
 14    66 declare	convert$to_integer	entry(pointer,bit(36)aligned)
 14    67 			returns(pointer);
 14    68 			/* parameter 1:	(input)	any node pointer		*/
 14    69 			/* parameter 2:	(input)	target type		*/
 14    70 			/* return:	(output)	target value tree pointer	*/
 14    71 
 14    72 declare	convert$from_builtin entry(pointer,bit(36) aligned)
 14    73 			returns(pointer);
 14    74 			/* parameter 1:	(input)	any node pointer		*/
 14    75 			/* parameter 2:	(input)	target type		*/
 14    76 			/* return:	(output)	target value tree pointer	*/
 14    77 
 14    78 declare	convert$validate	entry(pointer,pointer);
 14    79 			/* parameter 1:	(input)	source value tree pointer	*/
 14    80 			/* parameter 2:	(input)	target reference node pointer	*/
 14    81 
 14    82 declare	convert$to_target_fb entry(pointer,pointer)
 14    83 			returns(pointer);
 14    84 			/* parameter 1:	(input)	source value tree pointer	*/
 14    85 			/* parameter 2:	(input)	target reference node pointer	*/
 14    86 			/* return:	(output)	target value tree pointer	*/
 14    87 
 14    88 declare	convert$to_target	entry(pointer,pointer)
 14    89 			returns(pointer);
 14    90 			/* parameter 1:	(input)	source value tree pointer	*/
 14    91 			/* parameter 2:	(input)	target reference node pointer	*/
 14    92 			/* return:	(output)	target value tree pointer	*/
 14    93 
 14    94 declare	copy_expression	entry(pointer unaligned)
 14    95 			returns(pointer);
 14    96 			/* parameter 1:	(input)	any node pointer		*/
 14    97 			/* return:	(output)	any node pointer		*/
 14    98 
 14    99 declare	copy_expression$copy_sons entry(pointer,pointer);
 14   100 			/* parameter 1:	(input)	father symbol node pointer	*/
 14   101 			/* parameter 2:	(input)	stepfather symbol node ptr	*/
 14   102 
 14   103 declare	copy_unique_expression entry(pointer)
 14   104 			returns(pointer);
 14   105 			/* parameter 1:	(input)	any node pointer		*/
 14   106 			/* return:	(output)	any node pointer		*/
 14   107 
 14   108 declare	create_array	entry()
 14   109 			returns(pointer);
 14   110 			/* return:	(output)	array node pointer		*/
 14   111 
 14   112 declare	create_block	entry(bit(9) aligned,pointer)
 14   113 			returns(pointer);
 14   114 			/* parameter 1:	(input)	block type		*/
 14   115 			/* parameter 2:	(input)	father block node pointer	*/
 14   116 			/* return:	(output)	block node pointer		*/
 14   117 
 14   118 declare	create_bound	entry()
 14   119 			returns(pointer);
 14   120 			/* return:	(output)	bound node pointer		*/
 14   121 
 14   122 declare	create_context	entry(pointer,pointer)
 14   123 			returns(pointer);
 14   124 			/* parameter 1:	(input)	block node pointer		*/
 14   125 			/* parameter 2:	(input)	token pointer		*/
 14   126 			/* return:	(output)	context node pointer	*/
 14   127 
 14   128 declare	create_cross_reference entry()
 14   129 			returns(pointer);
 14   130 			/* return:	(output)	cross reference node pointer	*/
 14   131 
 14   132 declare	create_default	entry
 14   133 			returns(pointer);
 14   134 			/* return:	(output)	default node pointer	*/
 14   135 
 14   136 declare	create_identifier	entry()
 14   137 			returns(pointer);
 14   138 			/* return:	(output)	token node pointer		*/
 14   139 
 14   140 declare	create_label	entry(pointer,pointer,bit(3) aligned)
 14   141 			returns(pointer);
 14   142 			/* parameter 1:	(input)	block node pointer		*/
 14   143 			/* parameter 2:	(input)	token node pointer		*/
 14   144 			/* parameter 3:	(input)	declare type		*/
 14   145 			/* return:	(output)	label node pointer		*/
 14   146 
 14   147 declare	create_list	entry(fixed bin(15))
 14   148 			returns(pointer);
 14   149 			/* parameter 1:	(input)	number of list elements	*/
 14   150 			/* return:	(output)	list node pointer		*/
 14   151 
 14   152 declare	create_operator	entry(bit(9) aligned,fixed bin(15))
 14   153 			returns(pointer);
 14   154 			/* parameter 1:	(input)	operator type		*/
 14   155 			/* parameter 2:	(input)	number of operands		*/
 14   156 			/* return:	(output)	operator node pointer	*/
 14   157 
 14   158 declare	create_reference	entry(pointer)
 14   159 			returns(pointer);
 14   160 			/* parameter 1:	(input)	symbol node pointer		*/
 14   161 			/* return:	(output)	reference node pointer	*/
 14   162 
 14   163 declare	create_statement	entry(bit(9) aligned,pointer,pointer,bit(12) aligned)
 14   164 			returns(pointer);
 14   165 			/* parameter 1:	(input)	statement type		*/
 14   166 			/* parameter 2:	(input)	block node pointer		*/
 14   167 			/* parameter 3:	(input)	label node pointer		*/
 14   168 			/* parameter 4:	(input)	conditions		*/
 14   169 			/* return:	(output)	statement node pointer	*/
 14   170 
 14   171 declare	create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned)
 14   172 			returns(pointer);
 14   173 			/* parameter 1:	(input)	statement type		*/
 14   174 			/* parameter 2:	(input)	block node pointer		*/
 14   175 			/* parameter 3:	(input)	label node pointer		*/
 14   176 			/* parameter 4:	(input)	conditions		*/
 14   177 			/* return:	(output)	statement node pointer	*/
 14   178 
 14   179 declare	create_storage	entry(fixed bin(15))
 14   180 			returns(pointer);
 14   181 			/* parameter 1:	(input)	number of words		*/
 14   182 			/* return:	(output)	storage block pointer	*/
 14   183 
 14   184 declare	create_symbol	entry(pointer,pointer,bit(3) aligned)
 14   185 			returns(pointer);
 14   186 			/* parameter 1:	(input)	block node pointer		*/
 14   187 			/* parameter 2:	(input)	token node pointer		*/
 14   188 			/* parameter 3:	(input)	declare type		*/
 14   189 			/* return:	(output)	symbol node pointer		*/
 14   190 
 14   191 declare	create_token	entry (character (*), bit (9) aligned)
 14   192 			returns (ptr);
 14   193 			/* parameter 1:	(input)	token string		*/
 14   194 			/* parameter 2:	(input)	token type		*/
 14   195 			/* return:	(output)	token node ptr		*/
 14   196 
 14   197 declare	create_token$init_hash_table entry ();
 14   198 
 14   199 declare	create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned)
 14   200 			returns (ptr);
 14   201 			/* parameter 1:	(input)	token string		*/
 14   202 			/* parameter 2:	(input)	token type		*/
 14   203 			/* parameter 3:	(input)	protected flag		*/
 14   204 			/* return:	(output)	token node ptr		*/
 14   205 
 14   206 declare	decbin		entry(character(*) aligned) reducible
 14   207 			returns(fixed bin(31));
 14   208 			/* parameter 1:	(input)	decimal character string	*/
 14   209 			/* return:	(output)	binary value		*/
 14   210 
 14   211 declare	declare_constant	entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15))
 14   212 			returns(pointer);
 14   213 			/* parameter 1:	(input)	value			*/
 14   214 			/* parameter 2:	(input)	type			*/
 14   215 			/* parameter 3:	(input)	size			*/
 14   216 			/* parameter 4:	(input)	scale			*/
 14   217 			/* return:	(output)	reference node pointer	*/
 14   218 
 14   219 declare	declare_constant$bit entry(bit(*) aligned)
 14   220 			returns(pointer);
 14   221 			/* parameter 1:	(input)	bit			*/
 14   222 			/* return:	(output)	reference node pointer	*/
 14   223 
 14   224 declare	declare_constant$char entry(character(*) aligned)
 14   225 			returns(pointer);
 14   226 			/* parameter 1:	(input)	character			*/
 14   227 			/* return:	(output)	reference node pointer	*/
 14   228 
 14   229 declare	declare_constant$desc entry(bit(*) aligned)
 14   230 			returns(pointer);
 14   231 			/* parameter 1:	(input)	descriptor bit value	*/
 14   232 			/* return:	(output)	reference node pointer	*/
 14   233 
 14   234 declare	declare_constant$integer entry(fixed bin(31))	/* note...should really be fixed bin(24) */
 14   235 			returns(pointer);
 14   236 			/* parameter 1:	(input)	integer			*/
 14   237 			/* return:	(output)	reference node pointer	*/
 14   238 
 14   239 declare	declare_descriptor	entry(pointer,pointer,pointer,pointer,bit(2) aligned)
 14   240 			returns(pointer);
 14   241 			/* parameter 1:	(input)	block node pointer		*/
 14   242 			/* parameter 2:	(input)	statement node pointer	*/
 14   243 			/* parameter 3:	(input)	symbol node pointer		*/
 14   244 			/* parameter 4:	(input)	loc pointer		*/
 14   245 			/* parameter 5:	(input)	array descriptor bit
 14   246*						cross_section bit	*/
 14   247 			/* return:	(output)	reference node pointer	*/
 14   248 
 14   249 declare	declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned)
 14   250 			returns(pointer);
 14   251 			/* parameter 1:	(input)	block node pointer	*/
 14   252 			/* parameter 2:	(input)	statement node pointer 	*/
 14   253 			/* parameter 3:	(input)	symbol node pointer	*/
 14   254 			/* parameter 4:	(input)	loc pointer	*/
 14   255 			/* parameter 5:	(input)	array descriptor bit
 14   256*						cross_section bit	*/
 14   257 			/* return:	(output)	reference node pointer	*/
 14   258 
 14   259 declare	declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned)
 14   260 			returns(pointer);
 14   261 			/* parameter 1:	(input)	block node pointer		*/
 14   262 			/* parameter 2:	(input)	statement node pointer	*/
 14   263 			/* parameter 3:	(input)	symbol node pointer		*/
 14   264 			/* parameter 4:	(input)	loc pointer		*/
 14   265 			/* parameter 5:	(input)	array descriptor bit
 14   266*						cross_section bit	*/
 14   267 			/* return:	(output)	reference node pointer	*/
 14   268 
 14   269 declare	declare_integer	entry(pointer)
 14   270 			returns(pointer);
 14   271 			/* parameter 1:	(input)	block node pointer		*/
 14   272 			/* return:	(output)	reference node pointer 	*/
 14   273 
 14   274 declare	declare_picture	entry(char(*)aligned,pointer,fixed bin(15));
 14   275 			/* parameter 1:	(input)	picture string		*/
 14   276 			/* parameter 2:	(input)	symbol node pointer		*/
 14   277 			/* parameter 3:	(output)	error code, if any		*/
 14   278 
 14   279 declare	declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned)
 14   280 			returns(pointer);
 14   281 			/* parameter 1:	(input)	picture string		*/
 14   282 			/* parameter 2:	(input)	scalefactor of picture	*/
 14   283 			/* parameter 3:	(input)	="1"b => complex picture	*/
 14   284 			/* parameter 4:	(input)	="1"b => unaligned temp	*/
 14   285 			/* return:	(output)	reference node pointer	*/
 14   286 
 14   287 declare	declare_pointer	entry(pointer)
 14   288 			returns(pointer);
 14   289 			/* parameter 1:	(input)	block node pointer		*/
 14   290 			/* return:	(output)	reference node pointer	*/
 14   291 
 14   292 declare	declare_temporary	entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer)
 14   293 			returns(pointer);
 14   294 			/* parameter 1:	(input)	type			*/
 14   295 			/* parameter 2:	(input)	precision			*/
 14   296 			/* parameter 3:	(input)	scale			*/
 14   297 			/* parameter 4:	(input)	length			*/
 14   298 			/* return:	(output)	reference node pointer	*/
 14   299 
 14   300 declare	decode_node_id	entry(pointer,bit(1) aligned)
 14   301 			returns(char(120) varying);
 14   302 			/* parameter 1:	(input)	node pointer		*/
 14   303 			/* parameter 2:	(input)	="1"b => capitals		*/
 14   304 			/* return:	(output)	source line id		*/
 14   305 
 14   306 declare	decode_source_id	entry(
 15     1 			1 structure unaligned,
 15     2 			  2 /* file_number */	bit(8),
 15     3 			  2 /* line_number */	bit(14),
 15     4 			  2 /* stmt_number */	bit(5),
 14   307 
 14   308 			bit(1) aligned)
 14   309 			returns(char(120) varying);
 14   310 			/* parameter 1:	(input)	source id			*/
 14   311 			/* parameter 2:	(input)	="1"b => capitals		*/
 14   312 			/* return:	(output)	source line id		*/
 14   313 
 14   314 declare	error		entry(fixed bin(15),pointer,pointer);
 14   315 			/* parameter 1:	(input)	error number		*/
 14   316 			/* parameter 2:	(input)	statement node pointer or null*/
 14   317 			/* parameter 3:	(input)	token node pointer 		*/
 14   318 
 14   319 declare	error$omit_text	entry(fixed bin(15),pointer,pointer);
 14   320 			/* parameter 1:	(input)	error number		*/
 14   321 			/* parameter 2:	(input)	statement node pointer or null*/
 14   322 			/* parameter 3:	(input)	token node pointer 		*/
 14   323 
 14   324 declare	error_		entry(fixed bin(15),
 16     1 			1 structure unaligned,
 16     2 			  2 /* file_number */	bit(8),
 16     3 			  2 /* line_number */	bit(14),
 16     4 			  2 /* stmt_number */	bit(5),
 14   325 
 14   326 			pointer,fixed bin(8),fixed bin(23),fixed bin(11));
 14   327 			/* parameter 1:	(input)	error number		*/
 14   328 			/* parameter 2:	(input)	statement id		*/
 14   329 			/* parameter 3:	(input)	any node pointer		*/
 14   330 			/* parameter 4:	(input)	source segment		*/
 14   331 			/* parameter 5:	(input)	source starting character	*/
 14   332 			/* parameter 6:	(input)	source length		*/
 14   333 
 14   334 declare	error_$no_text	entry(fixed bin(15),
 17     1 			1 structure unaligned,
 17     2 			  2 /* file_number */	bit(8),
 17     3 			  2 /* line_number */	bit(14),
 17     4 			  2 /* stmt_number */	bit(5),
 14   335 
 14   336 			pointer);
 14   337 			/* parameter 1:	(input)	error number		*/
 14   338 			/* parameter 2:	(input)	statement id		*/
 14   339 			/* parameter 3:	(input)	any node pointer		*/
 14   340 
 14   341 declare	error_$initialize_error entry();
 14   342 
 14   343 declare	error_$finish	entry();
 14   344 
 14   345 declare	free_node		entry(pointer);
 14   346 			/* parameter 1:	any node pointer			*/
 14   347 
 14   348 declare	get_array_size	entry(pointer,fixed bin(3));
 14   349 			/* parameter 1:	(input)	symbol node pointer		*/
 14   350 			/* parameter 2:	(input)	units			*/
 14   351 
 14   352 declare	get_size		entry(pointer);
 14   353 			/* parameter 1:	(input)	symbol node pointer		*/
 14   354 
 14   355 declare	merge_attributes	external entry(pointer,pointer)
 14   356 			returns(bit(1) aligned);
 14   357 			/* parameter 1:	(input)	target symbol node pointer */
 14   358 			/* parameter 2:	(input)	source symbol node pointer */
 14   359 			/* return:	(output)	"1"b if merge was unsuccessful */
 14   360 
 14   361 declare	optimizer		entry(pointer);
 14   362 			/* parameter 1:	(input)	root pointer		*/
 14   363 
 14   364 declare	parse_error	entry(fixed bin(15),pointer);
 14   365 			/* parameter 1:	(input)	error number		*/
 14   366 			/* parameter 2:	(input)	any node pointer		*/
 14   367 
 14   368 declare	parse_error$no_text	entry(fixed bin(15),pointer);
 14   369 			/* parameter 1:	(input)	error number		*/
 14   370 			/* parameter 2:	(input)	any node pointer		*/
 14   371 
 14   372 declare	pl1_error_print$write_out
 14   373 			entry(fixed bin(15),
 18     1 			1 structure unaligned,
 18     2 			  2 /* file_number */	bit(8),
 18     3 			  2 /* line_number */	bit(14),
 18     4 			  2 /* stmt_number */	bit(5),
 14   374 
 14   375 			pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15));
 14   376 			/* parameter 1:	(input)	error number		*/
 14   377 			/* parameter 2:	(input)	statement identification	*/
 14   378 			/* parameter 3:	(input)	any node pointer		*/
 14   379 			/* parameter 4:	(input)	source segment		*/
 14   380 			/* parameter 5:	(input)	source character index	*/
 14   381 			/* parameter 6:	(input)	source length		*/
 14   382 			/* parameter 7:	(input)	source line		*/
 14   383 
 14   384 declare	pl1_error_print$listing_segment
 14   385 			entry(fixed bin(15),
 19     1 			1 structure unaligned,
 19     2 			  2 /* file_number */	bit(8),
 19     3 			  2 /* line_number */	bit(14),
 19     4 			  2 /* stmt_number */	bit(5),
 14   386 
 14   387 			pointer);
 14   388 			/* parameter 1:	(input)	error number		*/
 14   389 			/* parameter 2:	(input)	statement identification	*/
 14   390 			/* parameter 3:	(input)	token node pointer		*/
 14   391 
 14   392 declare	pl1_print$varying		entry(character(*) aligned varying);
 14   393 			/* parameter 1:	(input)	string			*/
 14   394 
 14   395 declare	pl1_print$varying_nl	entry(character(*) aligned varying);
 14   396 			/* parameter 1:	(input)	string			*/
 14   397 
 14   398 declare	pl1_print$non_varying	entry(character(*) aligned,fixed bin(31));
 14   399 			/* parameter 1:	(input)	string			*/
 14   400 			/* parameter 2:	(input)	string length or 0		*/
 14   401 
 14   402 declare	pl1_print$non_varying_nl	entry(character(*) aligned,fixed bin(31));
 14   403 			/* parameter 1:	(input)	string			*/
 14   404 			/* parameter 2:	(input)	string length or 0		*/
 14   405 
 14   406 declare	pl1_print$string_pointer	entry(pointer,fixed bin(31));
 14   407 			/* parameter 1:	(input)	string pointer		*/
 14   408 			/* parameter 2:	(input)	string size		*/
 14   409 
 14   410 declare	pl1_print$string_pointer_nl	entry(pointer,fixed bin(31));
 14   411 			/* parameter 1:	(input)	string pointer		*/
 14   412 			/* parameter 2:	(input)	string length or 0		*/
 14   413 
 14   414 declare	pl1_print$unaligned_nl	entry(character(*) unaligned,fixed bin(31));
 14   415 			/* parameter 1:	(input)	string			*/
 14   416 			/* parameter 2:	(input)	length			*/
 14   417 
 14   418 declare	pl1_print$for_lex	entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned);
 14   419 			/* parameter 1:	(input)	ptr to base of source segment	*/
 14   420 			/* parameter 2:	(input)	line number		*/
 14   421 			/* parameter 3:	(input)	starting offset in source seg	*/
 14   422 			/* parameter 4:	(input)	number of chars to copy	*/
 14   423 			/* parameter 5:	(input)	ON iff shd print line number	*/
 14   424 			/* parameter 6:	(input)	ON iff line begins in comment	*/
 14   425 
 14   426 declare	refer_extent	entry(pointer,pointer);
 14   427 			/* parameter 1:	(input/output)	null,ref node,op node pointer	*/
 14   428 			/* parameter 2:	(input)	null,ref node,op node pointer	*/
 14   429 
 14   430 declare	reserve$clear	entry()
 14   431 			returns(pointer);
 14   432 			/* return:	(output)	pointer			*/
 14   433 
 14   434 declare	reserve$declare_lib	entry(fixed bin(15))
 14   435 			returns(pointer);
 14   436 			/* parameter 1:	(input)	builtin function number	*/
 14   437 			/* return:	(output)	pointer			*/
 14   438 
 14   439 declare	reserve$read_lib	entry(fixed bin(15))
 14   440 			returns(pointer);
 14   441 			/* parameter 1:	(input)	builtin function number	*/
 14   442 			/* return:	(output)	pointer			*/
 14   443 
 14   444 declare	semantic_translator	entry();
 14   445 
 14   446 declare	semantic_translator$abort entry(fixed bin(15),pointer);
 14   447 			/* parameter 1:	(input)	error number		*/
 14   448 			/* parameter 2:	(input)	any node pointer		*/
 14   449 
 14   450 declare	semantic_translator$error entry(fixed bin(15),pointer);
 14   451 			/* parameter 1:	(input)	error number		*/
 14   452 			/* parameter 2:	(input)	any node pointer		*/
 14   453 
 14   454 declare	share_expression	entry(ptr)
 14   455 			returns(ptr);
 14   456 			/* parameter 1:	(input)	usually operator node pointer	*/
 14   457 			/* return:	(output)	tree pointer or null	*/
 14   458 
 14   459 declare	token_to_binary	entry(ptr) reducible
 14   460 			returns(fixed bin(31));
 14   461 			/* parameter 1:	(input)	token node pointer		*/
 14   462 			/* return:	(output)	converted binary value	*/
 14   463 
 14   464 /* END INCLUDE FILE ... language_utility.incl.pl1 */
 13   228 
 13   229 /* END INCLUDE FILE ... semant.incl.pl1 */
       67 
       68 
       69 /* program */
       70 
       71 	ev_qual = create_operator (param_ptr, 3);
       72 	ev_temp, ev_qual -> operator.operand (1) = declare_temporary (pointer_type, 0, 0, null);
       73 	ev_qual -> operator.operand (2) = declare_constant$integer (1);
       74 	ev_qual -> operator.operand (3), pl1_stat_$dummy_block = create_block (internal_procedure, null);
       75 
       76 	ev_ref = declare_pointer (pl1_stat_$dummy_block);
       77 	ev_ref -> reference.qualifier, pl1_stat_$dummy_block -> block.context = ev_qual;
       78 
       79 	ev_ref -> reference.symbol -> symbol.auto = "0"b;
       80 	ev_ref -> reference.symbol -> symbol.parameter = "1"b;
       81 	ev_ref -> reference.symbol -> symbol.location = 1;
       82 
       83 	ev_based_var = declare_integer (pl1_stat_$dummy_block);
       84 	ev_based_var -> reference.qualifier = ev_ref;
       85 
       86 	ev_based_var -> reference.symbol -> symbol.auto = "0"b;
       87 	ev_based_var -> reference.symbol -> symbol.based = "1"b;
       88 
       89 	s1 = create_statement (unknown_statement, pl1_stat_$dummy_block, null, ""b);
       90 	s2 = null;
       91 
       92 /* Sometimes the entire symbol table must be scanned more than once.
       93*   Processing a symbol node may cause another symbol node's
       94*   symbol.cross_references pointer to be set, symbol.allocate bit to be turned
       95*   on, or symbol.put_in_symtab bit to be turned on.  If that symbol node has
       96*   already been passed in the symbol chain, we have to pass over the symbol
       97*   table again to ensure that the symbol node is processed.  If we didn't, the
       98*   code generator will fault when generating a thunk for the symbol node.
       99*   Another pass is made over the symbol table if any of these fields could
      100*   have been set for the first time.  This fixes 1971. */
      101 
      102 	scan_again = "1"b;
      103 	do while (scan_again);
      104 	     scan_again = "0"b;
      105 	     call scan_symbol_table;
      106 	end;
      107 
      108 	return;
      109 
      110 /* This procedure makes a prefix walk of the block node tree.  For each block
      111*   node, all the declarations local to that block are examined for entry into
      112*   the runtime symbol table.  If the declaration is eligible, process is
      113*   called to prepare the symbol node for the runtime symbol table. */
      114 
      115 scan_symbol_table:
      116      procedure;
      117 
      118 dcl	cb		ptr;
      119 dcl	found_brother	bit (1) aligned;
      120 dcl	get_data		bit (1) aligned;
      121 dcl	p		ptr;
      122 dcl	q		ptr;
      123 
      124 	cb = root;
      125 	do while (cb ^= null);
      126 	     get_data = cb -> block.get_data;
      127 	     do p = cb -> block.declaration repeat p -> symbol.next while (p ^= null);
      128 		if p -> node.type = symbol_node
      129 		then if p -> symbol.dcl_type ^= by_compiler & ^p -> symbol.builtin & ^p -> symbol.condition
      130 			& ^p -> symbol.constant & ^p -> symbol.symtab_processed
      131 			& (p -> symbol.cross_references ^= null | p -> symbol.allocate | get_data)
      132 		     then do;
      133 			     do q = p repeat q -> symbol.father while (q -> symbol.father ^= null);
      134 			     end;
      135 
      136 			     if q -> symbol.put_in_symtab | get_data | pl1_stat_$table
      137 			     then call process (q);
      138 			end;
      139 	     end;
      140 
      141 	     if cb -> block.son ^= null
      142 	     then cb = cb -> block.son;
      143 	     else do;
      144 		     found_brother = "0"b;
      145 		     do while (cb ^= null & ^found_brother);
      146 			if cb -> block.brother = null
      147 			then cb = cb -> block.father;
      148 			else do;
      149 				cb = cb -> block.brother;
      150 				found_brother = "1"b;
      151 			     end;
      152 		     end;
      153 		end;
      154 	end;
      155 
      156 	return;
      157 
      158 /* This procedure prepares a symbol node for entry into the runtime symbol
      159*   table.  If the symbol node is a structure declaration, this procedure makes
      160*   a prefix walk of the member symbol nodes to prepare them also.  Any
      161*   expression or variable used as a size or bound on symbols are encoded.
      162*   This procedure ensures that all variables referenced in size or bound
      163*   expressions are marked for inclusion into the runtime symbol table. */
      164 
      165 process:
      166      procedure (pt);
      167 
      168 dcl	pt		ptr;
      169 
      170 dcl	ap		ptr;
      171 dcl	array_ref		bit (1) aligned;
      172 dcl	bp		ptr;
      173 dcl	qp		ptr;
      174 dcl	rp		ptr;
      175 dcl	sp		ptr;
      176 
      177 	sp = pt;
      178 	do while (sp ^= null);
      179 	     pl1_stat_$cur_statement = sp;
      180 	     string (pl1_stat_$statement_id) = string (sp -> symbol.source_id);
      181 
      182 	     if sp -> symbol.picture
      183 	     then do;
      184 		     scan_again = scan_again | ^sp -> symbol.general -> reference.symbol -> symbol.allocate;
      185 		     sp -> symbol.general -> reference.symbol -> symbol.allocate = "1"b;
      186 		end;
      187 
      188 	     if sp -> symbol.offset
      189 	     then if sp -> symbol.general ^= null
      190 		then do;
      191 			sp -> symbol.general = encode_qual (sp -> symbol.general);
      192 
      193 			if sp -> symbol.general ^= null
      194 			then if sp -> symbol.general -> node.type = reference_node
      195 			     then do;
      196 				     scan_again =
      197 					scan_again
      198 					| ^sp -> symbol.general -> reference.symbol -> symbol.put_in_symtab;
      199 				     sp -> symbol.general -> reference.symbol -> symbol.put_in_symtab = "1"b;
      200 				end;
      201 		     end;
      202 
      203 	     if ^sp -> symbol.entry
      204 	     then sp -> symbol.symtab_size = encode (sp -> symbol.dcl_size);
      205 
      206 	     rp = sp -> symbol.reference;
      207 	     rp -> reference.offset = encode (rp -> reference.offset);
      208 
      209 	     if sp -> symbol.defined
      210 	     then if sp -> symbol.structure
      211 		then do;
      212 
      213 /* try to locate base reference so we can determine addressing information
      214*   for the defined element */
      215 
      216 			if sp -> symbol.reference -> reference.qualifier = null
      217 			then if lookup ((sp -> symbol.block_node), null, copy_expression (sp -> symbol.equivalence), bp,
      218 				"0"b)
      219 			     then sp -> symbol.reference -> reference.qualifier = bp -> symbol.reference;
      220 		     end;
      221 
      222 		else do;
      223 
      224 /* expression_semantics won't call defined_reference for an array */
      225 
      226 			array_ref = sp -> symbol.reference -> reference.array_ref;
      227 			sp -> symbol.reference -> reference.array_ref = "0"b;
      228 
      229 			qp = encode_qual (sp -> symbol.reference);
      230 			if qp ^= null
      231 			then if qp -> node.type = reference_node
      232 			     then do;
      233 				     qp -> reference.ref_count = 0;
      234 				     qp -> reference.shared = "1"b;
      235 						/* symbol.reference must be shared */
      236 				     qp -> reference.processed = "0"b;
      237 						/* prevent expr_semantics anomalies */
      238 				     sp -> symbol.reference = qp;
      239 				end;
      240 
      241 			sp -> symbol.reference -> reference.array_ref = array_ref;
      242 		     end;
      243 
      244 	     if sp -> symbol.based
      245 	     then if rp -> reference.qualifier ^= null
      246 		then do;
      247 			rp -> reference.qualifier = encode_qual (rp -> reference.qualifier);
      248 
      249 			if rp -> reference.qualifier ^= null
      250 			then if rp -> reference.qualifier -> node.type = reference_node
      251 			     then do;
      252 				     scan_again =
      253 					scan_again
      254 					| ^rp -> reference.qualifier -> reference.symbol -> symbol.put_in_symtab;
      255 				     rp -> reference.qualifier -> reference.symbol -> symbol.put_in_symtab = "1"b;
      256 				end;
      257 		     end;
      258 
      259 	     ap = sp -> symbol.array;
      260 	     if ap ^= null
      261 	     then do;
      262 		     ap -> array.symtab_virtual_origin = encode (ap -> array.virtual_origin);
      263 
      264 		     do bp = ap -> array.bounds repeat bp -> bound.next while (bp ^= null);
      265 			bp -> bound.symtab_lower = encode (bp -> bound.lower);
      266 			bp -> bound.symtab_upper = encode (bp -> bound.upper);
      267 
      268 			if bp -> bound.c_multiplier = 0
      269 			then bp -> bound.symtab_multiplier = encode (bp -> bound.multiplier);
      270 		     end;
      271 		end;
      272 
      273 	     sp -> symbol.symtab_processed = "1"b;
      274 
      275 	     if sp -> symbol.son ^= null
      276 	     then sp = sp -> symbol.son;
      277 	     else do;
      278 		     found_brother = "0"b;
      279 		     do while (sp ^= null & ^found_brother);
      280 			if sp -> symbol.brother = null
      281 			then sp = sp -> symbol.father;
      282 			else do;
      283 				sp = sp -> symbol.brother;
      284 				found_brother = "1"b;
      285 			     end;
      286 		     end;
      287 		end;
      288 	end;
      289 
      290 	return;
      291 
      292 /* This procedure encodes for the runtime symbol table one expression used as
      293*   a size or bound on a symbol node.  It runs the semantic translator over the
      294*   expression in case it has not been previously referenced in the program.
      295**/
      296 encode:
      297      procedure (t) returns (ptr);
      298 
      299 dcl	t		ptr unaligned;
      300 
      301 dcl	convert_to_integer	bit (1) aligned;
      302 dcl	tp		ptr;
      303 
      304 	convert_to_integer = "1"b;
      305 	goto common;
      306 
      307 encode_qual:
      308      entry (t) returns (ptr);
      309 
      310 	convert_to_integer = "0"b;
      311 
      312 common:
      313 	if t = null
      314 	then return (t);
      315 
      316 	if s2 = null
      317 	then s2 = create_statement (unknown_statement, s1, null, ""b);
      318 	else do;
      319 		s2 -> statement.root = null;
      320 		string (s2 -> statement.source_id) = string (pl1_stat_$statement_id);
      321 	     end;
      322 
      323 	s2 -> statement.put_in_profile = "0"b;
      324 
      325 	tp = copy_expression (t);
      326 
      327 	if sp -> symbol.refer_extents
      328 	then tp = fill_refer (tp, ev_ref, "0"b);
      329 
      330 	pl1_stat_$locator (1) = ev_based_var;
      331 	pl1_stat_$index = 1;
      332 
      333 	tp = semantic_translator$call_es (cb, s2, tp, fail, convert_to_integer);
      334 	scan_again = "1"b;
      335 
      336 	if tp ^= null
      337 	then if tp -> node.type = operator_node
      338 	     then if tp -> operator.op_code = loop | tp -> operator.op_code = join
      339 		then do;
      340 			call error (73, null, sp);
      341 
      342 fail:
      343 			call error (318, null, sp);
      344 			return (null);
      345 		     end;
      346 
      347 	if ev_qual -> operator.operand (1) ^= ev_temp
      348 	then do;
      349 		call free_node ((ev_qual -> operator.operand (1)));
      350 		ev_qual -> operator.operand (1) = ev_temp;
      351 	     end;
      352 
      353 	if ev_ref -> reference.qualifier ^= ev_qual
      354 	then do;
      355 		call free_node ((ev_ref -> reference.qualifier));
      356 		ev_ref -> reference.qualifier = ev_qual;
      357 	     end;
      358 
      359 	if s1 -> statement.next ^= s2
      360 	then do;
      361 		s2 -> statement.root = tp;
      362 		s2 = null;
      363 		return (s1 -> statement.next);
      364 	     end;
      365 
      366 	return (tp);
      367      end encode;
      368 
      369      end process;
      370 
      371      end scan_symbol_table;
      372 
      373      end prepare_symbol_table;
	SOURCE FILES USED IN THIS COMPILATION.

LINE      NUMBER  DATE MODIFIED     NAME			PATHNAME
             0    04/18/00  1131.6  prepare_symbol_table.pl1          >udd>sm>ds>w>ml>prepare_symbol_table.pl1
55           1    08/13/81  2143.5  block.incl.pl1                    >ldd>incl>block.incl.pl1
56           2    12/07/83  1801.7  symbol.incl.pl1                   >ldd>incl>symbol.incl.pl1
57           3    05/06/74  1841.6  array.incl.pl1                    >ldd>incl>array.incl.pl1
58           4    07/21/80  1646.3  reference.incl.pl1                >ldd>incl>reference.incl.pl1
59           5    07/21/80  1646.3  operator.incl.pl1                 >ldd>incl>operator.incl.pl1
60           6    04/07/83  1735.0  statement.incl.pl1                >ldd>incl>statement.incl.pl1
61           7    07/21/80  1646.3  nodes.incl.pl1                    >ldd>incl>nodes.incl.pl1
62           8    05/03/76  1420.8  block_types.incl.pl1              >ldd>incl>block_types.incl.pl1
63           9    10/25/79  1745.8  declare_type.incl.pl1             >ldd>incl>declare_type.incl.pl1
64          10    05/03/76  1420.4  statement_types.incl.pl1          >ldd>incl>statement_types.incl.pl1
65          11    04/07/83  1735.0  op_codes.incl.pl1                 >ldd>incl>op_codes.incl.pl1
66          12    12/07/83  1801.7  system.incl.pl1                   >ldd>incl>system.incl.pl1
67          13    07/21/80  1646.3  semant.incl.pl1                   >ldd>incl>semant.incl.pl1
13-228      14    08/01/89  1339.9  language_utility.incl.pl1         >ldd>incl>language_utility.incl.pl1
14-307      15    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
14-325      16    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
14-335      17    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
14-374      18    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
14-386      19    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.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.
allocate                 33(02)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 set ref 128
                                                                                  184 185*
ap                              000142 automatic       pointer                  dcl 170 set ref 259* 260 262 262 264
array                    12            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 259
array                                  based           structure                level 1 dcl 3-1 in procedure "prepare_symbol_table"
array_ref                       000144 automatic       bit(1)                   dcl 171 in procedure "process" set ref 226* 241
array_ref                 0(09)        based           bit(1)                   level 2 in structure "reference" packed packed
                                                                                  unaligned dcl 4-3 in procedure
                                                                                  "prepare_symbol_table" set ref 226 227* 241*
attributes               31            based           structure                level 2 dcl 2-3
auto                     32(09)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 set ref 79*
                                                                                  86*
based                    32(10)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 set ref 87*
                                                                                  244
bits                     13            based           structure                level 2 packed packed unaligned dcl 6-9
block                                  based           structure                level 1 dcl 1-5
block_node                4            based           pointer                  level 2 packed packed unaligned dcl 2-3 ref 216
bound                                  based           structure                level 1 dcl 3-21
bounds                   12            based           pointer                  level 2 packed packed unaligned dcl 3-1 ref 264
bp                              000146 automatic       pointer                  dcl 172 set ref 216* 216 264* 264* 265 265 266 266
                                                                                  268 268 268* 270
brother                  20            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 280 283
brother                   2            based           pointer                  level 2 in structure "block" packed packed unaligned
                                                                                  dcl 1-5 in procedure "prepare_symbol_table" ref
                                                                                  146 149
builtin                  31(16)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 128
by_compiler                            constant        bit(3)                   initial dcl 9-5 ref 128
c_multiplier              3            based           fixed bin(24,0)          level 2 dcl 3-21 ref 268
cb                              000124 automatic       pointer                  dcl 118 set ref 124* 125 126 127 141 141* 141 145
                                                                                  146 146* 146 149* 149 333*
compiler_developed       32(35)        based           structure                level 3 packed packed unaligned dcl 2-3
condition                31(14)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 128
constant                 32(16)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 128
context                  10            based           pointer                  level 2 packed packed unaligned dcl 1-5 set ref 77*
convert_to_integer              000164 automatic       bit(1)                   dcl 301 set ref 304* 310* 333*
copy_expression                 000032 constant        entry                    external dcl 14-94 ref 216 216 325
create_block                    000034 constant        entry                    external dcl 14-112 ref 74
create_operator                 000036 constant        entry                    external dcl 14-152 ref 71
create_statement                000040 constant        entry                    external dcl 14-163 ref 89 316
cross_references         10            based           pointer                  level 2 packed packed unaligned dcl 2-3 ref 128
data_type                31            based           structure                level 3 packed packed unaligned dcl 2-3
dcl_size                 24            based           pointer                  level 2 packed packed unaligned dcl 2-3 set ref 203*
dcl_type                  1(19)        based           bit(3)                   level 2 packed packed unaligned dcl 2-3 ref 128
declaration               4            based           pointer                  level 2 packed packed unaligned dcl 1-5 ref 127
declare_constant$integer        000042 constant        entry                    external dcl 14-234 ref 73
declare_integer                 000044 constant        entry                    external dcl 14-269 ref 83
declare_pointer                 000046 constant        entry                    external dcl 14-287 ref 76
declare_temporary               000050 constant        entry                    external dcl 14-292 ref 72
defined                  32(13)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 209
entry                    31(09)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 203
equivalence              14            based           pointer                  level 2 packed packed unaligned dcl 2-3 set ref 216*
                                                                                  216*
error                           000052 constant        entry                    external dcl 14-314 ref 340 342
ev_based_var                    000100 automatic       pointer                  dcl 27 set ref 83* 84 86 87 330
ev_qual                         000102 automatic       pointer                  dcl 28 set ref 71* 72 73 74 77 347 349 350 353 356
ev_ref                          000104 automatic       pointer                  dcl 29 set ref 76* 77 79 80 81 84 327* 353 355 356
ev_temp                         000106 automatic       pointer                  dcl 30 set ref 72* 347 350
father                   17            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 133 134 280
father                    1            based           pointer                  level 2 in structure "block" packed packed unaligned
                                                                                  dcl 1-5 in procedure "prepare_symbol_table" ref
                                                                                  146
fill_refer                      000024 constant        entry                    external dcl 13-113 ref 327
found_brother                   000126 automatic       bit(1)                   dcl 119 set ref 144* 145 150* 278* 279 284*
free_node                       000054 constant        entry                    external dcl 14-345 ref 349 355
general                  16            based           pointer                  level 2 packed packed unaligned dcl 2-3 set ref 184
                                                                                  185 188 191* 191* 193 193 196 199
get_data                        000127 automatic       bit(1)                   dcl 120 in procedure "scan_symbol_table" set ref
                                                                                  126* 128 136
get_data                 24(23)        based           bit(1)                   level 2 in structure "block" packed packed unaligned
                                                                                  dcl 1-5 in procedure "prepare_symbol_table" ref
                                                                                  126
internal_procedure              000002 constant        bit(9)                   initial dcl 8-1 set ref 74*
join                                   constant        bit(9)                   initial dcl 11-8 ref 336
location                  1            based           fixed bin(18,0)          level 2 packed packed unsigned unaligned dcl 2-3 set
                                                                                  ref 81*
lookup                          000026 constant        entry                    external dcl 13-153 ref 216
loop                                   constant        bit(9)                   initial dcl 11-8 ref 336
lower                     5            based           pointer                  level 2 packed packed unaligned dcl 3-21 set ref
                                                                                  265*
multiplier                7            based           pointer                  level 2 packed packed unaligned dcl 3-21 set ref
                                                                                  268*
next                     14            based           pointer                  level 2 in structure "bound" packed packed unaligned
                                                                                  dcl 3-21 in procedure "prepare_symbol_table" ref
                                                                                  270
next                      6            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 139
next                      1            based           pointer                  level 2 in structure "statement" packed packed
                                                                                  unaligned dcl 6-9 in procedure
                                                                                  "prepare_symbol_table" ref 359 363
node                                   based           structure                level 1 dcl 7-27
null                                                   builtin function         dcl 37 ref 72 72 74 74 89 89 90 125 127 128 133 141
                                                                                  145 146 178 188 193 216 216 216 230 244 249 260
                                                                                  264 275 279 280 312 316 316 316 319 336 340 340
                                                                                  342 342 344 362
offset                    5            based           pointer                  level 2 in structure "reference" packed packed
                                                                                  unaligned dcl 4-3 in procedure
                                                                                  "prepare_symbol_table" set ref 207* 207*
offset                   31(06)        based           bit(1)                   level 4 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 188
op_code                   0(09)        based           bit(9)                   level 2 packed packed unaligned dcl 5-6 ref 336 336
operand                   1            based           pointer                  array level 2 packed packed unaligned dcl 5-6 set
                                                                                  ref 72* 73* 74* 347 349 350*
operator                               based           structure                level 1 dcl 5-6
operator_node                   000002 constant        bit(9)                   initial dcl 7-5 ref 336
p                               000130 automatic       pointer                  dcl 121 set ref 127* 127* 128 128 128 128 128 128
                                                                                  128 128 133* 139
param_ptr                       000001 constant        bit(9)                   initial dcl 11-8 set ref 71*
parameter                32(14)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 set ref 80*
picture                  31(18)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 182
pl1_stat_$cur_statement         000010 external static pointer                  dcl 41 set ref 179*
pl1_stat_$dummy_block           000012 external static pointer                  dcl 43 set ref 74* 76* 77 83* 89*
pl1_stat_$index                 000014 external static fixed bin(17,0)          dcl 45 set ref 331*
pl1_stat_$locator               000016 external static pointer                  array dcl 46 set ref 330*
pl1_stat_$statement_id          000020 external static structure                level 1 packed packed unaligned dcl 47 set ref 180*
                                                                                  320
pl1_stat_$table                 000022 external static bit(1)                   dcl 53 ref 136
pointer_type                    000000 constant        bit(36)                  initial dcl 12-71 set ref 72*
processed                 0(13)        based           bit(1)                   level 2 packed packed unaligned dcl 4-3 set ref 236*
pt                                     parameter       pointer                  dcl 168 ref 165 177
put_in_profile           13(01)        based           bit(1)                   level 3 packed packed unaligned dcl 6-9 set ref 323*
put_in_symtab            33(08)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 set ref 136
                                                                                  196 199* 252 255*
q                               000132 automatic       pointer                  dcl 122 set ref 133* 133* 134 136 136*
qp                              000150 automatic       pointer                  dcl 173 set ref 229* 230 230 233 234 236 238
qualifier                 4            based           pointer                  level 2 packed packed unaligned dcl 4-3 set ref 77*
                                                                                  84* 216 216* 244 247* 247* 249 249 252 255 353 355
                                                                                  356*
ref_count                 0(18)        based           fixed bin(17,0)          level 2 packed packed unaligned dcl 4-3 set ref 233*
refer_extents            33(05)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 327
reference                15            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" set ref 206 216 216 216 226
                                                                                  227 229* 238* 241
reference                              based           structure                level 1 dcl 4-3 in procedure "prepare_symbol_table"
reference_node                         constant        bit(9)                   initial dcl 7-5 ref 193 230 249
root                      3            based           pointer                  level 2 in structure "statement" packed packed
                                                                                  unaligned dcl 6-9 in procedure
                                                                                  "prepare_symbol_table" set ref 319* 361*
root                                   parameter       pointer                  dcl 23 in procedure "prepare_symbol_table" ref 20
                                                                                  124
rp                              000152 automatic       pointer                  dcl 174 set ref 206* 207 207 244 247 247 249 249 252
                                                                                  255
s1                              000110 automatic       pointer                  dcl 31 set ref 89* 316* 359 363
s2                              000112 automatic       pointer                  dcl 32 set ref 90* 316 316* 319 320 323 333* 359 361
                                                                                  362*
scan_again                      000114 automatic       bit(1)                   dcl 33 set ref 102* 103 104* 184* 184 196* 196 252*
                                                                                  252 334*
semantic_translator$call_es     000030 constant        entry                    external dcl 13-196 ref 333
shared                    0(11)        based           bit(1)                   level 2 packed packed unaligned dcl 4-3 set ref 234*
son                      21            based           pointer                  level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 275 275
son                       3            based           pointer                  level 2 in structure "block" packed packed unaligned
                                                                                  dcl 1-5 in procedure "prepare_symbol_table" ref
                                                                                  141 141
source_id                 0(09)        based           structure                level 2 in structure "statement" packed packed
                                                                                  unaligned dcl 6-9 in procedure
                                                                                  "prepare_symbol_table" set ref 320*
source_id                 0(09)        based           structure                level 2 in structure "symbol" packed packed
                                                                                  unaligned dcl 2-3 in procedure
                                                                                  "prepare_symbol_table" ref 180
sp                              000154 automatic       pointer                  dcl 175 set ref 177* 178 179 180 182 184 185 188 188
                                                                                  191 191 193 193 196 199 203 203 203 206 209 209
                                                                                  216 216 216 216 216 226 227 229 238 241 244 259
                                                                                  273 275 275* 275 279 280 280* 280 283* 283 327
                                                                                  340* 342*
statement                              based           structure                level 1 dcl 6-9
storage_class            32(09)        based           structure                level 3 packed packed unaligned dcl 2-3
string                                                 builtin function         dcl 37 set ref 180* 180 320* 320
structure                31            based           bit(1)                   level 4 packed packed unaligned dcl 2-3 ref 209
symbol                                 based           structure                level 1 dcl 2-3 in procedure "prepare_symbol_table"
symbol                    3            based           pointer                  level 2 in structure "reference" packed packed
                                                                                  unaligned dcl 4-3 in procedure
                                                                                  "prepare_symbol_table" ref 79 80 81 86 87 184 185
                                                                                  196 199 252 255
symbol_node                            constant        bit(9)                   initial dcl 7-5 ref 128
symtab_lower             11            based           pointer                  level 2 packed packed unaligned dcl 3-21 set ref
                                                                                  265*
symtab_multiplier        13            based           pointer                  level 2 packed packed unaligned dcl 3-21 set ref
                                                                                  268*
symtab_processed         33(13)        based           bit(1)                   level 4 packed packed unaligned dcl 2-3 set ref 128
                                                                                  273*
symtab_size              25            based           pointer                  level 2 packed packed unaligned dcl 2-3 set ref 203*
symtab_upper             12            based           pointer                  level 2 packed packed unaligned dcl 3-21 set ref
                                                                                  266*
symtab_virtual_origin
                         10            based           pointer                  level 2 packed packed unaligned dcl 3-1 set ref 262*
t                                      parameter       pointer                  packed unaligned dcl 299 set ref 296 307 312 312
                                                                                  325*
tp                              000166 automatic       pointer                  dcl 302 set ref 325* 327* 327* 333* 333* 336 336 336
                                                                                  336 361 366
type                                   based           bit(9)                   level 2 packed packed unaligned dcl 7-27 ref 128 193
                                                                                  230 249 336
unknown_statement               000004 constant        bit(9)                   initial dcl 10-3 set ref 89* 316*
upper                     6            based           pointer                  level 2 packed packed unaligned dcl 3-21 set ref
                                                                                  266*
virtual_origin            7            based           pointer                  level 2 packed packed unaligned dcl 3-1 set ref 262*

NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED.
a_format                               internal static bit(9)                   initial dcl 11-8
abs_fun                                internal static bit(9)                   initial dcl 11-8
acos_fun                               internal static bit(9)                   initial dcl 11-8
acosd_fun                              internal static bit(9)                   initial dcl 11-8
add                                    internal static bit(9)                   initial dcl 11-8
addbitno_fun                           internal static bit(9)                   initial dcl 11-8
addcharno_fun                          internal static bit(9)                   initial dcl 11-8
addr_fun                               internal static bit(9)                   initial dcl 11-8
addr_fun_bits                          internal static bit(9)                   initial dcl 11-8
addrel_fun                             internal static bit(9)                   initial dcl 11-8
adjust_count                    000000 constant        entry                    external dcl 14-20
alloc_semantics                 000000 constant        entry                    external dcl 13-7
alloc_semantics$init_only       000000 constant        entry                    external dcl 13-12
allocate_statement                     internal static bit(9)                   initial dcl 10-3
allocation_fun                         internal static bit(9)                   initial dcl 11-8
allot_auto                             internal static bit(9)                   initial dcl 11-8
allot_based                            internal static bit(9)                   initial dcl 11-8
allot_ctl                              internal static bit(9)                   initial dcl 11-8
allot_var                              internal static bit(9)                   initial dcl 11-8
and_bits                               internal static bit(9)                   initial dcl 11-8
arg_desc_type                          internal static bit(36)                  initial dcl 12-71
array_node                             internal static bit(9)                   initial dcl 7-5
asin_fun                               internal static bit(9)                   initial dcl 11-8
asind_fun                              internal static bit(9)                   initial dcl 11-8
assign                                 internal static bit(9)                   initial dcl 11-8
assign_by_name                         internal static bit(9)                   initial dcl 11-8
assign_round                           internal static bit(9)                   initial dcl 11-8
assign_size_ck                         internal static bit(9)                   initial dcl 11-8
assign_zero                            internal static bit(9)                   initial dcl 11-8
assignment_statement                   internal static bit(9)                   initial dcl 10-3
atan_fun                               internal static bit(9)                   initial dcl 11-8
atand_fun                              internal static bit(9)                   initial dcl 11-8
b_format                               internal static bit(9)                   initial dcl 11-8
baseno_fun                             internal static bit(9)                   initial dcl 11-8
baseptr_fun                            internal static bit(9)                   initial dcl 11-8
begin_block                            internal static bit(9)                   initial dcl 8-1
begin_statement                        internal static bit(9)                   initial dcl 10-3
binary_to_octal_string          000000 constant        entry                    external dcl 14-38
binary_to_octal_var_string      000000 constant        entry                    external dcl 14-43
bindec                          000000 constant        entry                    external dcl 14-23
bindec$vs                       000000 constant        entry                    external dcl 14-28
binoct                          000000 constant        entry                    external dcl 14-33
bit_pointer                            internal static bit(9)                   initial dcl 11-8
bit_to_char                            internal static bit(9)                   initial dcl 11-8
bit_to_word                            internal static bit(9)                   initial dcl 11-8
bit_type                               internal static bit(36)                  initial dcl 12-71
bitno_fun                              internal static bit(9)                   initial dcl 11-8
bits_per_binary_exponent               internal static fixed bin(31,0)          initial dcl 12-5
bits_per_character                     internal static fixed bin(31,0)          initial dcl 12-5
bits_per_decimal_digit                 internal static fixed bin(31,0)          initial dcl 12-5
bits_per_digit                         internal static fixed bin(31,1)          initial dcl 12-69
bits_per_double                        internal static fixed bin(31,0)          initial dcl 12-5
bits_per_half                          internal static fixed bin(31,0)          initial dcl 12-5
bits_per_packed_ptr                    internal static fixed bin(31,0)          initial dcl 12-5
bits_per_word                          internal static fixed bin(31,0)          initial dcl 12-5
block_node                             internal static bit(9)                   initial dcl 7-5
bn_format                              internal static bit(9)                   initial dcl 11-8
bool_fun                               internal static bit(9)                   initial dcl 11-8
bound_ck                               internal static bit(9)                   initial dcl 11-8
bound_node                             internal static bit(9)                   initial dcl 7-5
builtin                         000000 constant        entry                    external dcl 13-17
builtin_type                           internal static bit(36)                  initial dcl 12-71
by_context                             internal static bit(3)                   initial dcl 9-5
by_declare                             internal static bit(3)                   initial dcl 9-5
by_explicit_context                    internal static bit(3)                   initial dcl 9-5
by_implication                         internal static bit(3)                   initial dcl 9-5
by_name_agg_node                       internal static bit(9)                   initial dcl 7-5
byte_fun                               internal static bit(9)                   initial dcl 11-8
c_format                               internal static bit(9)                   initial dcl 11-8
call_statement                         internal static bit(9)                   initial dcl 10-3
cat_string                             internal static bit(9)                   initial dcl 11-8
ceil_fun                               internal static bit(9)                   initial dcl 11-8
char_to_word                           internal static bit(9)                   initial dcl 11-8
char_type                              internal static bit(36)                  initial dcl 12-71
characters_per_double                  internal static fixed bin(31,0)          initial dcl 12-5
characters_per_half                    internal static fixed bin(31,0)          initial dcl 12-5
characters_per_word                    internal static fixed bin(31,0)          initial dcl 12-5
charno_fun                             internal static bit(9)                   initial dcl 11-8
check_star_extents              000000 constant        entry                    external dcl 13-27
clock_fun                              internal static bit(9)                   initial dcl 11-8
close_file                             internal static bit(9)                   initial dcl 11-8
close_statement                        internal static bit(9)                   initial dcl 10-3
codeptr_fun                            internal static bit(9)                   initial dcl 11-8
column_format                          internal static bit(9)                   initial dcl 11-8
compare_declaration             000000 constant        entry                    external dcl 13-31
compare_expression              000000 constant        entry                    external dcl 14-48
complex_fun                            internal static bit(9)                   initial dcl 11-8
complex_type                           internal static bit(36)                  initial dcl 12-71
conjg_fun                              internal static bit(9)                   initial dcl 11-8
constant_length                 000000 constant        entry                    external dcl 14-54
context_node                           internal static bit(9)                   initial dcl 7-5
context_processor               000000 constant        entry                    external dcl 13-38
continue_statement                     internal static bit(9)                   initial dcl 10-3
convert                         000000 constant        entry                    external dcl 14-60
convert$from_builtin            000000 constant        entry                    external dcl 14-72
convert$to_integer              000000 constant        entry                    external dcl 14-66
convert$to_target               000000 constant        entry                    external dcl 14-88
convert$to_target_fb            000000 constant        entry                    external dcl 14-82
convert$validate                000000 constant        entry                    external dcl 14-78
copy_expression$copy_sons       000000 constant        entry                    external dcl 14-99
copy_string                            internal static bit(9)                   initial dcl 11-8
copy_unique_expression          000000 constant        entry                    external dcl 14-103
copy_words                             internal static bit(9)                   initial dcl 11-8
cos_fun                                internal static bit(9)                   initial dcl 11-8
cosd_fun                               internal static bit(9)                   initial dcl 11-8
create_array                    000000 constant        entry                    external dcl 14-108
create_bound                    000000 constant        entry                    external dcl 14-118
create_context                  000000 constant        entry                    external dcl 14-122
create_cross_reference          000000 constant        entry                    external dcl 14-128
create_default                  000000 constant        entry                    external dcl 14-132
create_identifier               000000 constant        entry                    external dcl 14-136
create_label                    000000 constant        entry                    external dcl 14-140
create_list                     000000 constant        entry                    external dcl 14-147
create_reference                000000 constant        entry                    external dcl 14-158
create_statement$prologue       000000 constant        entry                    external dcl 14-171
create_storage                  000000 constant        entry                    external dcl 14-179
create_symbol                   000000 constant        entry                    external dcl 14-184
create_token                    000000 constant        entry                    external dcl 14-191
create_token$init_hash_table    000000 constant        entry                    external dcl 14-197
create_token$protected          000000 constant        entry                    external dcl 14-199
cross_reference_node                   internal static bit(9)                   initial dcl 7-5
dec_integer_type                       internal static bit(36)                  initial dcl 12-71
decbin                          000000 constant        entry                    external dcl 14-206
declare                         000000 constant        entry                    external dcl 13-41
declare_constant                000000 constant        entry                    external dcl 14-211
declare_constant$bit            000000 constant        entry                    external dcl 14-219
declare_constant$char           000000 constant        entry                    external dcl 14-224
declare_constant$desc           000000 constant        entry                    external dcl 14-229
declare_descriptor              000000 constant        entry                    external dcl 14-239
declare_descriptor$ctl          000000 constant        entry                    external dcl 14-249
declare_descriptor$param        000000 constant        entry                    external dcl 14-259
declare_picture                 000000 constant        entry                    external dcl 14-274
declare_picture_temp            000000 constant        entry                    external dcl 14-279
declare_statement                      internal static bit(9)                   initial dcl 10-3
declare_structure               000000 constant        entry                    external dcl 13-44
decode_node_id                  000000 constant        entry                    external dcl 14-300
decode_source_id                000000 constant        entry                    external dcl 14-306
default_area_size                      internal static fixed bin(31,0)          initial dcl 12-5
default_fix_bin_p                      internal static fixed bin(31,0)          initial dcl 12-5
default_fix_dec_p                      internal static fixed bin(31,0)          initial dcl 12-5
default_flt_bin_p                      internal static fixed bin(31,0)          initial dcl 12-5
default_flt_dec_p                      internal static fixed bin(31,0)          initial dcl 12-5
default_node                           internal static bit(9)                   initial dcl 7-5
default_statement                      internal static bit(9)                   initial dcl 10-3
defined_reference               000000 constant        entry                    external dcl 13-47
delete_file                            internal static bit(9)                   initial dcl 11-8
delete_statement                       internal static bit(9)                   initial dcl 10-3
desc_size                              internal static bit(9)                   initial dcl 11-8
digit_to_bit                           internal static bit(9)                   initial dcl 11-8
display_statement                      internal static bit(9)                   initial dcl 10-3
div                                    internal static bit(9)                   initial dcl 11-8
do_fun                                 internal static bit(9)                   initial dcl 11-8
do_semantics                    000000 constant        entry                    external dcl 13-57
do_spec                                internal static bit(9)                   initial dcl 11-8
do_statement                           internal static bit(9)                   initial dcl 10-3
e_format                               internal static bit(9)                   initial dcl 11-8
else_clause                            internal static bit(9)                   initial dcl 10-3
empty_area                             internal static bit(9)                   initial dcl 11-8
enable_on                              internal static bit(9)                   initial dcl 11-8
end_statement                          internal static bit(9)                   initial dcl 10-3
entry_statement                        internal static bit(9)                   initial dcl 10-3
entry_var_type                         internal static bit(36)                  initial dcl 12-71
environmentptr_fun                     internal static bit(9)                   initial dcl 11-8
equal                                  internal static bit(9)                   initial dcl 11-8
error$omit_text                 000000 constant        entry                    external dcl 14-319
error_                          000000 constant        entry                    external dcl 14-324
error_$finish                   000000 constant        entry                    external dcl 14-343
error_$initialize_error         000000 constant        entry                    external dcl 14-341
error_$no_text                  000000 constant        entry                    external dcl 14-334
ex_prologue                            internal static bit(9)                   initial dcl 11-8
exit_statement                         internal static bit(9)                   initial dcl 10-3
exp                                    internal static bit(9)                   initial dcl 11-8
exp_fun                                internal static bit(9)                   initial dcl 11-8
expand_assign                   000000 constant        entry                    external dcl 13-62
expand_by_name                  000000 constant        entry                    external dcl 13-71
expand_infix                    000000 constant        entry                    external dcl 13-76
expand_initial                  000000 constant        entry                    external dcl 13-84
expand_prefix                   000000 constant        entry                    external dcl 13-89
expand_primitive                000000 constant        entry                    external dcl 13-97
expression_semantics            000000 constant        entry                    external dcl 13-105
external_procedure                     internal static bit(9)                   initial dcl 8-1
f_format                               internal static bit(9)                   initial dcl 11-8
floor_fun                              internal static bit(9)                   initial dcl 11-8
format_statement                       internal static bit(9)                   initial dcl 10-3
format_value_node                      internal static bit(9)                   initial dcl 7-5
fortran_read                           internal static bit(9)                   initial dcl 11-8
fortran_write                          internal static bit(9)                   initial dcl 11-8
free_based                             internal static bit(9)                   initial dcl 11-8
free_ctl                               internal static bit(9)                   initial dcl 11-8
free_statement                         internal static bit(9)                   initial dcl 10-3
free_var                               internal static bit(9)                   initial dcl 11-8
ftn_file_manip                         internal static bit(9)                   initial dcl 11-8
ftn_trans_loop                         internal static bit(9)                   initial dcl 11-8
function                        000000 constant        entry                    external dcl 13-125
generic_selector                000000 constant        entry                    external dcl 13-134
get_array_size                  000000 constant        entry                    external dcl 14-348
get_data_trans                         internal static bit(9)                   initial dcl 11-8
get_edit_trans                         internal static bit(9)                   initial dcl 11-8
get_file                               internal static bit(9)                   initial dcl 11-8
get_list_trans                         internal static bit(9)                   initial dcl 11-8
get_size                        000000 constant        entry                    external dcl 14-352
get_statement                          internal static bit(9)                   initial dcl 10-3
get_string                             internal static bit(9)                   initial dcl 11-8
goto_statement                         internal static bit(9)                   initial dcl 10-3
greater_or_equal                       internal static bit(9)                   initial dcl 11-8
greater_than                           internal static bit(9)                   initial dcl 11-8
half_to_word                           internal static bit(9)                   initial dcl 11-8
if_statement                           internal static bit(9)                   initial dcl 10-3
imag_fun                               internal static bit(9)                   initial dcl 11-8
index_after_fun                        internal static bit(9)                   initial dcl 11-8
index_before_fun                       internal static bit(9)                   initial dcl 11-8
index_fun                              internal static bit(9)                   initial dcl 11-8
index_rev_fun                          internal static bit(9)                   initial dcl 11-8
integer_type                           internal static bit(36)                  initial dcl 12-71
io_data_list_semantics          000000 constant        entry                    external dcl 13-143
io_data_list_semantics$format_list_semantics
                                000000 constant        entry                    external dcl 13-120
io_semantics                    000000 constant        entry                    external dcl 13-148
jump                                   internal static bit(9)                   initial dcl 11-8
jump_false                             internal static bit(9)                   initial dcl 11-8
jump_if_eq                             internal static bit(9)                   initial dcl 11-8
jump_if_ge                             internal static bit(9)                   initial dcl 11-8
jump_if_gt                             internal static bit(9)                   initial dcl 11-8
jump_if_le                             internal static bit(9)                   initial dcl 11-8
jump_if_lt                             internal static bit(9)                   initial dcl 11-8
jump_if_ne                             internal static bit(9)                   initial dcl 11-8
jump_true                              internal static bit(9)                   initial dcl 11-8
l_parn                                 internal static bit(9)                   initial dcl 11-8
label_array_element_node               internal static bit(9)                   initial dcl 7-5
label_node                             internal static bit(9)                   initial dcl 7-5
length_fun                             internal static bit(9)                   initial dcl 11-8
less_or_equal                          internal static bit(9)                   initial dcl 11-8
less_than                              internal static bit(9)                   initial dcl 11-8
line_format                            internal static bit(9)                   initial dcl 11-8
list_node                              internal static bit(9)                   initial dcl 7-5
local_label_var_type                   internal static bit(36)                  initial dcl 12-71
locate_file                            internal static bit(9)                   initial dcl 11-8
locate_statement                       internal static bit(9)                   initial dcl 10-3
lock_file                              internal static bit(9)                   initial dcl 11-8
lock_fun                               internal static bit(9)                   initial dcl 11-8
lock_statement                         internal static bit(9)                   initial dcl 10-3
log10_fun                              internal static bit(9)                   initial dcl 11-8
log2_fun                               internal static bit(9)                   initial dcl 11-8
log_fun                                internal static bit(9)                   initial dcl 11-8
machine_state_node                     internal static bit(9)                   initial dcl 7-5
make_desc                              internal static bit(9)                   initial dcl 11-8
make_non_quick                  000000 constant        entry                    external dcl 13-162
match_arguments                 000000 constant        entry                    external dcl 13-166
max_area_size                          internal static fixed bin(31,0)          initial dcl 12-5
max_bit_string                         internal static fixed bin(31,0)          initial dcl 12-5
max_bit_string_constant                internal static fixed bin(31,0)          initial dcl 12-5
max_block_number                       internal static fixed bin(17,0)          initial dcl 1-74
max_char_string                        internal static fixed bin(31,0)          initial dcl 12-5
max_char_string_constant               internal static fixed bin(31,0)          initial dcl 12-5
max_fun                                internal static bit(9)                   initial dcl 11-8
max_identifier_length                  internal static fixed bin(31,0)          initial dcl 12-5
max_index_register_value               internal static fixed bin(31,0)          initial dcl 12-5
max_length_precision                   internal static fixed bin(31,0)          initial dcl 12-5
max_number_of_dimensions               internal static fixed bin(31,0)          initial dcl 12-5
max_number_of_operands                 internal static fixed bin(15,0)          initial dcl 5-15
max_offset_precision                   internal static fixed bin(31,0)          initial dcl 12-5
max_p_bin_or_dec                       internal static fixed bin(31,0)          initial dcl 12-5
max_p_dec                              internal static fixed bin(31,0)          initial dcl 12-5
max_p_fix_bin_1                        internal static fixed bin(31,0)          initial dcl 12-5
max_p_fix_bin_2                        internal static fixed bin(31,0)          initial dcl 12-5
max_p_flt_bin_1                        internal static fixed bin(31,0)          initial dcl 12-5
max_p_flt_bin_2                        internal static fixed bin(31,0)          initial dcl 12-5
max_scale                              internal static fixed bin(31,0)          initial dcl 12-5
max_signed_index_register_value        internal static fixed bin(31,0)          initial dcl 12-5
max_signed_xreg_precision              internal static fixed bin(31,0)          initial dcl 12-5
max_uns_xreg_precision                 internal static fixed bin(31,0)          initial dcl 12-5
max_words_per_variable                 internal static fixed bin(31,0)          initial dcl 12-5
merge_attributes                000000 constant        entry                    external dcl 14-355
min_area_size                          internal static fixed bin(31,0)          initial dcl 12-5
min_fun                                internal static bit(9)                   initial dcl 11-8
min_scale                              internal static fixed bin(31,0)          initial dcl 12-5
mod_bit                                internal static bit(9)                   initial dcl 11-8
mod_byte                               internal static bit(9)                   initial dcl 11-8
mod_fun                                internal static bit(9)                   initial dcl 11-8
mod_half                               internal static bit(9)                   initial dcl 11-8
mod_word                               internal static bit(9)                   initial dcl 11-8
mult                                   internal static bit(9)                   initial dcl 11-8
negate                                 internal static bit(9)                   initial dcl 11-8
nop                                    internal static bit(9)                   initial dcl 11-8
not_bits                               internal static bit(9)                   initial dcl 11-8
not_equal                              internal static bit(9)                   initial dcl 11-8
null_statement                         internal static bit(9)                   initial dcl 10-3
off_fun                                internal static bit(9)                   initial dcl 11-8
offset_adder                    000000 constant        entry                    external dcl 13-172
on_statement                           internal static bit(9)                   initial dcl 10-3
on_unit                                internal static bit(9)                   initial dcl 8-1
open_file                              internal static bit(9)                   initial dcl 11-8
open_statement                         internal static bit(9)                   initial dcl 10-3
operator_semantics              000000 constant        entry                    external dcl 13-184
optimizer                       000000 constant        entry                    external dcl 14-361
or_bits                                internal static bit(9)                   initial dcl 11-8
pack                                   internal static bit(9)                   initial dcl 11-8
packed_digits_per_character            internal static fixed bin(31,0)          initial dcl 12-5
page_format                            internal static bit(9)                   initial dcl 11-8
param_desc_ptr                         internal static bit(9)                   initial dcl 11-8
parse_error                     000000 constant        entry                    external dcl 14-364
parse_error$no_text             000000 constant        entry                    external dcl 14-368
picture_format                         internal static bit(9)                   initial dcl 11-8
pl1_error_print$listing_segment 000000 constant        entry                    external dcl 14-384
pl1_error_print$write_out       000000 constant        entry                    external dcl 14-372
pl1_mod_fun                            internal static bit(9)                   initial dcl 11-8
pl1_print$for_lex               000000 constant        entry                    external dcl 14-418
pl1_print$non_varying           000000 constant        entry                    external dcl 14-398
pl1_print$non_varying_nl        000000 constant        entry                    external dcl 14-402
pl1_print$string_pointer        000000 constant        entry                    external dcl 14-406
pl1_print$string_pointer_nl     000000 constant        entry                    external dcl 14-410
pl1_print$unaligned_nl          000000 constant        entry                    external dcl 14-414
pl1_print$varying               000000 constant        entry                    external dcl 14-392
pl1_print$varying_nl            000000 constant        entry                    external dcl 14-395
prefix_plus                            internal static bit(9)                   initial dcl 11-8
procedure_statement                    internal static bit(9)                   initial dcl 10-3
propagate_bit                   000000 constant        entry                    external dcl 13-192
ptr_fun                                internal static bit(9)                   initial dcl 11-8
put_control                            internal static bit(9)                   initial dcl 11-8
put_data_trans                         internal static bit(9)                   initial dcl 11-8
put_edit_trans                         internal static bit(9)                   initial dcl 11-8
put_field                              internal static bit(9)                   initial dcl 11-8
put_field_chk                          internal static bit(9)                   initial dcl 11-8
put_file                               internal static bit(9)                   initial dcl 11-8
put_list_trans                         internal static bit(9)                   initial dcl 11-8
put_statement                          internal static bit(9)                   initial dcl 10-3
put_string                             internal static bit(9)                   initial dcl 11-8
r_format                               internal static bit(9)                   initial dcl 11-8
r_parn                                 internal static bit(9)                   initial dcl 11-8
range_ck                               internal static bit(9)                   initial dcl 11-8
rank_fun                               internal static bit(9)                   initial dcl 11-8
read_file                              internal static bit(9)                   initial dcl 11-8
read_statement                         internal static bit(9)                   initial dcl 10-3
real_fun                               internal static bit(9)                   initial dcl 11-8
real_type                              internal static bit(36)                  initial dcl 12-71
record_io                              internal static bit(9)                   initial dcl 11-8
refer                                  internal static bit(9)                   initial dcl 11-8
refer_extent                    000000 constant        entry                    external dcl 14-426
rel_fun                                internal static bit(9)                   initial dcl 11-8
repeat_fun                             internal static bit(9)                   initial dcl 11-8
reserve$clear                   000000 constant        entry                    external dcl 14-430
reserve$declare_lib             000000 constant        entry                    external dcl 14-434
reserve$read_lib                000000 constant        entry                    external dcl 14-439
return_bits                            internal static bit(9)                   initial dcl 11-8
return_statement                       internal static bit(9)                   initial dcl 10-3
return_string                          internal static bit(9)                   initial dcl 11-8
return_value                           internal static bit(9)                   initial dcl 11-8
return_words                           internal static bit(9)                   initial dcl 11-8
reverse_fun                            internal static bit(9)                   initial dcl 11-8
revert_on                              internal static bit(9)                   initial dcl 11-8
revert_statement                       internal static bit(9)                   initial dcl 10-3
rewrite_file                           internal static bit(9)                   initial dcl 11-8
rewrite_statement                      internal static bit(9)                   initial dcl 10-3
root_block                             internal static bit(9)                   initial dcl 8-1
round_fun                              internal static bit(9)                   initial dcl 11-8
search_fun                             internal static bit(9)                   initial dcl 11-8
search_rev_fun                         internal static bit(9)                   initial dcl 11-8
segno_fun                              internal static bit(9)                   initial dcl 11-8
semantic_translator             000000 constant        entry                    external dcl 14-444
semantic_translator$abort       000000 constant        entry                    external dcl 14-446
semantic_translator$error       000000 constant        entry                    external dcl 14-450
setbitno_fun                           internal static bit(9)                   initial dcl 11-8
setcharno_fun                          internal static bit(9)                   initial dcl 11-8
sf_par_node                            internal static bit(9)                   initial dcl 7-5
share_expression                000000 constant        entry                    external dcl 14-454
sign_fun                               internal static bit(9)                   initial dcl 11-8
signal_on                              internal static bit(9)                   initial dcl 11-8
signal_statement                       internal static bit(9)                   initial dcl 10-3
simplify_expression             000000 constant        entry                    external dcl 13-205
simplify_offset                 000000 constant        entry                    external dcl 13-212
sin_fun                                internal static bit(9)                   initial dcl 11-8
sind_fun                               internal static bit(9)                   initial dcl 11-8
skip_format                            internal static bit(9)                   initial dcl 11-8
source_node                            internal static bit(9)                   initial dcl 7-5
sqrt_fun                               internal static bit(9)                   initial dcl 11-8
stack_ptr                              internal static bit(9)                   initial dcl 11-8
stackbaseptr_fun                       internal static bit(9)                   initial dcl 11-8
stackframeptr_fun                      internal static bit(9)                   initial dcl 11-8
stacq_fun                              internal static bit(9)                   initial dcl 11-8
statement_node                         internal static bit(9)                   initial dcl 7-5
std_arg_list                           internal static bit(9)                   initial dcl 11-8
std_call                               internal static bit(9)                   initial dcl 11-8
std_entry                              internal static bit(9)                   initial dcl 11-8
std_return                             internal static bit(9)                   initial dcl 11-8
stop                                   internal static bit(9)                   initial dcl 11-8
stop_statement                         internal static bit(9)                   initial dcl 10-3
storage_block_type                     internal static bit(36)                  initial dcl 12-71
stream_prep                            internal static bit(9)                   initial dcl 11-8
sub                                    internal static bit(9)                   initial dcl 11-8
subscripter                     000000 constant        entry                    external dcl 13-216
system_on_unit                         internal static bit(9)                   initial dcl 10-3
tan_fun                                internal static bit(9)                   initial dcl 11-8
tand_fun                               internal static bit(9)                   initial dcl 11-8
temporary_node                         internal static bit(9)                   initial dcl 7-5
terminate_trans                        internal static bit(9)                   initial dcl 11-8
token_node                             internal static bit(9)                   initial dcl 7-5
token_to_binary                 000000 constant        entry                    external dcl 14-459
translate_fun                          internal static bit(9)                   initial dcl 11-8
trunc_fun                              internal static bit(9)                   initial dcl 11-8
unlock_file                            internal static bit(9)                   initial dcl 11-8
unlock_statement                       internal static bit(9)                   initial dcl 10-3
unpack                                 internal static bit(9)                   initial dcl 11-8
validate                        000000 constant        entry                    external dcl 13-225
vclock_fun                             internal static bit(9)                   initial dcl 11-8
verify_fun                             internal static bit(9)                   initial dcl 11-8
verify_ltrim_fun                       internal static bit(9)                   initial dcl 11-8
verify_rev_fun                         internal static bit(9)                   initial dcl 11-8
verify_rtrim_fun                       internal static bit(9)                   initial dcl 11-8
wait_statement                         internal static bit(9)                   initial dcl 10-3
word_to_mod2                           internal static bit(9)                   initial dcl 11-8
word_to_mod4                           internal static bit(9)                   initial dcl 11-8
word_to_mod8                           internal static bit(9)                   initial dcl 11-8
wordno_fun                             internal static bit(9)                   initial dcl 11-8
words_per_condition_var                internal static fixed bin(31,0)          initial dcl 12-5
words_per_entry_var                    internal static fixed bin(31,0)          initial dcl 12-5
words_per_file_var                     internal static fixed bin(31,0)          initial dcl 12-5
words_per_fix_bin_1                    internal static fixed bin(31,0)          initial dcl 12-5
words_per_fix_bin_2                    internal static fixed bin(31,0)          initial dcl 12-5
words_per_flt_bin_1                    internal static fixed bin(31,0)          initial dcl 12-5
words_per_flt_bin_2                    internal static fixed bin(31,0)          initial dcl 12-5
words_per_format                       internal static fixed bin(31,0)          initial dcl 12-5
words_per_label_var                    internal static fixed bin(31,0)          initial dcl 12-5
words_per_offset                       internal static fixed bin(31,0)          initial dcl 12-5
words_per_packed_pointer               internal static fixed bin(31,0)          initial dcl 12-5
words_per_pointer                      internal static fixed bin(31,0)          initial dcl 12-5
words_per_varying_string_header        internal static fixed bin(31,0)          initial dcl 12-5
write_file                             internal static bit(9)                   initial dcl 11-8
write_statement                        internal static bit(9)                   initial dcl 10-3
x_format                               internal static bit(9)                   initial dcl 11-8
xor_bits                               internal static bit(9)                   initial dcl 11-8

NAMES DECLARED BY EXPLICIT CONTEXT.
common                          001102 constant        label                    dcl 312 ref 305
encode                          001072 constant        entry                    internal dcl 296 ref 203 207 262 265 266 268
encode_qual                     001077 constant        entry                    internal dcl 307 ref 191 229 247
fail                            001305 constant        label                    dcl 342 ref 333 333
prepare_symbol_table            000021 constant        entry                    external dcl 20
process                         000400 constant        entry                    internal dcl 165 ref 136
scan_symbol_table               000234 constant        entry                    internal dcl 115 ref 105

THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION.

STORAGE REQUIREMENTS FOR THIS PROGRAM.

	Object	Text	Link	Symbol	Defs	Static
Start          0       0      1660        1736    1426        1670
Length      2506    1426        56         533     232           0

BLOCK NAME	         STACK SIZE     TYPE		WHY NONQUICK/WHO SHARES STACK FRAME
prepare_symbol_table                220 external procedure  is an external procedure.  
scan_symbol_table                       internal procedure  shares stack frame of external procedure prepare_symbol_table.  
process                                 internal procedure  shares stack frame of external procedure prepare_symbol_table.  
encode                                  internal procedure  shares stack frame of external procedure prepare_symbol_table.  

STORAGE FOR AUTOMATIC VARIABLES.

STACK FRAME                 LOC IDENTIFIER                  BLOCK NAME
prepare_symbol_table     000100 ev_based_var                prepare_symbol_table
                         000102 ev_qual                     prepare_symbol_table
                         000104 ev_ref                      prepare_symbol_table
                         000106 ev_temp                     prepare_symbol_table
                         000110 s1                          prepare_symbol_table
                         000112 s2                          prepare_symbol_table
                         000114 scan_again                  prepare_symbol_table
                         000124 cb                          scan_symbol_table
                         000126 found_brother               scan_symbol_table
                         000127 get_data                    scan_symbol_table
                         000130 p                           scan_symbol_table
                         000132 q                           scan_symbol_table
                         000142 ap                          process
                         000144 array_ref                   process
                         000146 bp                          process
                         000150 qp                          process
                         000152 rp                          process
                         000154 sp                          process
                         000164 convert_to_integer          encode
                         000166 tp                          encode

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

THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM.
copy_expression               create_block                  create_operator               create_statement
declare_constant$integer      declare_integer               declare_pointer               declare_temporary
error                         fill_refer                    free_node                     lookup
semantic_translator$call_es

THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM.
pl1_stat_$cur_statement       pl1_stat_$dummy_block         pl1_stat_$index               pl1_stat_$locator
pl1_stat_$statement_id        pl1_stat_$table




   LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC   
     20 000016        71 000026        72 000042        73 000071        74 000107        76 000131        77 000141
     79 000150        80 000153        81 000155        83 000157        84 000167        86 000172        87 000175
     89 000177        90 000222       102 000224       103 000226       104 000230       105 000231       106 000232
    108 000233       115 000234       124 000235       125 000241       126 000246       127 000253       128 000262
    133 000315       134 000322       136 000325       139 000337       141 000343       144 000352       145 000353
    146 000362       149 000371       150 000373       152 000375       154 000376       156 000377       165 000400
    177 000402       178 000405       179 000412       180 000415       182 000421       184 000424       185 000433
    188 000435       191 000443       193 000456       196 000467       199 000475       203 000477       206 000516
    207 000521       209 000534       216 000543       220 000617       226 000620       227 000625       229 000627
    230 000637       233 000647       234 000652       236 000654       238 000656       241 000661       244 000670
    247 000700       249 000713       252 000724       255 000732       259 000734       260 000737       262 000743
    264 000756       265 000764       266 001000       268 001013       270 001030       273 001033       275 001036
    278 001044       279 001045       280 001054       283 001063       284 001065       286 001067       288 001070
    290 001071       296 001072       304 001074       305 001076       307 001077       310 001101       312 001102
    316 001115       319 001145       320 001150       323 001154       325 001157       327 001171       330 001214
    331 001217       333 001221       334 001244       336 001246       340 001266       342 001305       344 001324
    347 001330       349 001335       350 001346       353 001351       355 001356       356 001367       359 001372
    361 001377       362 001402       363 001404       366 001411


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


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