COMPILATION LISTING OF SEGMENT display_text Compiled by: Multics PL/I Compiler, Release 28d, of September 14, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 10/03/83 1614.4 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* program to display output text produced by pl/1 12* 13* Initial Version: 17 October, 1968 14* Modified: 19 August 1972 by BLW 15* Modified: 20 February 1973 by RAB for multiple base-regs 16* Modified: 3 July 1973 by RAB for EIS 17* Modified: 21 December 1976 by RAB to fix 1565 18* Modified: 5 May 1977 by SHW for new format pl1_operator_names 19* Modified 770630 by PG to fix 1615 (stop printing fill(000) field for TCT and SCD) 20* Modified: 9 August 1978 by PCK to print the name of the external entry operator with the entry sequence 21* Modified: 25 April 1979 by PCK to implement 4-bit decimal 22* Modified: 20 August 1979 by RAB to recognize 04 for andnot 23**/ 24 25 display_text: proc (t_pt, r_pt, s_pt, delta, number); 26 27 /* parameters */ 28 29 dcl t_pt ptr, /* points at text base */ 30 r_pt ptr, /* points at relocation base */ 31 s_pt ptr, /* points at symbol use base */ 32 delta fixed bin, /* offset of starting position */ 33 number fixed bin; /* number to print */ 34 35 dcl (p, q, s, sym_pt, tok_pt, line_pt, pt) ptr, 36 (i, j, k, m, mop, n, save_k, irand, nrands, ndesc) fixed bin, 37 (fract_offset, offset, size, scale) fixed bin (18), 38 (ignore_ic_mod, double, eis, eis_desc, need_comma, ext_base, itag, has_ic, decimal) bit (1), 39 ht char (1) int static aligned init (" "), /* tab */ 40 htht char (2) int static aligned init (" "), /* two tabs */ 41 c char (1), 42 cstring char (12), 43 op_code char (5), 44 tag char (3), 45 line char (256); 46 47 /* entries */ 48 49 dcl binoct entry (aligned bit (*)) returns (char (12) aligned), 50 pl1_print$string_ptr_nl entry (ptr, fixed bin); 51 52 /* external static */ 53 54 dcl (cg_static_$text_pos fixed bin, 55 pl1_operators_$operator_table, 56 pl1_operator_names_$first fixed bin (18), 57 pl1_operator_names_$pl1_operator_names_ 58 ) external static; 59 60 /* builtins */ 61 62 dcl (addr, addrel, char, divide, fixed, length, ltrim, min, null, ptr, rel, string, substr) builtin; 63 1 1 /* BEGIN INCLUDE FILE operator_names.incl.pl1 77-5-2 SHW */ 1 2 1 3 dcl op_names_pt ptr; 1 4 1 5 dcl 1 operator_names aligned based (op_names_pt), 1 6 2 first fixed bin (18), /* offset of first operator in operator segment */ 1 7 2 last fixed bin (18), /* offset of last operator in operator segment */ 1 8 2 first_special fixed bin (18), /* offset of first special operator */ 1 9 2 last_special fixed bin (18), /* offset of last special operator */ 1 10 2 number_special fixed bin, /* number of special operators */ 1 11 1 12 2 names (1 refer (first) : 1 refer (last)), /* array of pointers to and lengths of names */ 1 13 3 namep bit (18) unal, /* rel pointer to ACI string for name */ 1 14 3 len fixed bin (17) unal, /* length of this operator name */ 1 15 1 16 2 special (0 refer (number_special)), /* array of info about special operators */ 1 17 3 offset fixed bin (18), /* offset of start of code for this operator */ 1 18 3 namep bit (18) unal, /* rel pointer to ACI string for name */ 1 19 3 len fixed bin (17) unal; /* length of this operator name */ 1 20 1 21 /* END INCLUDE FILE operator_names.incl.pl1 */ 64 65 2 1 /* Begin include file op_mnemonic_dcl_.incl.pl1 BIM 12/82 */ 2 2 /* format: style3 */ 2 3 /* INTERNAL INTERFACE OF THE PL/I COMPILER */ 2 4 2 5 declare 1 op_mnemonic_$op_mnemonic_ 2 6 (0:1023) aligned like op_mnemonic external static; 2 7 2 8 declare op_mnemonic_ptr pointer; 2 9 declare 1 op_mnemonic aligned based (op_mnemonic_ptr), 2 10 2 name char (6) unaligned, /* opcode name, save abd/abdx, or .... */ 2 11 2 dtype fixed bin (2) unaligned, /* for num_words > 1, 0 ==> char, 1 ==> bit, 2 ==> other. Else 1 ==> abd/abdx (funny bit 29) */ 2 12 2 num_desc fixed bin (5) unaligned, 2 13 2 num_words fixed bin (8) unaligned; 2 14 2 15 /* End include file op_mnemonic_dcl_ */ 66 67 68 dcl 1 name_pair aligned based (p), 69 2 rel_ptr unaligned bit (18),/* ptr to ascii string */ 70 2 size unaligned bit (18);/* size of string */ 71 72 dcl based_string aligned char (size) based (p); 73 74 dcl digit (0:9) char (1) aligned int static 75 init ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9"); 76 77 dcl relocation (-1:11) char (1) aligned int static 78 init ("a", "t", "1", "2", "3", "l", "d", "s", "7", "8", "i", "r", "e"); 79 80 dcl base (0:7) char (4) aligned int static 81 init ("pr0|", "pr1|", "pr2|", "pr3|", "pr4|", "pr5|", "pr6|", "pr7|"); 82 83 dcl modifier (0:63) char (3) aligned int static 84 init ("n", "au", "qu", "du", "ic", "al", "ql", "dl", 85 "0", "1", "2", "3", "4", "5", "6", "7", 86 "*", "au*", "qu*", "...", "ic*", "al*", "ql*", "...", 87 "0*", "1*", "2*", "3*", "4*", "5*", "6*", "7*", 88 (8) (1)"...", 89 (8) (1)"...", 90 "*n", "*au", "*qu", "...", "*ic", "*al", "*ql", "...", 91 "*0", "*1", "*2", "*3", "*4", "*5", "*6", "*7"); 92 93 dcl word (0:1) bit (36) aligned based (p); 94 95 dcl 1 instruction based (p) aligned, 96 2 base unaligned bit (3), 97 2 offset unaligned bit (15), 98 2 op_code unaligned bit (10), 99 2 unused unaligned bit (1), 100 2 ext_base unaligned bit (1), 101 2 tag unaligned bit (6); 102 103 dcl 1 half based (p) aligned, 104 2 left unaligned bit (18), 105 2 right unaligned bit (18); 106 107 dcl 1 rel_tab based (p) aligned, 108 2 dummy_l unaligned bit (14), 109 2 left unaligned bit (4), 110 2 dummy_r unaligned bit (14), 111 2 right unaligned bit (4); 112 113 dcl 1 mod_factor aligned, 114 2 ext_base bit (1) unal, 115 2 length_in_reg bit (1) unal, 116 2 indirect_descriptor bit (1) unal, 117 2 tag bit (4) unal; 118 119 dcl mf (3) fixed bin (6) int static init (30, 12, 3); /* location of modification factor fields in EIS inst */ 120 121 dcl 1 packed_ptr_st based aligned, 122 2 packed_ptr ptr unal; 123 124 dcl (ebase, len_reg, ic) (3) bit (1) aligned; 125 dcl desc_word char (8) varying; 126 127 dcl desc_op (0:9) char (8) varying int static 128 init ("desc9a", "descb", "desc9fl", "desc9ls", "desc9ts", "desc9ns", "desc4fl", "desc4ls", "desc4ts", "desc4ns"); 129 130 dcl eis_modifier (0:15) char (3) aligned int static 131 init ("n", "au", "qu", "du", "ic", "al", "ql", "...", 132 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7"); 133 134 dcl bool_word (0:15) char (6) aligned int static varying 135 init ("clear", "and", "andnot", "move", "andnot", "", "xor", "or", 136 "", "", "", "", "invert", "", "nand", "set"); 137 138 dcl 1 descriptor based aligned, /* EIS alphanumeric and bit operand descriptor */ 139 2 address bit (18) unal, 140 2 char bit (2) unal, 141 2 bit bit (4) unal, 142 2 length bit (12) unal; 143 144 dcl 1 four_bit_descriptor based aligned, /* EIS 4-bit operand descriptor */ 145 2 address bit (18) unal, 146 2 char bit (3) unal, 147 2 bit bit (3) unal, 148 2 length bit (12) unal; 149 3 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 3 2 3 3 dcl 1 symbol based aligned, 3 4 2 node_type bit(9) unal, 3 5 2 source_id structure unal, 3 6 3 file_number bit(8), 3 7 3 line_number bit(14), 3 8 3 statement_number bit(5), 3 9 2 location fixed(18) unal unsigned, 3 10 2 allocated bit(1) unal, 3 11 2 dcl_type bit(3) unal, 3 12 2 reserved bit(6) unal, 3 13 2 pix unal, 3 14 3 pic_fixed bit(1) unal, 3 15 3 pic_float bit(1) unal, 3 16 3 pic_char bit(1) unal, 3 17 3 pic_scale fixed(7) unal, 3 18 3 pic_size fixed(7) unal, 3 19 2 level fixed(8) unal, 3 20 2 boundary fixed(3) unal, 3 21 2 size_units fixed(3) unal, 3 22 2 scale fixed(7) unal, 3 23 2 runtime bit(18) unal, 3 24 2 runtime_offset bit(18) unal, 3 25 2 block_node ptr unal, 3 26 2 token ptr unal, 3 27 2 next ptr unal, 3 28 2 multi_use ptr unal, 3 29 2 cross_references ptr unal, 3 30 2 initial ptr unal, 3 31 2 array ptr unal, 3 32 2 descriptor ptr unal, 3 33 2 equivalence ptr unal, 3 34 2 reference ptr unal, 3 35 2 general ptr unal, 3 36 2 father ptr unal, 3 37 2 brother ptr unal, 3 38 2 son ptr unal, 3 39 2 word_size ptr unal, 3 40 2 bit_size ptr unal, 3 41 2 dcl_size ptr unal, 3 42 2 symtab_size ptr unal, 3 43 2 c_word_size fixed(24), 3 44 2 c_bit_size fixed(24), 3 45 2 c_dcl_size fixed(24), 3 46 3 47 2 attributes structure aligned, 3 48 3 data_type structure unal, 3 49 4 structure bit(1) , 3 50 4 fixed bit(1), 3 51 4 float bit(1), 3 52 4 bit bit(1), 3 53 4 char bit(1), 3 54 4 ptr bit(1), 3 55 4 offset bit(1), 3 56 4 area bit(1), 3 57 4 label bit(1), 3 58 4 entry bit(1), 3 59 4 file bit(1), 3 60 4 arg_descriptor bit(1), 3 61 4 storage_block bit(1), 3 62 4 explicit_packed bit(1), /* options(packed) */ 3 63 4 condition bit(1), 3 64 4 format bit(1), 3 65 4 builtin bit(1), 3 66 4 generic bit(1), 3 67 4 picture bit(1), 3 68 3 69 3 misc_attributes structure unal, 3 70 4 dimensioned bit(1), 3 71 4 initialed bit(1), 3 72 4 aligned bit(1), 3 73 4 unaligned bit(1), 3 74 4 signed bit(1), 3 75 4 unsigned bit(1), 3 76 4 precision bit(1), 3 77 4 varying bit(1), 3 78 4 local bit(1), 3 79 4 decimal bit(1), 3 80 4 binary bit(1), 3 81 4 real bit(1), 3 82 4 complex bit(1), 3 83 4 variable bit(1), 3 84 4 reducible bit(1), 3 85 4 irreducible bit(1), 3 86 4 returns bit(1), 3 87 4 position bit(1), 3 88 4 internal bit(1), 3 89 4 external bit(1), 3 90 4 like bit(1), 3 91 4 member bit(1), 3 92 4 non_varying bit(1), 3 93 4 options bit(1), 3 94 4 variable_arg_list bit(1), /* options(variable) */ 3 95 4 alloc_in_text bit(1), /* options(constant) */ 3 96 3 97 3 storage_class structure unal, 3 98 4 auto bit(1), 3 99 4 based bit(1), 3 100 4 static bit(1), 3 101 4 controlled bit(1), 3 102 4 defined bit(1), 3 103 4 parameter bit(1), 3 104 4 param_desc bit(1), 3 105 4 constant bit(1), 3 106 4 temporary bit(1), 3 107 4 return_value bit(1), 3 108 3 109 3 file_attributes structure unal, 3 110 4 print bit(1), 3 111 4 input bit(1), 3 112 4 output bit(1), 3 113 4 update bit(1), 3 114 4 stream bit(1), 3 115 4 reserved_1 bit(1), 3 116 4 record bit(1), 3 117 4 sequential bit(1), 3 118 4 direct bit(1), 3 119 4 interactive bit(1), /* env(interactive) */ 3 120 4 reserved_2 bit(1), 3 121 4 reserved_3 bit(1), 3 122 4 stringvalue bit(1), /* env(stringvalue) */ 3 123 4 keyed bit(1), 3 124 4 reserved_4 bit(1), 3 125 4 environment bit(1), 3 126 3 127 3 compiler_developed structure unal, 3 128 4 aliasable bit(1), 3 129 4 packed bit(1), 3 130 4 passed_as_arg bit(1), 3 131 4 allocate bit(1), 3 132 4 set bit(1), 3 133 4 exp_extents bit(1), 3 134 4 refer_extents bit(1), 3 135 4 star_extents bit(1), 3 136 4 isub bit(1), 3 137 4 put_in_symtab bit(1), 3 138 4 contiguous bit(1), 3 139 4 put_data bit(1), 3 140 4 overlayed bit(1), 3 141 4 error bit(1), 3 142 4 symtab_processed bit(1), 3 143 4 overlayed_by_builtin bit(1), 3 144 4 defaulted bit(1), 3 145 4 connected bit(1); 3 146 3 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 150 4 1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */ 4 2 4 3 dcl 1 token based aligned, 4 4 2 node_type bit(9) unaligned, 4 5 2 type bit(9) unaligned, 4 6 2 loc bit(18) unaligned, /* symtab offset for identifiers, "p" flag for constants */ 4 7 2 declaration ptr unaligned, 4 8 2 next ptr unaligned, 4 9 2 size fixed(9), 4 10 2 string char(n refer(token.size)); 4 11 4 12 /* END INCLUDE FILE ... token.incl.pl1 */ 151 5 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 5 2 5 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 5 4 5 5 dcl ( by_declare initial("001"b), 5 6 by_explicit_context initial("010"b), 5 7 by_context initial("011"b), 5 8 by_implication initial("100"b), 5 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 5 10 5 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 152 6 1 /* BEGIN INCLUDE FILE ... cgsystem.incl.pl1 */ 6 2 6 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 6 4 6 5 dcl ( bits_per_char init(9), 6 6 bits_per_half init(18), 6 7 bits_per_word init(36), 6 8 bits_per_two_words init(72), 6 9 bits_per_four_words init(144), 6 10 bits_per_words(2) init(36,72), 6 11 packed_digits_per_char init(2), 6 12 chars_per_word init(4), 6 13 packed_digits_per_word init(8), 6 14 6 15 break_even_bits init(216), 6 16 break_even_words init(6), 6 17 6 18 label_size init(4), 6 19 6 20 convert_size(13:14) init(9,1), 6 21 max_offset(13:14) init(27,35), 6 22 max_short_size(13:14) init(8,72), 6 23 6 24 units_per_word(0:5) init(1,36,8,4,2,1), 6 25 6 26 max_dec_scale init(32), 6 27 min_dec_scale init(-31), 6 28 max_p_xreg init(18), 6 29 max_p_fix_bin_1 init(35), 6 30 max_p_flt_bin_1 init(27), 6 31 max_p_fix_dec init(59), 6 32 max_length_p init(24), 6 33 default_fix_bin_p init(17)) fixed bin(8) int static options(constant); 6 34 6 35 dcl (convert_offset(0:5) init(36,1,4.5,9,18,36), 6 36 bits_per_packed_digit init(4.5)) fixed bin(8,1) int static options(constant); 6 37 6 38 dcl max_index_register_value init(262143) fixed bin(31) int static options(constant); 6 39 6 40 /* END INCLUDE FILE ... cgsystem.incl.pl1 */ 6 41 153 7 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 7 2 7 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 7 4 7 5 dcl ( block_node initial("000000001"b), 7 6 statement_node initial("000000010"b), 7 7 operator_node initial("000000011"b), 7 8 reference_node initial("000000100"b), 7 9 token_node initial("000000101"b), 7 10 symbol_node initial("000000110"b), 7 11 context_node initial("000000111"b), 7 12 array_node initial("000001000"b), 7 13 bound_node initial("000001001"b), 7 14 format_value_node initial("000001010"b), 7 15 list_node initial("000001011"b), 7 16 default_node initial("000001100"b), 7 17 machine_state_node initial("000001101"b), 7 18 source_node initial("000001110"b), 7 19 label_node initial("000001111"b), 7 20 cross_reference_node initial("000010000"b), 7 21 sf_par_node initial("000010001"b), 7 22 temporary_node initial("000010010"b), 7 23 label_array_element_node initial("000010011"b), 7 24 by_name_agg_node initial("000010100"b)) 7 25 bit(9) internal static aligned options(constant); 7 26 7 27 dcl 1 node based aligned, 7 28 2 type unal bit(9), 7 29 2 source_id unal structure, 7 30 3 file_number bit(8), 7 31 3 line_number bit(14), 7 32 3 statement_number bit(5); 7 33 7 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 154 155 156 begin: p = addrel (t_pt, delta); 157 q = addrel (r_pt, delta); 158 s = addrel (s_pt, delta); 159 160 line_pt = addr (line); 161 eis = "0"b; 162 irand = 0; 163 164 do i = 1 to number; 165 166 tag = " "; 167 substr (line, 1, 6) = binoct (rel (p)); 168 substr (line, 7, 2) = " "; 169 170 call insert_relocation; 171 172 cstring = binoct (p -> word (0)); 173 174 if ^eis 175 then do; 176 mop = fixed (p -> instruction.op_code, 10); 177 op_mnemonic_ptr = addr (op_mnemonic_$op_mnemonic_ (mop)); 178 op_code = op_mnemonic.name; 179 end; 180 else do; 181 mop = 0; 182 op_mnemonic_ptr = addr (op_mnemonic_$op_mnemonic_ (0)); 183 end; 184 185 if op_code = ".... " 186 then do; 187 not_ins: substr (line, 13, 3) = " "; 188 substr (line, 16, 5) = substr (cstring, 1, 5); 189 substr (line, 21, 7) = substr (cstring, 6, 7); 190 k = 28; 191 goto prt; 192 end; 193 194 if op_mnemonic.num_words > 1 195 then do; 196 197 /* EIS */ 198 199 call init_eis; 200 201 substr (line, 13, 4) = substr (cstring, 1, 3); 202 substr (line, 17, 4) = substr (cstring, 4, 3); 203 substr (line, 21, 4) = substr (cstring, 7, 3); 204 substr (line, 25, 3) = substr (cstring, 10, 3); 205 206 substr (line, 28, 1) = ht; 207 substr (line, 29, 5) = op_code; 208 substr (line, 34, 1) = ht; 209 210 k = 35; 211 212 do j = 1 to ndesc; 213 string (mod_factor) = substr (p -> word (0), mf (j), 7); 214 ebase (j) = mod_factor.ext_base; 215 len_reg (j) = mod_factor.length_in_reg; 216 217 substr (line, k, 1) = "("; 218 k = k + 1; 219 need_comma = "0"b; 220 221 if ebase (j) 222 then do; 223 substr (line, k, 2) = "pr"; 224 k = k + 2; 225 need_comma = "1"b; 226 end; 227 228 if len_reg (j) 229 then do; 230 if need_comma 231 then do; 232 substr (line, k, 1) = ","; 233 k = k + 1; 234 end; 235 substr (line, k, 2) = "rl"; 236 k = k + 2; 237 need_comma = "1"b; 238 end; 239 240 if mod_factor.tag 241 then do; 242 if need_comma 243 then do; 244 substr (line, k, 1) = ","; 245 k = k + 1; 246 end; 247 ic (j) = mod_factor.tag = "0100"b; /* IC */ 248 substr (line, k, 2) = eis_modifier (fixed (mod_factor.tag, 4)); 249 k = k + 2; 250 end; 251 else ic (j) = "0"b; 252 253 substr (line, k, 2) = "),"; 254 k = k + 2; 255 end; 256 257 258 if substr (p -> word (0), 10, 1) 259 then do; 260 substr (line, k, 12) = "enablefault,"; 261 k = k + 12; 262 end; 263 264 if desc_word = "desc9a" | desc_word = "desc4a" 265 then if ndesc < 3 266 then if (substr (op_code, 1, 3) ^= "scd") & (substr (op_code, 1, 3) ^= "tct") 267 then do; 268 if substr (op_code, 1, 3) = "scm" 269 then substr (line, k, 5) = "mask("; 270 else substr (line, k, 5) = "fill("; 271 272 k = k + 5; 273 substr (line, k, 3) = substr (cstring, 1, 3); 274 k = k + 3; 275 substr (line, k, 1) = ")"; 276 k = k + 1; 277 end; 278 else k = k - 1; /* flush trailing , */ 279 else k = k - 1; /* .. */ 280 else if desc_word = "descb" 281 then do; 282 substr (line, k, 5) = "fill("; 283 k = k + 5; 284 substr (line, k, 1) = digit (fixed (substr (p -> word (0), 1, 1), 1)); 285 k = k + 1; 286 substr (line, k, 1) = ")"; 287 k = k + 1; 288 if op_code ^= "cmpb " 289 then do; 290 substr (line, k, 6) = ",bool("; 291 k = k + 6; 292 j = fixed (substr (p -> word (0), 6, 4), 4); 293 m = length (bool_word (j)); 294 if m > 0 295 then do; 296 substr (line, k, m) = bool_word (j); 297 k = k + m; 298 end; 299 else do; 300 substr (line, k, 1) = digit (fixed (substr (p -> word (0), 6, 1), 1)); 301 substr (line, k + 1, 1) = digit (fixed (substr (p -> word (0), 7, 3), 3)); 302 k = k + 2; 303 end; 304 substr (line, k, 1) = ")"; 305 k = k + 1; 306 end; 307 end; 308 else if substr (p -> word (0), 11, 1) 309 then do; 310 substr (line, k, 5) = "round"; 311 k = k + 5; 312 end; 313 else k = k - 1; 314 315 irand = 0; 316 go to prt; 317 end; 318 319 double, ignore_ic_mod = "0"b; 320 321 eis_desc = eis & desc_word ^= "arg"; 322 if eis_desc 323 then do; 324 substr (line, 13, 2) = " "; 325 substr (line, 15, 6) = substr (cstring, 2, 5); 326 substr (line, 21, 3) = substr (cstring, 7, 2); 327 substr (line, 24, 4) = substr (cstring, 9, 4); 328 329 substr (line, 28, 1) = ht; 330 331 if decimal 332 then desc_word = desc_op (2 + fixed (p -> four_bit_descriptor.bit, 3)); 333 else if desc_word = "desc9a" & p -> four_bit_descriptor.bit = "100"b 334 then desc_word = "desc4a"; 335 if irand > 1 336 then if op_code = "dtb " | op_code = "mvne " 337 then desc_word = desc_op (0); 338 else ; 339 else if op_code = "btd " 340 then desc_word = desc_op (0); 341 342 substr (line, 29, length (desc_word)) = desc_word; 343 k = length (desc_word) + 29; 344 345 ext_base = ebase (irand); 346 itag = len_reg (irand); 347 if itag 348 then tag = eis_modifier (fixed (substr (p -> descriptor.length, 9, 4), 4)); 349 has_ic = ic (irand); 350 go to chk_ext; 351 end; 352 353 if op_code = "rpd " then goto set; 354 if op_code = "rpt " then goto set; 355 356 if p -> instruction.unused then goto not_ins; 357 358 if op_mnemonic.num_desc ^= 0 359 then do; 360 tag = substr (binoct ((p -> instruction.tag)), 1, 2); 361 ignore_ic_mod = "1"b; 362 goto set; 363 end; 364 365 if p -> instruction.tag 366 then do; 367 tag = modifier (fixed (p -> instruction.tag, 6)); 368 if tag = "..." then goto not_ins; 369 end; 370 371 set: substr (line, 13, 2) = " "; 372 substr (line, 15, 6) = substr (cstring, 2, 5); 373 substr (line, 21, 5) = substr (cstring, 7, 4); 374 substr (line, 26, 2) = substr (cstring, 11, 2); 375 376 substr (line, 28, 1) = ht; 377 k = 29; 378 379 if ^eis & op_mnemonic.dtype = 1 & ^p -> instruction.ext_base 380 then op_code = rtrim (op_code) || "x"; 381 substr (line, k, 5) = op_code; 382 383 c = substr (line, k + 3, 1); 384 385 double = substr (op_code, 1, 2) = "df" | substr (op_code, 3, 2) = "aq" | substr (op_code, 4, 2) = "aq"; 386 387 ext_base = p -> instruction.ext_base | (^eis & op_mnemonic.dtype = 1); /* force PR format for aXdb/sXbd */ 388 389 itag = p -> instruction.tag ^= "000000"b; 390 has_ic = p -> instruction.tag = "000100"b; /* IC */ 391 392 k = 34; 393 chk_ext: 394 chk_ext1: substr (line, k, 1) = ht; 395 k = k + 1; 396 397 save_k = k; 398 399 if ^eis 400 then if p -> instruction.unused 401 then do; 402 403 /* have rpd | rpt instruction */ 404 405 tag = digit (fixed (p -> instruction.tag, 6)); 406 offset = fixed (substr (p -> half.left, 1, 8), 8); 407 ignore_ic_mod = "1"b; 408 goto sk; 409 end; 410 411 if ext_base 412 then do; 413 substr (line, k, 4) = base (fixed (p -> instruction.base, 3)); 414 offset = fixed (p -> instruction.offset, 15); 415 if offset > 16384 then offset = offset - 32768; 416 k = k + 4; 417 j = 13; 418 end; 419 else do; 420 offset = fixed (p -> half.left, 18); 421 422 if offset > 131072 423 then do; 424 if tag = "du " then goto sk; 425 if tag = "dl " then goto sk; 426 offset = offset - 262144;/* 2's comp */ 427 end; 428 429 sk: j = 14; 430 end; 431 432 substr (line, j, 1) = cstring; 433 434 call bin2dec (offset); 435 436 if eis_desc 437 then do; 438 if desc_word = "descb" 439 then fract_offset = fixed (p -> descriptor.char, 2) * bits_per_char + fixed (p -> descriptor.bit, 4); 440 else if substr (desc_word, 1, 5) = "desc4" 441 then fract_offset = fixed (p -> four_bit_descriptor.char, 3); 442 else fract_offset = fixed (p -> descriptor.char, 2); 443 if fract_offset ^= 0 444 then do; 445 substr (line, k, 1) = "("; 446 k = k + 1; 447 call bin2dec (fract_offset); 448 substr (line, k, 1) = ")"; 449 k = k + 1; 450 end; 451 end; 452 453 if itag 454 then do; 455 substr (line, k, 1) = ","; 456 substr (line, k + 1, 3) = tag; 457 458 k = k + 2; 459 if substr (line, k, 1) ^= " " then k = k + 1; 460 if substr (line, k, 1) ^= " " then k = k + 1; 461 end; 462 else if eis_desc 463 then do; 464 substr (line, k, 1) = ","; 465 k = k + 1; 466 if desc_word = "desc9ls" | desc_word = "desc4ls" 467 then do; 468 call bin2dec (fixed (substr (p -> descriptor.length, 7, 6), 6)); 469 substr (line, k, 1) = ","; 470 k = k + 1; 471 scale = fixed (substr (p -> descriptor.length, 1, 6), 6); 472 if scale >= 32 473 then scale = scale - 64; 474 call bin2dec (scale); 475 end; 476 else call bin2dec (fixed (p -> descriptor.length, 12)); 477 end; 478 479 if ignore_ic_mod then goto chk_base; 480 481 if has_ic 482 then do; 483 substr (line, k, 2) = htht; 484 k = k + 2; 485 486 pt = addrel (p, offset - irand); 487 substr (line, k, 6) = binoct (rel (pt)); 488 489 k = k + 6; 490 491 if substr (op_code, 1, 1) = "t" then goto prt; 492 if fixed (rel (pt), 18) > cg_static_$text_pos then goto prt; 493 494 substr (line, k, 1) = " "; 495 k = k + 1; 496 497 equal: substr (line, k, 2) = "= "; 498 substr (line, k + 2, 12) = binoct (pt -> word (0)); 499 k = k + 14; 500 501 if double 502 then do; 503 substr (line, k, 1) = " "; 504 substr (line, k + 1, 12) = binoct (pt -> word (1)); 505 k = k + 13; 506 end; 507 508 goto prt; 509 end; 510 511 chk_base: if ^ext_base then goto prt; 512 513 if p -> instruction.base ^= "000"b & op_code ^= "tsp2" /* Assumes that tsp2 is used only to invoke entry operators */ 514 then do; 515 if s -> word (0) = "0"b then goto prt; 516 517 sym_pt = s -> packed_ptr; 518 if sym_pt = null then goto prt; 519 520 if sym_pt -> symbol.dcl_type = by_compiler 521 then if ^sym_pt -> symbol.entry 522 then goto prt; 523 524 j = 2 - divide (k - save_k, 10, 17, 0); 525 substr (line, k, j) = htht; 526 k = k + j; 527 528 if sym_pt -> node.type = label_node 529 then go to put; 530 531 tok_pt = sym_pt -> symbol.father; 532 if tok_pt = null then goto put; 533 534 do while (tok_pt -> symbol.father ^= null); 535 tok_pt = tok_pt -> symbol.father; 536 end; 537 538 tok_pt = tok_pt -> symbol.token; 539 j = tok_pt -> token.size; 540 substr (line, k, j) = tok_pt -> token.string; 541 k = k + j; 542 543 substr (line, k, 1) = "."; 544 k = k + 1; 545 546 put: tok_pt = sym_pt -> symbol.token; 547 j = tok_pt -> token.size; 548 substr (line, k, j) = tok_pt -> token.string; 549 k = k + j; 550 551 goto prt; 552 end; 553 554 if op_code = "xec " 555 then do; 556 pt = addrel (addr (pl1_operators_$operator_table), offset); 557 mop = fixed (pt -> instruction.op_code, 10); 558 op_mnemonic_ptr = addr (op_mnemonic_$op_mnemonic_ (mop)); 559 if op_mnemonic.num_words > 1 560 then do; 561 562 /* we are executing an EIS instruction in pl1_operators_ */ 563 564 call init_eis; 565 566 do j = 1 to ndesc; 567 ebase (j) = "1"b; 568 len_reg (j) = ^decimal; 569 ic (j) = "0"b; 570 end; 571 572 irand = 0; 573 end; 574 end; 575 576 if itag then goto prt; 577 578 if substr (op_code, 1, 1) ^= "t" 579 then do; 580 if offset >= pl1_operator_names_$first then goto prt; 581 pt = addrel (addr (pl1_operators_$operator_table), offset); 582 substr (line, k, 2) = htht; 583 k = k + 2; 584 goto equal; 585 end; 586 587 op_names_pt = addr (pl1_operator_names_$pl1_operator_names_); 588 589 if offset >= operator_names.first & offset <= operator_names.last 590 then do; 591 pt = addr (operator_names.names (offset)); 592 goto str_info; 593 end; 594 595 else if offset >= operator_names.first_special & offset <= operator_names.last_special 596 then do; 597 do j = 1 to operator_names.number_special; 598 if operator_names.special (j).offset = offset 599 then do; 600 pt = addr (operator_names.special (j).namep); 601 goto str_info; 602 end; 603 end; 604 goto prt; 605 end; 606 str_info: size = fixed (pt -> name_pair.size, 18); 607 pt = ptr (pt, pt -> name_pair.rel_ptr); 608 609 substr (line, k, 2) = htht; 610 k = k + 2; 611 612 substr (line, k, size) = pt -> based_string; 613 k = size + k; 614 615 prt: call pl1_print$string_ptr_nl (line_pt, k - 1); 616 617 if eis 618 then do; 619 irand = irand + 1; 620 if irand > nrands 621 then do; 622 eis = "0"b; 623 irand = 0; 624 end; 625 else if irand > ndesc 626 then op_code, desc_word = "arg"; 627 end; 628 629 p = addrel (p, 1); 630 q = addrel (q, 1); 631 s = addrel (s, 1); 632 end; 633 634 return; 635 636 display_text$display_abs: entry (t_pt, r_pt, n_words); 637 638 dcl n_words fixed bin; /* size of block to be displayed */ 639 640 p = t_pt; 641 q = r_pt; 642 line_pt = addr (line); 643 644 do i = 1 to n_words; 645 646 substr (line, 1, 6) = binoct (rel (p)); 647 substr (line, 7, 2) = " "; 648 call insert_relocation; 649 substr (line, 13, 3) = " "; 650 substr (line, 16, 12) = binoct (p -> word (0)); 651 652 k = 27; 653 654 call pl1_print$string_ptr_nl (line_pt, k); 655 p = addrel (p, 1); 656 q = addrel (q, 1); 657 end; 658 659 return; 660 661 display_text$display_ascii: entry (t_pt, n_chars); 662 663 dcl n_chars fixed bin; /* size of string to be displayed */ 664 665 dcl nc fixed bin, 666 char_string char (4) aligned based (p); 667 668 p = t_pt; 669 nc = n_chars; 670 line_pt = addr (line); 671 672 673 do i = 1 by 4 to nc; 674 675 substr (line, 1, 6) = binoct (rel (p)); 676 substr (line, 7, 2) = " "; 677 substr (line, 9, 4) = "aa "; 678 679 cstring = binoct (p -> word (0)); 680 k = 13; 681 do j = 1 by 3 to 12; 682 substr (line, k, 4) = substr (cstring, j, 3); 683 k = k + 4; 684 end; 685 686 substr (line, 28, 1) = ht; 687 688 k = min (4, nc - i + 1); 689 substr (line, 29, k) = substr (p -> char_string, 1, k); 690 691 call pl1_print$string_ptr_nl (line_pt, k + 28); 692 p = addrel (p, 1); 693 end; 694 695 696 insert_relocation: proc; 697 698 /* inserts relocation characters in line */ 699 700 if r_pt = null 701 then do; 702 substr (line, 9, 4) = "aa "; 703 return; 704 end; 705 706 if q -> rel_tab.dummy_l then k = fixed (q -> rel_tab.left, 4); 707 else k = -1; 708 709 substr (line, 9, 1) = relocation (k); 710 711 if q -> rel_tab.dummy_r then k = fixed (q -> rel_tab.right, 4); 712 else k = -1; 713 714 substr (line, 10, 3) = relocation (k); 715 716 end; 717 718 719 bin2dec: proc (number); 720 721 dcl number fixed bin (18); 722 723 substr (line, k, length (ltrim (char (number)))) = ltrim (char (number)); 724 k = k + length (ltrim (char (number))); 725 726 end; 727 728 729 init_eis: proc; 730 731 eis = "1"b; 732 nrands = op_mnemonic.num_words - 1; 733 ndesc = op_mnemonic.num_desc; 734 decimal = op_mnemonic.dtype = 2; 735 desc_word = desc_op (op_mnemonic.dtype); 736 737 end; 738 739 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/03/83 1007.5 display_text.pl1 >spec>on>pl128d>display_text.pl1 64 1 09/14/77 1705.7 operator_names.incl.pl1 >ldd>include>operator_names.incl.pl1 66 2 04/07/83 1635.0 op_mnemonic_dcl_.incl.pl1 >ldd>include>op_mnemonic_dcl_.incl.pl1 150 3 10/02/83 0828.4 symbol.incl.pl1 >spec>on>pl128d>symbol.incl.pl1 151 4 09/14/77 1705.7 token.incl.pl1 >ldd>include>token.incl.pl1 152 5 10/25/79 1645.8 declare_type.incl.pl1 >ldd>include>declare_type.incl.pl1 153 6 10/25/79 1645.8 cgsystem.incl.pl1 >ldd>include>cgsystem.incl.pl1 154 7 07/21/80 1546.3 nodes.incl.pl1 >ldd>include>nodes.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. addr builtin function dcl 62 ref 160 177 182 556 558 581 587 591 600 642 670 addrel builtin function dcl 62 ref 156 157 158 486 556 581 629 630 631 655 656 692 attributes 31 based structure level 2 dcl 3-3 base 000241 constant char(4) initial array dcl 80 in procedure "display_text" ref 413 base based bit(3) level 2 in structure "instruction" packed unaligned dcl 95 in procedure "display_text" ref 413 513 based_string based char dcl 72 ref 612 binoct 000010 constant entry external dcl 49 ref 167 172 360 487 498 504 646 650 675 679 bit 0(21) based bit(3) level 2 in structure "four_bit_descriptor" packed unaligned dcl 144 in procedure "display_text" ref 331 333 bit 0(20) based bit(4) level 2 in structure "descriptor" packed unaligned dcl 138 in procedure "display_text" ref 438 bits_per_char constant fixed bin(8,0) initial dcl 6-5 ref 438 bool_word 000000 constant varying char(6) initial array dcl 134 ref 293 296 by_compiler constant bit(3) initial dcl 5-5 ref 520 c 000144 automatic char(1) unaligned dcl 35 set ref 383* cg_static_$text_pos 000014 external static fixed bin(17,0) dcl 54 ref 492 char 0(18) based bit(2) level 2 in structure "descriptor" packed unaligned dcl 138 in procedure "display_text" ref 438 442 char builtin function dcl 62 in procedure "display_text" ref 723 723 724 char 0(18) based bit(3) level 2 in structure "four_bit_descriptor" packed unaligned dcl 144 in procedure "display_text" ref 440 char_string based char(4) dcl 665 ref 689 cstring 000145 automatic char(12) unaligned dcl 35 set ref 172* 188 189 201 202 203 204 273 325 326 327 372 373 374 432 679* 682 data_type 31 based structure level 3 packed unaligned dcl 3-3 dcl_type 1(19) based bit(3) level 2 packed unaligned dcl 3-3 ref 520 decimal 000143 automatic bit(1) unaligned dcl 35 set ref 331 568 734* delta parameter fixed bin(17,0) dcl 29 ref 25 156 157 158 desc_op 000100 constant varying char(8) initial array dcl 127 ref 331 335 339 735 desc_word 000272 automatic varying char(8) dcl 125 set ref 264 264 280 321 331* 333 333* 335* 339* 342 342 343 438 440 466 466 625* 735* descriptor based structure level 1 dcl 138 digit 000266 constant char(1) initial array dcl 74 ref 284 300 301 405 divide builtin function dcl 62 ref 524 double 000134 automatic bit(1) unaligned dcl 35 set ref 319* 385* 501 dtype 1(18) based fixed bin(2,0) level 2 packed unaligned dcl 2-9 ref 379 387 734 735 dummy_l based bit(14) level 2 packed unaligned dcl 107 ref 706 dummy_r 0(18) based bit(14) level 2 packed unaligned dcl 107 ref 711 ebase 000261 automatic bit(1) array dcl 124 set ref 214* 221 345 567* eis 000135 automatic bit(1) unaligned dcl 35 set ref 161* 174 321 379 387 399 617 622* 731* eis_desc 000136 automatic bit(1) unaligned dcl 35 set ref 321* 322 436 462 eis_modifier 000060 constant char(3) initial array dcl 130 ref 248 347 entry 31(09) based bit(1) level 4 packed unaligned dcl 3-3 ref 520 ext_base 000140 automatic bit(1) unaligned dcl 35 in procedure "display_text" set ref 345* 387* 411 511 ext_base 000260 automatic bit(1) level 2 in structure "mod_factor" packed unaligned dcl 113 in procedure "display_text" set ref 214 ext_base 0(29) based bit(1) level 2 in structure "instruction" packed unaligned dcl 95 in procedure "display_text" ref 379 387 father 17 based pointer level 2 packed unaligned dcl 3-3 ref 531 534 535 first based fixed bin(18,0) level 2 dcl 1-5 ref 589 591 598 600 first_special 2 based fixed bin(18,0) level 2 dcl 1-5 ref 595 fixed builtin function dcl 62 ref 176 248 284 292 300 301 331 347 367 405 406 413 414 420 438 438 440 442 468 468 471 476 476 492 557 606 706 711 four_bit_descriptor based structure level 1 dcl 144 fract_offset 000127 automatic fixed bin(18,0) dcl 35 set ref 438* 440* 442* 443 447* half based structure level 1 dcl 103 has_ic 000142 automatic bit(1) unaligned dcl 35 set ref 349* 390* 481 ht constant char(1) initial dcl 35 ref 206 208 329 376 393 686 htht 003277 constant char(2) initial dcl 35 ref 483 525 582 609 i 000116 automatic fixed bin(17,0) dcl 35 set ref 164* 644* 673* 688* ic 000267 automatic bit(1) array dcl 124 set ref 247* 251* 349 569* ignore_ic_mod 000133 automatic bit(1) unaligned dcl 35 set ref 319* 361* 407* 479 instruction based structure level 1 dcl 95 irand 000124 automatic fixed bin(17,0) dcl 35 set ref 162* 315* 335 345 346 349 486 572* 619* 619 620 623* 625 itag 000141 automatic bit(1) unaligned dcl 35 set ref 346* 347 389* 453 576 j 000117 automatic fixed bin(17,0) dcl 35 set ref 212* 213 214 215 221 228 247 251* 292* 293 296 417* 429* 432 524* 525 526 539* 540 541 547* 548 549 566* 567 568 569* 597* 598 600* 681* 682* k 000120 automatic fixed bin(17,0) dcl 35 set ref 190* 210* 217 218* 218 223 224* 224 232 233* 233 235 236* 236 244 245* 245 248 249* 249 253 254* 254 260 261* 261 268 270 272* 272 273 274* 274 275 276* 276 278* 278 279* 279 282 283* 283 284 285* 285 286 287* 287 290 291* 291 296 297* 297 300 301 302* 302 304 305* 305 310 311* 311 313* 313 343* 377* 381 383 392* 393 395* 395 397 413 416* 416 445 446* 446 448 449* 449 455 456 458* 458 459 459* 459 460 460* 460 464 465* 465 469 470* 470 483 484* 484 487 489* 489 494 495* 495 497 498 499* 499 503 504 505* 505 524 525 526* 526 540 541* 541 543 544* 544 548 549* 549 582 583* 583 609 610* 610 612 613* 613 615 652* 654* 680* 682 683* 683 688* 689 689 691 706* 707* 709 711* 712* 714 723 724* 724 label_node constant bit(9) initial dcl 7-5 ref 528 last 1 based fixed bin(18,0) level 2 dcl 1-5 ref 589 598 600 last_special 3 based fixed bin(18,0) level 2 dcl 1-5 ref 595 left based bit(18) level 2 in structure "half" packed unaligned dcl 103 in procedure "display_text" ref 406 420 left 0(14) based bit(4) level 2 in structure "rel_tab" packed unaligned dcl 107 in procedure "display_text" ref 706 len_reg 000264 automatic bit(1) array dcl 124 set ref 215* 228 346 568* length builtin function dcl 62 in procedure "display_text" ref 293 342 343 723 724 length 0(24) based bit(12) level 2 in structure "descriptor" packed unaligned dcl 138 in procedure "display_text" ref 347 468 468 471 476 476 length_in_reg 0(01) 000260 automatic bit(1) level 2 packed unaligned dcl 113 set ref 215 line 000153 automatic char(256) unaligned dcl 35 set ref 160 167* 168* 187* 188* 189* 201* 202* 203* 204* 206* 207* 208* 217* 223* 232* 235* 244* 248* 253* 260* 268* 270* 273* 275* 282* 284* 286* 290* 296* 300* 301* 304* 310* 324* 325* 326* 327* 329* 342* 371* 372* 373* 374* 376* 381* 383 393* 413* 432* 445* 448* 455* 456* 459 460 464* 469* 483* 487* 494* 497* 498* 503* 504* 525* 540* 543* 548* 582* 609* 612* 642 646* 647* 649* 650* 670 675* 676* 677* 682* 686* 689* 702* 709* 714* 723* line_pt 000112 automatic pointer dcl 35 set ref 160* 615* 642* 654* 670* 691* ltrim builtin function dcl 62 ref 723 723 724 m 000121 automatic fixed bin(17,0) dcl 35 set ref 293* 294 296 297 mf 000136 constant fixed bin(6,0) initial array dcl 119 ref 213 min builtin function dcl 62 ref 688 mod_factor 000260 automatic structure level 1 dcl 113 set ref 213* modifier 000141 constant char(3) initial array dcl 83 ref 367 mop 000122 automatic fixed bin(17,0) dcl 35 set ref 176* 177 181* 557* 558 n_chars parameter fixed bin(17,0) dcl 663 ref 661 669 n_words parameter fixed bin(17,0) dcl 638 ref 636 644 name based char(6) level 2 packed unaligned dcl 2-9 ref 178 name_pair based structure level 1 dcl 68 namep based bit(18) array level 3 packed unaligned dcl 1-5 set ref 600 names 5 based structure array level 2 dcl 1-5 set ref 591 nc 000275 automatic fixed bin(17,0) dcl 665 set ref 669* 673 688 ndesc 000126 automatic fixed bin(17,0) dcl 35 set ref 212 264 566 625 733* need_comma 000137 automatic bit(1) unaligned dcl 35 set ref 219* 225* 230 237* 242 node based structure level 1 dcl 7-27 nrands 000125 automatic fixed bin(17,0) dcl 35 set ref 620 732* null builtin function dcl 62 ref 518 532 534 700 num_desc 1(21) based fixed bin(5,0) level 2 packed unaligned dcl 2-9 ref 358 733 num_words 1(27) based fixed bin(8,0) level 2 packed unaligned dcl 2-9 ref 194 559 732 number parameter fixed bin(18,0) dcl 721 in procedure "bin2dec" ref 719 723 723 724 number parameter fixed bin(17,0) dcl 29 in procedure "display_text" ref 25 164 number_special 4 based fixed bin(17,0) level 2 dcl 1-5 ref 597 offset 0(03) based bit(15) level 2 in structure "instruction" packed unaligned dcl 95 in procedure "display_text" ref 414 offset 000130 automatic fixed bin(18,0) dcl 35 in procedure "display_text" set ref 406* 414* 415 415* 415 420* 422 426* 426 434* 486 556 580 581 589 589 591 595 595 598 offset based fixed bin(18,0) array level 3 in structure "operator_names" dcl 1-5 in procedure "display_text" ref 598 op_code 0(18) based bit(10) level 2 in structure "instruction" packed unaligned dcl 95 in procedure "display_text" ref 176 557 op_code 000150 automatic char(5) unaligned dcl 35 in procedure "display_text" set ref 178* 185 207 264 264 268 288 335 335 339 353 354 379* 379 381 385 385 385 491 513 554 578 625* op_mnemonic based structure level 1 dcl 2-9 op_mnemonic_$op_mnemonic_ 000024 external static structure array level 1 dcl 2-5 set ref 177 182 558 op_mnemonic_ptr 000256 automatic pointer dcl 2-8 set ref 177* 178 182* 194 358 379 387 558* 559 732 733 734 735 op_names_pt 000254 automatic pointer dcl 1-3 set ref 587* 589 589 591 595 595 597 598 600 operator_names based structure level 1 dcl 1-5 p 000100 automatic pointer dcl 35 set ref 156* 167 167 172 176 213 258 284 292 300 301 308 331 333 347 356 360 365 367 379 387 389 390 399 405 406 413 414 420 438 438 440 442 468 468 471 476 476 486 513 629* 629 640* 646 646 650 655* 655 668* 675 675 679 689 692* 692 packed_ptr based pointer level 2 packed unaligned dcl 121 ref 517 packed_ptr_st based structure level 1 dcl 121 pl1_operator_names_$first 000020 external static fixed bin(18,0) dcl 54 ref 580 pl1_operator_names_$pl1_operator_names_ 000022 external static fixed bin(17,0) dcl 54 set ref 587 pl1_operators_$operator_table 000016 external static fixed bin(17,0) dcl 54 set ref 556 581 pl1_print$string_ptr_nl 000012 constant entry external dcl 49 ref 615 654 691 pt 000114 automatic pointer dcl 35 set ref 486* 487 487 492 498 504 556* 557 581* 591* 600* 606 607* 607 607 612 ptr builtin function dcl 62 ref 607 q 000102 automatic pointer dcl 35 set ref 157* 630* 630 641* 656* 656 706 706 711 711 r_pt parameter pointer dcl 29 ref 25 157 636 641 700 rel builtin function dcl 62 ref 167 167 487 487 492 646 646 675 675 rel_ptr based bit(18) level 2 packed unaligned dcl 68 ref 607 rel_tab based structure level 1 dcl 107 relocation 000251 constant char(1) initial array dcl 77 ref 709 714 right 0(32) based bit(4) level 2 packed unaligned dcl 107 ref 711 s 000104 automatic pointer dcl 35 set ref 158* 515 517 631* 631 s_pt parameter pointer dcl 29 ref 25 158 save_k 000123 automatic fixed bin(17,0) dcl 35 set ref 397* 524 scale 000132 automatic fixed bin(18,0) dcl 35 set ref 471* 472 472* 472 474* size 000131 automatic fixed bin(18,0) dcl 35 in procedure "display_text" set ref 606* 612 612 613 size 3 based fixed bin(9,0) level 2 in structure "token" dcl 4-3 in procedure "display_text" ref 539 540 547 548 size 0(18) based bit(18) level 2 in structure "name_pair" packed unaligned dcl 68 in procedure "display_text" ref 606 special based structure array level 2 dcl 1-5 string builtin function dcl 62 in procedure "display_text" set ref 213* string 4 based char level 2 in structure "token" dcl 4-3 in procedure "display_text" ref 540 548 substr builtin function dcl 62 set ref 167* 168* 187* 188* 188 189* 189 201* 201 202* 202 203* 203 204* 204 206* 207* 208* 213 217* 223* 232* 235* 244* 248* 253* 258 260* 264 264 268 268* 270* 273* 273 275* 282* 284* 284 286* 290* 292 296* 300* 300 301* 301 304* 308 310* 324* 325* 325 326* 326 327* 327 329* 342* 347 360 371* 372* 372 373* 373 374* 374 376* 381* 383 385 385 385 393* 406 413* 432* 440 445* 448* 455* 456* 459 460 464* 468 468 469* 471 483* 487* 491 494* 497* 498* 503* 504* 525* 540* 543* 548* 578 582* 609* 612* 646* 647* 649* 650* 675* 676* 677* 682* 682 686* 689* 689 702* 709* 714* 723* sym_pt 000106 automatic pointer dcl 35 set ref 517* 518 520 520 528 531 546 symbol based structure level 1 dcl 3-3 t_pt parameter pointer dcl 29 ref 25 156 636 640 661 668 tag 0(03) 000260 automatic bit(4) level 2 in structure "mod_factor" packed unaligned dcl 113 in procedure "display_text" set ref 240 247 248 tag 0(30) based bit(6) level 2 in structure "instruction" packed unaligned dcl 95 in procedure "display_text" ref 360 365 367 389 390 405 tag 000152 automatic char(3) unaligned dcl 35 in procedure "display_text" set ref 166* 347* 360* 367* 368 405* 424 425 456 tok_pt 000110 automatic pointer dcl 35 set ref 531* 532 534 535* 535 538* 538 539 540 546* 547 548 token based structure level 1 dcl 4-3 in procedure "display_text" token 5 based pointer level 2 in structure "symbol" packed unaligned dcl 3-3 in procedure "display_text" ref 538 546 type based bit(9) level 2 packed unaligned dcl 7-27 ref 528 unused 0(28) based bit(1) level 2 packed unaligned dcl 95 ref 356 399 word based bit(36) array dcl 93 set ref 172* 213 258 284 292 300 301 308 498* 504* 515 650* 679* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. array_node internal static bit(9) initial dcl 7-5 bits_per_four_words internal static fixed bin(8,0) initial dcl 6-5 bits_per_half internal static fixed bin(8,0) initial dcl 6-5 bits_per_packed_digit internal static fixed bin(8,1) initial dcl 6-35 bits_per_two_words internal static fixed bin(8,0) initial dcl 6-5 bits_per_word internal static fixed bin(8,0) initial dcl 6-5 bits_per_words internal static fixed bin(8,0) initial array dcl 6-5 block_node internal static bit(9) initial dcl 7-5 bound_node internal static bit(9) initial dcl 7-5 break_even_bits internal static fixed bin(8,0) initial dcl 6-5 break_even_words internal static fixed bin(8,0) initial dcl 6-5 by_context internal static bit(3) initial dcl 5-5 by_declare internal static bit(3) initial dcl 5-5 by_explicit_context internal static bit(3) initial dcl 5-5 by_implication internal static bit(3) initial dcl 5-5 by_name_agg_node internal static bit(9) initial dcl 7-5 chars_per_word internal static fixed bin(8,0) initial dcl 6-5 context_node internal static bit(9) initial dcl 7-5 convert_offset internal static fixed bin(8,1) initial array dcl 6-35 convert_size internal static fixed bin(8,0) initial array dcl 6-5 cross_reference_node internal static bit(9) initial dcl 7-5 default_fix_bin_p internal static fixed bin(8,0) initial dcl 6-5 default_node internal static bit(9) initial dcl 7-5 format_value_node internal static bit(9) initial dcl 7-5 label_array_element_node internal static bit(9) initial dcl 7-5 label_size internal static fixed bin(8,0) initial dcl 6-5 list_node internal static bit(9) initial dcl 7-5 machine_state_node internal static bit(9) initial dcl 7-5 max_dec_scale internal static fixed bin(8,0) initial dcl 6-5 max_index_register_value internal static fixed bin(31,0) initial dcl 6-38 max_length_p internal static fixed bin(8,0) initial dcl 6-5 max_offset internal static fixed bin(8,0) initial array dcl 6-5 max_p_fix_bin_1 internal static fixed bin(8,0) initial dcl 6-5 max_p_fix_dec internal static fixed bin(8,0) initial dcl 6-5 max_p_flt_bin_1 internal static fixed bin(8,0) initial dcl 6-5 max_p_xreg internal static fixed bin(8,0) initial dcl 6-5 max_short_size internal static fixed bin(8,0) initial array dcl 6-5 min_dec_scale internal static fixed bin(8,0) initial dcl 6-5 n automatic fixed bin(17,0) dcl 35 operator_node internal static bit(9) initial dcl 7-5 packed_digits_per_char internal static fixed bin(8,0) initial dcl 6-5 packed_digits_per_word internal static fixed bin(8,0) initial dcl 6-5 reference_node internal static bit(9) initial dcl 7-5 sf_par_node internal static bit(9) initial dcl 7-5 source_node internal static bit(9) initial dcl 7-5 statement_node internal static bit(9) initial dcl 7-5 symbol_node internal static bit(9) initial dcl 7-5 temporary_node internal static bit(9) initial dcl 7-5 token_node internal static bit(9) initial dcl 7-5 units_per_word internal static fixed bin(8,0) initial array dcl 6-5 NAMES DECLARED BY EXPLICIT CONTEXT. begin 000407 constant label dcl 156 bin2dec 003163 constant entry internal dcl 719 ref 434 447 468 474 476 chk_base 002221 constant label dcl 511 ref 479 chk_ext 001573 constant label dcl 393 ref 350 chk_ext1 001573 constant label dcl 393 display_text 000402 constant entry external dcl 25 display_text$display_abs 002620 constant entry external dcl 636 display_text$display_ascii 002744 constant entry external dcl 661 equal 002137 constant label dcl 497 ref 584 init_eis 003215 constant entry internal dcl 729 ref 199 564 insert_relocation 003117 constant entry internal dcl 696 ref 170 648 not_ins 000542 constant label dcl 187 ref 356 368 prt 002543 constant label dcl 615 ref 191 316 491 492 508 511 515 518 520 551 576 580 604 put 002327 constant label dcl 546 ref 528 532 set 001425 constant label dcl 371 ref 353 354 362 sk 001665 constant label dcl 429 ref 408 424 425 str_info 002516 constant label dcl 606 ref 592 601 NAME DECLARED BY CONTEXT OR IMPLICATION. rtrim builtin function ref 379 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3464 3512 3306 3474 Length 4042 3306 26 314 155 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME display_text 241 external procedure is an external procedure. insert_relocation internal procedure shares stack frame of external procedure display_text. bin2dec internal procedure shares stack frame of external procedure display_text. init_eis internal procedure shares stack frame of external procedure display_text. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME display_text 000100 p display_text 000102 q display_text 000104 s display_text 000106 sym_pt display_text 000110 tok_pt display_text 000112 line_pt display_text 000114 pt display_text 000116 i display_text 000117 j display_text 000120 k display_text 000121 m display_text 000122 mop display_text 000123 save_k display_text 000124 irand display_text 000125 nrands display_text 000126 ndesc display_text 000127 fract_offset display_text 000130 offset display_text 000131 size display_text 000132 scale display_text 000133 ignore_ic_mod display_text 000134 double display_text 000135 eis display_text 000136 eis_desc display_text 000137 need_comma display_text 000140 ext_base display_text 000141 itag display_text 000142 has_ic display_text 000143 decimal display_text 000144 c display_text 000145 cstring display_text 000150 op_code display_text 000152 tag display_text 000153 line display_text 000254 op_names_pt display_text 000256 op_mnemonic_ptr display_text 000260 mod_factor display_text 000261 ebase display_text 000264 len_reg display_text 000267 ic display_text 000272 desc_word display_text 000275 nc display_text THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_cs call_ext_out_desc call_ext_out return shorten_stack ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. binoct pl1_print$string_ptr_nl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cg_static_$text_pos op_mnemonic_$op_mnemonic_ pl1_operator_names_$first pl1_operator_names_$pl1_operator_names_ pl1_operators_$operator_table LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 25 000375 156 000407 157 000415 158 000421 160 000425 161 000427 162 000430 164 000431 166 000441 167 000443 168 000465 170 000467 172 000470 174 000512 176 000516 177 000522 178 000526 179 000532 181 000533 182 000534 185 000537 187 000542 188 000544 189 000551 190 000555 191 000557 194 000560 199 000565 201 000566 202 000572 203 000601 204 000607 206 000612 207 000614 208 000617 210 000621 212 000623 213 000633 214 000641 215 000645 217 000651 218 000655 219 000656 221 000657 223 000661 224 000665 225 000667 228 000671 230 000673 232 000675 233 000701 235 000702 236 000706 237 000710 240 000712 242 000717 244 000721 245 000725 247 000726 248 000732 249 000741 250 000743 251 000744 253 000745 254 000751 255 000753 258 000755 260 000760 261 000764 264 000766 268 001012 270 001021 272 001025 273 001027 274 001033 275 001035 276 001041 277 001042 278 001043 279 001046 280 001051 282 001056 283 001062 284 001064 285 001073 286 001074 287 001100 288 001101 290 001104 291 001110 292 001112 293 001116 294 001122 296 001123 297 001132 298 001133 300 001134 301 001144 302 001153 304 001155 305 001161 307 001162 308 001163 310 001166 311 001172 312 001174 313 001175 315 001177 316 001200 319 001201 321 001203 322 001212 324 001213 325 001215 326 001224 327 001232 329 001236 331 001240 333 001257 335 001276 338 001313 339 001314 342 001324 343 001331 345 001334 346 001337 347 001341 349 001346 350 001350 353 001351 354 001354 356 001356 358 001361 360 001365 361 001411 362 001413 365 001414 367 001420 368 001423 371 001425 372 001427 373 001436 374 001444 376 001447 377 001451 379 001453 381 001521 383 001526 385 001533 387 001555 389 001560 390 001565 392 001571 393 001573 395 001577 397 001600 399 001602 405 001607 406 001615 407 001620 408 001622 411 001623 413 001625 414 001634 415 001640 416 001644 417 001646 418 001650 420 001651 422 001654 424 001656 425 001661 426 001663 429 001665 432 001667 434 001672 436 001674 438 001676 440 001716 442 001730 443 001734 445 001736 446 001742 447 001743 448 001745 449 001751 453 001752 455 001754 456 001760 458 001763 459 001765 460 001773 461 002001 462 002002 464 002004 465 002010 466 002011 468 002023 469 002030 470 002034 471 002035 472 002041 474 002045 475 002047 476 002050 479 002055 481 002057 483 002061 484 002065 486 002067 487 002074 489 002117 491 002121 492 002125 494 002132 495 002136 497 002137 498 002143 499 002164 501 002166 503 002170 504 002174 505 002216 508 002220 511 002221 513 002223 515 002234 517 002236 518 002240 520 002244 524 002254 525 002263 526 002267 528 002270 531 002274 532 002276 534 002302 535 002306 536 002310 538 002311 539 002313 540 002315 541 002321 543 002322 544 002326 546 002327 547 002332 548 002334 549 002340 551 002341 554 002342 556 002345 557 002353 558 002357 559 002362 564 002367 566 002371 567 002401 568 002403 569 002406 570 002407 572 002411 576 002412 578 002414 580 002420 581 002424 582 002430 583 002434 584 002436 587 002437 589 002442 591 002447 592 002452 595 002453 597 002457 598 002467 600 002505 601 002512 603 002513 604 002515 606 002516 607 002521 609 002526 610 002532 612 002534 613 002541 615 002543 617 002557 619 002561 620 002562 622 002565 623 002566 624 002567 625 002570 629 002600 630 002603 631 002606 632 002611 634 002613 636 002614 640 002625 641 002631 642 002634 644 002636 646 002645 647 002667 648 002671 649 002672 650 002674 652 002714 654 002716 655 002727 656 002732 657 002735 659 002737 661 002740 668 002751 669 002755 670 002757 673 002761 675 002767 676 003011 677 003013 679 003015 680 003037 681 003041 682 003047 683 003053 684 003055 686 003060 688 003062 689 003071 691 003075 692 003110 693 003113 739 003116 696 003117 700 003120 702 003125 703 003127 706 003130 707 003140 709 003142 711 003144 712 003153 714 003155 716 003162 719 003163 723 003165 724 003213 726 003214 729 003215 731 003216 732 003220 733 003226 734 003232 735 003240 737 003250 ----------------------------------------------------------- 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