COMPILATION LISTING OF SEGMENT if_parse
	Compiled by: Multics PL/I Compiler, Release 33c, of October 25, 1990
	Compiled at: ACTC Technologies Inc.          
	Compiled on: 92-04-24_1120.68_Fri_mdt
	    Options: optimize map

        1 /****^  ***********************************************************
        2*        *                                                         *
        3*        * Copyright, (C) BULL HN Information Systems Inc., 1990   *
        4*        *                                                         *
        5*        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        6*        *                                                         *
        7*        * Copyright (c) 1972 by Massachusetts Institute of        *
        8*        * Technology and Honeywell Information Systems, Inc.      *
        9*        *                                                         *
       10*        *********************************************************** */
       11 
       12 
       13 
       14 
       15 /****^  HISTORY COMMENTS:
       16*  1) change(91-01-18,Blackmore), approve(91-01-18,MCR8234),
       17*     audit(91-12-05,Huen), install(92-04-24,MR12.5-1011):
       18*     Change calls to 'lex' and 'statement_type', for constant reference
       19*     resolution fix.
       20*                                                   END HISTORY COMMENTS */
       21 
       22 
       23 if_parse:
       24      procedure (k, entry_ptr, our_conditions, father_block, his_end_ptr, our_return_flag);
       25 
       26 /* This procedure parses if statements and else clauses.
       27*   It always returns having called lex to look at the next statement. */
       28 
       29 /* Original by:	J. D. Mills	4 June 1968
       30*   to pl1:			26 July 1969
       31*   Re-written by:	P. Green		25 October 1970 for Version II
       32*
       33*   Modified:	29 May 1979 by R. A. Barnes to fix bug 1829 (WARNING 56 by
       34*   	if <expr> then stop; else ...)
       35*   Modified 790823 by PG to perform goto optimization only if -optimize was specified.
       36**/
       37 
       38 /* Variables
       39*
       40*   if		ptr to if statement.
       41*   expr		ptr to if statement expression.
       42*   loc		ptr to label used for jump around then body.
       43*   location	ptr to token of loc.
       44*   t		temporary ptr.		*/
       45 
       46 /* builtins */
       47 
       48 dcl	(bit, binary, null, string, substr)
       49 			builtin;
       50 
       51 /* automatic */
       52 
       53 dcl	(k, then_type, type, n)
       54 			fixed bin (15);
       55 dcl	(t, if, do, entry_ptr, label_ptr, father_block, cblock, end_ptr, his_end_ptr, p, q, expr, loc, location)
       56 			ptr;
       57 dcl	(conditions, our_conditions)
       58 			bit (12) aligned;
       59 dcl	(our_return_flag, return_flag, else, then_goto_optimized)
       60 			bit (1) aligned;
       61 dcl	(bit_type, jump_if_false, jump_if_true)
       62 			bit (9);
       63 
       64 /* external static */
       65 
       66 dcl	(
       67 	pl1_stat_$cur_statement
       68 			ptr,
       69 	pl1_stat_$optimize	bit (1) aligned,
       70 	pl1_stat_$profile	bit (1) aligned
       71 	)		external static;
       72 
       73 /* internal static */
       74 
       75 dcl	rel_to_jump	(4:9) bit (9) internal static initial ("001011001"b,
       76 						/* less_than	-> jump_if_ge */
       77 			"001011000"b,		/* greater_than	-> jump_if_le */
       78 			"001010111"b,		/* equal		-> jump_if_ne */
       79 			"001010110"b,		/* not_equal	-> jump_if_eq */
       80 			"001010101"b,		/* less_or_equal	-> jump_if_gt */
       81 			"001010100"b);		/* greater_or_equal	-> jump_if_lt */
       82 
       83 dcl	action_index	(0:36) fixed bin (15) int static
       84 			init (0, 0, 0, 1, 0, 7, 5, 7, 7, 0, 2, 0, 5, 5, 0, 5, 0, 7, 6, 3, 7, 0, 4, 7, 5, 7, 7, 5, 0, 7,
       85 			0, 0, 4, 7, 0, 7, 5);
       86 
       87 /* include files */
       88 
  1     1 /* BEGIN INCLUDE FILE parse.incl.pl1 */
  1     2 
  1     3 
  1     4 /****^  HISTORY COMMENTS:
  1     5*  1) change(91-01-09,Blackmore), approve(91-01-09,MCR8234),
  1     6*     audit(91-12-05,Huen), install(92-04-24,MR12.5-1011):
  1     7*     Change entry points for 'lex', 'lex$write_last_line', and
  1     8*     'statement_type', for constant reference resolution fix.
  1     9*                                                   END HISTORY COMMENTS */
  1    10 
  1    11 declare	attribute_parse	entry(ptr,ptr,fixed bin(15),bit(1) aligned);
  1    12 			/* parameter 1:	(input)	block node ptr		*/
  1    13 			/* parameter 2:	(input)	symbol node ptr		*/
  1    14 			/* parameter 3:	(in/out)	token index		*/
  1    15 			/* parameter 4:	(input)   called while doing generic	*/
  1    16 
  1    17 declare	context		entry(ptr,ptr,fixed bin(15));
  1    18 			/* parameter 1:	(input)	usually token node ptr	*/
  1    19 			/* parameter 2:	(input)	block node ptr		*/
  1    20 			/* parameter 3:	(input)	context type		*/
  1    21 
  1    22 declare	data_list_parse	entry(fixed bin(15),ptr,ptr)
  1    23 			returns(bit(1) aligned);
  1    24 			/* parameter 1:	(in/out)	token index		*/
  1    25 			/* parameter 2:	(input)	block node ptr		*/
  1    26 			/* parameter 3:	(output)	data list parse tree ptr	*/
  1    27 			/* return:	(output)	valid parse bit		*/
  1    28 
  1    29 declare	declare_label	entry(ptr,ptr,ptr,bit(3) aligned);
  1    30 			/* parameter 1:	(input)	block node ptr		*/
  1    31 			/* parameter 2:	(input)	statement node ptr	*/
  1    32 			/* parameter 3:	(input)	label list ptr or null	*/
  1    33 			/* parameter 4:	(input)	declare type		*/
  1    34 
  1    35 declare	declare_parse	entry(fixed bin(15),ptr,ptr);
  1    36 			/* parameter 1:	(input)	token index		*/
  1    37 			/* parameter 2:	(input)	block node ptr		*/
  1    38 			/* parameter 3:	(input)	label list ptr or null	*/
  1    39 
  1    40 declare	declare_parse$abort	entry(fixed bin(15),ptr);
  1    41 			/* parameter 1:	(input)	error number		*/
  1    42 			/* parameter 2:	(input)	any node ptr		*/
  1    43 
  1    44 declare	default_parse	entry(fixed bin(15),ptr,ptr);
  1    45 			/* parameter 1:	(input)	token index		*/
  1    46 			/* parameter 2:	(input)	block node ptr		*/
  1    47 			/* parameter 3:	(input)	label list ptr or null	*/
  1    48 
  1    49 declare	descriptor_parse	entry(ptr,ptr,fixed bin(15))
  1    50 			returns(ptr);
  1    51 			/* parameter 1:	(input)	block node ptr		*/
  1    52 			/* parameter 2:	(input)	token node ptr or null	*/
  1    53 			/* parameter 3:	(in/out)	token index		*/
  1    54 			/* return:	(output)	symbol node ptr		*/
  1    55 
  1    56 declare	do_parse		entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
  1    57 			bit(1) aligned,bit(1) aligned,bit(1) aligned);
  1    58 			/* parameter 1:	(in/out)	token index		*/
  1    59 			/* parameter 2:	(input)	label list ptr or null	*/
  1    60 			/* parameter 3:	(input)	conditions		*/
  1    61 			/* parameter 4:	(input)	father block node ptr	*/
  1    62 			/* parameter 5:	(output)	end ptr			*/
  1    63 			/* parameter 6:	(input)	entry bit			*/
  1    64 			/* parameter 7:	(input)	return bit		*/
  1    65 			/* parameter 8:	(input)	iterative do bit		*/
  1    66 
  1    67 declare	evaluate		entry(bit(9) aligned,ptr,ptr) returns(ptr);
  1    68 			/* parameter 1:	(input)	opcode		*/
  1    69 			/* parameter 2:	(input)	left operand (token ptr)	*/
  1    70 			/* parameter 3:	(input)	right operand (token ptr)	*/
  1    71 			/* return:	(output)	ptr to result node	*/
  1    72 
  1    73 declare	expression_parse	entry(fixed bin(15),ptr)
  1    74 			returns(ptr);
  1    75 			/* parameter 1:	(in/out)	token index		*/
  1    76 			/* parameter 2:	(input)	block node ptr		*/
  1    77 			/* return:	(output)	expression parse tree ptr	*/
  1    78 
  1    79 declare	format_list_parse	entry(fixed bin(15),ptr,ptr,ptr)
  1    80 			returns(bit(1) aligned);
  1    81 			/* parameter 1:	(in/out)	token index		*/
  1    82 			/* parameter 2:	(input)	block node ptr		*/
  1    83 			/* parameter 3:	(input)	statement node ptr		*/
  1    84 			/* parameter 4:	(output)	format list parse tree ptr	*/
  1    85 			/* return:	(output)	valid parse bit		*/
  1    86 
  1    87 declare	if_parse		entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
  1    88 			bit(1) aligned);
  1    89 			/* parameter 1:	(in/out)	token index		*/
  1    90 			/* parameter 2:	(input)	label list ptr or null	*/
  1    91 			/* parameter 3:	(input)	conditions		*/
  1    92 			/* parameter 4:	(input)	father block node ptr	*/
  1    93 			/* parameter 5:	(input)	end ptr			*/
  1    94 			/* parameter 6:	(output)	valid parse bit		*/
  1    95 
  1    96 declare	io_statement_parse	entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
  1    97 			bit(1) aligned,bit(9) aligned);
  1    98 			/* parameter 1:	(in/out)	token index		*/
  1    99 			/* parameter 2:	(input)	label list ptr or null	*/
  1   100 			/* parameter 3:	(input)	conditions		*/
  1   101 			/* parameter 4:	(input)	father block node ptr	*/
  1   102 			/* parameter 5:	(output)	end ptr			*/
  1   103 			/* parameter 6:	(output)	valid parse bit		*/
  1   104 			/* parameter 7:	(output)	statement type		*/
  1   105 
  1   106 declare	lex		entry(ptr);
  1   107 			/* parameter 1:	(input)	block node ptr		*/
  1   108 
  1   109 declare	lex$write_last_line	entry(ptr);
  1   110 			/* parameter 1:	(input)	block node ptr		*/
  1   111 
  1   112 declare	lex$initialize_lex	entry(ptr,fixed bin(15));
  1   113 			/* parameter 1:	(input)	ptr to source		*/
  1   114 			/* parameter 2:	(input)	length of source (chars)	*/
  1   115 
  1   116 declare	on_parse		entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr);
  1   117 			/* parameter 1:	(in/out)	token index		*/
  1   118 			/* parameter 2:	(input)	label list ptr or null	*/
  1   119 			/* parameter 3:	(input)	conditions		*/
  1   120 			/* parameter 4:	(input)	father block node ptr	*/
  1   121 			/* parameter 5:	(output)	end ptr (set to null)	*/
  1   122 
  1   123 declare	on_parse$revert	entry(fixed bin(15),ptr,ptr);
  1   124 			/* parameter 1:	(input)	token index	*/
  1   125 			/* parameter 2:	(input)	statement node ptr	*/
  1   126 			/* parameter 3:	(input)	block node ptr	*/
  1   127 
  1   128 declare	parse		entry(ptr,ptr,fixed bin(15));
  1   129 			/* parameter 1:	(output)	root ptr		*/
  1   130 			/* parameter 2	(input)	source ptr		*/
  1   131 			/* parameter 3:	(input)	source length		*/
  1   132 
  1   133 declare	procedure_parse	entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
  1   134 			bit(9) aligned,bit(1) aligned);
  1   135 			/* parameter 1:	(in/out)	token index		*/
  1   136 			/* parameter 2:	(input)	label list ptr or null	*/
  1   137 			/* parameter 3:	(input)	conditions		*/
  1   138 			/* parameter 4:	(input)	father block node ptr	*/
  1   139 			/* parameter 5:	(output)	end ptr		*/
  1   140 			/* parameter 6:	(input)	block type		*/
  1   141 			/* parameter 7:	(input)	no return statement bit	*/
  1   142 
  1   143 declare	process_entry	entry(fixed bin(15),bit(9) aligned,ptr,ptr,bit(12) aligned);
  1   144 			/* parameter 1:	(in/out)	token index		*/
  1   145 			/* parameter 2:	(input)	statement type		*/
  1   146 			/* parameter 3:	(input)	block node ptr		*/
  1   147 			/* parameter 4:	(input)	label list ptr or null	*/
  1   148 			/* parameter 5:	(input)	conditions		*/
  1   149 
  1   150 declare	reference_parse	entry(fixed bin(15),ptr)
  1   151 			returns(ptr);
  1   152 			/* parameter 1:	(in/out)	token index		*/
  1   153 			/* parameter 2:	(input)	block node ptr		*/
  1   154 			/* return:	(output)	reference parse tree ptr	*/
  1   155 
  1   156 declare	reserve$rename_parse entry(fixed bin(15)) returns(bit(1) aligned);
  1   157 			/* parameter 1:	(in/out)	token index	 */
  1   158 			/* return:	(output)	success bit	 */
  1   159 
  1   160 declare	statement_parse	entry(fixed bin(15),ptr,bit(12) aligned,ptr,fixed bin(15));
  1   161 			/* parameter 1:	(in/out)	token index		*/
  1   162 			/* parameter 2:	(input)	label list ptr or null	*/
  1   163 			/* parameter 3:	(input)	conditions		*/
  1   164 			/* parameter 4:	(input)	block node ptr		*/
  1   165 			/* parameter 5:	(input)	statement type		*/
  1   166 
  1   167 declare	statement_type	entry(ptr,fixed bin(15),ptr,bit(12) aligned)
  1   168 			returns(fixed bin(15));
  1   169 			/* parameter 1:	(input)	block node ptr		*/
  1   170 			/* parameter 2:	(in/out)	token index		*/
  1   171 			/* parameter 3:	(output)	label list ptr or null	*/
  1   172 			/* parameter 4:	(output)	conditions		*/
  1   173 			/* return:	(output)	statement type		*/
  1   174 
  2     1 /****^  *********************************************************
  2     2*        *                                                       *
  2     3*        * Copyright, (C) BULL HN Information Systems Inc., 1989 *
  2     4*        *                                                       *
  2     5*        ********************************************************* */
  2     6 
  2     7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */
  2     8 
  2     9 
  2    10 /****^  HISTORY COMMENTS:
  2    11*  1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu),
  2    12*     install(89-07-31,MR12.3-1066):	
  2    13*     Removed the obsolete parameter source_line from the dcl of error_().
  2    14*                                                   END HISTORY COMMENTS */
  2    15 
  2    16 /* Modified: 6 Jun 1979 by PG to add rank and byte
  2    17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 
  2    18* */
  2    19 
  2    20 declare	adjust_count	entry(pointer);
  2    21 			/* parameter 1:	(input)	any node pointer		*/
  2    22 
  2    23 declare	bindec		entry(fixed bin(31)) reducible
  2    24 			returns(character(12) aligned);
  2    25 			/* parameter 1:	(input)	bin value			*/
  2    26 			/* return:	(output)	character value with blanks	*/
  2    27 
  2    28 declare	bindec$vs		entry(fixed bin(31)) reducible
  2    29 			returns(character(12) aligned varying);
  2    30 			/* parameter 1:	(input)	binary value		*/
  2    31 			/* return:	(output)	char value without blanks	*/
  2    32 
  2    33 declare	binoct		entry(fixed bin(31)) reducible
  2    34 			returns(char(12) aligned);
  2    35 			/* parameter 1:	(input)	binary value		*/
  2    36 			/* return:	(output)	char value with blanks	*/
  2    37 
  2    38 declare	binary_to_octal_string	entry(fixed bin(31)) reducible
  2    39 			returns(char(12) aligned);
  2    40 			/* parameter 1:	(input)	binary value		*/
  2    41 			/* return:	(output)	right-aligned char value	*/
  2    42 
  2    43 declare	binary_to_octal_var_string	entry(fixed bin(31)) reducible
  2    44 			returns(char(12) varying aligned);
  2    45 			/* parameter 1:	(input)	binary value		*/
  2    46 			/* returns:	(output)	char value without blanks	*/
  2    47 
  2    48 declare	compare_expression	entry(pointer,pointer) reducible
  2    49 			returns(bit(1) aligned);
  2    50 			/* parameter 1:	(input)	any node pointer		*/
  2    51 			/* parameter 2:	(input)	any node pointer		*/
  2    52 			/* return:	(output)	compare bit		*/
  2    53 
  2    54 declare	constant_length	entry (pointer, fixed bin (71))
  2    55 			returns (bit (1) aligned);
  2    56 			/* parameter 1:	(input)	reference node pointer	*/
  2    57 			/* parameter 2:	(input)	value of constant length	*/
  2    58 			/* return:	(output)	"1"b if constant length	*/
  2    59 
  2    60 declare	convert		entry(pointer,bit(36) aligned)
  2    61 			returns(pointer);
  2    62 			/* parameter 1:	(input)	any node pointer		*/
  2    63 			/* parameter 2:	(input)	target type		*/
  2    64 			/* return:	(output)	target value tree pointer	*/
  2    65 
  2    66 declare	convert$to_integer	entry(pointer,bit(36)aligned)
  2    67 			returns(pointer);
  2    68 			/* parameter 1:	(input)	any node pointer		*/
  2    69 			/* parameter 2:	(input)	target type		*/
  2    70 			/* return:	(output)	target value tree pointer	*/
  2    71 
  2    72 declare	convert$from_builtin entry(pointer,bit(36) aligned)
  2    73 			returns(pointer);
  2    74 			/* parameter 1:	(input)	any node pointer		*/
  2    75 			/* parameter 2:	(input)	target type		*/
  2    76 			/* return:	(output)	target value tree pointer	*/
  2    77 
  2    78 declare	convert$validate	entry(pointer,pointer);
  2    79 			/* parameter 1:	(input)	source value tree pointer	*/
  2    80 			/* parameter 2:	(input)	target reference node pointer	*/
  2    81 
  2    82 declare	convert$to_target_fb entry(pointer,pointer)
  2    83 			returns(pointer);
  2    84 			/* parameter 1:	(input)	source value tree pointer	*/
  2    85 			/* parameter 2:	(input)	target reference node pointer	*/
  2    86 			/* return:	(output)	target value tree pointer	*/
  2    87 
  2    88 declare	convert$to_target	entry(pointer,pointer)
  2    89 			returns(pointer);
  2    90 			/* parameter 1:	(input)	source value tree pointer	*/
  2    91 			/* parameter 2:	(input)	target reference node pointer	*/
  2    92 			/* return:	(output)	target value tree pointer	*/
  2    93 
  2    94 declare	copy_expression	entry(pointer unaligned)
  2    95 			returns(pointer);
  2    96 			/* parameter 1:	(input)	any node pointer		*/
  2    97 			/* return:	(output)	any node pointer		*/
  2    98 
  2    99 declare	copy_expression$copy_sons entry(pointer,pointer);
  2   100 			/* parameter 1:	(input)	father symbol node pointer	*/
  2   101 			/* parameter 2:	(input)	stepfather symbol node ptr	*/
  2   102 
  2   103 declare	copy_unique_expression entry(pointer)
  2   104 			returns(pointer);
  2   105 			/* parameter 1:	(input)	any node pointer		*/
  2   106 			/* return:	(output)	any node pointer		*/
  2   107 
  2   108 declare	create_array	entry()
  2   109 			returns(pointer);
  2   110 			/* return:	(output)	array node pointer		*/
  2   111 
  2   112 declare	create_block	entry(bit(9) aligned,pointer)
  2   113 			returns(pointer);
  2   114 			/* parameter 1:	(input)	block type		*/
  2   115 			/* parameter 2:	(input)	father block node pointer	*/
  2   116 			/* return:	(output)	block node pointer		*/
  2   117 
  2   118 declare	create_bound	entry()
  2   119 			returns(pointer);
  2   120 			/* return:	(output)	bound node pointer		*/
  2   121 
  2   122 declare	create_context	entry(pointer,pointer)
  2   123 			returns(pointer);
  2   124 			/* parameter 1:	(input)	block node pointer		*/
  2   125 			/* parameter 2:	(input)	token pointer		*/
  2   126 			/* return:	(output)	context node pointer	*/
  2   127 
  2   128 declare	create_cross_reference entry()
  2   129 			returns(pointer);
  2   130 			/* return:	(output)	cross reference node pointer	*/
  2   131 
  2   132 declare	create_default	entry
  2   133 			returns(pointer);
  2   134 			/* return:	(output)	default node pointer	*/
  2   135 
  2   136 declare	create_identifier	entry()
  2   137 			returns(pointer);
  2   138 			/* return:	(output)	token node pointer		*/
  2   139 
  2   140 declare	create_label	entry(pointer,pointer,bit(3) aligned)
  2   141 			returns(pointer);
  2   142 			/* parameter 1:	(input)	block node pointer		*/
  2   143 			/* parameter 2:	(input)	token node pointer		*/
  2   144 			/* parameter 3:	(input)	declare type		*/
  2   145 			/* return:	(output)	label node pointer		*/
  2   146 
  2   147 declare	create_list	entry(fixed bin(15))
  2   148 			returns(pointer);
  2   149 			/* parameter 1:	(input)	number of list elements	*/
  2   150 			/* return:	(output)	list node pointer		*/
  2   151 
  2   152 declare	create_operator	entry(bit(9) aligned,fixed bin(15))
  2   153 			returns(pointer);
  2   154 			/* parameter 1:	(input)	operator type		*/
  2   155 			/* parameter 2:	(input)	number of operands		*/
  2   156 			/* return:	(output)	operator node pointer	*/
  2   157 
  2   158 declare	create_reference	entry(pointer)
  2   159 			returns(pointer);
  2   160 			/* parameter 1:	(input)	symbol node pointer		*/
  2   161 			/* return:	(output)	reference node pointer	*/
  2   162 
  2   163 declare	create_statement	entry(bit(9) aligned,pointer,pointer,bit(12) aligned)
  2   164 			returns(pointer);
  2   165 			/* parameter 1:	(input)	statement type		*/
  2   166 			/* parameter 2:	(input)	block node pointer		*/
  2   167 			/* parameter 3:	(input)	label node pointer		*/
  2   168 			/* parameter 4:	(input)	conditions		*/
  2   169 			/* return:	(output)	statement node pointer	*/
  2   170 
  2   171 declare	create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned)
  2   172 			returns(pointer);
  2   173 			/* parameter 1:	(input)	statement type		*/
  2   174 			/* parameter 2:	(input)	block node pointer		*/
  2   175 			/* parameter 3:	(input)	label node pointer		*/
  2   176 			/* parameter 4:	(input)	conditions		*/
  2   177 			/* return:	(output)	statement node pointer	*/
  2   178 
  2   179 declare	create_storage	entry(fixed bin(15))
  2   180 			returns(pointer);
  2   181 			/* parameter 1:	(input)	number of words		*/
  2   182 			/* return:	(output)	storage block pointer	*/
  2   183 
  2   184 declare	create_symbol	entry(pointer,pointer,bit(3) aligned)
  2   185 			returns(pointer);
  2   186 			/* parameter 1:	(input)	block node pointer		*/
  2   187 			/* parameter 2:	(input)	token node pointer		*/
  2   188 			/* parameter 3:	(input)	declare type		*/
  2   189 			/* return:	(output)	symbol node pointer		*/
  2   190 
  2   191 declare	create_token	entry (character (*), bit (9) aligned)
  2   192 			returns (ptr);
  2   193 			/* parameter 1:	(input)	token string		*/
  2   194 			/* parameter 2:	(input)	token type		*/
  2   195 			/* return:	(output)	token node ptr		*/
  2   196 
  2   197 declare	create_token$init_hash_table entry ();
  2   198 
  2   199 declare	create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned)
  2   200 			returns (ptr);
  2   201 			/* parameter 1:	(input)	token string		*/
  2   202 			/* parameter 2:	(input)	token type		*/
  2   203 			/* parameter 3:	(input)	protected flag		*/
  2   204 			/* return:	(output)	token node ptr		*/
  2   205 
  2   206 declare	decbin		entry(character(*) aligned) reducible
  2   207 			returns(fixed bin(31));
  2   208 			/* parameter 1:	(input)	decimal character string	*/
  2   209 			/* return:	(output)	binary value		*/
  2   210 
  2   211 declare	declare_constant	entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15))
  2   212 			returns(pointer);
  2   213 			/* parameter 1:	(input)	value			*/
  2   214 			/* parameter 2:	(input)	type			*/
  2   215 			/* parameter 3:	(input)	size			*/
  2   216 			/* parameter 4:	(input)	scale			*/
  2   217 			/* return:	(output)	reference node pointer	*/
  2   218 
  2   219 declare	declare_constant$bit entry(bit(*) aligned)
  2   220 			returns(pointer);
  2   221 			/* parameter 1:	(input)	bit			*/
  2   222 			/* return:	(output)	reference node pointer	*/
  2   223 
  2   224 declare	declare_constant$char entry(character(*) aligned)
  2   225 			returns(pointer);
  2   226 			/* parameter 1:	(input)	character			*/
  2   227 			/* return:	(output)	reference node pointer	*/
  2   228 
  2   229 declare	declare_constant$desc entry(bit(*) aligned)
  2   230 			returns(pointer);
  2   231 			/* parameter 1:	(input)	descriptor bit value	*/
  2   232 			/* return:	(output)	reference node pointer	*/
  2   233 
  2   234 declare	declare_constant$integer entry(fixed bin(31))	/* note...should really be fixed bin(24) */
  2   235 			returns(pointer);
  2   236 			/* parameter 1:	(input)	integer			*/
  2   237 			/* return:	(output)	reference node pointer	*/
  2   238 
  2   239 declare	declare_descriptor	entry(pointer,pointer,pointer,pointer,bit(2) aligned)
  2   240 			returns(pointer);
  2   241 			/* parameter 1:	(input)	block node pointer		*/
  2   242 			/* parameter 2:	(input)	statement node pointer	*/
  2   243 			/* parameter 3:	(input)	symbol node pointer		*/
  2   244 			/* parameter 4:	(input)	loc pointer		*/
  2   245 			/* parameter 5:	(input)	array descriptor bit
  2   246*						cross_section bit	*/
  2   247 			/* return:	(output)	reference node pointer	*/
  2   248 
  2   249 declare	declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned)
  2   250 			returns(pointer);
  2   251 			/* parameter 1:	(input)	block node pointer	*/
  2   252 			/* parameter 2:	(input)	statement node pointer 	*/
  2   253 			/* parameter 3:	(input)	symbol node pointer	*/
  2   254 			/* parameter 4:	(input)	loc pointer	*/
  2   255 			/* parameter 5:	(input)	array descriptor bit
  2   256*						cross_section bit	*/
  2   257 			/* return:	(output)	reference node pointer	*/
  2   258 
  2   259 declare	declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned)
  2   260 			returns(pointer);
  2   261 			/* parameter 1:	(input)	block node pointer		*/
  2   262 			/* parameter 2:	(input)	statement node pointer	*/
  2   263 			/* parameter 3:	(input)	symbol node pointer		*/
  2   264 			/* parameter 4:	(input)	loc pointer		*/
  2   265 			/* parameter 5:	(input)	array descriptor bit
  2   266*						cross_section bit	*/
  2   267 			/* return:	(output)	reference node pointer	*/
  2   268 
  2   269 declare	declare_integer	entry(pointer)
  2   270 			returns(pointer);
  2   271 			/* parameter 1:	(input)	block node pointer		*/
  2   272 			/* return:	(output)	reference node pointer 	*/
  2   273 
  2   274 declare	declare_picture	entry(char(*)aligned,pointer,fixed bin(15));
  2   275 			/* parameter 1:	(input)	picture string		*/
  2   276 			/* parameter 2:	(input)	symbol node pointer		*/
  2   277 			/* parameter 3:	(output)	error code, if any		*/
  2   278 
  2   279 declare	declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned)
  2   280 			returns(pointer);
  2   281 			/* parameter 1:	(input)	picture string		*/
  2   282 			/* parameter 2:	(input)	scalefactor of picture	*/
  2   283 			/* parameter 3:	(input)	="1"b => complex picture	*/
  2   284 			/* parameter 4:	(input)	="1"b => unaligned temp	*/
  2   285 			/* return:	(output)	reference node pointer	*/
  2   286 
  2   287 declare	declare_pointer	entry(pointer)
  2   288 			returns(pointer);
  2   289 			/* parameter 1:	(input)	block node pointer		*/
  2   290 			/* return:	(output)	reference node pointer	*/
  2   291 
  2   292 declare	declare_temporary	entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer)
  2   293 			returns(pointer);
  2   294 			/* parameter 1:	(input)	type			*/
  2   295 			/* parameter 2:	(input)	precision			*/
  2   296 			/* parameter 3:	(input)	scale			*/
  2   297 			/* parameter 4:	(input)	length			*/
  2   298 			/* return:	(output)	reference node pointer	*/
  2   299 
  2   300 declare	decode_node_id	entry(pointer,bit(1) aligned)
  2   301 			returns(char(120) varying);
  2   302 			/* parameter 1:	(input)	node pointer		*/
  2   303 			/* parameter 2:	(input)	="1"b => capitals		*/
  2   304 			/* return:	(output)	source line id		*/
  2   305 
  2   306 declare	decode_source_id	entry(
  3     1 			1 structure unaligned,
  3     2 			  2 /* file_number */	bit(8),
  3     3 			  2 /* line_number */	bit(14),
  3     4 			  2 /* stmt_number */	bit(5),
  2   307 
  2   308 			bit(1) aligned)
  2   309 			returns(char(120) varying);
  2   310 			/* parameter 1:	(input)	source id			*/
  2   311 			/* parameter 2:	(input)	="1"b => capitals		*/
  2   312 			/* return:	(output)	source line id		*/
  2   313 
  2   314 declare	error		entry(fixed bin(15),pointer,pointer);
  2   315 			/* parameter 1:	(input)	error number		*/
  2   316 			/* parameter 2:	(input)	statement node pointer or null*/
  2   317 			/* parameter 3:	(input)	token node pointer 		*/
  2   318 
  2   319 declare	error$omit_text	entry(fixed bin(15),pointer,pointer);
  2   320 			/* parameter 1:	(input)	error number		*/
  2   321 			/* parameter 2:	(input)	statement node pointer or null*/
  2   322 			/* parameter 3:	(input)	token node pointer 		*/
  2   323 
  2   324 declare	error_		entry(fixed bin(15),
  4     1 			1 structure unaligned,
  4     2 			  2 /* file_number */	bit(8),
  4     3 			  2 /* line_number */	bit(14),
  4     4 			  2 /* stmt_number */	bit(5),
  2   325 
  2   326 			pointer,fixed bin(8),fixed bin(23),fixed bin(11));
  2   327 			/* parameter 1:	(input)	error number		*/
  2   328 			/* parameter 2:	(input)	statement id		*/
  2   329 			/* parameter 3:	(input)	any node pointer		*/
  2   330 			/* parameter 4:	(input)	source segment		*/
  2   331 			/* parameter 5:	(input)	source starting character	*/
  2   332 			/* parameter 6:	(input)	source length		*/
  2   333 
  2   334 declare	error_$no_text	entry(fixed bin(15),
  5     1 			1 structure unaligned,
  5     2 			  2 /* file_number */	bit(8),
  5     3 			  2 /* line_number */	bit(14),
  5     4 			  2 /* stmt_number */	bit(5),
  2   335 
  2   336 			pointer);
  2   337 			/* parameter 1:	(input)	error number		*/
  2   338 			/* parameter 2:	(input)	statement id		*/
  2   339 			/* parameter 3:	(input)	any node pointer		*/
  2   340 
  2   341 declare	error_$initialize_error entry();
  2   342 
  2   343 declare	error_$finish	entry();
  2   344 
  2   345 declare	free_node		entry(pointer);
  2   346 			/* parameter 1:	any node pointer			*/
  2   347 
  2   348 declare	get_array_size	entry(pointer,fixed bin(3));
  2   349 			/* parameter 1:	(input)	symbol node pointer		*/
  2   350 			/* parameter 2:	(input)	units			*/
  2   351 
  2   352 declare	get_size		entry(pointer);
  2   353 			/* parameter 1:	(input)	symbol node pointer		*/
  2   354 
  2   355 declare	merge_attributes	external entry(pointer,pointer)
  2   356 			returns(bit(1) aligned);
  2   357 			/* parameter 1:	(input)	target symbol node pointer */
  2   358 			/* parameter 2:	(input)	source symbol node pointer */
  2   359 			/* return:	(output)	"1"b if merge was unsuccessful */
  2   360 
  2   361 declare	optimizer		entry(pointer);
  2   362 			/* parameter 1:	(input)	root pointer		*/
  2   363 
  2   364 declare	parse_error	entry(fixed bin(15),pointer);
  2   365 			/* parameter 1:	(input)	error number		*/
  2   366 			/* parameter 2:	(input)	any node pointer		*/
  2   367 
  2   368 declare	parse_error$no_text	entry(fixed bin(15),pointer);
  2   369 			/* parameter 1:	(input)	error number		*/
  2   370 			/* parameter 2:	(input)	any node pointer		*/
  2   371 
  2   372 declare	pl1_error_print$write_out
  2   373 			entry(fixed bin(15),
  6     1 			1 structure unaligned,
  6     2 			  2 /* file_number */	bit(8),
  6     3 			  2 /* line_number */	bit(14),
  6     4 			  2 /* stmt_number */	bit(5),
  2   374 
  2   375 			pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15));
  2   376 			/* parameter 1:	(input)	error number		*/
  2   377 			/* parameter 2:	(input)	statement identification	*/
  2   378 			/* parameter 3:	(input)	any node pointer		*/
  2   379 			/* parameter 4:	(input)	source segment		*/
  2   380 			/* parameter 5:	(input)	source character index	*/
  2   381 			/* parameter 6:	(input)	source length		*/
  2   382 			/* parameter 7:	(input)	source line		*/
  2   383 
  2   384 declare	pl1_error_print$listing_segment
  2   385 			entry(fixed bin(15),
  7     1 			1 structure unaligned,
  7     2 			  2 /* file_number */	bit(8),
  7     3 			  2 /* line_number */	bit(14),
  7     4 			  2 /* stmt_number */	bit(5),
  2   386 
  2   387 			pointer);
  2   388 			/* parameter 1:	(input)	error number		*/
  2   389 			/* parameter 2:	(input)	statement identification	*/
  2   390 			/* parameter 3:	(input)	token node pointer		*/
  2   391 
  2   392 declare	pl1_print$varying		entry(character(*) aligned varying);
  2   393 			/* parameter 1:	(input)	string			*/
  2   394 
  2   395 declare	pl1_print$varying_nl	entry(character(*) aligned varying);
  2   396 			/* parameter 1:	(input)	string			*/
  2   397 
  2   398 declare	pl1_print$non_varying	entry(character(*) aligned,fixed bin(31));
  2   399 			/* parameter 1:	(input)	string			*/
  2   400 			/* parameter 2:	(input)	string length or 0		*/
  2   401 
  2   402 declare	pl1_print$non_varying_nl	entry(character(*) aligned,fixed bin(31));
  2   403 			/* parameter 1:	(input)	string			*/
  2   404 			/* parameter 2:	(input)	string length or 0		*/
  2   405 
  2   406 declare	pl1_print$string_pointer	entry(pointer,fixed bin(31));
  2   407 			/* parameter 1:	(input)	string pointer		*/
  2   408 			/* parameter 2:	(input)	string size		*/
  2   409 
  2   410 declare	pl1_print$string_pointer_nl	entry(pointer,fixed bin(31));
  2   411 			/* parameter 1:	(input)	string pointer		*/
  2   412 			/* parameter 2:	(input)	string length or 0		*/
  2   413 
  2   414 declare	pl1_print$unaligned_nl	entry(character(*) unaligned,fixed bin(31));
  2   415 			/* parameter 1:	(input)	string			*/
  2   416 			/* parameter 2:	(input)	length			*/
  2   417 
  2   418 declare	pl1_print$for_lex	entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned);
  2   419 			/* parameter 1:	(input)	ptr to base of source segment	*/
  2   420 			/* parameter 2:	(input)	line number		*/
  2   421 			/* parameter 3:	(input)	starting offset in source seg	*/
  2   422 			/* parameter 4:	(input)	number of chars to copy	*/
  2   423 			/* parameter 5:	(input)	ON iff shd print line number	*/
  2   424 			/* parameter 6:	(input)	ON iff line begins in comment	*/
  2   425 
  2   426 declare	refer_extent	entry(pointer,pointer);
  2   427 			/* parameter 1:	(input/output)	null,ref node,op node pointer	*/
  2   428 			/* parameter 2:	(input)	null,ref node,op node pointer	*/
  2   429 
  2   430 declare	reserve$clear	entry()
  2   431 			returns(pointer);
  2   432 			/* return:	(output)	pointer			*/
  2   433 
  2   434 declare	reserve$declare_lib	entry(fixed bin(15))
  2   435 			returns(pointer);
  2   436 			/* parameter 1:	(input)	builtin function number	*/
  2   437 			/* return:	(output)	pointer			*/
  2   438 
  2   439 declare	reserve$read_lib	entry(fixed bin(15))
  2   440 			returns(pointer);
  2   441 			/* parameter 1:	(input)	builtin function number	*/
  2   442 			/* return:	(output)	pointer			*/
  2   443 
  2   444 declare	semantic_translator	entry();
  2   445 
  2   446 declare	semantic_translator$abort entry(fixed bin(15),pointer);
  2   447 			/* parameter 1:	(input)	error number		*/
  2   448 			/* parameter 2:	(input)	any node pointer		*/
  2   449 
  2   450 declare	semantic_translator$error entry(fixed bin(15),pointer);
  2   451 			/* parameter 1:	(input)	error number		*/
  2   452 			/* parameter 2:	(input)	any node pointer		*/
  2   453 
  2   454 declare	share_expression	entry(ptr)
  2   455 			returns(ptr);
  2   456 			/* parameter 1:	(input)	usually operator node pointer	*/
  2   457 			/* return:	(output)	tree pointer or null	*/
  2   458 
  2   459 declare	token_to_binary	entry(ptr) reducible
  2   460 			returns(fixed bin(31));
  2   461 			/* parameter 1:	(input)	token node pointer		*/
  2   462 			/* return:	(output)	converted binary value	*/
  2   463 
  2   464 /* END INCLUDE FILE ... language_utility.incl.pl1 */
  1   175 
  1   176 /* END INCLUDE FILE parse.incl.pl1 */
       89 
  8     1 dcl	pl1_stat_$token_list_ptr ptr external static;		/* pointer to token list	*/
  8     2 dcl	token_list(token_list_length) ptr based(token_list_pointer);
  8     3 dcl	token_list_pointer ptr initial(pl1_stat_$token_list_ptr);	/* for efficiency only */
  8     4 dcl	token_list_length fixed(15) internal static initial(3000) options(constant);
  8     5 
  8     6 dcl	1 pl1_stat_$statement_id	external static,
  8     7 	2 file_number		bit(8),
  8     8 	2 line_number		bit(14),
  8     9 	2 statement_number		bit(5);
  8    10 
  8    11 dcl	1 t_table 		based(token_list(k)) aligned,
  8    12 	2 node_type		bit(9) unaligned,
  8    13 	2 type			bit(9) unaligned,
  8    14 	2 loc			bit(18) unaligned,
  8    15 	2 declaration		ptr unaligned,
  8    16 	2 next			ptr unaligned,
  8    17 	2 size			fixed(9),
  8    18 	2 string			char(n refer(t_table.size));
       90 
  9     1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */
  9     2 
  9     3 dcl	1 token			based aligned,
  9     4 	2 node_type		bit(9) unaligned,
  9     5 	2 type			bit(9) unaligned,
  9     6 	2 loc			bit(18) unaligned,	/* symtab offset for identifiers, "p" flag for constants */
  9     7 	2 declaration		ptr unaligned,
  9     8 	2 next			ptr unaligned,
  9     9 	2 size			fixed(9),
  9    10 	2 string			char(n refer(token.size));
  9    11 
  9    12 /* END INCLUDE FILE ... token.incl.pl1 */
       91 
 10     1 /* BEGIN INCLUDE FILE ... token_types.incl.pl1 */
 10     2 
 10     3 dcl (	no_token		initial("000000000"b),	/*	token types		*/
 10     4 	identifier	initial("100000000"b),
 10     5 	isub		initial("010000000"b),
 10     6 	plus		initial("001000001"b),
 10     7 	minus		initial("001000010"b),
 10     8 	asterisk		initial("001000011"b),
 10     9 	slash		initial("001000100"b),
 10    10 	expon		initial("001000101"b),
 10    11 	not		initial("001000110"b),
 10    12 	and		initial("001000111"b),
 10    13 	or		initial("001001000"b),
 10    14 	cat		initial("001001001"b),
 10    15 	eq		initial("001001010"b),
 10    16 	ne		initial("001001011"b),
 10    17 	lt		initial("001001100"b),
 10    18 	gt		initial("001001101"b),
 10    19 	le		initial("001001110"b),
 10    20 	ge		initial("001001111"b),
 10    21 	ngt		initial("001010000"b),
 10    22 	nlt		initial("001010001"b),
 10    23 	assignment	initial("001010010"b),
 10    24 	colon		initial("001010011"b),
 10    25 	semi_colon	initial("001010100"b),
 10    26 	comma		initial("001010101"b),
 10    27 	period		initial("001010110"b),
 10    28 	arrow		initial("001010111"b),
 10    29 	left_parn		initial("001011000"b),
 10    30 	right_parn	initial("001011001"b),
 10    31 	percent		initial("001011100"b),
 10    32 	bit_string	initial("000100001"b),
 10    33 	char_string	initial("000100010"b),
 10    34 	bin_integer	initial("000110001"b),
 10    35 	dec_integer	initial("000110011"b),
 10    36 	fixed_bin		initial("000110000"b),
 10    37 	fixed_dec		initial("000110010"b),
 10    38 	float_bin		initial("000110100"b),
 10    39 	float_dec		initial("000110110"b),
 10    40 	i_bin_integer	initial("000111001"b),
 10    41 	i_dec_integer	initial("000111011"b),
 10    42 	i_fixed_bin	initial("000111000"b),
 10    43 	i_fixed_dec	initial("000111010"b),
 10    44 	i_float_bin	initial("000111100"b),
 10    45 	i_float_dec	initial("000111110"b)) bit (9) aligned internal static options (constant);
 10    46 
 10    47 dcl (	is_identifier		initial ("100000000"b),	/*	token type masks		*/
 10    48 	is_isub			initial ("010000000"b),
 10    49 	is_delimiter		initial ("001000000"b),
 10    50 	is_constant		initial ("000100000"b),
 10    51 	is_arith_constant		initial ("000010000"b),	/* N.B. not really a mask...s/b "000110000"b */
 10    52 	is_arithmetic_constant	initial ("000110000"b),
 10    53 	is_imaginary_constant	initial ("000111000"b),
 10    54 	is_float_constant		initial ("000110100"b),
 10    55 	is_decimal_constant		initial ("000110010"b),
 10    56 	is_integral_constant 	initial ("000110001"b)
 10    57 	) bit(9) internal static aligned options(constant);
 10    58 
 10    59 /* END INCLUDE FILE ... token_types.incl.pl1 */
       92 
 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 */
       93 
 12     1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */
 12     2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */
 12     3 /* format: style3,idind30 */
 12     4 
 12     5 declare	1 block			aligned based,
 12     6 	  2 node_type		bit (9) unaligned,
 12     7 	  2 source_id		structure unaligned,
 12     8 	    3 file_number		bit (8),
 12     9 	    3 line_number		bit (14),
 12    10 	    3 statement_number	bit (5),
 12    11 	  2 father		ptr unaligned,
 12    12 	  2 brother		ptr unaligned,
 12    13 	  2 son			ptr unaligned,
 12    14 	  2 declaration		ptr unaligned,
 12    15 	  2 end_declaration		ptr unaligned,
 12    16 	  2 default		ptr unaligned,
 12    17 	  2 end_default		ptr unaligned,
 12    18 	  2 context		ptr unaligned,
 12    19 	  2 prologue		ptr unaligned,
 12    20 	  2 end_prologue		ptr unaligned,
 12    21 	  2 main			ptr unaligned,
 12    22 	  2 end_main		ptr unaligned,
 12    23 	  2 return_values		ptr unaligned,
 12    24 	  2 return_count		ptr unaligned,
 12    25 	  2 plio_ps		ptr unaligned,
 12    26 	  2 plio_fa		ptr unaligned,
 12    27 	  2 plio_ffsb		ptr unaligned,
 12    28 	  2 plio_ssl		ptr unaligned,
 12    29 	  2 plio_fab2		ptr unaligned,
 12    30 	  2 block_type		bit (9) unaligned,
 12    31 	  2 prefix		bit (12) unaligned,
 12    32 	  2 like_attribute		bit (1) unaligned,
 12    33 	  2 no_stack		bit (1) unaligned,
 12    34 	  2 get_data		bit (1) unaligned,
 12    35 	  2 flush_at_call		bit (1) unaligned,
 12    36 	  2 processed		bit (1) unaligned,
 12    37 	  2 text_displayed		bit (1) unaligned,
 12    38 	  2 number		fixed bin (9) unsigned unaligned,
 12    39 	  2 free_temps		dimension (3) ptr,	/* these fields are used by the code generator */
 12    40 	  2 temp_list		ptr,
 12    41 	  2 entry_list		ptr,
 12    42 	  2 o_and_s		ptr,
 12    43 	  2 why_nonquick		aligned,
 12    44 	    3 auto_adjustable_storage bit (1) unaligned,
 12    45 	    3 returns_star_extents	bit (1) unaligned,
 12    46 	    3 stack_extended_by_args	bit (1) unaligned,
 12    47 	    3 invoked_by_format	bit (1) unaligned,
 12    48 	    3 format_statement	bit (1) unaligned,
 12    49 	    3 io_statements		bit (1) unaligned,
 12    50 	    3 assigned_to_entry_var	bit (1) unaligned,
 12    51 	    3 condition_statements	bit (1) unaligned,
 12    52 	    3 no_owner		bit (1) unaligned,
 12    53 	    3 recursive_call	bit (1) unaligned,
 12    54 	    3 options_non_quick	bit (1) unaligned,
 12    55 	    3 options_variable	bit (1) unaligned,
 12    56 	    3 never_referenced	bit (1) unaligned,
 12    57 	    3 pad_nonquick		bit (5) unaligned,
 12    58 	  2 prologue_flag		bit (1) unaligned,
 12    59 	  2 options_main		bit (1) unaligned,
 12    60 	  2 pad			bit (16) unaligned,
 12    61 	  2 number_of_entries	fixed bin (17),
 12    62 	  2 level			fixed bin (17),
 12    63 	  2 last_auto_loc		fixed bin (17),
 12    64 	  2 symbol_block		fixed bin (17),
 12    65 	  2 entry_info		fixed bin (18),
 12    66 	  2 enter			structure unaligned,
 12    67 	    3 start		fixed bin (17),
 12    68 	    3 end			fixed bin (17),
 12    69 	  2 leave			structure unaligned,
 12    70 	    3 start		fixed bin (17),
 12    71 	    3 end			fixed bin (17),
 12    72 	  2 owner			ptr;
 12    73 
 12    74 declare	max_block_number		fixed bin internal static options (constant) initial (511);
 12    75 
 12    76 /* END INCLUDE FILE ... block.incl.pl1 */
       94 
 13     1 dcl (	root_block		initial("000000001"b),
 13     2 	external_procedure		initial("000000010"b),
 13     3 	internal_procedure		initial("000000011"b),
 13     4 	begin_block		initial("000000100"b),
 13     5 	on_unit			initial("000000101"b))  internal static bit(9) aligned options(constant);
       95 
 14     1 /* ***********************************************************
 14     2*   *                                                         *
 14     3*   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
 14     4*   *                                                         *
 14     5*   *********************************************************** */
 14     6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */
 14     7 /* Internal interface of the PL/I compiler */
 14     8 
 14     9 dcl	1 statement		based aligned,
 14    10 	2 node_type		bit(9) unaligned,
 14    11 	2 source_id		structure unaligned,
 14    12 	  3 file_number		bit(8),
 14    13 	  3 line_number		bit(14),
 14    14 	  3 statement_number	bit(5),
 14    15 	2 next			ptr unaligned,
 14    16 	2 back			ptr unaligned,
 14    17 	2 root			ptr unaligned,
 14    18 	2 labels			ptr unaligned,
 14    19 	2 reference_list		ptr unaligned,
 14    20 	2 state_list		ptr unaligned,
 14    21 	2 reference_count		fixed(17) unaligned,
 14    22 	2 ref_count_copy		fixed(17) unaligned,
 14    23 	2 object			structure unaligned,
 14    24 	  3 start			fixed(17),
 14    25 	  3 finish		fixed(17),
 14    26 	2 source			structure unaligned,
 14    27 	  3 segment		fixed(11),
 14    28 	  3 start			fixed(23),
 14    29 	  3 length		fixed(11),
 14    30 	2 prefix			bit(12) unaligned,
 14    31 	2 optimized		bit(1) unaligned,
 14    32 	2 free_temps		bit(1) unaligned,
 14    33 	2 LHS_in_RHS		bit(1) unaligned,
 14    34 	2 statement_type		bit(9) unaligned,
 14    35 	2 bits			structure unaligned,
 14    36 	  3 processed		bit(1) unaligned,
 14    37 	  3 put_in_profile		bit(1) unaligned,
 14    38 	  3 generated		bit(1) unaligned,
 14    39 	  3 snap			bit(1) unaligned,
 14    40 	  3 system		bit(1) unaligned,
 14    41 	  3 irreducible		bit(1) unaligned,
 14    42 	  3 checked		bit(1) unaligned,
 14    43 	  3 save_temps		bit(1) unaligned,
 14    44 	  3 suppress_warnings	bit(1) unaligned,
 14    45 	  3 force_nonquick		bit(1) unaligned,
 14    46 	  3 expanded_by_name	bit(1) unaligned,
 14    47 	  3 begins_loop		bit(1) unaligned,
 14    48 	  3 pad			bit(24) unaligned;
 14    49 
 14    50 /* END INCLUDE FILE ... statement.incl.pl1 */
       96 
 15     1 	/* statement types */
 15     2 
 15     3 dcl (	unknown_statement		initial("000000000"b),
 15     4 	allocate_statement		initial("000000001"b),
 15     5 	assignment_statement	initial("000000010"b),
 15     6 	begin_statement		initial("000000011"b),
 15     7 	call_statement		initial("000000100"b),
 15     8 	close_statement		initial("000000101"b),
 15     9 	declare_statement		initial("000000110"b),
 15    10 	lock_statement		initial("000000111"b),
 15    11 	delete_statement		initial("000001000"b),
 15    12 	display_statement		initial("000001001"b),
 15    13 	do_statement		initial("000001010"b),
 15    14 	else_clause		initial("000001011"b),
 15    15 	end_statement		initial("000001100"b),
 15    16 	entry_statement		initial("000001101"b),
 15    17 	exit_statement		initial("000001110"b),
 15    18 	format_statement		initial("000001111"b),
 15    19 	free_statement		initial("000010000"b),
 15    20 	get_statement		initial("000010001"b),
 15    21 	goto_statement		initial("000010010"b),
 15    22 	if_statement		initial("000010011"b),
 15    23 	locate_statement		initial("000010100"b),
 15    24 	null_statement		initial("000010101"b),
 15    25 	on_statement		initial("000010110"b),
 15    26 	open_statement		initial("000010111"b),
 15    27 	procedure_statement 	initial("000011000"b),
 15    28 	put_statement		initial("000011001"b),
 15    29 	read_statement		initial("000011010"b),
 15    30 	return_statement		initial("000011011"b),
 15    31 	revert_statement		initial("000011100"b),
 15    32 	rewrite_statement		initial("000011101"b),
 15    33 	signal_statement		initial("000011110"b),
 15    34 	stop_statement		initial("000011111"b),
 15    35 	system_on_unit		initial("000100000"b),
 15    36 	unlock_statement		initial("000100001"b),
 15    37 	wait_statement		initial("000100010"b),
 15    38 	write_statement		initial("000100011"b),
 15    39 	default_statement		initial("000100100"b),
 15    40 	continue_statement		initial("000100101"b)) bit(9) internal static aligned options(constant);
       97 
 16     1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */
 16     2 
 16     3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */
 16     4 
 16     5 dcl (	block_node		initial("000000001"b),
 16     6 	statement_node		initial("000000010"b),
 16     7 	operator_node		initial("000000011"b),
 16     8 	reference_node		initial("000000100"b),
 16     9 	token_node		initial("000000101"b),
 16    10 	symbol_node		initial("000000110"b),
 16    11 	context_node		initial("000000111"b),
 16    12 	array_node		initial("000001000"b),
 16    13 	bound_node		initial("000001001"b),
 16    14 	format_value_node		initial("000001010"b),
 16    15 	list_node			initial("000001011"b),
 16    16 	default_node		initial("000001100"b),
 16    17 	machine_state_node		initial("000001101"b),
 16    18 	source_node		initial("000001110"b),
 16    19 	label_node		initial("000001111"b),
 16    20 	cross_reference_node	initial("000010000"b),
 16    21 	sf_par_node		initial("000010001"b),
 16    22 	temporary_node		initial("000010010"b),
 16    23 	label_array_element_node	initial("000010011"b),
 16    24 	by_name_agg_node		initial("000010100"b))
 16    25 				bit(9) internal static aligned options(constant);
 16    26 
 16    27 dcl	1 node			based aligned,
 16    28 	2 type			unal bit(9),
 16    29 	2 source_id		unal structure,
 16    30 	  3 file_number		bit(8),
 16    31 	  3 line_number		bit(14),
 16    32 	  3 statement_number	bit(5);
 16    33 
 16    34 /* END INCLUDE FILE ... nodes.incl.pl1 */
       98 
 17     1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */
 17     2 
 17     3 /*	Modified: 2 Apr 1980 by PCK to add max_number_of_operands */
 17     4 
 17     5 /* format: style3 */
 17     6 dcl	1 operator	based aligned,
 17     7 	  2 node_type	bit (9) unaligned,
 17     8 	  2 op_code	bit (9) unaligned,
 17     9 	  2 shared	bit (1) unaligned,
 17    10 	  2 processed	bit (1) unaligned,
 17    11 	  2 optimized	bit (1) unaligned,
 17    12 	  2 number	fixed (14) unaligned,
 17    13 	  2 operand	dimension (n refer (operator.number)) ptr unaligned;
 17    14 
 17    15 dcl	max_number_of_operands
 17    16 			fixed bin (15) int static options (constant) initial (32767);
 17    17 
 17    18 /* END INCLUDE FILE ... operator.incl.pl1 */
       99 
 18     1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */
 18     2 
 18     3 /* Modified 26 June 81 by EBush to add max_list_elements */
 18     4 
 18     5 
 18     6 dcl	1 list		based aligned,
 18     7 	2 node_type	bit(9) unaligned,
 18     8 	2 reserved	bit(12) unaligned,
 18     9 	2 number		fixed(14) unaligned,
 18    10 	2 element		dimension(n refer(list.number)) ptr unaligned;
 18    11 
 18    12 dcl       max_list_elements   fixed bin(17) internal static options (constant)
 18    13 	                    init(16383);
 18    14 
 18    15 /* END INCLUDE FILE ... list.incl.pl1 */
      100 
 19     1 dcl	1 label			based aligned,
 19     2 	2 node_type		bit(9) unaligned,
 19     3 	2 source_id		structure unaligned,
 19     4 	  3 file_number		bit(8),
 19     5 	  3 line_number		bit(14),
 19     6 	  3 statement_number	bit(5),
 19     7 	2 location		fixed(17) unaligned,
 19     8 	2 allocated		bit(1) unaligned,
 19     9 	2 dcl_type		bit(3) unaligned,
 19    10 	2 reserved		bit(29) unaligned,
 19    11 	2 array			bit(1) unaligned,
 19    12 	2 used_as_format		bit(1) unaligned,
 19    13 	2 used_in_goto		bit(1) unaligned,
 19    14 	2 symbol_table		bit(18) unaligned,
 19    15 	2 low_bound		fixed(17) unaligned,
 19    16 	2 high_bound		fixed(17) unaligned,
 19    17 	2 block_node		ptr unaligned,
 19    18 	2 token			ptr unaligned,
 19    19 	2 next			ptr unaligned,
 19    20 	2 multi_use		ptr unaligned,
 19    21 	2 cross_reference		ptr unaligned,
 19    22 	2 statement		ptr unaligned;
      101 
 20     1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */
 20     2 
 20     3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */
 20     4 
 20     5 dcl  (	by_declare	initial("001"b),
 20     6 	by_explicit_context initial("010"b),
 20     7 	by_context	initial("011"b),
 20     8 	by_implication	initial("100"b),
 20     9 	by_compiler	initial("101"b)) int static bit(3) aligned options(constant);
 20    10 
 20    11 /* END INCLUDE FILE ... declare_type.incl.pl1 */
      102 
      103 
      104 /* program */
      105 
      106 	then_goto_optimized, else = "0"b;
      107 	end_ptr = null;
      108 	cblock = father_block;
      109 	return_flag = our_return_flag;
      110 	conditions = our_conditions;
      111 
      112 	pl1_stat_$cur_statement, if = create_statement (if_statement, cblock, entry_ptr, conditions);
      113 
      114 	if entry_ptr ^= null
      115 	then call declare_label (cblock, if, entry_ptr, by_explicit_context);
      116 
      117 	k = k + 1;
      118 	expr = expression_parse (k, cblock);
      119 
      120 	if expr = null
      121 	then do;
      122 		call parse_error (432, null);
      123 		loc = null;
      124 
      125 		do while ("1"b);
      126 		     if t_table.type = semi_colon
      127 		     then do;
      128 			     label_ptr = null;
      129 			     type = binary (null_statement);
      130 			     go to action (0);
      131 			end;
      132 
      133 		     if t_table.string = "then"
      134 		     then do;
      135 			     k = k + 1;
      136 			     go to get_statement_type;
      137 			end;
      138 		     k = k + 1;
      139 		end;
      140 	     end;
      141 
      142 	bit_type = ""b;
      143 
      144 	if expr -> node.type = operator_node
      145 	then bit_type = expr -> operator.op_code;
      146 
      147 	if substr (bit_type, 1, 5) = "00100"b		/* relational class */
      148 	then do;					/* change relational to jump op */
      149 		jump_if_false, expr -> operator.op_code = rel_to_jump (binary (substr (bit_type, 6, 4), 4));
      150 		jump_if_true = bit_type | "000010000"b;
      151 	     end;
      152 	else do;
      153 		q = create_operator (jump_false, 2);
      154 		q -> operator.operand (2) = expr;
      155 		expr = q;
      156 		jump_if_true = jump_true;
      157 		jump_if_false = jump_false;
      158 	     end;
      159 
      160 	loc = create_label (cblock, null, by_compiler);	/* label is used to jump around then clause */
      161 	expr -> operand (1) = loc;
      162 	if -> statement.root = expr;
      163 	location = loc -> label.token;
      164 
      165 	if t_table.string = "then"
      166 	then k = k + 1;
      167 	else call parse_error (431, null);
      168 
      169 get_statement_type:
      170 	conditions = cblock -> block.prefix;
      171 	then_type, type = statement_type (cblock, k, label_ptr, conditions);
      172 	go to action (action_index (type));
      173 
      174 /* 	***************** Statements requiring individual parsing procedures. ******** */
      175 
      176 action (1):					/* begin statement */
      177 	call procedure_parse (k, label_ptr, conditions, cblock, end_ptr, begin_block, return_flag);
      178 	go to end_up;
      179 
      180 action (2):					/* do statement    */
      181 	call do_parse (k, label_ptr, conditions, cblock, end_ptr, return_flag, return_flag, "0"b);
      182 	go to end_up;
      183 
      184 action (3):					/* if statement    */
      185 	call if_parse (k, label_ptr, conditions, cblock, end_ptr, return_flag);
      186 	go to if_end_up;
      187 
      188 action (4):					/* on statement    */
      189 	call on_parse (k, label_ptr, conditions, cblock, end_ptr);
      190 	go to end_up;
      191 
      192 /*	***************** Statements in error. *************************************** */
      193 
      194 action (5):					/* declare,end,entry,format,procedure & possibly return stmts */
      195 	if type = binary (return_statement, 9)
      196 	then if return_flag
      197 	     then n = 412;
      198 	     else go to action (0);
      199 	else n = 430;
      200 	call parse_error (n, null);
      201 	go to end_up;
      202 
      203 /* 	***************** Statements all parsed in statement_parse. ****************** */
      204 
      205 action (0):
      206 	call statement_parse (k, label_ptr, conditions, cblock, type);
      207 	go to end_up;
      208 
      209 /*	***************** Statements processed in-line ******************************* */
      210 
      211 action (6):					/* go to statement in then clause */
      212 	if label_ptr ^= null | conditions ^= cblock -> block.prefix | ^pl1_stat_$optimize
      213 	then go to action (0);
      214 
      215 	if t_table.string = "goto"
      216 	then k = k + 1;
      217 	else do;
      218 		k = k + 1;
      219 
      220 		if t_table.string ^= "to"
      221 		then call parse_error (446, null);
      222 		else k = k + 1;
      223 	     end;
      224 
      225 	if expr = null
      226 	then expr = create_operator ((jump_if_true), 2);
      227 	else expr -> op_code = jump_if_true;
      228 
      229 	expr -> operand (1) = reference_parse (k, cblock);
      230 
      231 	if expr -> operand (1) = null
      232 	then call print (446);
      233 	else if t_table.type ^= semi_colon
      234 	then call parse_error (1, null);
      235 
      236 	then_goto_optimized = "1"b;
      237 	goto end_up;
      238 
      239 action (7):
      240 	call io_statement_parse (k, label_ptr, conditions, cblock, end_ptr, return_flag, bit (binary (type, 9)));
      241 	goto end_up;
      242 
      243 end_up:
      244 	if end_ptr = null
      245 	then call lex(cblock);			/* ^=null ==> end of block */
      246 
      247 /* If the statement following the if statement has a label on it, e.g.
      248*   	if e1 then label: ....
      249*   we have to insert a null statement with 0 statement id before it.  This is
      250*   done to prevent problems if the semantic translator has to expand the
      251*   labelled statement into several statements.  This must also
      252*   be done if the profile option is used. */
      253 
      254 if_end_up:
      255 	q = if -> statement.next;
      256 	if q ^= null
      257 	then if q -> statement.labels ^= null | (^else & pl1_stat_$profile)
      258 	     then do;
      259 		     q = create_statement (null_statement, if, null, conditions);
      260 		     string (q -> statement.source_id) = "0"b;
      261 		end;
      262 
      263 	if else
      264 	then go to process_else_clause;		/* second time thru */
      265 
      266 	if ^then_goto_optimized
      267 	then do;
      268 
      269 /* following code is executed after the then clause is parsed. */
      270 
      271 		q = create_statement (null_statement, cblock, null, conditions);
      272 
      273 /* following code sets the id of the statement holding
      274*   the label to the id of the statement preceding it.  This is
      275*   done so that the following statement can be expanded into several
      276*   statements.  We can't just set id of statement to 0 because that
      277*   fouls up the optimizer */
      278 
      279 		string (q -> statement.source_id) = string (q -> statement.back -> statement.source_id);
      280 
      281 		if loc ^= null
      282 		then do;
      283 			t, q -> statement.labels = create_list (2);
      284 			loc -> label.statement = q;
      285 			t -> list.element (2) = location;
      286 		     end;
      287 		else go to exit;
      288 	     end;
      289 
      290 	if end_ptr ^= null				/* unsatisfied labelled END statement */
      291 	then go to exit;
      292 
      293 	k = 1;
      294 	if t_table.string ^= "else"
      295 	then go to exit;				/* no else clause; return */
      296 
      297 	k = k + 1;
      298 	if t_table.type ^= left_parn
      299 	then go to call_st1;
      300 
      301 /*  else  (  */
      302 
      303 	if token_list (k + 3) -> token.type ^= colon
      304 	then go to call_st1;			/* could be assignment or condition prefix list */
      305 
      306 /*  else  (  <anything>  )  :  */
      307 
      308 	k = k + 1;
      309 
      310 	if t_table.type = identifier			/* it's a CPL in an else clause */
      311 	then do;
      312 		k = 2;
      313 		else = "1"b;			/* this is the case that statement type */
      314 		go to call_st;			/* can't handle.  */
      315 	     end;
      316 
      317 /* it must be a label array named "else" ! */
      318 
      319 call_st1:
      320 	k = 1;
      321 call_st:
      322 	conditions = cblock -> block.prefix;
      323 	type = statement_type (cblock, k, label_ptr, conditions);
      324 
      325 	if type = binary (else_clause, 9)
      326 	then do;
      327 		if else
      328 		then call print (150);		/* no if stmnt before else */
      329 
      330 		else = "1"b;
      331 		k = k + 1;
      332 		go to call_st;
      333 	     end;
      334 
      335 	if ^else
      336 	then go to exit;
      337 
      338 /* Now that we know we have an else clause, we check the type of statement
      339*   in it--certain combinations may be optimized slightly.	*/
      340 
      341 	if type ^= binary (goto_statement, 9) | label_ptr ^= null | conditions ^= cblock -> block.prefix
      342 	     | ^pl1_stat_$optimize
      343 	then go to action (action_index (type));
      344 
      345 	if then_goto_optimized
      346 	then go to action (0);
      347 
      348 	if t_table.string = "goto"
      349 	then k = k + 1;
      350 	else do;
      351 		k = k + 1;
      352 
      353 		if t_table.string ^= "to"
      354 		then call parse_error (446, null);
      355 		else k = k + 1;
      356 	     end;
      357 
      358 	expr -> operator.op_code = jump_if_false;
      359 	expr -> operand (1) = reference_parse (k, cblock);
      360 
      361 	if expr -> operand (1) = null
      362 	then call print (446);
      363 	else if t_table.type ^= semi_colon
      364 	then call parse_error (1, null);
      365 						/* delete null statement. */
      366 	q -> statement.back -> statement.next = null;	/* since this is the last statement on the chain. */
      367 	cblock -> block.end_main = q -> statement.back;	/* reset block ptr */
      368 	loc -> label.statement = null;
      369 
      370 	if end_ptr = null
      371 	then call lex(cblock);
      372 
      373 	goto exit;
      374 
      375 /* following code is executed after the else clause is parsed. */
      376 
      377 /* When control reaches here, the tree is as follows:
      378*
      379*  if->      ----  if_statement
      380*            |           |
      381*            |           |
      382*            |     then body
      383*            |           |
      384*            |           |     q->  - - - - - - go to statement
      385*	  |	    |			|
      386*   t->      ----> null statement		|
      387*	              |			|
      388*		    |			|
      389*		    |			|
      390*	          else body			|
      391*		    |			|
      392*  p->		    |    < - - - - - - - - null statement
      393*
      394*   We must insert a goto statement after the "then" body which
      395*   transfers control around the else body. This action is not done
      396*   if the then body does not exist, or if it is a return statement 
      397*   or a stop statement.  This action is also not done if the "then"
      398*   body is a noniterative do-group whose end statement has only one
      399*   label (which therefore must be compiler created), and which has
      400*   a return statement, a goto statement, or a stop statement preceding
      401*   the end statement.	*/
      402 
      403 process_else_clause:
      404 	t = loc -> label.statement;
      405 	if t = null
      406 	then go to exit;
      407 
      408 	if (then_type = binary (return_statement, 9)) | (then_type = binary (stop_statement, 9))
      409 	then go to exit;
      410 
      411 	p = t -> statement.back;
      412 	bit_type = p -> statement.statement_type;
      413 
      414 	if (bit_type = return_statement) | (bit_type = goto_statement) | (bit_type = stop_statement)
      415 	then go to exit;
      416 
      417 	if then_type = binary (do_statement, 9)
      418 	then do;
      419 		do = if -> statement.next;
      420 		do while (do -> statement.statement_type ^= do_statement);
      421 						/* skip any null stmts */
      422 		     do = do -> statement.next;	/* to get to the do stmt */
      423 		end;
      424 		if do -> statement.root -> operator.operand (3) = null
      425 						/* if no do_spec operator */
      426 		then if p -> statement.labels -> list.element (1) = null
      427 						/* if one label */
      428 		     then do;			/* we know p -> end stmt */
      429 			     bit_type = p -> statement.back -> statement.statement_type;
      430 			     if (bit_type = return_statement) | (bit_type = goto_statement)
      431 				| (bit_type = stop_statement)
      432 			     then go to exit;
      433 			end;
      434 	     end;
      435 
      436 	if label_ptr = null & type = binary (null_statement, 9)
      437 	then go to exit;
      438 
      439 	q = create_statement (goto_statement, p, null, conditions);
      440 
      441 /* we have to set the id of the goto and the null statement following
      442*   it to be the same as the id of the last statement in the then group.
      443*   This is necessary to prevent difficulties if the semantic translator
      444*   has to expand the first statement of else group into several statements */
      445 
      446 	string (t -> statement.source_id), string (q -> statement.source_id) = string (p -> statement.source_id);
      447 
      448 	t, q -> statement.root = create_operator (jump, 1);
      449 	q, t -> operand (1) = create_label (cblock, null, by_compiler);
      450 
      451 /* make a label for the newly created jump operator */
      452 
      453 	p = create_statement (null_statement, cblock, null, conditions);
      454 
      455 /* following code sets the id of the statement holding
      456*   the label to the id of the statement before it.  This is
      457*   done so that the following statement can be expanded into several
      458*   statements.  We can't just set id of statement to 0 because
      459*   that fouls up the optimizer */
      460 
      461 	string (p -> statement.source_id) = string (p -> statement.back -> statement.source_id);
      462 
      463 	q -> label.statement = p;
      464 	t, p -> statement.labels = create_list (2);	/* again, t is a temporary ptr. */
      465 	t -> list.element (2) = q -> label.token;	/* fish out name from label node */
      466 
      467 exit:
      468 	entry_ptr = label_ptr;
      469 	his_end_ptr = end_ptr;
      470 	return;
      471 
      472 print:
      473      proc (m);
      474 
      475 dcl	m		fixed bin (15);
      476 
      477 	call parse_error (m, null);
      478 	if -> statement.root = null;
      479 	if -> statement.statement_type = null_statement;
      480 
      481      end print;
      482 
      483      end /* if_parse */;
	SOURCE FILES USED IN THIS COMPILATION.

