COMPILATION LISTING OF SEGMENT db_fnp_disp_cmd_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/15/82 1615.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 /* DB_FNP_DISP_CMD_: Various entries to perform display type command for debug_fnp */ 12 /* Extracted from main command, and added to, February 1978 by Larry Johnson */ 13 /* Added set_flag and clear_flag commands October 1978 */ 14 15 db_fnp_disp_cmd_: proc; 16 17 /* Arguments */ 18 19 dcl arg_corep ptr; 20 dcl arg_fnp fixed bin; 21 dcl arg_cmd_infop ptr; 22 dcl arg_expr_infop ptr; 23 24 /* Automatic */ 25 26 dcl code fixed bin (35); 27 dcl corep ptr; 28 dcl fnp fixed bin; 29 dcl unal_temp fixed bin (17) unal; 30 dcl fnp_buf (0:2047) bit (18) unal; 31 dcl flag_work bit (18); 32 dcl flag_orig bit (18); 33 dcl fnp_addr fixed bin; 34 dcl fnp_len fixed bin; 35 dcl expr_val fixed bin; 36 dcl sw bit (1); 37 dcl addr_sw bit (1); 38 dcl first_sw bit (1); 39 dcl found_sw bit (1); 40 dcl (i, j) fixed bin; 41 dcl mask bit (18); 42 dcl temp_word bit (18); 43 dcl flag_name char (6); 44 dcl symno fixed bin; 45 dcl nbits fixed bin; 46 dcl disp_type fixed bin; 47 dcl disp_len fixed bin; 48 dcl type_sw bit (1); 49 dcl length_sw bit (1); 50 dcl brief_sw bit (1); 51 dcl set_flag_sw bit (1); 52 53 dcl based_char char (i) based; 54 55 /* Internal static */ 56 57 dcl next_buf_addr fixed bin int static init (0); /* Forward link from last buffer */ 58 dcl next_block_addr fixed bin int static init (0); /* Forward link from last block */ 59 dcl block_length fixed bin int static init (0); 60 dcl block_offset fixed bin int static init (0); 61 62 /* External */ 63 64 dcl ioa_ entry options (variable); 65 dcl ioa_$nnl entry options (variable); 66 dcl db_fnp_eval_ entry (ptr, fixed bin, char (*), ptr, char (*), fixed bin, fixed bin (35)); 67 dcl db_fnp_reader_$get_operand entry (ptr); 68 dcl db_fnp_memory_$fetch entry (ptr, fixed bin, fixed bin, fixed bin, ptr, fixed bin (35)); 69 dcl db_fnp_memory_$store entry (ptr, fixed bin, fixed bin, fixed bin, ptr, char (*), fixed bin, fixed bin (35)); 70 dcl db_fnp_display_ entry (ptr, fixed bin, fixed bin, fixed bin, ptr, fixed bin, fixed bin (35)); 71 dcl db_fnp_sym_util_$lookup entry (char (*), ptr); 72 dcl com_err_ entry options (variable); 73 74 dcl (addr, bin, copy, divide, hbound, index, lbound, length, mod, null, substr, unspec) builtin; 75 76 /* Entry to display memory in various forms */ 77 78 display: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 79 80 call setup; 81 82 call get_operand_req ("Address"); 83 call cv_expr_op; 84 fnp_addr = expr_val; 85 disp_type = expr_info.type; 86 disp_len = expr_info.len; 87 length_sw = "0"b; /* Length not specified */ 88 type_sw = "0"b; 89 call get_operand; /* Look for more operands */ 90 do while (^cmd_info.endline); 91 if ^type_sw then do; 92 call check_type; 93 if type_sw then go to display_command2; 94 end; 95 if ^length_sw then do; 96 call cv_length_op; 97 disp_len = expr_val; 98 length_sw = "1"b; 99 end; 100 else do; 101 call ioa_ ("Invalid operand: ^a", operand); 102 go to error_return; 103 end; 104 display_command2: 105 call get_operand; 106 end; 107 108 if length_sw & ^type_sw then disp_type = type_oct; 109 call fetch (fnp_addr, disp_len, addr (fnp_buf)); 110 expr_info.star_addr = fnp_addr; /* Now safe to remember this address as "*" */ 111 expr_info.star_known = "1"b; 112 call db_fnp_display_ (corep, fnp, fnp_addr, disp_len, addr (fnp_buf), disp_type, code); 113 if code ^= 0 then call com_err_ (code, "", "Unable to display memory."); 114 return; 115 116 /* Entry to patch memory */ 117 118 patch: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 119 120 call setup; 121 122 call get_operand_req ("Address"); 123 call cv_expr_op; 124 fnp_addr = expr_val; 125 patch_command2: 126 fnp_len = 0; 127 call get_operand_req ("Data word"); 128 do while (^cmd_info.endline); 129 if ^cmd_info.opstring then do; /* If not a quoted string */ 130 if fnp_len >= 32 then do; 131 long_patch: call ioa_ ("Too much data"); 132 go to error_return; 133 end; 134 call cv_expr_op; 135 code = expr_val; /* Move into full word area */ 136 fnp_buf (fnp_len) = substr (unspec (code), 19, 18); 137 fnp_len = fnp_len + 1; 138 end; 139 else do; /* Do a character patch */ 140 i = length (operand); 141 i = i + mod (i, 2); /* Round to full words */ 142 if i = 0 then i = 2; 143 if (fnp_len + divide (i, 2, 17, 0)) > 32 then go to long_patch; 144 addr (fnp_buf (fnp_len)) -> based_char = operand; 145 fnp_len = fnp_len + divide (i, 2, 17, 0); 146 end; 147 call get_operand; 148 end; 149 expr_info.star_addr = fnp_addr; /* Remember location as "*" */ 150 expr_info.star_known = "1"b; 151 call store (fnp_addr, fnp_len, addr (fnp_buf)); 152 return; 153 154 155 /* Entry to do the = command, equivalent to patch * */ 156 157 equal: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 158 159 call setup; 160 161 if ^expr_info.star_known then do; 162 call ioa_ ("Value of ""*"" not known."); 163 go to error_return; 164 end; 165 fnp_addr = expr_info.star_addr; 166 go to patch_command2; 167 168 /* Entries for dealing with buffers */ 169 170 buffer: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 171 172 call setup; 173 174 call parse_buffer_command; 175 call display_buffer; 176 177 return; 178 179 180 buffer_chain: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 181 182 call setup; 183 184 call parse_buffer_command; 185 call display_buffer; 186 do while (next_buf_addr ^= 0); 187 call ioa_ (""); 188 call display_buffer; 189 end; 190 return; 191 192 /* Entries for dealing with blocks chained together */ 193 194 block: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 195 196 call setup; 197 198 call parse_block_command; 199 call display_block; 200 201 return; 202 203 block_chain: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 204 205 call setup; 206 207 call parse_block_command; 208 call display_block; 209 do while (next_block_addr ^= 0); 210 call ioa_ (""); 211 call display_block; 212 end; 213 return; 214 215 216 forget: entry; 217 218 next_buf_addr, next_block_addr, block_offset = 0; 219 block_length = 8; 220 221 return; 222 223 /* Procudure to parse commands like buffer and buffer_chain */ 224 225 parse_buffer_command: proc; 226 227 dcl got_addr bit (1) init ("0"b); 228 229 type_sw = "0"b; 230 disp_type = type_char; 231 brief_sw = "0"b; 232 call get_operand; 233 do while (^cmd_info.endline); 234 if operand = "brief" | operand = "bf" | operand = "-brief" | operand = "-bf" then do; 235 brief_sw = "1"b; 236 go to next_buffer_operand; 237 end; 238 if ^type_sw then do; 239 call check_type; 240 if type_sw then go to next_buffer_operand; /* Valid type */ 241 end; 242 if ^got_addr then do; 243 call cv_expr_op; 244 next_buf_addr = expr_val; 245 got_addr = "1"b; 246 end; 247 else do; 248 call ioa_ ("Unrecognized operand: ^a", operand); 249 go to error_return; 250 end; 251 next_buffer_operand: call get_operand; 252 end; 253 if ^got_addr then if next_buf_addr = 0 then do; 254 call ioa_ ("No next buffer"); 255 go to error_return; 256 end; 257 return; 258 259 end parse_buffer_command; 260 261 /* Procedure to fetch and display a buffer */ 262 263 display_buffer: proc; 264 265 dcl i fixed bin; 266 dcl nwords fixed bin; 267 268 if (next_buf_addr = 0) | (mod (next_buf_addr, 32) ^= 0) then do; /* Boundary is wrong */ 269 call ioa_ ("Invalid buffer address: ^o", next_buf_addr); 270 go to error_return; 271 end; 272 call fetch (next_buf_addr, 2, addr (fnp_buf)); /* Read header */ 273 if brief_sw then nwords = 2; /* If brief, thats all */ 274 else do; 275 nwords = 32 * (bin (substr (fnp_buf (1), 1, 3)) + 1); /* Calc word count of buffer */ 276 call fetch (next_buf_addr + 2, nwords - 2, addr (fnp_buf (2))); /* Read rest of buffer */ 277 end; 278 expr_info.star_addr = next_buf_addr; 279 expr_info.star_known = "1"b; 280 i = next_buf_addr; 281 next_buf_addr = bin (fnp_buf (0)); 282 call db_fnp_display_ (corep, fnp, i, nwords, addr (fnp_buf), disp_type, code); 283 if code ^= 0 then do; 284 call com_err_ (code, "", "Unable to display memory."); 285 go to error_return; 286 end; 287 return; 288 289 end display_buffer; 290 291 /* Procedure to parse command lines for block and block_chain commands */ 292 293 parse_block_command: proc; 294 295 dcl new_block_addr fixed bin; 296 dcl new_block_length fixed bin; 297 dcl new_block_offset fixed bin; 298 dcl got_addr bit (1); 299 300 call get_operand; 301 if cmd_info.endline then do; 302 if next_block_addr = 0 then do; 303 call ioa_ ("No block address."); 304 go to error_return; 305 end; 306 else return; 307 end; 308 new_block_offset = 0; 309 new_block_length = 8; 310 new_block_addr = next_block_addr; 311 got_addr = "0"b; 312 do while (^cmd_info.endline); 313 if operand = "-offset" | operand = "-o" then do; 314 call get_operand_req ("Offset"); 315 call cv_expr_op; 316 if expr_val < 0 | expr_val > 2044 then do; 317 call ioa_ ("Invalid offset: ^a", operand); 318 go to error_return; 319 end; 320 new_block_offset = expr_val; 321 end; 322 else if operand = "-length" | operand = "-l" then do; 323 call get_operand_req ("Length"); 324 call cv_length_op; 325 new_block_length = expr_val; 326 end; 327 else if ^got_addr then do; 328 call cv_expr_op; 329 new_block_addr = expr_val; 330 got_addr = "1"b; 331 end; 332 else do; 333 call ioa_ ("Unrecognized operand: ^a", operand); 334 go to error_return; 335 end; 336 call get_operand; 337 end; 338 339 if new_block_offset >= new_block_length then do; 340 call ioa_ ("Offset greater than block length"); 341 go to error_return; 342 end; 343 if new_block_addr = 0 then do; 344 call ioa_ ("No block address"); 345 go to error_return; 346 end; 347 next_block_addr = new_block_addr; 348 block_length = new_block_length; 349 block_offset = new_block_offset; 350 return; 351 352 end parse_block_command; 353 354 /* Procedure to display a block for block and block chain commands */ 355 356 display_block: proc; 357 358 dcl i fixed bin; 359 360 if next_block_addr = 0 then do; 361 call ioa_ ("No next block address"); 362 go to error_return; 363 end; 364 call fetch (next_block_addr, block_length, addr (fnp_buf)); 365 expr_info.star_addr = next_block_addr; 366 expr_info.star_known = "1"b; 367 i = next_block_addr; 368 next_block_addr = bin (fnp_buf (block_offset)); 369 call db_fnp_display_ (corep, fnp, i, block_length, addr (fnp_buf), type_oct, code); 370 if code ^= 0 then do; 371 call com_err_ (code, "", "Unable to display memory"); 372 go to error_return; 373 end; 374 return; 375 376 end display_block; 377 378 /* Entry to display a word by interpreting its flags */ 379 380 flags: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 381 382 call setup; 383 384 call get_operand_req ("address"); /* Need address to decode */ 385 if substr (operand, 1, 1) = "=" then do; /* A literal, no memory reference needed */ 386 call db_fnp_eval_ (corep, fnp, substr (operand, 2), expr_infop, "", expr_val, code); 387 if code ^= 0 then go to error_return; 388 unal_temp = expr_val; /* Need unaligned version for unspec */ 389 flag_orig = unspec (unal_temp); 390 flag_name = ""; 391 addr_sw = "0"b; 392 end; 393 else do; /* Must read data from memory */ 394 call cv_expr_op; 395 call fetch (expr_val, 1, addr (fnp_buf)); /* Get word */ 396 flag_orig = fnp_buf (0); 397 flag_name = operand; /* Flag type defaults to first operand */ 398 if flag_name ^= operand then flag_name = ""; /* Unless too long */ 399 addr_sw = "1"b; /* Have address to print */ 400 fnp_addr = expr_val; 401 end; 402 call get_operand; /* Type of flag decoding to do */ 403 if ^cmd_info.endline then flag_name = operand; 404 if flag_name = "" then do; 405 call ioa_ ("No flag type specified"); 406 go to error_return; 407 end; 408 409 symbol_tablep = addr (db_fnp_symbols_$db_fnp_symbols_); 410 found_sw, first_sw = "0"b; 411 flag_work = flag_orig; /* Starting value of word */ 412 do symno = 1 to symbol_table.cnt; /* Scan entire symbol table */ 413 symp = addr (symbol_table.entry (symno)); 414 if sym.flag_mem = flag_name then do; /* Symbol defines a flag in this kind of word */ 415 found_sw = "1"b; 416 if ^first_sw then do; /* Print start of line */ 417 call ioa_$nnl ("^[^5o ^;^s^]^.3b", addr_sw, fnp_addr, flag_orig); 418 first_sw = "1"b; 419 end; 420 temp_word = unspec (sym.value); /* Copy value of symbol */ 421 i = index (temp_word, "1"b); /* Find first 1 bit */ 422 if i = 0 then go to check_next_sym; /* All zero value useless here */ 423 substr (temp_word, i, 1) = "0"b; /* Turn off first bit */ 424 if temp_word then do; /* Symbol is a multiple bit symbol */ 425 nbits = 1; 426 do j = i+1 to 18 while (temp_word); /* First, count the bits */ 427 substr (temp_word, j, 1) = "0"b; 428 nbits = nbits + 1; 429 end; 430 mask = unspec (sym.value); 431 temp_word = flag_orig & mask; /* Isolate origional value of symbol */ 432 if sym.type = type_oct then call ioa_$nnl (" ^a=^.3b", sym.name, copy ("0"b, mod (3 - mod (nbits, 3), 3)) || substr (temp_word, i, nbits)); 433 else call ioa_$nnl (" ^a=^b", sym.name, substr (temp_word, i, nbits)); 434 flag_work = flag_work & ^mask; /* These bits have been explained */ 435 end; 436 else do; /* Simpler case, flag is a single bit */ 437 temp_word = unspec (sym.value); 438 if temp_word & flag_work then do; /* Bit is on */ 439 call ioa_$nnl (" ^a", sym.name); 440 sw = "0"b; 441 do i = symno+1 to symbol_table.cnt; /* Scan rest of table for synonyms */ 442 symp = addr (symbol_table.entry (i)); 443 if (unspec (sym.value) = temp_word) & (sym.flag_mem = flag_name) then do; /* Got one */ 444 call ioa_$nnl (" ^[^;(^]^a", sw, sym.name); 445 sw = "1"b; 446 end; 447 end; 448 if sw then call ioa_$nnl (")"); /* Close list of synonyms */ 449 end; 450 flag_work = flag_work & ^temp_word; /* Flag is identified */ 451 end; 452 end; 453 check_next_sym: 454 end; 455 456 if ^found_sw then do; 457 call ioa_ ("No flags found in symbol_table for ^a", flag_name); 458 go to error_return; 459 end; 460 if addr_sw then do; 461 expr_info.star_addr = fnp_addr; 462 expr_info.star_known = "1"b; /* Remember flag addres as "*" */ 463 end; 464 if ^first_sw then call ioa_ ("^[^5o ^;^s^]^.3b", addr_sw, fnp_addr, flag_orig); 465 else call ioa_ (""); 466 if flag_work then call ioa_ ("No flags defined for ^.3b", flag_work); 467 return; 468 469 /* Commands for setting and clearing flags */ 470 471 set_flag: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 472 473 set_flag_sw = "1"b; 474 go to join_clear_flag; 475 476 clear_flag: entry (arg_corep, arg_fnp, arg_cmd_infop, arg_expr_infop); 477 478 set_flag_sw = "0"b; 479 join_clear_flag: 480 call setup; 481 482 call get_operand_req ("Flag"); 483 call db_fnp_sym_util_$lookup (operand, symp); 484 if symp = null () then do; 485 call ioa_ ("Undefined symbol: ^a", operand); 486 go to error_return; 487 end; 488 if sym.flag_mem = "" then do; 489 call ioa_ ("Symbol is not a flag: ^a", operand); 490 go to error_return; 491 end; 492 493 call db_fnp_eval_ (corep, fnp, sym.flag_mem, expr_infop, "", expr_val, code); 494 if code ^= 0 then go to error_return; 495 496 call fetch (expr_val, 1, addr (fnp_buf)); /* Read old word value */ 497 expr_info.star_addr = expr_val; 498 expr_info.star_known = "1"b; 499 if set_flag_sw then fnp_buf (0) = fnp_buf (0) | unspec (sym.value); 500 else fnp_buf (0) = fnp_buf (0) & ^unspec (sym.value); 501 call store (expr_val, 1, addr (fnp_buf)); 502 return; 503 504 error_return: 505 cmd_info.flush = "1"b; 506 return; 507 508 /* Procedure to extract 1 operand from the command line */ 509 510 get_operand: proc; 511 512 call db_fnp_reader_$get_operand (cmd_infop); 513 if cmd_info.error then go to error_return; 514 return; 515 516 end get_operand; 517 518 get_operand_req: proc (s); 519 520 dcl s char (*); 521 522 call get_operand; 523 if cmd_info.endline then do; 524 call ioa_ ("^a missing.", s); 525 go to error_return; 526 end; 527 else return; 528 529 end get_operand_req; 530 531 /* Procedure to convert an operand intended to be a length */ 532 533 cv_length_op: proc; 534 535 call cv_expr_op; 536 if (expr_val < 1) | (expr_val > 2044) then do; 537 call ioa_ ("Invalid length: ^a", operand); 538 go to error_return; 539 end; 540 return; 541 542 end cv_length_op; 543 544 /* Procedure called when operand is an expression */ 545 546 cv_expr_op: proc; 547 548 call db_fnp_eval_ (corep, fnp, operand, expr_infop, "", expr_val, code); 549 if code ^= 0 then go to error_return; 550 else return; 551 552 end cv_expr_op; 553 554 /* Read some fnp words */ 555 556 fetch: proc (a, l, p); 557 558 dcl a fixed bin; /* Address to read */ 559 dcl l fixed bin; /* Length to read */ 560 dcl p ptr; /* Where to put it */ 561 562 call db_fnp_memory_$fetch (corep, fnp, a, l, p, code); 563 if code ^= 0 then do; 564 call com_err_ (code, "", "Unable to read fnp memory."); 565 go to error_return; 566 end; 567 else return; 568 569 store: entry (a, l, p); 570 571 call db_fnp_memory_$store (corep, fnp, a, l, p, "", 2, code); 572 if code ^= 0 then do; 573 call com_err_ (code, "", "Unable to patch memory"); 574 go to error_return; 575 end; 576 577 578 end fetch; 579 580 /* Setup arguments */ 581 582 setup: proc; 583 584 corep = arg_corep; 585 fnp = arg_fnp; 586 cmd_infop = arg_cmd_infop; 587 expr_infop = arg_expr_infop; 588 return; 589 590 end setup; 591 592 /* Procedure to check operand for valid display type */ 593 594 check_type: proc; 595 596 dcl i fixed bin; 597 598 do i = lbound (long_type_names, 1) to hbound (long_type_names, 1); 599 if operand = short_type_names (i) | operand = long_type_names (i) 600 | operand = "-" || short_type_names (i) | operand = "-" || long_type_names (i) then do; 601 type_sw = "1"b; 602 disp_type = i; 603 return; 604 end; 605 end; 606 return; 607 608 end check_type; 609 610 1 1 /* Begin include file ..... debug_fnp_data.incl.pl1 */ 1 2 1 3 /* Describes various structures used by the debug_fnp command */ 1 4 1 5 /* Written February 1977 by Larry Johnson */ 1 6 1 7 /* Structures describing a symbol table used by the debug_fnp command, 1 8* to find values for common FNP symbols. */ 1 9 1 10 dcl db_fnp_symbols_$db_fnp_symbols_ ext; 1 11 1 12 dcl symbol_tablep ptr; 1 13 1 14 dcl 1 symbol_table aligned based (symbol_tablep), 1 15 2 cnt fixed bin, /* Number of entries */ 1 16 2 maxcnt fixed bin, /* Max count */ 1 17 2 entry (symbol_table.cnt) unal, 1 18 3 one_symbol like sym unal; 1 19 1 20 dcl symp ptr; /* Pointer to one symbol */ 1 21 1 22 dcl 1 sym unal based (symp), 1 23 2 name char (6), 1 24 2 value fixed bin (17), 1 25 2 len fixed bin (17), /* Number of words */ 1 26 2 reloc fixed bin (17), 1 27 2 type fixed bin (17), 1 28 2 flag_mem char (6), /* If non blank, name of word in which this is a flag */ 1 29 2 explain bit (18), /* Offset to explanation for symbol */ 1 30 2 pad bit (18); 1 31 1 32 dcl exptextp ptr; 1 33 1 34 dcl 1 exptext aligned based (exptextp), /* Symbol explanation entry */ 1 35 2 len fixed bin (8) unal, 1 36 2 data char (exptext.len) unal; 1 37 1 38 /* Values for sym.reloc, which is relocation required to find the symbol */ 1 39 1 40 dcl (reloc_abs init (0), /* Value is absolute */ 1 41 reloc_tib init (1), /* Value is relative to current tib addr */ 1 42 reloc_hwcm init (2), /* Value is relative to current hwcm */ 1 43 reloc_sfcm init (3), /* Value is relative to software comm region */ 1 44 reloc_meters init (4)) /* Value is relative to tib meters */ 1 45 int static options (constant); 1 46 1 47 /* Values for sym.type, which is the mode to be used in displaying symbol */ 1 48 1 49 dcl (type_oct init (0), /* Octal, default for most symbols */ 1 50 type_char init (1), /* Ascii characters */ 1 51 type_addr init (2), /* Address to be converted to mod|offset */ 1 52 type_clock init (3), /* Multics clock value */ 1 53 type_inst init (4), /* Machine instruction */ 1 54 type_op init (5), /* Interpreter opblock format */ 1 55 type_dec init (6), /* Decimal */ 1 56 type_bit init (7), /* In bits */ 1 57 type_ebcdic init (8)) /* 8-bit ebcdic characters */ 1 58 int static options (constant); 1 59 1 60 dcl long_type_names (0:8) char (12) int static options (constant) init ( 1 61 "octal", "character", "address", "clock", "instruction", "opblock", "decimal", "bit", "ebcdic"); 1 62 dcl short_type_names (0:8) char (4) int static options (constant) init ( 1 63 "oct", "ch", "addr", "ck", "inst", "op", "dec", "bit", "ebc"); 1 64 1 65 1 66 /* Structure of suplmental data used in evaluating expressions */ 1 67 1 68 dcl expr_infop ptr; 1 69 1 70 dcl 1 expr_info aligned based (expr_infop), 1 71 2 flags, 1 72 3 star_known bit (1) unal, /* Value of "*" is known */ 1 73 3 tib_known bit (1) unal, /* TIB addresses may be used */ 1 74 3 hwcm_known bit (1) unal, /* HWCM address may be used */ 1 75 3 sfcm_known bit (1) unal, /* SFCM address may be used */ 1 76 3 pad bit (32) unal, 1 77 2 star_addr fixed bin, /* Value of "*" */ 1 78 2 tib_addr fixed bin, /* Address of TIB */ 1 79 2 hwcm_addr fixed bin, /* Address of HWCM */ 1 80 2 sfcm_addr fixed bin, /* Address of SFCM */ 1 81 2 type fixed bin, /* Expression type (mode for printing) */ 1 82 2 len fixed bin, /* Implied length of expression */ 1 83 2 user_tablep ptr; /* Pointer to a user symbol table */ 1 84 1 85 1 86 /* Structure of opcode table of machine instructions */ 1 87 1 88 dcl db_fnp_opcodes_$ ext; 1 89 1 90 dcl optablep ptr; 1 91 1 92 dcl 1 optable aligned based (optablep), 1 93 2 cnt fixed bin, 1 94 2 entry (optable.cnt) unal, 1 95 3 one_op like op; 1 96 1 97 dcl opp ptr; 1 98 1 99 dcl 1 op unal based (opp), 1 100 2 name char (6), /* The mneumonic */ 1 101 2 code bit (12), /* The opcode */ 1 102 2 mask bit (12), /* Mask that says where the opcode is */ 1 103 2 type fixed bin (11), /* Type of display required */ 1 104 2 pad bit (18); 1 105 1 106 /* Values for op.type are: 1 107* 0 - storage reference 1 108* 1 - non-storage reference (immediate), 1 109* 2 - non-storage reference (iacxn only), 1 110* 3 - non-storage reference (shifts), 1 111* 4 - non-storage reference (no operands) */ 1 112 1 113 1 114 /* Stuctures used while parsing commands into operands */ 1 115 1 116 dcl cmd_infop ptr; 1 117 1 118 dcl 1 cmd_info aligned based (cmd_infop), 1 119 2 inbuf char (256), /* For reading lines */ 1 120 2 opbuf char (256), /* Used for operand in undoubling quotes */ 1 121 2 commandp ptr, /* Address of unparsed part of command */ 1 122 2 commandl fixed bin, /* Length of unparsed part */ 1 123 2 operandp ptr, /* Address of current operand */ 1 124 2 operandl fixed bin, /* And its length */ 1 125 2 error bit (1), /* Set if error parsing operand */ 1 126 2 endline bit (1), /* Set if no more operands on line */ 1 127 2 opstring bit (1), /* Set if operand was unquoted string */ 1 128 2 flush bit (1), /* If set, rest of input line will be ignored */ 1 129 2 envp ptr; /* Pointer to the debug_fnp environment structure */ 1 130 1 131 dcl command char (cmd_info.commandl) based (cmd_info.commandp); 1 132 dcl operand char (cmd_info.operandl) based (cmd_info.operandp); 1 133 1 134 /* The following structure describes the current debug_fnp environment. */ 1 135 /* It specifies whether we are working on a dump, fnp, core image, etc. */ 1 136 1 137 dcl envp ptr; 1 138 1 139 dcl 1 env aligned based (envp), 1 140 2 corep ptr, /* Ptr to current dump or core-image. Null means live FNP */ 1 141 2 fnp fixed bin, /* Current fnp number */ 1 142 2 dump_dir char (168) unal, /* Directory where dumps are found */ 1 143 2 dir char (168) unal, /* Directory for current dump or core image */ 1 144 2 ename char (32) unal, /* Ename for current dump or core image */ 1 145 2 tty_name char (32), /* Name of current channel */ 1 146 2 segp ptr, /* Pointer to base of current segment */ 1 147 2 flags unal, 1 148 3 fnps_configured bit (8), /* Says which FNP's appear in config deck */ 1 149 3 fnp_sw bit (1), /* 1 if currently working on fnp */ 1 150 3 image_sw bit (1), /* 1 if currently working on a core-image */ 1 151 3 dump_sw bit (1), /* 1 if current working on a dump */ 1 152 3 fdump_sw bit (1), /* 1 if current dump is a fdump */ 1 153 3 pad bit (24), 1 154 2 dump_time fixed bin (71); /* Clock time dump occured */ 1 155 1 156 /* Structure of data defining table of interpreter opblock names */ 1 157 1 158 dcl db_fnp_opblocks_$ ext; 1 159 1 160 dcl opblock_tablep ptr; 1 161 1 162 dcl 1 opblock_table aligned based (opblock_tablep), 1 163 2 cnt fixed bin, 1 164 2 name (0:opblock_table.cnt) char (6) unal; 1 165 1 166 /* End include file ..... debug_fnp_data.incl.pl1 */ 611 612 613 end db_fnp_disp_cmd_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/82 1501.7 db_fnp_disp_cmd_.pl1 >dumps>old>recomp>db_fnp_disp_cmd_.pl1 611 1 06/19/81 2115.0 debug_fnp_data.incl.pl1 >ldd>include>debug_fnp_data.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. a parameter fixed bin(17,0) dcl 558 set ref 556 562* 569 571* addr builtin function dcl 74 ref 109 109 112 112 144 151 151 272 272 276 276 282 282 364 364 369 369 395 395 409 413 442 496 496 501 501 addr_sw 002114 automatic bit(1) unaligned dcl 37 set ref 391* 399* 417* 460 464* arg_cmd_infop parameter pointer dcl 21 ref 78 118 157 170 180 194 203 380 471 476 586 arg_corep parameter pointer dcl 19 ref 78 118 157 170 180 194 203 380 471 476 584 arg_expr_infop parameter pointer dcl 22 ref 78 118 157 170 180 194 203 380 471 476 587 arg_fnp parameter fixed bin(17,0) dcl 20 ref 78 118 157 170 180 194 203 380 471 476 585 based_char based char unaligned dcl 53 set ref 144* bin builtin function dcl 74 ref 275 281 368 block_length 000012 internal static fixed bin(17,0) initial dcl 59 set ref 219* 348* 364* 369* block_offset 000013 internal static fixed bin(17,0) initial dcl 60 set ref 218* 349* 368 brief_sw 002134 automatic bit(1) unaligned dcl 50 set ref 231* 235* 273 cmd_info based structure level 1 dcl 1-118 cmd_infop 002144 automatic pointer dcl 1-116 set ref 90 101 101 101 128 129 140 140 144 144 233 234 234 234 234 234 234 234 234 248 248 248 301 312 313 313 313 313 317 317 317 322 322 322 322 333 333 333 385 385 386 386 386 386 397 397 398 398 403 403 403 483 483 483 485 485 485 489 489 489 504 512* 513 523 537 537 537 548 548 548 586* 599 599 599 599 599 599 599 599 cnt based fixed bin(17,0) level 2 dcl 1-14 ref 412 441 code 000100 automatic fixed bin(35,0) dcl 26 set ref 112* 113 113* 135* 136 282* 283 284* 369* 370 371* 386* 387 493* 494 548* 549 562* 563 564* 571* 572 573* com_err_ 000034 constant entry external dcl 72 ref 113 284 371 564 573 copy builtin function dcl 74 ref 432 corep 000102 automatic pointer dcl 27 set ref 112* 282* 369* 386* 493* 548* 562* 571* 584* db_fnp_display_ 000030 constant entry external dcl 70 ref 112 282 369 db_fnp_eval_ 000020 constant entry external dcl 66 ref 386 493 548 db_fnp_memory_$fetch 000024 constant entry external dcl 68 ref 562 db_fnp_memory_$store 000026 constant entry external dcl 69 ref 571 db_fnp_reader_$get_operand 000022 constant entry external dcl 67 ref 512 db_fnp_sym_util_$lookup 000032 constant entry external dcl 71 ref 483 db_fnp_symbols_$db_fnp_symbols_ 000036 external static fixed bin(17,0) dcl 1-10 set ref 409 disp_len 002131 automatic fixed bin(17,0) dcl 47 set ref 86* 97* 109* 112* disp_type 002130 automatic fixed bin(17,0) dcl 46 set ref 85* 108* 112* 230* 282* 602* divide builtin function dcl 74 ref 143 145 endline 210 based bit(1) level 2 dcl 1-118 ref 90 128 233 301 312 403 523 entry 2 based structure array level 2 packed unaligned dcl 1-14 set ref 413 442 error 207 based bit(1) level 2 dcl 1-118 ref 513 expr_info based structure level 1 dcl 1-70 expr_infop 002142 automatic pointer dcl 1-68 set ref 85 86 110 111 149 150 161 165 278 279 365 366 386* 461 462 493* 497 498 548* 587* expr_val 002112 automatic fixed bin(17,0) dcl 35 set ref 84 97 124 135 244 316 316 320 325 329 386* 388 395* 400 493* 496* 497 501* 536 536 548* first_sw 002115 automatic bit(1) unaligned dcl 38 set ref 410* 416 418* 464 flag_mem 3(18) based char(6) level 2 packed unaligned dcl 1-22 set ref 414 443 488 493* flag_name 002124 automatic char(6) unaligned dcl 43 set ref 390* 397* 398 398* 403* 404 414 443 457* flag_orig 002107 automatic bit(18) unaligned dcl 32 set ref 389* 396* 411 417* 431 464* flag_work 002106 automatic bit(18) unaligned dcl 31 set ref 411* 434* 434 438 450* 450 466 466* flags based structure level 2 dcl 1-70 flush 212 based bit(1) level 2 dcl 1-118 set ref 504* fnp 000104 automatic fixed bin(17,0) dcl 28 set ref 112* 282* 369* 386* 493* 548* 562* 571* 585* fnp_addr 002110 automatic fixed bin(17,0) dcl 33 set ref 84* 109* 110 112* 124* 149 151* 165* 400* 417* 461 464* fnp_buf 000106 automatic bit(18) array unaligned dcl 30 set ref 109 109 112 112 136* 144 151 151 272 272 275 276 276 281 282 282 364 364 368 369 369 395 395 396 496 496 499* 499 500* 500 501 501 fnp_len 002111 automatic fixed bin(17,0) dcl 34 set ref 125* 130 136 137* 137 143 144 145* 145 151* found_sw 002116 automatic bit(1) unaligned dcl 39 set ref 410* 415* 456 got_addr 002201 automatic bit(1) unaligned dcl 298 in procedure "parse_block_command" set ref 311* 327 330* got_addr 002156 automatic bit(1) initial unaligned dcl 227 in procedure "parse_buffer_command" set ref 227* 242 245* 253 hbound builtin function dcl 74 ref 598 i 002166 automatic fixed bin(17,0) dcl 265 in procedure "display_buffer" set ref 280* 282* i 002210 automatic fixed bin(17,0) dcl 358 in procedure "display_block" set ref 367* 369* i 002117 automatic fixed bin(17,0) dcl 40 in procedure "db_fnp_disp_cmd_" set ref 140* 141* 141 141 142 142* 143 144 145 421* 422 423 426 432 433 433 441* 442* i 002264 automatic fixed bin(17,0) dcl 596 in procedure "check_type" set ref 598* 599 599 599 599 602* index builtin function dcl 74 ref 421 ioa_ 000014 constant entry external dcl 64 ref 101 131 162 187 210 248 254 269 303 317 333 340 344 361 405 457 464 465 466 485 489 524 537 ioa_$nnl 000016 constant entry external dcl 65 ref 417 432 433 439 444 448 j 002120 automatic fixed bin(17,0) dcl 40 set ref 426* 427* l parameter fixed bin(17,0) dcl 559 set ref 556 562* 569 571* lbound builtin function dcl 74 ref 598 len 6 based fixed bin(17,0) level 2 dcl 1-70 ref 86 length builtin function dcl 74 ref 140 length_sw 002133 automatic bit(1) unaligned dcl 49 set ref 87* 95 98* 108 long_type_names 000011 constant char(12) initial array unaligned dcl 1-60 ref 598 598 599 599 mask 002121 automatic bit(18) unaligned dcl 41 set ref 430* 431 434 mod builtin function dcl 74 ref 141 268 432 432 name based char(6) level 2 packed unaligned dcl 1-22 set ref 432* 433* 439* 444* nbits 002127 automatic fixed bin(17,0) dcl 45 set ref 425* 428* 428 432 432 433 433 new_block_addr 002176 automatic fixed bin(17,0) dcl 295 set ref 310* 329* 343 347 new_block_length 002177 automatic fixed bin(17,0) dcl 296 set ref 309* 325* 339 348 new_block_offset 002200 automatic fixed bin(17,0) dcl 297 set ref 308* 320* 339 349 next_block_addr 000011 internal static fixed bin(17,0) initial dcl 58 set ref 209 218* 302 310 347* 360 364* 365 367 368* next_buf_addr 000010 internal static fixed bin(17,0) initial dcl 57 set ref 186 218* 244* 253 268 268 269* 272* 276 278 280 281* null builtin function dcl 74 ref 484 nwords 002167 automatic fixed bin(17,0) dcl 266 set ref 273* 275* 276 282* op based structure level 1 packed unaligned dcl 1-99 operand based char unaligned dcl 1-132 set ref 101* 140 144 234 234 234 234 248* 313 313 317* 322 322 333* 385 386 386 397 398 403 483* 485* 489* 537* 548* 599 599 599 599 operandl 206 based fixed bin(17,0) level 2 dcl 1-118 ref 101 101 140 144 234 234 234 234 248 248 313 313 317 317 322 322 333 333 385 386 386 397 398 403 483 483 485 485 489 489 537 537 548 548 599 599 599 599 operandp 204 based pointer level 2 dcl 1-118 ref 101 140 144 234 234 234 234 248 313 313 317 322 322 333 385 386 386 397 398 403 483 485 489 537 548 599 599 599 599 opstring 211 based bit(1) level 2 dcl 1-118 ref 129 p parameter pointer dcl 560 set ref 556 562* 569 571* s parameter char unaligned dcl 520 set ref 518 524* set_flag_sw 002135 automatic bit(1) unaligned dcl 51 set ref 473* 478* 499 short_type_names 000000 constant char(4) initial array unaligned dcl 1-62 ref 599 599 star_addr 1 based fixed bin(17,0) level 2 dcl 1-70 set ref 110* 149* 165 278* 365* 461* 497* star_known based bit(1) level 3 packed unaligned dcl 1-70 set ref 111* 150* 161 279* 366* 462* 498* substr builtin function dcl 74 set ref 136 275 385 386 386 423* 427* 432 433 433 sw 002113 automatic bit(1) unaligned dcl 36 set ref 440* 444* 445* 448 sym based structure level 1 packed unaligned dcl 1-22 symbol_table based structure level 1 dcl 1-14 symbol_tablep 002136 automatic pointer dcl 1-12 set ref 409* 412 413 441 442 symno 002126 automatic fixed bin(17,0) dcl 44 set ref 412* 413 441* symp 002140 automatic pointer dcl 1-20 set ref 413* 414 420 430 432 432 433 437 439 442* 443 443 444 483* 484 488 493 499 500 temp_word 002122 automatic bit(18) unaligned dcl 42 set ref 420* 421 423* 424 426 427* 431* 432 433 433 437* 438 443 450 type 3 based fixed bin(17,0) level 2 in structure "sym" packed unaligned dcl 1-22 in procedure "db_fnp_disp_cmd_" ref 432 type 5 based fixed bin(17,0) level 2 in structure "expr_info" dcl 1-70 in procedure "db_fnp_disp_cmd_" ref 85 type_char constant fixed bin(17,0) initial dcl 1-49 ref 230 type_oct 000106 constant fixed bin(17,0) initial dcl 1-49 set ref 108 369* 432 type_sw 002132 automatic bit(1) unaligned dcl 48 set ref 88* 91 93 108 229* 238 240 601* unal_temp 000105 automatic fixed bin(17,0) unaligned dcl 29 set ref 388* 389 unspec builtin function dcl 74 ref 136 389 420 430 437 443 499 500 value 1(18) based fixed bin(17,0) level 2 packed unaligned dcl 1-22 ref 420 430 437 443 499 500 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. command based char unaligned dcl 1-131 db_fnp_opblocks_$ external static fixed bin(17,0) dcl 1-158 db_fnp_opcodes_$ external static fixed bin(17,0) dcl 1-88 env based structure level 1 dcl 1-139 envp automatic pointer dcl 1-137 exptext based structure level 1 dcl 1-34 exptextp automatic pointer dcl 1-32 opblock_table based structure level 1 dcl 1-162 opblock_tablep automatic pointer dcl 1-160 opp automatic pointer dcl 1-97 optable based structure level 1 dcl 1-92 optablep automatic pointer dcl 1-90 reloc_abs internal static fixed bin(17,0) initial dcl 1-40 reloc_hwcm internal static fixed bin(17,0) initial dcl 1-40 reloc_meters internal static fixed bin(17,0) initial dcl 1-40 reloc_sfcm internal static fixed bin(17,0) initial dcl 1-40 reloc_tib internal static fixed bin(17,0) initial dcl 1-40 type_addr internal static fixed bin(17,0) initial dcl 1-49 type_bit internal static fixed bin(17,0) initial dcl 1-49 type_clock internal static fixed bin(17,0) initial dcl 1-49 type_dec internal static fixed bin(17,0) initial dcl 1-49 type_ebcdic internal static fixed bin(17,0) initial dcl 1-49 type_inst internal static fixed bin(17,0) initial dcl 1-49 type_op internal static fixed bin(17,0) initial dcl 1-49 NAMES DECLARED BY EXPLICIT CONTEXT. block 001011 constant entry external dcl 194 block_chain 001024 constant entry external dcl 203 buffer 000746 constant entry external dcl 170 buffer_chain 000761 constant entry external dcl 180 check_next_sym 001714 constant label dcl 453 ref 422 check_type 003605 constant entry internal dcl 594 ref 92 239 clear_flag 002055 constant entry external dcl 476 cv_expr_op 003346 constant entry internal dcl 546 ref 83 123 134 243 315 328 394 535 cv_length_op 003311 constant entry internal dcl 533 ref 96 324 db_fnp_disp_cmd_ 000344 constant entry external dcl 15 display 000357 constant entry external dcl 78 display_block 003100 constant entry internal dcl 356 ref 199 208 211 display_buffer 002446 constant entry internal dcl 263 ref 175 185 188 display_command2 000455 constant label dcl 104 ref 93 equal 000712 constant entry external dcl 157 error_return 002311 constant label dcl 504 ref 102 132 163 249 255 270 285 304 318 334 341 345 362 372 387 406 458 486 490 494 513 525 538 549 565 574 fetch 003415 constant entry internal dcl 556 ref 109 272 276 364 395 496 flags 001071 constant entry external dcl 380 forget 001053 constant entry external dcl 216 get_operand 003233 constant entry internal dcl 510 ref 89 104 147 232 251 300 336 402 522 get_operand_req 003247 constant entry internal dcl 518 ref 82 122 127 314 323 384 482 join_clear_flag 002063 constant label dcl 479 ref 474 long_patch 000612 constant label dcl 131 ref 143 next_buffer_operand 002417 constant label dcl 251 ref 236 240 parse_block_command 002633 constant entry internal dcl 293 ref 198 207 parse_buffer_command 002315 constant entry internal dcl 225 ref 174 184 patch 000554 constant entry external dcl 118 patch_command2 000572 constant label dcl 125 ref 166 set_flag 002043 constant entry external dcl 471 setup 003567 constant entry internal dcl 582 ref 80 120 159 172 182 196 205 382 479 store 003471 constant entry internal dcl 569 ref 151 501 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4222 4262 3772 4232 Length 4542 3772 40 244 230 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME db_fnp_disp_cmd_ 1534 external procedure is an external procedure. parse_buffer_command internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. display_buffer internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. parse_block_command internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. display_block internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. get_operand internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. get_operand_req internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. cv_length_op internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. cv_expr_op internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. fetch internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. setup internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. check_type internal procedure shares stack frame of external procedure db_fnp_disp_cmd_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 next_buf_addr db_fnp_disp_cmd_ 000011 next_block_addr db_fnp_disp_cmd_ 000012 block_length db_fnp_disp_cmd_ 000013 block_offset db_fnp_disp_cmd_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME db_fnp_disp_cmd_ 000100 code db_fnp_disp_cmd_ 000102 corep db_fnp_disp_cmd_ 000104 fnp db_fnp_disp_cmd_ 000105 unal_temp db_fnp_disp_cmd_ 000106 fnp_buf db_fnp_disp_cmd_ 002106 flag_work db_fnp_disp_cmd_ 002107 flag_orig db_fnp_disp_cmd_ 002110 fnp_addr db_fnp_disp_cmd_ 002111 fnp_len db_fnp_disp_cmd_ 002112 expr_val db_fnp_disp_cmd_ 002113 sw db_fnp_disp_cmd_ 002114 addr_sw db_fnp_disp_cmd_ 002115 first_sw db_fnp_disp_cmd_ 002116 found_sw db_fnp_disp_cmd_ 002117 i db_fnp_disp_cmd_ 002120 j db_fnp_disp_cmd_ 002121 mask db_fnp_disp_cmd_ 002122 temp_word db_fnp_disp_cmd_ 002124 flag_name db_fnp_disp_cmd_ 002126 symno db_fnp_disp_cmd_ 002127 nbits db_fnp_disp_cmd_ 002130 disp_type db_fnp_disp_cmd_ 002131 disp_len db_fnp_disp_cmd_ 002132 type_sw db_fnp_disp_cmd_ 002133 length_sw db_fnp_disp_cmd_ 002134 brief_sw db_fnp_disp_cmd_ 002135 set_flag_sw db_fnp_disp_cmd_ 002136 symbol_tablep db_fnp_disp_cmd_ 002140 symp db_fnp_disp_cmd_ 002142 expr_infop db_fnp_disp_cmd_ 002144 cmd_infop db_fnp_disp_cmd_ 002156 got_addr parse_buffer_command 002166 i display_buffer 002167 nwords display_buffer 002176 new_block_addr parse_block_command 002177 new_block_length parse_block_command 002200 new_block_offset parse_block_command 002201 got_addr parse_block_command 002210 i display_block 002264 i check_type THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs alloc_bs cat_realloc_bs call_ext_out_desc call_ext_out return mpfx2 mod_fx1 shorten_stack ext_entry index_bs_1_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ db_fnp_display_ db_fnp_eval_ db_fnp_memory_$fetch db_fnp_memory_$store db_fnp_reader_$get_operand db_fnp_sym_util_$lookup ioa_ ioa_$nnl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. db_fnp_symbols_$db_fnp_symbols_ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 15 000343 78 000351 80 000364 82 000365 83 000372 84 000373 85 000375 86 000400 87 000402 88 000403 89 000404 90 000405 91 000410 92 000412 93 000413 95 000415 96 000417 97 000420 98 000422 99 000424 101 000425 102 000454 104 000455 106 000456 108 000457 109 000465 110 000471 111 000474 112 000476 113 000523 114 000551 118 000552 120 000561 122 000562 123 000567 124 000570 125 000572 127 000573 128 000602 129 000605 130 000607 131 000612 132 000631 134 000632 135 000633 136 000635 137 000642 138 000643 140 000644 141 000646 142 000651 143 000655 144 000662 145 000672 147 000674 148 000675 149 000676 150 000701 151 000703 152 000707 157 000710 159 000717 161 000720 162 000723 163 000737 165 000740 166 000743 170 000744 172 000753 174 000754 175 000755 177 000756 180 000757 182 000766 184 000767 185 000770 186 000771 187 000774 188 001004 189 001005 190 001006 194 001007 196 001016 198 001017 199 001020 201 001021 203 001022 205 001031 207 001032 208 001033 209 001034 210 001037 211 001047 212 001050 213 001051 216 001052 218 001060 219 001064 221 001066 380 001067 382 001076 384 001077 385 001104 386 001112 387 001162 388 001165 389 001170 390 001173 391 001175 392 001176 394 001177 395 001200 396 001206 397 001210 398 001216 399 001225 400 001227 402 001231 403 001232 404 001242 405 001252 406 001266 409 001267 410 001272 411 001274 412 001277 413 001306 414 001312 415 001316 416 001320 417 001322 418 001352 420 001354 421 001361 422 001366 423 001367 424 001372 425 001375 426 001377 427 001410 428 001413 429 001414 430 001416 431 001423 432 001427 433 001511 434 001545 435 001555 437 001556 438 001561 439 001570 440 001607 441 001610 442 001620 443 001624 444 001634 445 001662 447 001664 448 001666 450 001704 453 001714 456 001716 457 001720 458 001740 460 001741 461 001744 462 001747 464 001751 465 002004 466 002015 467 002040 471 002041 473 002050 474 002052 476 002053 478 002062 479 002063 482 002064 483 002071 484 002112 485 002116 486 002145 488 002146 489 002153 490 002177 493 002200 494 002241 496 002243 497 002251 498 002254 499 002256 500 002267 501 002302 502 002310 504 002311 506 002314 225 002315 227 002316 229 002317 230 002320 231 002322 232 002323 233 002324 234 002327 235 002351 236 002353 238 002354 239 002356 240 002357 242 002361 243 002363 244 002364 245 002367 246 002371 248 002372 249 002416 251 002417 252 002420 253 002421 254 002426 255 002444 257 002445 263 002446 268 002447 269 002455 270 002474 272 002475 273 002513 275 002520 276 002531 278 002544 279 002550 280 002552 281 002554 282 002557 283 002603 284 002605 285 002631 287 002632 293 002633 300 002634 301 002635 302 002640 303 002643 304 002656 306 002657 308 002660 309 002661 310 002663 311 002666 312 002667 313 002672 314 002704 315 002711 316 002712 317 002716 318 002745 320 002746 321 002747 322 002750 323 002760 324 002765 325 002766 326 002770 327 002771 328 002773 329 002774 330 002776 331 003000 333 003001 334 003024 336 003025 337 003026 339 003027 340 003032 341 003046 343 003047 344 003051 345 003070 347 003071 348 003073 349 003075 350 003077 356 003100 360 003101 361 003104 362 003117 364 003120 365 003134 366 003140 367 003142 368 003144 369 003154 370 003200 371 003202 372 003231 374 003232 510 003233 512 003234 513 003243 514 003246 518 003247 522 003260 523 003261 524 003264 525 003307 527 003310 533 003311 535 003312 536 003313 537 003320 538 003344 540 003345 546 003346 548 003347 549 003412 550 003414 556 003415 562 003417 563 003441 564 003443 565 003467 567 003470 569 003471 571 003473 572 003537 573 003541 574 003565 578 003566 582 003567 584 003570 585 003574 586 003576 587 003601 588 003604 594 003605 598 003606 599 003612 601 003657 602 003662 603 003664 605 003665 606 003667 ----------------------------------------------------------- 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