COMPILATION LISTING OF SEGMENT probe_display_data_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/27/88 1231.6 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 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 /****^ HISTORY COMMENTS: 15* 1) change(88-09-07,WAAnderson), approve(88-09-30,MCR7952), 16* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 17* Added format control comment to make the source more readable. 18* END HISTORY COMMENTS */ 19 20 21 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll78,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 22 23 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 24 25 probe_display_data_: 26 proc (P_probe_info_ptr, P_ap, P_format, P_units, P_code); 27 28 /* displays data pointed to by P_ap in format given by P_units 29* 30* James R. Davis 20 May 79 */ 31 /* Added formats bin, bin71, f, f63, code 09/30/81 S. Herbst */ 32 /* Changed to print entry point name of error code as well 10/23/81 S. Herbst */ 33 /* Fixed message printed for zero status code 10/18/82 S. Herbst */ 34 35 dcl P_probe_info_ptr ptr aligned parameter; 36 dcl P_ap ptr aligned parameter; 37 dcl P_format char (32) aligned parameter; 38 dcl P_units fixed bin parameter; 39 dcl P_code fixed bin (35) parameter; 40 /* output: error code */ 41 42 dcl ap ptr; /* to data, copy of P_ap */ 43 dcl strp ptr; 44 dcl units fixed bin;/* copy of P_units */ 45 46 dcl 1 format_how (29) internal static options (constant), 47 2 fname char (12) init 48 ("ascii", "character", "ch", "c", "a", 49 "bit", "b", 50 "binary", "bin", "binary35", "bin35", 51 "binary71", "bin71", 52 "float", "f", "float27", "f27", 53 "float63", "f63", 54 "pointer", "ptr", "its", "p", 55 "octal", "o", 56 "instruction", "inst", "i", 57 "code"), 58 59 2 method fixed bin (9) unsigned unaligned init 60 (1, 1, 1, 1, 1, 61 2, 2, 62 3, 3, 3, 3, 63 4, 4, 64 5, 5, 5, 5, 65 6, 6, 66 7, 7, 7, 7, 67 8, 8, 68 9, 9, 9, 69 10); 70 71 dcl based_bits bit (units) based (ap); 72 dcl based_char char (units) based (ap); 73 dcl based_fixed fixed bin (35) based (ap); 74 dcl based_fixed71 fixed bin (71) based (ap); 75 dcl based_float float bin (27) based (ap); 76 dcl based_ptr_array (units) ptr aligned based (ap); 77 dcl based_words (units) bit (36) aligned based (ap); 78 79 dcl i fixed bin; 80 dcl error_message char (100) aligned; 81 82 dcl convert_status_code_ entry (fixed bin (35), char (8) aligned, 83 char (100) aligned); 84 dcl print_instructions_ entry (ptr, fixed bin, ptr); 85 dcl octals_per_line fixed bin internal static 86 options (constant) init (8); 87 88 dcl probe_error_$record entry options (variable); 89 dcl probe_et_$recorded_message 90 fixed bin (35) external; 91 92 dcl ( 93 ioa_$ioa_switch, 94 ioa_$ioa_switch_nnl 95 ) entry options (variable); 96 97 dcl (addr, divide, hbound, mod, null, ptr, rel, rtrim) 98 builtin; 99 100 P_code = 0; 101 units = P_units; 102 ap = P_ap; 103 probe_info_ptr = P_probe_info_ptr; 104 105 do i = 1 to hbound (format_how, 1); 106 if format_how (i).fname = P_format 107 then goto display_data (format_how (i).method); 108 end; 109 110 /* fell through - bad format */ 111 112 call probe_error_$record (probe_info_ptr, 0, 113 "Invalid format mode for displaying: ""^a"".", P_format); 114 P_code = probe_et_$recorded_message; 115 return; 116 117 display_data (1): /* chars */ 118 119 /* must translate unprintables ? */ 120 121 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^a", 122 based_char); 123 return; 124 125 126 display_data (2): /* bit strings */ 127 128 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^b", 129 based_bits); 130 return; 131 132 133 display_data (3): /* decimal */ 134 135 if units > 35 136 then go to FIXED71; 137 FIXED35: 138 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^d", 139 based_fixed); 140 return; 141 142 143 display_data (4): /* double precision decimal */ 144 145 if units < 36 146 then go to FIXED35; 147 FIXED71: 148 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^d", 149 based_fixed71); 150 return; 151 152 153 display_data (5): /* floating point */ 154 155 if units > 27 156 then go to FLOAT63; 157 FLOAT27: 158 159 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^f", 160 based_float); 161 return; 162 163 164 display_data (6): /* double precision floating point */ 165 166 if units < 28 167 then go to FLOAT27; 168 FLOAT63: 169 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^f", 170 based_float); 171 172 173 display_data (7): /* ptrs */ 174 175 do i = 1 to units; 176 call ioa_$ioa_switch (probe_info.io_switches.output_switch, "^p", 177 based_ptr_array (i)); 178 end; 179 180 return; 181 182 183 display_data (8): /* octals */ 184 185 do i = 1 to units; 186 call ioa_$ioa_switch_nnl (probe_info.io_switches.output_switch, 187 " ^12w^[^/^]", 188 based_words (i), 189 mod (i, octals_per_line) = 0 | i = units); 190 end; 191 return; 192 193 194 display_data (9): /* instructions */ 195 196 call print_instructions_ (ap, units, probe_info.io_switches.output_switch); 197 return; 198 199 200 display_data (10): /* status codes */ 201 202 call convert_status_code_ (based_fixed, "", error_message); 203 call ioa_$ioa_switch (probe_info.io_switches.output_switch, 204 "^a^2x^[""^a""^]", get_code_name (based_fixed), based_fixed ^= 0, 205 error_message); 206 return; 207 208 get_code_name: 209 proc (P_code) returns (char (128) varying); 210 211 /* Returns the entry point name corresponding to an octal status code */ 212 213 dcl P_code fixed bin (35); 214 215 dcl 1 def aligned, 216 2 next_def ptr, 217 2 last_def ptr, 218 2 block_ptr ptr, 219 2 section char (4) aligned, 220 2 offset fixed bin, 221 2 entrypoint fixed bin, 222 2 defname char (32) aligned; 223 224 dcl seg_word (0:last_word) fixed bin (35) based (entry_ptr); 225 dcl packed_ptr ptr unaligned based; 226 dcl based_code fixed bin (35) based; 227 228 dcl (segment_name, offset_name) 229 char (32); 230 dcl (entry_ptr, ptr1, ptr2) ptr; 231 dcl search_sw bit (1); 232 dcl type fixed bin (2); 233 dcl i fixed bin; 234 dcl (bit_count, last_word) fixed bin (24); 235 dcl (code, search_code) fixed bin (35); 236 237 dcl error_table_$ fixed bin (35) ext; 238 239 dcl decode_definition_ entry (ptr, ptr) returns (bit (1) aligned); 240 dcl decode_definition_$init entry (ptr, fixed bin (24)); 241 dcl hcs_$make_ptr entry (ptr, char (*), char (*), ptr, 242 fixed bin (35)); 243 dcl hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), 244 fixed bin (35)); 245 dcl interpret_ptr_ entry (ptr, ptr, ptr); 246 247 248 if P_code = 0 249 then 250 return ("0"); 251 252 entry_ptr = addr (P_code) -> packed_ptr; 253 254 if ptr (entry_ptr, 0) = ptr (null, 0) then do; 255 /* system's error_table_ */ 256 257 search_code = P_code; 258 ERROR_TABLE: 259 call hcs_$make_ptr (null, "error_table_", "", entry_ptr, (0)); 260 if entry_ptr = null 261 then 262 return (""); 263 264 call hcs_$status_mins (entry_ptr, type, bit_count, code); 265 if code ^= 0 266 then 267 return (""); 268 269 last_word = divide (bit_count, 36, 24, 0) - 1; 270 do i = 0 to last_word while (search_code ^= seg_word (i)); 271 end; 272 if i <= last_word 273 then entry_ptr = ptr (entry_ptr, i); 274 else 275 return (""); 276 277 strp = addr (strbuf); 278 call interpret_ptr_ (entry_ptr, null, strp); 279 return (rtrim (struc.segment) || rtrim (struc.entryn)); 280 end; 281 282 else if ptr (entry_ptr, 0) = addr (error_table_$) then do; 283 entry_ptr = ptr (null, rel (entry_ptr)); 284 addr (search_code) -> packed_ptr = entry_ptr; 285 search_code = search_code + 111000000000000000000000000000000b; 286 go to ERROR_TABLE; 287 end; 288 289 else do; /* another error table */ 290 ptr1 = ptr (entry_ptr, 0); 291 call hcs_$status_mins (ptr1, type, bit_count, code); 292 if code ^= 0 293 then 294 return (""); 295 296 segment_name, offset_name = ""; 297 call decode_definition_$init (ptr1, bit_count); 298 search_sw = ^decode_definition_ (ptr1, addr (def)); 299 do while (search_sw); 300 if def.section = "segn" 301 then segment_name = def.defname; 302 else if def.section = "link" | def.section = "stat" then do; 303 offset_name = def.defname; 304 call hcs_$make_ptr (null, segment_name, offset_name, ptr2, code); 305 if ptr2 ^= null 306 then 307 if ptr2 -> based_code = P_code 308 then search_sw = "0"b; 309 end; 310 if search_sw then do; 311 offset_name = ""; 312 search_sw = ^decode_definition_ (def.next_def, addr (def)); 313 end; 314 end; 315 316 if ptr2 ^= null 317 then 318 if ptr2 -> based_code = P_code 319 then 320 return (rtrim (segment_name) || "$" || rtrim (offset_name)); 321 return (""); 322 end; 323 324 end get_code_name; 325 1 1 /* BEGIN INCLUDE FILE probe_info.incl.pl1 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(88-10-24,WAAnderson), approve(88-10-24,MCR7952), 1 7* audit(88-10-24,RWaters), install(88-10-27,MR12.2-1194): 1 8* Added field 'retry_using_main' to add new C feature. 1 9* END HISTORY COMMENTS */ 1 10 1 11 1 12 /* Created: 04/22/79 W. Olin Sibert, from subsystem_info 1 13* Modified: 22 Sept 79 JRd to remove: default (ptr & (auto|based)) init (null ()); 1 14* Added flags.setting_break 08/22/83 Steve Herbst 1 15* Added flags.executing_quit_request 01/15/85 Steve Herbst 1 16**/ 1 17 1 18 dcl 1 probe_info aligned based (probe_info_ptr), /* standard data for a probe invocation */ 1 19 2 probe_info_version fixed bin, /* version of this structure */ 1 20 1 21 2 static_info_ptr pointer unaligned, /* pointer to static information structure */ 1 22 2 modes_ptr pointer unaligned, /* pointer to probe_modes structure */ 1 23 1 24 2 ptr_to_current_source ptr, /* current_source is based on this */ 1 25 2 ptr_to_initial_source ptr, /* initial_source is based on this */ 1 26 2 machine_cond_ptr pointer, /* pointer to machine conditions, if we faulted to get here */ 1 27 1 28 2 token_info aligned, /* information about token chain currently being processed */ 1 29 3 first_token pointer unaligned, /* first token in chain */ 1 30 3 ct pointer unaligned, /* pointer to current token; updated in MANY places */ 1 31 3 end_token bit (18) aligned, /* token type at which to stop scanning token chain */ 1 32 3 buffer_ptr pointer unaligned, /* pointer to input buffer */ 1 33 3 buffer_lth fixed bin (21), /* and length */ 1 34 1 35 2 random_info aligned, 1 36 3 current_stack_frame pointer unaligned, /* stack frame pointer for frame in which probe was invoked */ 1 37 3 input_type fixed bin, /* current input type */ 1 38 3 language_type fixed bin, /* current language being processed */ 1 39 3 return_method fixed bin, /* how we should return after exiting probe */ 1 40 3 entry_method fixed bin, /* how we got here in the first place */ 1 41 3 pad1 (19) bit (36) aligned, 1 42 1 43 2 break_info, /* break info -- only interesting if we got here via a break */ 1 44 3 break_slot_ptr pointer, /* pointer to break slot -- non-null IFF at a break */ 1 45 3 last_break_slot_ptr pointer unaligned, /* pointer to previous break slot, not presently used */ 1 46 3 break_reset bit (1) aligned, /* this break has been reset by somebody further on */ 1 47 3 real_break_return_loc pointer, /* where to REALLY return to, modulo previous bit */ 1 48 1 49 2 probe_area_info, /* information about various probe areas */ 1 50 3 break_segment_ptr pointer unaligned, /* pointer to Personid.probe */ 1 51 3 break_area_ptr pointer unaligned, /* pointer to area in break segment */ 1 52 3 scratch_area_ptr pointer unaligned, /* pointer to probe scratch seg in process dir */ 1 53 3 probe_area_ptr pointer unaligned, /* This area lasts as long as an invocation of probe. */ 1 54 3 work_area_ptr pointer unaligned, /* This area lasts as long as the current request line */ 1 55 3 expression_area_ptr pointer unaligned, /* This area lasts as long as the current command */ 1 56 1 57 2 flags aligned, /* this, in particular, should be saved and restored correctly */ 1 58 (3 execute, /* "1"b => execute requests, "0"b => just check syntax */ 1 59 3 in_listener, /* ON => in probe listener loop */ 1 60 3 executing_request, /* ON => executing a request */ 1 61 3 in_interpret_line, /* executing in probe_listen_$interpret_line */ 1 62 3 setting_break, /* executing "after" or "before": check syntax of "if" */ 1 63 3 executing_quit_request, /* to prevent error looping during "quit" request */ 1 64 3 pad (30)) bit (1) unaligned, 1 65 1 66 2 io_switches, /* switches probe will do normal I/O on */ 1 67 3 input_switch pointer, 1 68 3 output_switch pointer, 1 69 1 70 2 error_info, /* information about the last error saved for later printing */ 1 71 3 error_code fixed bin (35), 1 72 3 error_message char (300) varying, 1 73 1 74 2 listener_info, /* internal use by probe listener */ 1 75 3 request_name character (32) varying, /* primary name of the request being processed */ 1 76 3 abort_probe_label label variable, 1 77 3 abort_line_label label variable, 1 78 3 depth fixed binary, /* count of active invocations of probe */ 1 79 3 previous pointer unaligned, /* -> previous invocation's info */ 1 80 3 next pointer unaligned, 1 81 1 82 2 end_of_probe_info pointer aligned, 1 83 2 retry_using_main fixed bin aligned; 1 84 1 85 1 86 dcl probe_info_ptr pointer; 1 87 1 88 dcl probe_info_version fixed bin static options (constant) initial (1); 1 89 1 90 dcl probe_info_version_1 fixed bin static options (constant) initial (1); 1 91 1 92 dcl scratch_area area based (probe_info.scratch_area_ptr); 1 93 dcl probe_area area based (probe_info.probe_area_ptr); 1 94 dcl work_area area based (probe_info.work_area_ptr); 1 95 dcl expression_area area based (probe_info.expression_area_ptr); 1 96 1 97 /* END INCLUDE FILE probe_info.incl.pl1 */ 326 327 328 329 /* ;;;;;;; */ 330 331 2 1 /* BEGIN INCLUDE FILE ... interpret_ptr_struc.incl.pl1 */ 2 2 2 3 dcl 1 struc based (strp) aligned, /* This useful structure is in trace_stack pgms */ 2 4 2 comment char (64), /* name of boundseg, or thing pointed to, or .. */ 2 5 2 segment char (32), /* name of segment, or segment number with # */ 2 6 2 entryn char (33), /* entry name, preceded by $, or blank */ 2 7 2 offset char (6), /* offset in segment, or blank */ 2 8 2 opname char (32), /* may be pl1 operator name */ 2 9 2 ring char (1) unal, /* ring number of ptr */ 2 10 2 std_flag bit (1) unal, /* TRUE if std object. */ 2 11 2 xpad bit (26) unal, 2 12 2 bitoff char (4), /* bit offset */ 2 13 2 modifier char (8), /* ptr modifier, or special code like "noaccess" */ 2 14 2 symbolp ptr, /* ptr to symbol section */ 2 15 2 instruction_counter fixed bin, /* binary instruction counter */ 2 16 2 sourcemap fixed bin, /* source map offset in symbol section */ 2 17 2 compiler char (8), /* name of compiler */ 2 18 2 text_ptr ptr, /* ptr to segment text */ 2 19 2 stack_ptr ptr; /* ptr to stack frame */ 2 20 2 21 dcl 1 strbuf aligned like struc; /* If referenced, will make storage for struc */ 2 22 2 23 /* END INCLUDE FILE ... interpret_ptr_struc.incl.pl1 */ 332 333 334 end probe_display_data_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/27/88 1225.3 probe_display_data_.pl1 >spec>install>MR12.2-1194>probe_display_data_.pl1 326 1 10/27/88 1223.7 probe_info.incl.pl1 >spec>install>MR12.2-1194>probe_info.incl.pl1 332 2 06/11/74 0602.3 interpret_ptr_struc.incl.pl1 >ldd>include>interpret_ptr_struc.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. P_ap parameter pointer dcl 36 ref 25 102 P_code parameter fixed bin(35,0) dcl 213 in procedure "get_code_name" set ref 208 248 252 257 305 316 P_code parameter fixed bin(35,0) dcl 39 in procedure "probe_display_data_" set ref 25 100* 114* P_format parameter char(32) dcl 37 set ref 25 106 112* P_probe_info_ptr parameter pointer dcl 35 ref 25 103 P_units parameter fixed bin(17,0) dcl 38 ref 25 101 addr builtin function dcl 97 ref 252 277 282 284 298 298 312 312 ap 000100 automatic pointer dcl 42 set ref 102* 117 126 137 147 157 168 176 186 194* 200 203 203 based_bits based bit packed unaligned dcl 71 set ref 126* based_char based char packed unaligned dcl 72 set ref 117* based_code based fixed bin(35,0) dcl 226 ref 305 316 based_fixed based fixed bin(35,0) dcl 73 set ref 137* 200* 203* 203 based_fixed71 based fixed bin(71,0) dcl 74 set ref 147* based_float based float bin(27) dcl 75 set ref 157* 168* based_ptr_array based pointer array dcl 76 set ref 176* based_words based bit(36) array dcl 77 set ref 186* bit_count 000317 automatic fixed bin(24,0) dcl 234 set ref 264* 269 291* 297* code 000321 automatic fixed bin(35,0) dcl 235 set ref 264* 265 291* 292 304* convert_status_code_ 000010 constant entry external dcl 82 ref 200 decode_definition_ 000026 constant entry external dcl 239 ref 298 312 decode_definition_$init 000030 constant entry external dcl 240 ref 297 def 000244 automatic structure level 1 dcl 215 set ref 298 298 312 312 defname 11 000244 automatic char(32) level 2 dcl 215 set ref 300 303 divide builtin function dcl 97 ref 269 entry_ptr 000306 automatic pointer dcl 230 set ref 252* 254 258* 260 264* 270 272* 272 278* 282 283* 283 284 290 entryn 30 based char(33) level 2 dcl 2-3 ref 279 error_message 000106 automatic char(100) dcl 80 set ref 200* 203* error_table_$ 000024 external static fixed bin(35,0) dcl 237 set ref 282 fname 000000 constant char(12) initial array level 2 packed packed unaligned dcl 46 ref 106 format_how 000000 constant structure array level 1 packed packed unaligned dcl 46 ref 105 hbound builtin function dcl 97 ref 105 hcs_$make_ptr 000032 constant entry external dcl 241 ref 258 304 hcs_$status_mins 000034 constant entry external dcl 243 ref 264 291 i 000105 automatic fixed bin(17,0) dcl 79 in procedure "probe_display_data_" set ref 105* 106 106* 173* 176* 183* 186 186 186* i 000316 automatic fixed bin(17,0) dcl 233 in procedure "get_code_name" set ref 270* 270* 272 272 interpret_ptr_ 000036 constant entry external dcl 245 ref 278 io_switches 66 based structure level 2 dcl 1-18 ioa_$ioa_switch 000020 constant entry external dcl 92 ref 117 126 137 147 157 168 176 203 ioa_$ioa_switch_nnl 000022 constant entry external dcl 92 ref 186 last_word 000320 automatic fixed bin(24,0) dcl 234 set ref 269* 270 272 method 3 000000 constant fixed bin(9,0) initial array level 2 packed packed unsigned unaligned dcl 46 ref 106 mod builtin function dcl 97 ref 186 next_def 000244 automatic pointer level 2 dcl 215 set ref 312* null builtin function dcl 97 ref 254 258 258 260 278 278 283 304 304 305 316 octals_per_line 001604 constant fixed bin(17,0) initial dcl 85 ref 186 offset_name 000275 automatic char(32) packed unaligned dcl 228 set ref 296* 303* 304* 311* 316 output_switch 70 based pointer level 3 dcl 1-18 set ref 117* 126* 137* 147* 157* 168* 176* 186* 194* 203* packed_ptr based pointer packed unaligned dcl 225 set ref 252 284* print_instructions_ 000012 constant entry external dcl 84 ref 194 probe_error_$record 000014 constant entry external dcl 88 ref 112 probe_et_$recorded_message 000016 external static fixed bin(35,0) dcl 89 ref 114 probe_info based structure level 1 dcl 1-18 probe_info_ptr 000140 automatic pointer dcl 1-86 set ref 103* 112* 117 126 137 147 157 168 176 186 194 203 ptr builtin function dcl 97 ref 254 254 272 282 283 290 ptr1 000310 automatic pointer dcl 230 set ref 290* 291* 297* 298* ptr2 000312 automatic pointer dcl 230 set ref 304* 305 305 316 316 rel builtin function dcl 97 ref 283 rtrim builtin function dcl 97 ref 279 279 316 316 search_code 000322 automatic fixed bin(35,0) dcl 235 set ref 257* 270 284 285* 285 search_sw 000314 automatic bit(1) packed unaligned dcl 231 set ref 298* 299 305* 310 312* section 6 000244 automatic char(4) level 2 dcl 215 set ref 300 302 302 seg_word based fixed bin(35,0) array dcl 224 ref 270 segment 20 based char(32) level 2 dcl 2-3 ref 279 segment_name 000265 automatic char(32) packed unaligned dcl 228 set ref 296* 300* 304* 316 strbuf 000142 automatic structure level 1 dcl 2-21 set ref 277 strp 000102 automatic pointer dcl 43 set ref 277* 278* 279 279 struc based structure level 1 dcl 2-3 type 000315 automatic fixed bin(2,0) dcl 232 set ref 264* 291* units 000104 automatic fixed bin(17,0) dcl 44 set ref 101* 117 117 126 126 133 143 153 164 173 183 186 194* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. expression_area based area(1024) dcl 1-95 probe_area based area(1024) dcl 1-93 probe_info_version internal static fixed bin(17,0) initial dcl 1-88 probe_info_version_1 internal static fixed bin(17,0) initial dcl 1-90 scratch_area based area(1024) dcl 1-92 work_area based area(1024) dcl 1-94 NAMES DECLARED BY EXPLICIT CONTEXT. ERROR_TABLE 001052 constant label dcl 258 ref 286 FIXED35 000434 constant label dcl 137 ref 143 FIXED71 000464 constant label dcl 147 ref 133 FLOAT27 000514 constant label dcl 157 ref 164 FLOAT63 000544 constant label dcl 168 ref 153 display_data 000137 constant label array(10) dcl 117 ref 106 get_code_name 001022 constant entry internal dcl 208 ref 203 probe_display_data_ 000244 constant entry external dcl 25 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1772 2032 1606 2002 Length 2272 1606 40 224 163 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME probe_display_data_ 338 external procedure is an external procedure. get_code_name internal procedure shares stack frame of external procedure probe_display_data_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME probe_display_data_ 000100 ap probe_display_data_ 000102 strp probe_display_data_ 000104 units probe_display_data_ 000105 i probe_display_data_ 000106 error_message probe_display_data_ 000140 probe_info_ptr probe_display_data_ 000142 strbuf probe_display_data_ 000244 def get_code_name 000265 segment_name get_code_name 000275 offset_name get_code_name 000306 entry_ptr get_code_name 000310 ptr1 get_code_name 000312 ptr2 get_code_name 000314 search_sw get_code_name 000315 type get_code_name 000316 i get_code_name 000317 bit_count get_code_name 000320 last_word get_code_name 000321 code get_code_name 000322 search_code get_code_name THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out return_mac mdfx1 shorten_stack ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. convert_status_code_ decode_definition_ decode_definition_$init hcs_$make_ptr hcs_$status_mins interpret_ptr_ ioa_$ioa_switch ioa_$ioa_switch_nnl print_instructions_ probe_error_$record THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$ probe_et_$recorded_message LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 25 000237 100 000251 101 000253 102 000255 103 000260 105 000263 106 000271 108 000310 112 000312 114 000344 115 000350 117 000351 123 000400 126 000401 130 000430 133 000431 137 000434 140 000460 143 000461 147 000464 150 000510 153 000511 157 000514 161 000540 164 000541 168 000544 173 000570 176 000577 178 000630 180 000632 183 000633 186 000643 190 000713 191 000715 194 000716 197 000732 200 000733 203 000750 206 001021 208 001022 248 001024 252 001034 254 001036 257 001050 258 001052 260 001111 264 001121 265 001136 269 001144 270 001150 271 001161 272 001163 274 001172 277 001176 278 001200 279 001215 282 001271 283 001300 284 001303 285 001304 286 001310 290 001311 291 001313 292 001327 296 001335 297 001343 298 001354 299 001375 300 001400 302 001407 303 001413 304 001416 305 001447 310 001460 311 001462 312 001465 314 001506 316 001507 321 001600 ----------------------------------------------------------- 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