LINE      NUMBER  DATE MODIFIED     NAME			PATHNAME
             0    04/24/92  1040.9  if_parse.pl1                      >spec>install>MR12.5-1011>if_parse.pl1
89           1    04/24/92  1056.9  parse.incl.pl1                    >spec>install>MR12.5-1011>parse.incl.pl1
1-175        2    08/01/89  1339.9  language_utility.incl.pl1         >ldd>incl>language_utility.incl.pl1
2-307        3    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
2-325        4    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
2-335        5    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
2-374        6    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
2-386        7    05/06/74  1846.9  source_id_descriptor.incl.pl1     >ldd>incl>source_id_descriptor.incl.pl1
90           8    09/14/77  1805.7  token_list.incl.pl1               >ldd>incl>token_list.incl.pl1
91           9    09/14/77  1805.7  token.incl.pl1                    >ldd>incl>token.incl.pl1
92          10    11/30/78  1327.4  token_types.incl.pl1              >ldd>incl>token_types.incl.pl1
93          11    04/07/83  1735.0  op_codes.incl.pl1                 >ldd>incl>op_codes.incl.pl1
94          12    08/13/81  2143.5  block.incl.pl1                    >ldd>incl>block.incl.pl1
95          13    05/03/76  1420.8  block_types.incl.pl1              >ldd>incl>block_types.incl.pl1
96          14    04/07/83  1735.0  statement.incl.pl1                >ldd>incl>statement.incl.pl1
97          15    05/03/76  1420.4  statement_types.incl.pl1          >ldd>incl>statement_types.incl.pl1
98          16    07/21/80  1646.3  nodes.incl.pl1                    >ldd>incl>nodes.incl.pl1
99          17    07/21/80  1646.3  operator.incl.pl1                 >ldd>incl>operator.incl.pl1
100         18    08/13/81  2311.5  list.incl.pl1                     >ldd>incl>list.incl.pl1
101         19    05/06/74  1842.1  label.incl.pl1                    >ldd>incl>label.incl.pl1
102         20    10/25/79  1745.8  declare_type.incl.pl1             >ldd>incl>declare_type.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.
action_index                    000020 constant        fixed bin(15,0)          initial array dcl 83 ref 172 341
back                      2            based           pointer                  level 2 packed packed unaligned dcl 14-9 ref 279 366
                                                                                  367 411 429 461
begin_block                     000015 constant        bit(9)                   initial dcl 13-1 set ref 176*
binary                                                 builtin function         dcl 48 ref 129 149 194 239 239 325 341 408 408 417
                                                                                  436
bit                                                    builtin function         dcl 48 ref 239 239
bit_type                        000136 automatic       bit(9)                   packed unaligned dcl 61 set ref 142* 144* 147 149
                                                                                  150 412* 414 414 414 429* 430 430 430
block                                  based           structure                level 1 dcl 12-5
by_compiler                     000010 constant        bit(3)                   initial dcl 20-5 set ref 160* 449*
by_explicit_context             000011 constant        bit(3)                   initial dcl 20-5 set ref 114*
cblock                          000114 automatic       pointer                  dcl 55 set ref 108* 112* 114* 118* 160* 169 171*
                                                                                  176* 180* 184* 188* 205* 211 229* 239* 243* 271*
                                                                                  321 323* 341 359* 367 370* 449* 453*
colon                           000017 constant        bit(9)                   initial dcl 10-3 ref 303
conditions                      000132 automatic       bit(12)                  dcl 57 set ref 110* 112* 169* 171* 176* 180* 184*
                                                                                  188* 205* 211 239* 259* 271* 321* 323* 341 439*
                                                                                  453*
create_label                    000044 constant        entry                    external dcl 2-140 ref 160 449
create_list                     000046 constant        entry                    external dcl 2-147 ref 283 464
create_operator                 000050 constant        entry                    external dcl 2-152 ref 153 225 448
create_statement                000052 constant        entry                    external dcl 2-163 ref 112 259 271 439 453
declare_label                   000016 constant        entry                    external dcl 1-29 ref 114
do                              000110 automatic       pointer                  dcl 55 set ref 419* 420 422* 422 424
do_parse                        000020 constant        entry                    external dcl 1-56 ref 180
do_statement                           constant        bit(9)                   initial dcl 15-3 ref 417 420
element                   1            based           pointer                  array level 2 packed packed unaligned dcl 18-6 set
                                                                                  ref 285* 424 465*
else                            000134 automatic       bit(1)                   dcl 59 set ref 106* 256 263 313* 327 330* 335
else_clause                            constant        bit(9)                   initial dcl 15-3 ref 325
end_main                 14            based           pointer                  level 2 packed packed unaligned dcl 12-5 set ref
                                                                                  367*
end_ptr                         000116 automatic       pointer                  dcl 55 set ref 107* 176* 180* 184* 188* 239* 243 290
                                                                                  370 469
entry_ptr                              parameter       pointer                  dcl 55 set ref 23 112* 114 114* 467*
expr                            000124 automatic       pointer                  dcl 55 set ref 118* 120 144 144 149 154 155* 161 162
                                                                                  225 225* 227 229 231 358 359 361
expression_parse                000022 constant        entry                    external dcl 1-73 ref 118
father_block                           parameter       pointer                  dcl 55 ref 23 108
goto_statement                  000014 constant        bit(9)                   initial dcl 15-3 set ref 341 414 430 439*
his_end_ptr                            parameter       pointer                  dcl 55 set ref 23 469*
identifier                             constant        bit(9)                   initial dcl 10-3 ref 310
if                              000106 automatic       pointer                  dcl 55 set ref 112* 114* 162 254 259* 419 478 479
if_parse                        000024 constant        entry                    external dcl 1-87 ref 184
if_statement                    000013 constant        bit(9)                   initial dcl 15-3 set ref 112*
io_statement_parse              000026 constant        entry                    external dcl 1-96 ref 239
jump                            000016 constant        bit(9)                   initial dcl 11-8 set ref 448*
jump_false                      000017 constant        bit(9)                   initial dcl 11-8 set ref 153* 157
jump_if_false                   000137 automatic       bit(9)                   packed unaligned dcl 61 set ref 149* 157* 358
jump_if_true                    000140 automatic       bit(9)                   packed unaligned dcl 61 set ref 150* 156* 225 227
jump_true                              constant        bit(9)                   initial dcl 11-8 ref 156
k                                      parameter       fixed bin(15,0)          dcl 53 set ref 23 117* 117 118* 126 133 135* 135
                                                                                  138* 138 165 165* 165 171* 176* 180* 184* 188*
                                                                                  205* 215 215* 215 218* 218 220 222* 222 229* 233
                                                                                  239* 293* 294 297* 297 298 303 308* 308 310 312*
                                                                                  319* 323* 331* 331 348 348* 348 351* 351 353 355*
                                                                                  355 359* 363
label                                  based           structure                level 1 dcl 19-1
label_ptr                       000112 automatic       pointer                  dcl 55 set ref 128* 171* 176* 180* 184* 188* 205*
                                                                                  211 239* 323* 341 436 467
labels                    4            based           pointer                  level 2 packed packed unaligned dcl 14-9 set ref 256
                                                                                  283* 424 464*
left_parn                              constant        bit(9)                   initial dcl 10-3 ref 298
lex                             000030 constant        entry                    external dcl 1-106 ref 243 370
list                                   based           structure                level 1 dcl 18-6
loc                             000126 automatic       pointer                  dcl 55 set ref 123* 160* 161 163 281 284 368 403
location                        000130 automatic       pointer                  dcl 55 set ref 163* 285
m                                      parameter       fixed bin(15,0)          dcl 475 set ref 472 477*
n                               000102 automatic       fixed bin(15,0)          dcl 53 set ref 194* 199* 200*
next                      1            based           pointer                  level 2 packed packed unaligned dcl 14-9 set ref 254
                                                                                  366* 419 422
node                                   based           structure                level 1 dcl 16-27
null                                                   builtin function         dcl 48 ref 107 114 120 122 122 123 128 160 160 167
                                                                                  167 200 200 211 220 220 225 231 233 233 243 256
                                                                                  256 259 259 271 271 281 290 341 353 353 361 363
                                                                                  363 366 368 370 405 424 424 436 439 439 449 449
                                                                                  453 453 477 477 478
null_statement                  000012 constant        bit(9)                   initial dcl 15-3 set ref 129 259* 271* 436 453* 479
on_parse                        000032 constant        entry                    external dcl 1-116 ref 188
op_code                   0(09)        based           bit(9)                   level 2 packed packed unaligned dcl 17-6 set ref 144
                                                                                  149* 227* 358*
operand                   1            based           pointer                  array level 2 packed packed unaligned dcl 17-6 set
                                                                                  ref 154* 161* 229* 231 359* 361 424 449*
operator                               based           structure                level 1 dcl 17-6
operator_node                          constant        bit(9)                   initial dcl 16-5 ref 144
our_conditions                         parameter       bit(12)                  dcl 57 ref 23 110
our_return_flag                        parameter       bit(1)                   dcl 59 ref 23 109
p                               000120 automatic       pointer                  dcl 55 set ref 411* 412 424 429 439* 446 453* 461
                                                                                  461 463 464
parse_error                     000054 constant        entry                    external dcl 2-364 ref 122 167 200 220 233 353 363
                                                                                  477
pl1_stat_$cur_statement         000010 external static pointer                  dcl 66 set ref 112*
pl1_stat_$optimize              000012 external static bit(1)                   dcl 66 ref 211 341
pl1_stat_$profile               000014 external static bit(1)                   dcl 66 ref 256
pl1_stat_$token_list_ptr        000056 external static pointer                  dcl 8-1 ref 8-3
prefix                   24(09)        based           bit(12)                  level 2 packed packed unaligned dcl 12-5 ref 169 211
                                                                                  321 341
procedure_parse                 000034 constant        entry                    external dcl 1-133 ref 176
q                               000122 automatic       pointer                  dcl 55 set ref 153* 154 155 254* 256 256 259* 260
                                                                                  271* 279 279 283 284 366 367 439* 446 448 449* 463
                                                                                  465
reference_parse                 000036 constant        entry                    external dcl 1-150 ref 229 359
rel_to_jump                     000066 constant        bit(9)                   initial array packed unaligned dcl 75 ref 149
return_flag                     000133 automatic       bit(1)                   dcl 59 set ref 109* 176* 180* 180* 184* 194 239*
return_statement                       constant        bit(9)                   initial dcl 15-3 ref 194 408 414 430
root                      3            based           pointer                  level 2 packed packed unaligned dcl 14-9 set ref
                                                                                  162* 424 448* 478*
semi_colon                             constant        bit(9)                   initial dcl 10-3 ref 126 233 363
size                      3            based           fixed bin(9,0)           level 2 dcl 8-11 ref 133 165 215 220 294 348 353
source_id                 0(09)        based           structure                level 2 packed packed unaligned dcl 14-9 set ref
                                                                                  260* 279* 279 446 446* 446* 461* 461
statement                11            based           pointer                  level 2 in structure "label" packed packed unaligned
                                                                                  dcl 19-1 in procedure "if_parse" set ref 284* 368*
                                                                                  403 463*
statement                              based           structure                level 1 dcl 14-9 in procedure "if_parse"
statement_parse                 000040 constant        entry                    external dcl 1-160 ref 205
statement_type           12(27)        based           bit(9)                   level 2 in structure "statement" packed packed
                                                                                  unaligned dcl 14-9 in procedure "if_parse" set ref
                                                                                  412 420 429 479*
statement_type                  000042 constant        entry                    external dcl 1-167 in procedure "if_parse" ref 171
                                                                                  323
stop_statement                         constant        bit(9)                   initial dcl 15-3 ref 408 414 430
string                                                 builtin function         dcl 48 in procedure "if_parse" set ref 260* 279* 279
                                                                                  446 446* 446* 461* 461
string                    4            based           char                     level 2 in structure "t_table" dcl 8-11 in procedure
                                                                                  "if_parse" ref 133 165 215 220 294 348 353
substr                                                 builtin function         dcl 48 ref 147 149
t                               000104 automatic       pointer                  dcl 55 set ref 283* 285 403* 405 411 446 448* 449
                                                                                  464* 465
t_table                                based           structure                level 1 dcl 8-11
then_goto_optimized             000135 automatic       bit(1)                   dcl 59 set ref 106* 236* 266 345
then_type                       000100 automatic       fixed bin(15,0)          dcl 53 set ref 171* 408 408 417
token                                  based           structure                level 1 dcl 9-3 in procedure "if_parse"
token                     5            based           pointer                  level 2 in structure "label" packed packed unaligned
                                                                                  dcl 19-1 in procedure "if_parse" ref 163 465
token_list                             based           pointer                  array dcl 8-2 ref 126 133 165 215 220 233 294 298
                                                                                  303 310 348 353 363
token_list_pointer              000142 automatic       pointer                  initial dcl 8-3 set ref 126 133 165 215 220 233 294
                                                                                  298 303 310 348 353 363 8-3*
type                            000101 automatic       fixed bin(15,0)          dcl 53 in procedure "if_parse" set ref 129* 171* 172
                                                                                  194 205* 239 239 323* 325 341 341 436
type                      0(09)        based           bit(9)                   level 2 in structure "token" packed packed unaligned
                                                                                  dcl 9-3 in procedure "if_parse" ref 303
type                      0(09)        based           bit(9)                   level 2 in structure "t_table" packed packed
                                                                                  unaligned dcl 8-11 in procedure "if_parse" ref 126
                                                                                  233 298 310 363
type                                   based           bit(9)                   level 2 in structure "node" packed packed unaligned
                                                                                  dcl 16-27 in procedure "if_parse" ref 144

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 2-20
allocate_statement                     internal static bit(9)                   initial dcl 15-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                                    internal static bit(9)                   initial dcl 10-3
and_bits                               internal static bit(9)                   initial dcl 11-8
array_node                             internal static bit(9)                   initial dcl 16-5
arrow                                  internal static bit(9)                   initial dcl 10-3
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                             internal static bit(9)                   initial dcl 10-3
assignment_statement                   internal static bit(9)                   initial dcl 15-3
asterisk                               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
attribute_parse                 000000 constant        entry                    external dcl 1-11
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_statement                        internal static bit(9)                   initial dcl 15-3
bin_integer                            internal static bit(9)                   initial dcl 10-3
binary_to_octal_string          000000 constant        entry                    external dcl 2-38
binary_to_octal_var_string      000000 constant        entry                    external dcl 2-43
bindec                          000000 constant        entry                    external dcl 2-23
bindec$vs                       000000 constant        entry                    external dcl 2-28
binoct                          000000 constant        entry                    external dcl 2-33
bit_pointer                            internal static bit(9)                   initial dcl 11-8
bit_string                             internal static bit(9)                   initial dcl 10-3
bit_to_char                            internal static bit(9)                   initial dcl 11-8
bit_to_word                            internal static bit(9)                   initial dcl 11-8
bitno_fun                              internal static bit(9)                   initial dcl 11-8
block_node                             internal static bit(9)                   initial dcl 16-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 16-5
by_context                             internal static bit(3)                   initial dcl 20-5
by_declare                             internal static bit(3)                   initial dcl 20-5
by_implication                         internal static bit(3)                   initial dcl 20-5
by_name_agg_node                       internal static bit(9)                   initial dcl 16-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 15-3
cat                                    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_string                            internal static bit(9)                   initial dcl 10-3
char_to_word                           internal static bit(9)                   initial dcl 11-8
charno_fun                             internal static bit(9)                   initial dcl 11-8
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 15-3
codeptr_fun                            internal static bit(9)                   initial dcl 11-8
column_format                          internal static bit(9)                   initial dcl 11-8
comma                                  internal static bit(9)                   initial dcl 10-3
compare_expression              000000 constant        entry                    external dcl 2-48
complex_fun                            internal static bit(9)                   initial dcl 11-8
conjg_fun                              internal static bit(9)                   initial dcl 11-8
constant_length                 000000 constant        entry                    external dcl 2-54
context                         000000 constant        entry                    external dcl 1-17
context_node                           internal static bit(9)                   initial dcl 16-5
continue_statement                     internal static bit(9)                   initial dcl 15-3
convert                         000000 constant        entry                    external dcl 2-60
convert$from_builtin            000000 constant        entry                    external dcl 2-72
convert$to_integer              000000 constant        entry                    external dcl 2-66
convert$to_target               000000 constant        entry                    external dcl 2-88
convert$to_target_fb            000000 constant        entry                    external dcl 2-82
convert$validate                000000 constant        entry                    external dcl 2-78
copy_expression                 000000 constant        entry                    external dcl 2-94
copy_expression$copy_sons       000000 constant        entry                    external dcl 2-99
copy_string                            internal static bit(9)                   initial dcl 11-8
copy_unique_expression          000000 constant        entry                    external dcl 2-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 2-108
create_block                    000000 constant        entry                    external dcl 2-112
create_bound                    000000 constant        entry                    external dcl 2-118
create_context                  000000 constant        entry                    external dcl 2-122
create_cross_reference          000000 constant        entry                    external dcl 2-128
create_default                  000000 constant        entry                    external dcl 2-132
create_identifier               000000 constant        entry                    external dcl 2-136
create_reference                000000 constant        entry                    external dcl 2-158
create_statement$prologue       000000 constant        entry                    external dcl 2-171
create_storage                  000000 constant        entry                    external dcl 2-179
create_symbol                   000000 constant        entry                    external dcl 2-184
create_token                    000000 constant        entry                    external dcl 2-191
create_token$init_hash_table    000000 constant        entry                    external dcl 2-197
create_token$protected          000000 constant        entry                    external dcl 2-199
cross_reference_node                   internal static bit(9)                   initial dcl 16-5
data_list_parse                 000000 constant        entry                    external dcl 1-22
dec_integer                            internal static bit(9)                   initial dcl 10-3
decbin                          000000 constant        entry                    external dcl 2-206
declare_constant                000000 constant        entry                    external dcl 2-211
declare_constant$bit            000000 constant        entry                    external dcl 2-219
declare_constant$char           000000 constant        entry                    external dcl 2-224
declare_constant$desc           000000 constant        entry                    external dcl 2-229
declare_constant$integer        000000 constant        entry                    external dcl 2-234
declare_descriptor              000000 constant        entry                    external dcl 2-239
declare_descriptor$ctl          000000 constant        entry                    external dcl 2-249
declare_descriptor$param        000000 constant        entry                    external dcl 2-259
declare_integer                 000000 constant        entry                    external dcl 2-269
declare_parse                   000000 constant        entry                    external dcl 1-35
declare_parse$abort             000000 constant        entry                    external dcl 1-40
declare_picture                 000000 constant        entry                    external dcl 2-274
declare_picture_temp            000000 constant        entry                    external dcl 2-279
declare_pointer                 000000 constant        entry                    external dcl 2-287
declare_statement                      internal static bit(9)                   initial dcl 15-3
declare_temporary               000000 constant        entry                    external dcl 2-292
decode_node_id                  000000 constant        entry                    external dcl 2-300
decode_source_id                000000 constant        entry                    external dcl 2-306
default_node                           internal static bit(9)                   initial dcl 16-5
default_parse                   000000 constant        entry                    external dcl 1-44
default_statement                      internal static bit(9)                   initial dcl 15-3
delete_file                            internal static bit(9)                   initial dcl 11-8
delete_statement                       internal static bit(9)                   initial dcl 15-3
desc_size                              internal static bit(9)                   initial dcl 11-8
descriptor_parse                000000 constant        entry                    external dcl 1-49
digit_to_bit                           internal static bit(9)                   initial dcl 11-8
display_statement                      internal static bit(9)                   initial dcl 15-3
div                                    internal static bit(9)                   initial dcl 11-8
do_fun                                 internal static bit(9)                   initial dcl 11-8
do_spec                                internal static bit(9)                   initial dcl 11-8
e_format                               internal static bit(9)                   initial dcl 11-8
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 15-3
entry_statement                        internal static bit(9)                   initial dcl 15-3
environmentptr_fun                     internal static bit(9)                   initial dcl 11-8
eq                                     internal static bit(9)                   initial dcl 10-3
equal                                  internal static bit(9)                   initial dcl 11-8
error                           000000 constant        entry                    external dcl 2-314
error$omit_text                 000000 constant        entry                    external dcl 2-319
error_                          000000 constant        entry                    external dcl 2-324
error_$finish                   000000 constant        entry                    external dcl 2-343
error_$initialize_error         000000 constant        entry                    external dcl 2-341
error_$no_text                  000000 constant        entry                    external dcl 2-334
evaluate                        000000 constant        entry                    external dcl 1-67
ex_prologue                            internal static bit(9)                   initial dcl 11-8
exit_statement                         internal static bit(9)                   initial dcl 15-3
exp                                    internal static bit(9)                   initial dcl 11-8
exp_fun                                internal static bit(9)                   initial dcl 11-8
expon                                  internal static bit(9)                   initial dcl 10-3
external_procedure                     internal static bit(9)                   initial dcl 13-1
f_format                               internal static bit(9)                   initial dcl 11-8
fixed_bin                              internal static bit(9)                   initial dcl 10-3
fixed_dec                              internal static bit(9)                   initial dcl 10-3
float_bin                              internal static bit(9)                   initial dcl 10-3
float_dec                              internal static bit(9)                   initial dcl 10-3
floor_fun                              internal static bit(9)                   initial dcl 11-8
format_list_parse               000000 constant        entry                    external dcl 1-79
format_statement                       internal static bit(9)                   initial dcl 15-3
format_value_node                      internal static bit(9)                   initial dcl 16-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_node                       000000 constant        entry                    external dcl 2-345
free_statement                         internal static bit(9)                   initial dcl 15-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
ge                                     internal static bit(9)                   initial dcl 10-3
get_array_size                  000000 constant        entry                    external dcl 2-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 2-352
get_statement                          internal static bit(9)                   initial dcl 15-3
get_string                             internal static bit(9)                   initial dcl 11-8
greater_or_equal                       internal static bit(9)                   initial dcl 11-8
greater_than                           internal static bit(9)                   initial dcl 11-8
gt                                     internal static bit(9)                   initial dcl 10-3
half_to_word                           internal static bit(9)                   initial dcl 11-8
i_bin_integer                          internal static bit(9)                   initial dcl 10-3
i_dec_integer                          internal static bit(9)                   initial dcl 10-3
i_fixed_bin                            internal static bit(9)                   initial dcl 10-3
i_fixed_dec                            internal static bit(9)                   initial dcl 10-3
i_float_bin                            internal static bit(9)                   initial dcl 10-3
i_float_dec                            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
internal_procedure                     internal static bit(9)                   initial dcl 13-1
is_arith_constant                      internal static bit(9)                   initial dcl 10-47
is_arithmetic_constant                 internal static bit(9)                   initial dcl 10-47
is_constant                            internal static bit(9)                   initial dcl 10-47
is_decimal_constant                    internal static bit(9)                   initial dcl 10-47
is_delimiter                           internal static bit(9)                   initial dcl 10-47
is_float_constant                      internal static bit(9)                   initial dcl 10-47
is_identifier                          internal static bit(9)                   initial dcl 10-47
is_imaginary_constant                  internal static bit(9)                   initial dcl 10-47
is_integral_constant                   internal static bit(9)                   initial dcl 10-47
is_isub                                internal static bit(9)                   initial dcl 10-47
isub                                   internal static bit(9)                   initial dcl 10-3
join                                   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
l_parn                                 internal static bit(9)                   initial dcl 11-8
label_array_element_node               internal static bit(9)                   initial dcl 16-5
label_node                             internal static bit(9)                   initial dcl 16-5
le                                     internal static bit(9)                   initial dcl 10-3
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
lex$initialize_lex              000000 constant        entry                    external dcl 1-112
lex$write_last_line             000000 constant        entry                    external dcl 1-109
line_format                            internal static bit(9)                   initial dcl 11-8
list_node                              internal static bit(9)                   initial dcl 16-5
locate_file                            internal static bit(9)                   initial dcl 11-8
locate_statement                       internal static bit(9)                   initial dcl 15-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 15-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
loop                                   internal static bit(9)                   initial dcl 11-8
lt                                     internal static bit(9)                   initial dcl 10-3
machine_state_node                     internal static bit(9)                   initial dcl 16-5
make_desc                              internal static bit(9)                   initial dcl 11-8
max_block_number                       internal static fixed bin(17,0)          initial dcl 12-74
max_fun                                internal static bit(9)                   initial dcl 11-8
max_list_elements                      internal static fixed bin(17,0)          initial dcl 18-12
max_number_of_operands                 internal static fixed bin(15,0)          initial dcl 17-15
merge_attributes                000000 constant        entry                    external dcl 2-355
min_fun                                internal static bit(9)                   initial dcl 11-8
minus                                  internal static bit(9)                   initial dcl 10-3
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
ne                                     internal static bit(9)                   initial dcl 10-3
negate                                 internal static bit(9)                   initial dcl 11-8
ngt                                    internal static bit(9)                   initial dcl 10-3
nlt                                    internal static bit(9)                   initial dcl 10-3
no_token                               internal static bit(9)                   initial dcl 10-3
nop                                    internal static bit(9)                   initial dcl 11-8
not                                    internal static bit(9)                   initial dcl 10-3
not_bits                               internal static bit(9)                   initial dcl 11-8
not_equal                              internal static bit(9)                   initial dcl 11-8
off_fun                                internal static bit(9)                   initial dcl 11-8
on_parse$revert                 000000 constant        entry                    external dcl 1-123
on_statement                           internal static bit(9)                   initial dcl 15-3
on_unit                                internal static bit(9)                   initial dcl 13-1
open_file                              internal static bit(9)                   initial dcl 11-8
open_statement                         internal static bit(9)                   initial dcl 15-3
optimizer                       000000 constant        entry                    external dcl 2-361
or                                     internal static bit(9)                   initial dcl 10-3
or_bits                                internal static bit(9)                   initial dcl 11-8
pack                                   internal static bit(9)                   initial dcl 11-8
page_format                SysLog01T8�>system_control_1>as_logs                                                                                                                                               	�o	�T7|�T�:���P2cj�$�	�o
T7|�<��vinc  incremental_volume_dumper: Processed abb05: 0 0 99 4 0�$�	�p
T:��;��vinc  incremental_volume_dumper: Processed abb06: 0 0 3 2 0�$�	�q
T@/�<��vinc  incremental_volume_dumper: Processed abb07: 0 0 47 5 2�$�	�r
TEd<��vinc  incremental_volume_dumper: Processed abb08: 0 0 52 3 0�$�	�s
TE}�8��vinc  incremental_volume_dumper: Dump finished at 0727.8�$�	�t
TE��6��vinc  incremental_volume_dumper: Dumper going to sleep�$�	�u
TF&���vinc  r 07:27 41.164 1787�$�	�v
TF=���vinc  �$�	�w
T7 ��;��vinc  incremental_volume_dumper: Dumper waking up at 0824.7�$�	�x
T7�}=?��vinc  incremental_volume_dumper: Processed rpv: 146 50 412 40 3�$�	�y
T8ȻC��vinc  incremental_volume_dumper: Processed root_01: 139 53 883 53 2�$�	�z
T8uv�C��vinc  incremental_volume_dumper: Processed root_02: 167 64 303 49 3�$�	�{
T8�'C��vinc  incremental_volume_dumper: Processed root_03: 127 42 900 56 1�$�	�|
T8`�yC��vinc  incremental_volume_dumper: Processed root_04: 173 46 268 40 1�$�	�}
T8d;;��vinc  incremental_volume_dumper: Processed tr01: 0 0 1 3 15�$�	�~
T8u�>��vinc  incremental_volume_dumper: Processed bull01: 0 0 118 2 4�$�	�
T8wE�<��vinc  incremental_volume_dumper: Processed bull02: 0 0 1 1 4�$�	ʀ
T8yV�<��vinc  incremental_volume_dumper: Processed bull03: 0 0 0 1 4�$�	ʁ
T8{��<��vinc  incremental_volume_dumper: Processed bull04: 0 0 0 0 6�$�	ʂ
T8~��=��vinc  incremental_volume_dumper: Processed bull05: 0 0 0 0 12�$�	ʃ
T8��$=��vinc  incremental_volume_dumper: Processed pub_01: 0 0 27 6 0�$�	ʄ
T8�X=��vinc  incremental_volume_dumper: Processed pub_02: 0 0 35 7 0�$�	ʅ
T8���>��vinc  incremental_volume_dumper: Processed pub_03: 0 0 38 12 0�$�	ʆ
T8��=��vinc  incremental_volume_dumper: Processed pub_04: 0 0 14 7 0�$�	ʇ
T8��\=��vinc  incremental_volume_dumper: Processed pub_05: 0 0 38 9 0�$�	ʈ
T8�
'>��vinc  incremental_volume_dumper: Processed pub_06: 0 0 125 7 0�$�	ʉ
T8ġ=��vinc  incremental_volume_dumper: Processed pub_07: 0 0 54 6 0�$�	ʊ
T8�G�>��vinc  incremental_volume_dumper: Processed pub_08: 0 0 152 9 0�$�	ʋ
T8��;<��vinc  incremental_volume_dumper: Processed abb01: 0 0 31 3 1�$�	ʌ
T8���;��vinc  incremental_volume_dumper: Processed abb02: 0 0 5 5 3�$�	ʍ
T8�;<��vinc  incremental_volume_dumper: Processed abb03: 0 0 20 9 3�$�	ʎ
T8��=��vinc  incremental_volume_dumper: Processed abb04: 0 0 41 6 10�$�	ʏ
T92�<��vinc  incremental_volume_dumper: Processed abb05: 0 0 92 3 7�$�	ʐ
T9��<��vinc  incremental_volume_dumper: Processed abb06: 0 0 78 8 2�$�	ʑ
T9�
>��vinc  incremental_volume_dumper: Processed abb07: 0 0 16 11 10�$�	ʒ
T9%�<��vinc  incremental_volume_dumper: Processed abb08: 0 0 55 3 3�$�	ʓ
T9&
�8��vinc  incremental_volume_dumper: Dump finished at 0828.1�$�	ʔ
T9&/e6��vinc  incremental_volume_dumper: Dumper going to sleep�$�	ʕ
TR�q";��vinc  incremental_volume_dumper: Dumper waking up at 0924.7�$�	ʖ
TR�?��vinc  incremental_volume_dumper: Processed rpv: 130 49 379 37 3�$�	ʗ
TR}L�C��vinc  incremental_volume_dumper: Processed root_01: 149 46 609 50 4�$�	ʘ
TR��C��vinc  incremental_volume_dumper:refer                                  internal static bit(9)                   initial dcl 11-8
refer_extent                    000000 constant        entry                    external dcl 2-426
reference_node                         internal static bit(9)                   initial dcl 16-5
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 2-430
reserve$declare_lib             000000 constant        entry                    external dcl 2-434
reserve$read_lib                000000 constant        entry                    external dcl 2-439
reserve$rename_parse            000000 constant        entry                    external dcl 1-156
return_bits                            internal static bit(9)                   initial dcl 11-8
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 15-3
rewrite_file                           internal static bit(9)                   initial dcl 11-8
rewrite_statement                      internal static bit(9)                   initial dcl 15-3
right_parn                             internal static bit(9)                   initial dcl 10-3
root_block                             internal static bit(9)                   initial dcl 13-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 2-444
semantic_translator$abort       000000 constant        entry                    external dcl 2-446
semantic_translator$error       000000 constant        entry                    external dcl 2-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 16-5
share_expression                000000 constant        entry                    external dcl 2-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 15-3
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
slash                                  internal static bit(9)                   initial dcl 10-3
source_node                            internal static bit(9)                   initial dcl 16-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 16-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
stream_prep                            internal static bit(9)                   initial dcl 11-8
sub                                    internal static bit(9)                   initial dcl 11-8
symbol_node                            internal static bit(9)                   initial dcl 16-5
system_on_unit                         internal static bit(9)                   initial dcl 15-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 16-5
terminate_trans                        internal static bit(9)                   initial dcl 11-8
token_list_length                      internal static fixed bin(15,0)          initial dcl 8-4
token_node                             internal static bit(9)                   initial dcl 16-5
token_to_binary                 000000 constant        entry                    external dcl 2-459
translate_fun                          internal static bit(9)                   initial dcl 11-8
trunc_fun                              internal static bit(9)                   initial dcl 11-8
unknown_statement                      internal static bit(9)                   initial dcl 15-3
unlock_file                            internal static bit(9)                   initial dcl 11-8
unlock_statement                       internal static bit(9)                   initial dcl 15-3
unpack                                 internal static bit(9)                   initial dcl 11-8
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 15-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
write_file                             internal static bit(9)                   initial dcl 11-8
write_statement                        internal static bit(9)                   initial dcl 15-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.
action                          000000 constant        label                    array(0:7) dcl 176 ref 130 172 194 211 341 345
call_st                         001334 constant        label                    dcl 321 ref 314 332
call_st1                        001332 constant        label                    dcl 319 ref 298 303
end_up                          001117 constant        label                    dcl 243 ref 178 182 190 201 207 237 241
exit                            002067 constant        label                    dcl 467 ref 281 290 294 335 373 405 408 414 430 436
get_statement_type              000444 constant        label                    dcl 169 ref 136
if_end_up                       001132 constant        label                    dcl 254 ref 186
if_parse                        000114 constant        entry                    external dcl 23
print                           002075 constant        entry                    internal dcl 472 ref 231 327 361
process_else_clause             001610 constant        label                    dcl 403 ref 263

THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION.

STORAGE REQUIREMENTS FOR THIS PROGRAM.

	Object	Text	Link	Symbol	Defs	Static
Start          0       0      2356        2436    2126        2366
Length      3232    2126        60         560     230           0

BLOCK NAME	         STACK SIZE     TYPE		WHY NONQUICK/WHO SHARES STACK FRAME
if_parse                            176 external procedure  is an external procedure.  
print                                   internal procedure  shares stack frame of external procedure if_parse.  

STORAGE FOR AUTOMATIC VARIABLES.

STACK FRAME                 LOC IDENTIFIER                  BLOCK NAME
if_parse                 000100 then_type                   if_parse
                         000101 type                        if_parse
                         000102 n                           if_parse
                         000104 t                           if_parse
                         000106 if                          if_parse
                         000110 do                          if_parse
                         000112 label_ptr                   if_parse
                         000114 cblock                      if_parse
                         000116 end_ptr                     if_parse
                         000120 p                           if_parse
                         000122 q                           if_parse
                         000124 expr                        if_parse
                         000126 loc                         if_parse
                         000130 location                    if_parse
                         000132 conditions                  if_parse
                         000133 return_flag                 if_parse
                         000134 else                        if_parse
                         000135 then_goto_optimized         if_parse
                         000136 bit_type                    if_parse
                         000137 jump_if_false               if_parse
                         000140 jump_if_true                if_parse
                         000142 token_list_pointer          if_parse

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

THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM.
create_label                  create_list                   create_operator               create_statement
declare_label                 do_parse                      expression_parse              if_parse
io_statement_parse            lex                           on_parse                      parse_error
procedure_parse               reference_parse               statement_parse               statement_type

THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM.
pl1_stat_$cur_statement       pl1_stat_$optimize            pl1_stat_$profile             pl1_stat_$token_list_ptr




   LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC      LINE    LOC   
     23 000106    8    3 000121       106 000124       107 000126       108 000130       109 000134       110 000137
    112 000142       114 000164       117 000205       118 000207       120 000222       122 000226       123 000243
    125 000245       126 000246       128 000260       129 000262       130 000265       133 000266       135 000275
    136 000276       138 000277       139 000300       142 000301       144 000302       147 000312       149 000316
    150 000333       151 000336       153 000337       154 000354       155 000357       156 000360       157 000362
    160 000364       161 000403       162 000406       163 000410       165 000412       167 000427       169 000444
    171 000451       172 000474       176 000476       178 000522       180 000523       182 000552       184 000553
    186 000575       188 000576       190 000616       194 000617       199 000631       200 000633       201 000646
    205 000647       207 000667       211 000670       215 000710       218 000725       220 000726       222 000754
    225 000755       227 001001       229 001005       231 001024       233 001034       236 001062       237 001064
    239 001065       241 001116       243 001117       254 001132       256 001135       259 001151       260 001172
    263 001174       266 001176       271 001200       279 001221       281 001226       283 001232       284 001251
    285 001253       290 001256       293 001262       294 001265       297 001275       298 001276       303 001306
    308 001314       310 001315       312 001325       313 001327       314 001331       319 001332       321 001334
    323 001341       325 001361       327 001365       330 001373       331 001375       332 001377       335 001400
    341 001402       345 001431       348 001433       351 001450       353 001451       355 001477       358 001500
    359 001504       361 001523       363 001533       366 001561       367 001565       368 001571       370 001574
    373 001607       403 001610       405 001613       408 001617       411 001627       412 001631       414 001634
    417 001642       419 001646       420 001651       422 001657       423 001661       424 001662       429 001675
    430 001702       436 001710       439 001720       446 001741       448 001747       449 001770       453 002013
    461 002034       463 002041       464 002044       465 002063       467 002067       469 002072       470 002074
    472 002075       477 002077       478 002112       479 002115       481 002117


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


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