COMPILATION LISTING OF SEGMENT mst_tools_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 07/16/87 1337.2 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* *********************************************************** */ 8 9 /* format: style2 */ 10 11 mst_tools_: 12 procedure; 13 14 /* NOT A RETAINED ENTRYPOINT */ 15 16 copy_mst: 17 entry; 18 function = "copy_mst"; 19 severityp = addr (copy_mst_severity_); 20 go to join; 21 excerpt_mst: 22 entry; 23 function = "excerpt_mst"; 24 severityp = addr (excerpt_mst_severity_); 25 go to join; 26 list_mst: 27 entry; 28 function = "list_mst"; 29 severityp = addr (list_mst_severity_); 30 31 /***** Old style MST utilities, used for BOS tapes (and copying Multics tapes) */ 32 /* from merge_mst. */ 33 /* Bernard Greenberg, 1/12-13/76 34* 10/20/76 for tapes with defs 35* 2/80 by Michael R.Jordan to add call to parse_tape_reel_name_ and fix bugs. 36* Modified so it would compile again, and maybe still work afterwards, 37* 10/21/80 W.Olin Sibert 38* Modified by J.A.Bush to copy boot labels from input to output tapes 39* Modified 10/82 BIM remove merge, write. 40* Modified 05/85 GW May call tape_mult_ in async mode to avoid sync padding. */ 41 42 43 /****^ HISTORY COMMENTS: 44* 1) change(87-01-12,GDixon), approve(87-04-16,MCR7614), 45* audit(87-05-21,Farley), install(87-07-15,MR12.1-1040): 46* Support copying from or to disk file images of a Multics System Tape, in 47* addition to copying from/to tapes. Also, add severity variables to report 48* success/failure of copy/excerpt/list operations. 49* END HISTORY COMMENTS */ 50 51 52 declare check_star_name_$entry entry (character (*), fixed binary (35)); 53 declare cu_$arg_count entry (fixed bin, fixed bin (35)); 54 declare cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 55 declare ( 56 ioa_, 57 com_err_, 58 com_err_$suppress_name 59 ) entry options (variable); 60 declare date_time_ entry (fixed bin (71), char (*)); 61 declare absolute_pathname_ entry (char (*), char (*), fixed bin (35)); 62 declare get_shortest_path_ entry (char (*)) returns (char (168)); 63 declare get_temp_segments_ entry (char (*), (*) ptr, fixed bin (35)); 64 declare get_wdir_ entry returns (char (168)); 65 declare initiate_file_$create entry (char (*), char (*), bit (*), ptr, bit (1) aligned, fixed bin (24), 66 fixed bin (35)); 67 declare object_info_$display entry (ptr, fixed bin (24), ptr, fixed bin (35)); 68 declare pathname_ entry (char (*), char (*)) returns (char (168)); 69 declare parse_tape_reel_name_ entry (char (*), char (*)); 70 declare release_temp_segments_ entry (char (*), (*) ptr, fixed bin (35)); 71 declare terminate_file_ entry (ptr, fixed bin (24), bit (*), fixed bin (35)); 72 declare unique_chars_ entry (bit (*)) returns (char (15)); 73 74 declare ap pointer; 75 declare al fixed bin (21); 76 declare argx fixed bin; 77 declare arg_count fixed bin; 78 declare arg character (al) based (ap); 79 declare optp ptr; 80 declare optl fixed bin (21); 81 declare opt char (optl) based (optp); 82 83 declare boot_label bit (1) aligned; 84 declare code fixed bin (35); 85 declare date_time_compiled char (32); 86 declare function char (32); 87 88 declare (in, out) pointer; 89 declare out_seg_ptr pointer; 90 declare severityp pointer; 91 92 declare temp_seg_ptrs (3) ptr; 93 declare header_ptr pointer defined (temp_seg_ptrs (1)); 94 declare contents_ptr pointer defined (temp_seg_ptrs (2)); 95 declare boot_program_guts_ptr pointer defined (temp_seg_ptrs (3)); 96 97 declare (name_len, seg_len) fixed bin (18) uns unal; 98 declare header_wc fixed bin (18) uns unal; 99 declare copy (seg_len) bit (36) aligned based; 100 101 declare 1 select_list aligned, 102 2 count fixed bin, 103 2 names (get_arg_count ()), 104 3 arg_ptr pointer, 105 3 arg_length fixed bin (21); 106 107 declare atd char (256); 108 declare (in_den, out_den) fixed bin; 109 declare (in_file_name, out_file_name) 110 character (168); 111 declare (in_tape_name, out_tape_name) 112 character (32); 113 declare inout fixed bin, 114 ( 115 UNSET init (0), 116 IN init (1), 117 OUT init (2) 118 ) fixed bin int static options (constant); 119 120 declare (copy_mst_severity_, excerpt_mst_severity_, list_mst_severity_) 121 fixed bin (35) ext static init (0); 122 declare error_table_$bad_arg fixed bin (35) ext static; 123 declare error_table_$badopt fixed bin (35) ext static; 124 declare error_table_$end_of_info 125 fixed bin (35) ext static; 126 declare error_table_$inconsistent 127 fixed bin (35) ext static; 128 declare error_table_$noarg fixed bin (35) ext static; 129 130 dcl cleanup condition; 131 132 dcl 1 control_word aligned, 133 2 type fixed bin (17) unaligned, 134 2 count fixed bin (18) uns unal; 135 136 dcl 1 collection_mark aligned, 137 2 major fixed bin (17) unaligned, 138 2 minor fixed bin (17) unaligned; 139 140 dcl 1 oi like object_info aligned; 141 142 dcl 1 header aligned based (header_ptr), 143 2 slte like slte_uns, 144 2 segnam like segnam; 145 146 dcl severity fixed bin (35) based (severityp); 147 148 declare (expect_seg, expect_link, expect_defs) 149 bit (1) aligned; 150 151 152 declare COPY char (32) init ("copy_mst") int static options (constant); 153 declare LIST char (32) init ("list_mst") int static options (constant); 154 declare EXCERPT char (32) init ("excerpt_mst") int static options (constant); 155 declare (addr, char, codeptr, convert, divide, index, length, ltrim, null, rtrim, size) 156 builtin; 157 158 159 160 join: 161 severity = 4; /* assume error */ 162 call cu_$arg_count (arg_count, code); 163 if code ^= 0 164 then do; 165 call com_err_ (code, function); 166 return; 167 end; 168 169 if arg_count = 0 170 then 171 USAGE: 172 do; 173 if function = COPY 174 then call com_err_$suppress_name (0, function, "Usage: copy_mst INPUT_SPEC OUTPUT_SPEC"); 175 else if function = LIST 176 then call com_err_$suppress_name (0, function, "Usage: list_mst TAPE"); 177 else if function = EXCERPT 178 then call com_err_$suppress_name (0, function, "Usage: excerpt_mst TAPE name1 name2 ... nameN"); 179 return; 180 end; 181 182 boot_label = "0"b; 183 in, out, temp_seg_ptrs = null; /* init for cleanup */ 184 on cleanup call clean_up; 185 186 /* Parse */ 187 188 if function = COPY 189 then if arg_count < 2 190 then go to USAGE; 191 192 in_tape_name, in_file_name, out_tape_name, out_file_name = ""; 193 in_den, out_den = UNSET; 194 inout = UNSET; 195 select_list.count = 0; 196 197 do argx = 1 to arg_count; 198 call cu_$arg_ptr (argx, ap, al, (0)); 199 if index (arg, "-") = 1 200 then do; 201 if arg = "-input_volume" | arg = "-ivol" 202 then do; 203 in_tape_name, in_file_name = ""; 204 inout = IN; 205 if argx = arg_count 206 then do; 207 call com_err_ (error_table_$noarg, function, 208 "^a must be followed by a tape volume name.", arg); 209 go to RETURN; 210 end; 211 else do; 212 argx = argx + 1; 213 call cu_$arg_ptr (argx, optp, optl, (0)); 214 in_tape_name = opt; 215 end; 216 end; 217 else if arg = "-input_file" | arg = "-if" 218 then do; 219 in_tape_name, in_file_name = ""; 220 inout = UNSET; 221 if argx = arg_count 222 then do; 223 call com_err_ (error_table_$noarg, function, 224 "^a must be followed by a file name.", arg); 225 go to RETURN; 226 end; 227 else do; 228 argx = argx + 1; 229 call cu_$arg_ptr (argx, optp, optl, (0)); 230 in_file_name = opt; 231 end; 232 end; 233 else if (arg = "-output_volume" | arg = "-ovol") & function = COPY 234 then do; 235 out_tape_name, out_file_name = ""; 236 inout = OUT; 237 if argx = arg_count 238 then do; 239 call com_err_ (error_table_$noarg, function, 240 "^a must be followed by a tape volume name.", arg); 241 go to RETURN; 242 end; 243 else do; 244 argx = argx + 1; 245 call cu_$arg_ptr (argx, optp, optl, (0)); 246 out_tape_name = opt; 247 end; 248 end; 249 else if (arg = "-output_file" | arg = "-of") & function = COPY 250 then do; 251 out_tape_name, out_file_name = ""; 252 inout = UNSET; 253 if argx = arg_count 254 then do; 255 call com_err_ (error_table_$noarg, function, 256 "^a must be followed by a file name.", arg); 257 go to RETURN; 258 end; 259 else do; 260 argx = argx + 1; 261 call cu_$arg_ptr (argx, optp, optl, (0)); 262 out_file_name = opt; 263 end; 264 end; 265 else if arg = "-density" | arg = "-den" 266 then do; 267 if argx = arg_count 268 then do; 269 call com_err_ (error_table_$noarg, function, 270 "^a must be followed by a tape density.", arg); 271 go to RETURN; 272 end; 273 else do; 274 argx = argx + 1; 275 call cu_$arg_ptr (argx, optp, optl, (0)); 276 if opt = "800" | opt = "1600" | opt = "6250" 277 then do; 278 if inout = IN 279 then in_den = convert (in_den, opt); 280 else if inout = OUT 281 then out_den = convert (in_den, opt); 282 else do; 283 call com_err_ (error_table_$inconsistent, function, 284 "^a ^a must follow either -ivol or -ovol.", arg, 285 opt); 286 go to RETURN; 287 end; 288 end; 289 else do; 290 call com_err_ (error_table_$bad_arg, function, 291 "^a ^a^/Allowed densities are: 800, 1600, 6250.", arg, opt); 292 go to RETURN; 293 end; 294 end; 295 end; 296 else do; 297 call com_err_ (error_table_$badopt, function, arg); 298 go to RETURN; 299 end; 300 end; 301 else if in_tape_name = "" & in_file_name = "" 302 then in_tape_name = arg; 303 else if (out_tape_name = "" & out_file_name = "") & function = COPY 304 then out_tape_name = arg; 305 else if function = LIST | function = EXCERPT 306 then do; 307 call check_star_name_$entry (arg, code); 308 if code ^= 0 & code ^= 1 & code ^= 2 309 then do; 310 call com_err_ (code, function, "^a", arg); 311 go to RETURN; 312 end; 313 select_list.count = select_list.count + 1; 314 select_list.arg_ptr (select_list.count) = ap; 315 select_list.arg_length (select_list.count) = al; 316 end; 317 else do; 318 call com_err_ (error_table_$bad_arg, function, arg); 319 go to RETURN; 320 end; 321 end; 322 323 /* We know what we want */ 324 325 call get_temp_segments_ (function, temp_seg_ptrs, (0)); 326 327 /* There is always an input tape */ 328 329 call get_in_medium (); 330 331 /* Output if copy */ 332 333 if function = COPY 334 then do; 335 call get_out_medium (); 336 end; 337 338 339 /* YET ANOTHER VERSION OF SEGMENT_LOADER */ 340 341 severity = 0; /* no errors now */ 342 expect_seg, expect_link, expect_defs = "0"b; 343 344 loop: 345 call get_data (addr (control_word), size (control_word)); 346 if control_word.type = 0 /* read the control word */ 347 then do; /* header control word */ 348 header_wc = control_word.count; 349 call get_data (header_ptr, header_wc); /* read in header */ 350 expect_seg = "1"b; 351 if function = COPY 352 then do; 353 call put_data (addr (control_word), size (control_word)); 354 call put_data (header_ptr, header_wc); 355 end; 356 357 end; 358 359 else if control_word.type = 1 360 then do; /* A segment */ 361 expect_seg = "0"b; 362 seg_len = control_word.count; 363 call get_data (contents_ptr, seg_len); /* get real seg */ 364 365 if expect_link 366 then do; 367 if ^header.slte.link_sect 368 then call MST_format_error ("missing linkage segment"); 369 370 expect_link = "0"b; 371 expect_defs = "1"b; 372 end; 373 374 else if expect_defs 375 then do; 376 if ^header.slte.defs 377 then call MST_format_error ("missing defs segment"); 378 379 expect_defs = "0"b; 380 381 end; 382 383 else do; 384 if header.slte.defs | header.slte.link_sect 385 then call MST_format_error ("unexpected link or defs segment"); 386 expect_link = header.slte.link_provided; 387 end; 388 389 if function = COPY 390 then do; 391 call put_data (addr (control_word), size (control_word)); 392 call put_data (contents_ptr, control_word.count); 393 end; 394 395 else /* tree */ 396 if NAME_MATCHES () 397 then if function = LIST 398 then do; 399 oi.version_number = 2; 400 call object_info_$display (contents_ptr, (header.slte.bit_count), addr (oi), code); 401 if code = 0 402 then do; 403 call date_time_ (oi.compile_time, date_time_compiled); 404 date_time_compiled = rtrim (oi.compiler || " " || date_time_compiled); 405 end; 406 else date_time_compiled = ""; 407 call ioa_ ("^a^35t^d^-words ^a", NAME (), control_word.count, date_time_compiled); 408 end; 409 else if function = EXCERPT 410 then do; 411 call ioa_ ("Excerpting ^a.", pathname_ (get_wdir_ (), NAME ())); 412 call initiate_file_$create (get_wdir_ (), NAME (), RW_ACCESS, out_seg_ptr, ""b, 0, 413 code); 414 if out_seg_ptr = null 415 then do; 416 call com_err_ (code, function, "Could not write ^a>^a.", get_wdir_ (), 417 NAME ()); 418 severity = 4; 419 go to loop; 420 end; 421 out_seg_ptr -> copy = contents_ptr -> copy; 422 call terminate_file_ (out_seg_ptr, (header.slte.bit_count), TERM_FILE_TRUNC_BC_TERM, 423 (0)); 424 end; 425 end; 426 else if control_word.type = 2 427 then do; /* Collection mark */ 428 429 if expect_link | expect_defs 430 then call MST_format_error ("missing defs or link segment"); 431 call get_data (addr (collection_mark), 1); 432 433 call ioa_ ("Processed collection ^d.^d", collection_mark.major, collection_mark.minor); 434 if function = COPY 435 then do; 436 437 call put_data (addr (control_word), size (control_word)); 438 call put_data (addr (collection_mark), 1); 439 end; 440 441 expect_seg = "1"b; 442 end; 443 444 else call MST_format_error ("unrecognized control word"); 445 go to loop; 446 447 448 /* Subroutines that read and write */ 449 450 get_arg_count: 451 proc returns (fixed bin); 452 453 dcl arg_count fixed bin, 454 code fixed bin (35); 455 456 call cu_$arg_count (arg_count, code); 457 return (arg_count); 458 end get_arg_count; 459 460 461 get_in_file: 462 proc; 463 464 call absolute_pathname_ (in_file_name, in_file_name, code); 465 if code ^= 0 466 then do; 467 call com_err_ (code, function, "-if ^a", in_file_name); 468 go to RETURN; 469 end; 470 471 in_file_name = get_shortest_path_ (in_file_name); 472 473 call iox_$attach_name ("mst_tools_.input." || unique_chars_ (""b), in, "vfile_ " || in_file_name || " -old", 474 codeptr (mst_tools_), code); 475 if code ^= 0 476 then do; 477 call com_err_ (code, function, "Cannot attach input file ^a", in_file_name); 478 go to RETURN; 479 end; 480 481 call iox_$open (in, Stream_input, ("0"b), code); 482 if code ^= 0 483 then do; 484 call com_err_ (code, function, "Cannot open input file ^a", in_file_name); 485 go to RETURN; 486 end; 487 488 call get_data (addr (control_word), size (control_word)); 489 if control_word.type = -1 490 then do; /* bootload program control word */ 491 /* It is written as a name, followed by the pgm. */ 492 493 boot_program_info.version = BOOT_PROGRAM_INFO_VERSION_1; 494 /* set version */ 495 boot_label = "1"b; /* set flag to copy onto output tape */ 496 name_len = divide (length (boot_program_info.boot_program_name), CHARS_PER_WORD, 18, 0); 497 seg_len = control_word.count - name_len;/* set copy length */ 498 call get_data (addr (boot_program_info.boot_program_name), name_len); 499 call get_data (boot_program_guts_ptr, seg_len); 500 /* copy boot program in to temp seg */ 501 boot_program_info.boot_program_ptr = boot_program_guts_ptr; 502 /* set new boot program ptr */ 503 boot_program_info.boot_program_text_length = seg_len; 504 end; 505 else do; 506 boot_label = "0"b; 507 call iox_$close (in, (0)); 508 call iox_$open (in, Stream_input, ""b, (0)); 509 end; 510 511 end get_in_file; 512 513 514 get_in_medium: 515 proc; 516 517 if in_file_name ^= "" 518 then call get_in_file (); 519 else if in_tape_name ^= "" 520 then call get_in_tape (); 521 else do; 522 call com_err_ (error_table_$noarg, function, 523 "An input tape or file must be specified via -ivol or -if."); 524 go to RETURN; 525 end; 526 end get_in_medium; 527 528 get_in_tape: 529 proc; 530 531 call parse_tape_reel_name_ (in_tape_name, atd); 532 if in_den ^= UNSET 533 then atd = rtrim (atd) || " -density " || ltrim (char (in_den)); 534 535 call iox_$attach_name ("mst_tools_.input." || unique_chars_ (""b), in, "tape_mult_ " || rtrim (atd), 536 codeptr (mst_tools_), code); 537 if code ^= 0 538 then do; 539 call com_err_ (code, function, "Cannot attach input tape ^a", atd); 540 go to RETURN; 541 end; 542 543 call iox_$open (in, Stream_input, ("0"b), code); 544 if code ^= 0 545 then do; 546 call com_err_ (code, function, "Cannot open input tape ^a", atd); 547 go to RETURN; 548 end; 549 550 boot_program_info.version = BOOT_PROGRAM_INFO_VERSION_1; 551 /* set version */ 552 call iox_$control (in, "get_boot_program", addr (boot_program_info), code); 553 if code ^= 0 554 then do; /* can't do it */ 555 call com_err_ (code, function, "getting the input tape boot label"); 556 go to RETURN; 557 end; 558 559 if boot_program_info.boot_program_ptr ^= null 560 then do; /* if this tape has a boot label... */ 561 boot_label = "1"b; /* set flag to copy onto output tape */ 562 seg_len = boot_program_info.boot_program_text_length; 563 /* set copy length */ 564 boot_program_guts_ptr -> copy = boot_program_info.boot_program_ptr -> copy; 565 /* copy boot program in to temp seg */ 566 boot_program_info.boot_program_ptr = boot_program_guts_ptr; 567 /* set new boot program ptr */ 568 end; 569 end get_in_tape; 570 571 572 get_out_file: 573 proc; 574 575 call absolute_pathname_ (out_file_name, out_file_name, code); 576 if code ^= 0 577 then do; 578 call com_err_ (code, function, "-if ^a", out_file_name); 579 go to RETURN; 580 end; 581 582 out_file_name = get_shortest_path_ (out_file_name); 583 584 call iox_$attach_name ("mst_tools_.output." || unique_chars_ (""b), out, "vfile_ " || out_file_name, 585 codeptr (mst_tools_), code); 586 if code ^= 0 587 then do; 588 call com_err_ (code, function, "Cannot attach output file ^a", out_file_name); 589 go to RETURN; 590 end; 591 592 call iox_$open (out, Stream_output, ("0"b), code); 593 if code ^= 0 594 then do; 595 call com_err_ (code, function, "Cannot open output file ^a", out_file_name); 596 go to RETURN; 597 end; 598 599 if boot_label 600 then do; /* bootload program control word */ 601 /* It is written as a name, followed by the pgm. */ 602 603 name_len = divide (length (boot_program_info.boot_program_name), CHARS_PER_WORD, 18, 0); 604 seg_len = boot_program_info.boot_program_text_length; 605 606 control_word.type = -1; 607 control_word.count = name_len + seg_len; 608 609 call put_data (addr (control_word), size (control_word)); 610 call put_data (addr (boot_program_info.boot_program_name), name_len); 611 call put_data (boot_program_guts_ptr, seg_len); 612 /* copy boot program in to temp seg */ 613 end; 614 615 end get_out_file; 616 617 618 get_out_medium: 619 proc; 620 621 if out_file_name ^= "" 622 then call get_out_file (); 623 else if out_tape_name ^= "" 624 then call get_out_tape (); 625 else do; 626 call com_err_ (error_table_$noarg, function, 627 "An output tape or file must be specified via -ovol or -of."); 628 go to RETURN; 629 end; 630 631 end get_out_medium; 632 633 get_out_tape: 634 proc; 635 call parse_tape_reel_name_ (out_tape_name, atd); 636 if out_den ^= UNSET 637 then atd = rtrim (atd) || " -density " || ltrim (char (out_den)); 638 639 call iox_$attach_name ("mst_tools_.output." || unique_chars_ (""b), out, 640 "tape_mult_ " || rtrim (atd) || " -write", codeptr (mst_tools_), code); 641 if code ^= 0 642 then do; 643 call com_err_ (code, function, "Cannot attach output tape ^a.", out_tape_name); 644 go to RETURN; 645 end; 646 647 if boot_label 648 then do; /* if we have to copy input boot label program */ 649 call iox_$control (out, "boot_program", addr (boot_program_info), code); 650 if code ^= 0 651 then do; /* can't do it */ 652 call com_err_ (code, function, "writing boot label program"); 653 go to RETURN; 654 end; 655 end; 656 657 call iox_$open (out, Stream_output, ("0"b), code); 658 if code ^= 0 659 then do; 660 call com_err_ (code, function, "Cannot open output tape ^a.", out_tape_name); 661 go to RETURN; 662 end; 663 call iox_$modes (out, "async", (""), (0)); 664 end get_out_tape; 665 666 667 put_data: 668 proc (data_ptr, data_words); 669 declare data_ptr pointer; 670 declare data_words fixed bin (18) uns unal; 671 672 call iox_$put_chars (out, data_ptr, data_words * 4, code); 673 if code ^= 0 674 then do; 675 call com_err_ (code, function, "Fatal error writing output MST^[ ^a^;^s^]^[ ^a^;^s^].", 676 (out_tape_name ^= ""), out_tape_name, (out_file_name ^= ""), out_file_name); 677 severity = 4; 678 go to RETURN; 679 end; 680 return; 681 682 get_data: 683 entry (data_ptr, data_words); 684 685 call iox_$get_chars (in, data_ptr, data_words * 4, (0), code); 686 if code = error_table_$end_of_info 687 then go to DONE; 688 else if code ^= 0 689 then do; 690 call com_err_ (code, function, "Fatal error reading input MST^[ ^a^;^s^]^[ ^a^;^s^].", 691 (in_tape_name ^= ""), in_tape_name, (in_file_name ^= ""), in_file_name); 692 severity = 4; 693 go to RETURN; 694 end; 695 else return; 696 697 end put_data; 698 699 NAME: 700 procedure returns (character (32)); 701 702 703 return (header.segnam.names (1).name); 704 end NAME; 705 706 NAME_MATCHES: 707 procedure returns (bit (1) aligned); 708 declare starx fixed bin; 709 declare match_star_name_ entry (character (*), character (*), fixed binary (35)); 710 711 if select_list.count = 0 712 then return ("1"b); 713 714 do starx = 1 to select_list.count; 715 begin; 716 declare starname char (select_list.names (starx).arg_length) 717 based (select_list.names (starx).arg_ptr); 718 719 call match_star_name_ (NAME (), starname, code); 720 721 if code = 0 722 then return ("1"b); 723 end; 724 end; 725 return ("0"b); 726 727 end NAME_MATCHES; 728 729 MST_format_error: 730 procedure (what); 731 declare what char (*); 732 733 call com_err_ (0, function, "MST format error, ^a. Use check_mst to diagnose it.", what); 734 severity = 4; 735 go to RETURN; 736 end; 737 738 RETURN: 739 DONE: 740 call clean_up; 741 return; 742 743 clean_up: 744 procedure; 745 if in ^= null 746 then call clean_up_switch (in); 747 if out ^= null 748 then call clean_up_switch (out); 749 750 if temp_seg_ptrs (1) ^= null 751 then call release_temp_segments_ (function, temp_seg_ptrs, (0)); 752 753 in, out, temp_seg_ptrs = null; 754 end clean_up; 755 756 clean_up_switch: 757 procedure (switch); 758 759 declare switch pointer; 760 761 call iox_$close (switch, (0)); 762 call iox_$detach_iocb (switch, (0)); 763 764 end clean_up_switch; 765 766 767 768 769 770 771 772 /* format: off */ 773 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 1 2* 1 3* Values for the "access mode" argument so often used in hardcore 1 4* James R. Davis 26 Jan 81 MCR 4844 1 5* Added constants for SM access 4/28/82 Jay Pattin 1 6* Added text strings 03/19/85 Chris Jones 1 7**/ 1 8 1 9 1 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 1 11 dcl ( 1 12 N_ACCESS init ("000"b), 1 13 R_ACCESS init ("100"b), 1 14 E_ACCESS init ("010"b), 1 15 W_ACCESS init ("001"b), 1 16 RE_ACCESS init ("110"b), 1 17 REW_ACCESS init ("111"b), 1 18 RW_ACCESS init ("101"b), 1 19 S_ACCESS init ("100"b), 1 20 M_ACCESS init ("010"b), 1 21 A_ACCESS init ("001"b), 1 22 SA_ACCESS init ("101"b), 1 23 SM_ACCESS init ("110"b), 1 24 SMA_ACCESS init ("111"b) 1 25 ) bit (3) internal static options (constant); 1 26 1 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 1 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 1 29 1 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 1 31 static options (constant); 1 32 1 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 1 34 static options (constant); 1 35 1 36 dcl ( 1 37 N_ACCESS_BIN init (00000b), 1 38 R_ACCESS_BIN init (01000b), 1 39 E_ACCESS_BIN init (00100b), 1 40 W_ACCESS_BIN init (00010b), 1 41 RW_ACCESS_BIN init (01010b), 1 42 RE_ACCESS_BIN init (01100b), 1 43 REW_ACCESS_BIN init (01110b), 1 44 S_ACCESS_BIN init (01000b), 1 45 M_ACCESS_BIN init (00010b), 1 46 A_ACCESS_BIN init (00001b), 1 47 SA_ACCESS_BIN init (01001b), 1 48 SM_ACCESS_BIN init (01010b), 1 49 SMA_ACCESS_BIN init (01011b) 1 50 ) fixed bin (5) internal static options (constant); 1 51 1 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 773 774 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 2 2 2 3 /* Written 05/04/78 by C. D. Tavares */ 2 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 2 5 /* Modified 5/83 by S. Krupp to add declarations for: iox_$open_file, 2 6* iox_$close_file, iox_$detach and iox_$attach_loud entries. */ 2 7 2 8 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 2 9 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 2 10 iox_$close entry (pointer, fixed bin (35)), 2 11 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 2 12 iox_$delete_record entry (pointer, fixed bin (35)), 2 13 iox_$destroy_iocb entry (pointer, fixed bin (35)), 2 14 iox_$detach_iocb entry (pointer, fixed bin (35)), 2 15 iox_$err_not_attached entry options (variable), 2 16 iox_$err_not_closed entry options (variable), 2 17 iox_$err_no_operation entry options (variable), 2 18 iox_$err_not_open entry options (variable), 2 19 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 2 20 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 2 21 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 2 22 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 2 23 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 2 24 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 2 25 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 2 26 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 2 27 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 2 28 iox_$propagate entry (pointer), 2 29 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 2 30 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 2 31 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 2 32 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 2 33 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 2 34 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 2 35 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 2 36 iox_$open_file entry(ptr, fixed bin, char(*), bit(1) aligned, fixed bin(35)), 2 37 iox_$close_file entry(ptr, char(*), fixed bin(35)), 2 38 iox_$detach entry(ptr, char(*), fixed bin(35)), 2 39 iox_$attach_loud entry(ptr, char(*), ptr, fixed bin(35)); 2 40 2 41 dcl (iox_$user_output, 2 42 iox_$user_input, 2 43 iox_$user_io, 2 44 iox_$error_output) external static pointer; 2 45 2 46 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 774 775 /* Begin include file ..... iox_modes.incl.pl1 */ 3 2 3 3 /* Written by C. D. Tavares, 03/17/75 */ 3 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 3 5 3 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 3 7 ("stream_input", "stream_output", "stream_input_output", 3 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 3 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 3 10 "direct_input", "direct_output", "direct_update"); 3 11 3 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 3 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 3 14 3 15 dcl (Stream_input initial (1), 3 16 Stream_output initial (2), 3 17 Stream_input_output initial (3), 3 18 Sequential_input initial (4), 3 19 Sequential_output initial (5), 3 20 Sequential_input_output initial (6), 3 21 Sequential_update initial (7), 3 22 Keyed_sequential_input initial (8), 3 23 Keyed_sequential_output initial (9), 3 24 Keyed_sequential_update initial (10), 3 25 Direct_input initial (11), 3 26 Direct_output initial (12), 3 27 Direct_update initial (13)) fixed bin int static options (constant); 3 28 3 29 /* End include file ..... iox_modes.incl.pl1 */ 775 776 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 4 2*coded February 8, 1972 by Michael J. Spier */ 4 3 /* modified May 26, 1972 by M. Weaver */ 4 4 /* modified 15 April, 1975 by M. Weaver */ 4 5 4 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 4 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 4 8 2 textp pointer, /* pointer to beginning of text section */ 4 9 2 defp pointer, /* pointer to beginning of definition section */ 4 10 2 linkp pointer, /* pointer to beginning of linkage section */ 4 11 2 statp pointer, /* pointer to beginning of static section */ 4 12 2 symbp pointer, /* pointer to beginning of symbol section */ 4 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 4 14 2 tlng fixed bin, /* length in words of text section */ 4 15 2 dlng fixed bin, /* length in words of definition section */ 4 16 2 llng fixed bin, /* length in words of linkage section */ 4 17 2 ilng fixed bin, /* length in words of static section */ 4 18 2 slng fixed bin, /* length in words of symbol section */ 4 19 2 blng fixed bin, /* length in words of break map */ 4 20 2 format, /* word containing bit flags about object type */ 4 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 4 22 3 bound bit(1) unaligned, /* on if segment is bound */ 4 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 4 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 4 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 4 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 4 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 4 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 4 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 4 30 3 pad bit(27) unaligned, 4 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 4 32 2 textlinkp pointer, /* ptr to first link in text */ 4 33 4 34 /* LIMIT OF BRIEF STRUCTURE */ 4 35 4 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 4 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 4 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 4 39 2 cvers aligned, /* generator version name in printable char string form */ 4 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 4 41 3 length bit(18) unaligned, /* length of name in characters */ 4 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 4 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 4 44 3 length bit(18) unaligned, /* length of comment in characters */ 4 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 4 46 4 47 /* LIMIT OF DISPLAY STRUCTURE */ 4 48 4 49 2 rel_text pointer, /* pointer to text section relocation info */ 4 50 2 rel_def pointer, /* pointer to definition section relocation info */ 4 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 4 52 2 rel_static pointer, /* pointer to static section relocation info */ 4 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 4 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 4 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 4 56 /* currently not used by system */ 4 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 4 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 4 59 4 60 declare object_info_version_2 fixed bin int static init(2); 4 61 4 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 776 777 /* BEGIN INCLUDE FILE slt.incl.pl1 --- Last modified 2/76 SHW */ 5 2 5 3 /* Declarations for Segment Loading Table header and array. 5 4* 5 5* Used by Initialization and MST Checker subroutines */ 5 6 5 7 dcl sltp ptr, /* pointer to base of SLT segment */ 5 8 names_ptr ptr, /* pointer to base of SLT names segment */ 5 9 namep ptr, /* pointer to segment name list block */ 5 10 pathp ptr, /* pointer to segment's directory path name */ 5 11 aclp ptr; /* pointer to acl structure */ 5 12 5 13 declare 1 slt based (sltp) aligned, /* declaration of Segment Loading Table (SLT) */ 5 14 2 name_seg_ptr ptr, /* words 0-1, pointer (ITS pair) to name segment */ 5 15 2 free_core_start fixed bin (24), /* word 2, start of free core after perm-wired */ 5 16 2 first_sup_seg fixed bin (18), /* word 3, first supervisor segment number */ 5 17 2 last_sup_seg fixed bin (18), /* word 4, last supervisor segment number */ 5 18 2 first_init_seg fixed bin (18), /* word 5, first initializer segment number */ 5 19 2 last_init_seg fixed bin (18), /* word 6, last initializer segment number */ 5 20 2 free_core_size fixed bin (24), /* size (in words) of free core after perm-wired */ 5 21 2 seg (0:8191) aligned, /* segment entries (4 words each) */ 5 22 3 slte (4) fixed bin (35); /* Space for SLT entries */ 5 23 5 24 /* auxiliary segment of SLT for storing of segment names and directory path names */ 5 25 5 26 declare 1 name_seg based (names_ptr) aligned, /* name segment header */ 5 27 2 pad bit (18) unal, 5 28 2 next_loc bit (18) unal, /* Next available free location in name seg */ 5 29 2 ht (0:127) bit (18) aligned; /* Names hash table */ 5 30 5 31 declare 1 segnam based (namep) aligned, /* declaration for segment name block */ 5 32 2 count fixed bin (17), /* number of segment names in this block */ 5 33 2 names (50 refer (segnam.count)), /* segment name array */ 5 34 3 hp bit (18) unal, /* hash thread pointer */ 5 35 3 ref bit (1) unal, /* "1"b if name referenced */ 5 36 3 pad bit (5) unal, 5 37 3 segno bit (12) unal, /* segment number associated with this name */ 5 38 3 name char (32) unal; /* space for name (max 32 characters) */ 5 39 5 40 declare 1 path based (pathp) aligned, /* declaration for directory path name */ 5 41 2 size fixed bin (17), /* length of pathname */ 5 42 2 name char (168 refer (path.size)) unal, /* directory path name */ 5 43 2 acls fixed bin; /* ACL list starts here */ 5 44 5 45 declare 1 acls based (aclp) aligned, /* declaration for acl list */ 5 46 2 count fixed bin, /* number of entries in acl list */ 5 47 2 acl (50 refer (acls.count)), /* array of acl entries */ 5 48 3 userid char (32), /* user specification */ 5 49 3 mode bit (36) aligned, /* mode for the specified user */ 5 50 3 pad bit (36) aligned, 5 51 3 code fixed bin; 5 52 5 53 5 54 /* END INCLUDE FILE slt.incl.pl1 */ 777 778 /* BEGIN INCLUDE FILE slte.incl.pl1 */ 6 2 /* Declaration for Segment Loading Table Entry structure. 6 3* Used by Initialization, MST Generation, and MST Checker subroutines */ 6 4 /* modified 5/4/76 by Noel I. Morris */ 6 5 /* last modified 12/12/83 by Keith Loepere for breakpointable */ 6 6 /* format: style3 */ 6 7 6 8 dcl sltep ptr; 6 9 6 10 dcl 1 slte_uns based (sltep) aligned, 6 11 ( 2 names_ptr bit (18), /* rel pointer to thread of names */ 6 12 2 path_ptr bit (18), /* rel pointer to pathname (if present) */ 6 13 /**** End of word 1 */ 6 14 2 access bit (4), /* SDW access bit (REWP) */ 6 15 2 cache bit (1), /* Segment to be allowed in cache */ 6 16 2 abs_seg bit (1), /* segment is an abs seg if ON */ 6 17 2 firmware_seg bit (1), /* load in low 256 */ 6 18 2 layout_seg bit (1), /* mailbox & such */ 6 19 2 breakpointable bit (1), /* includes breakpoint_page */ 6 20 2 pad1 bit (3), /* unused */ 6 21 2 wired bit (1), /* segment is wired if ON */ 6 22 2 paged bit (1), /* segment is paged if ON */ 6 23 2 per_process bit (1), /* segment is per-process if ON */ 6 24 2 pad3 bit (2), 6 25 2 acl_provided bit (1), /* ON if acl structure follows path_name on MST */ 6 26 /**** End of 1st half of word 2 */ 6 27 2 pad4 bit (3), 6 28 2 branch_required bit (1), /* path name supplied if ON */ 6 29 2 init_seg bit (1), /* segment is init_seg if ON */ 6 30 2 temp_seg bit (1), /* segment is temp_seg if ON */ 6 31 2 link_provided bit (1), /* linkage segment provided if ON */ 6 32 2 link_sect bit (1), /* segment is linkage segment if ON */ 6 33 2 link_sect_wired bit (1), /* linkage segment is wired if ON */ 6 34 2 combine_link bit (1), /* linkage is combined if ON */ 6 35 2 pre_linked bit (1), /* lot entry has been made if ON */ 6 36 2 defs bit (1), /* segment is definitions segment if ON */ 6 37 /***** End of word 2 */ 6 38 2 pad5 bit (6), 6 39 2 cur_length fixed bin (9) uns, /* current length of segment (in 1024 word blocks) */ 6 40 2 ringbrack (3) fixed bin (3) uns, /* ringbrackets */ 6 41 2 segno fixed bin (18) uns, /* text/link segment number */ 6 42 /***** End of word 3 */ 6 43 2 pad7 bit (3), 6 44 2 max_length fixed bin (9) uns, /* maximum length for segment */ 6 45 2 bit_count fixed bin (24) uns 6 46 ) unaligned; /* bitcount of segment */ 6 47 6 48 dcl 1 slte based (sltep) aligned, 6 49 ( 2 names_ptr bit (18), /* rel pointer to thread of names */ 6 50 2 path_ptr bit (18), /* rel pointer to pathname (if present) */ 6 51 2 access bit (4), /* SDW access bit (REWP) */ 6 52 2 cache bit (1), /* Segment to be allowed in cache */ 6 53 2 abs_seg bit (1), /* segment is an abs seg if ON */ 6 54 2 firmware_seg bit (1), 6 55 2 layout_seg bit (1), 6 56 2 breakpointable bit (1), 6 57 2 pad2 bit (3), 6 58 2 wired bit (1), /* segment is wired if ON */ 6 59 2 paged bit (1), /* segment is paged if ON */ 6 60 2 per_process bit (1), /* segment is per-process if ON */ 6 61 2 pad3 bit (2), 6 62 2 acl_provided bit (1), /* ON if acl structure follows path_name on MST */ 6 63 2 pad4 bit (3), 6 64 2 branch_required bit (1), /* path name supplied if ON */ 6 65 2 init_seg bit (1), /* segment is init_seg if ON */ 6 66 2 temp_seg bit (1), /* segment is temp_seg if ON */ 6 67 2 link_provided bit (1), /* linkage segment provided if ON */ 6 68 2 link_sect bit (1), /* segment is linkage segment if ON */ 6 69 2 link_sect_wired bit (1), /* linkage segment is wired if ON */ 6 70 2 combine_link bit (1), /* linkage is combined if ON */ 6 71 2 pre_linked bit (1), /* lot entry has been made if ON */ 6 72 2 defs bit (1), /* segment is definitions segment if ON */ 6 73 2 pad5 bit (6), 6 74 2 cur_length bit (9), /* current length of segment (in 1024 word blocks) */ 6 75 2 ringbrack (3) bit (3), /* ringbrackets */ 6 76 2 segno bit (18), /* text/link segment number */ 6 77 2 pad6 bit (3), 6 78 2 max_length bit (9), /* maximum length for segment */ 6 79 2 bit_count bit (24) 6 80 ) unaligned; /* bitcount of segment */ 6 81 6 82 /* END INCLUDE FILE slte.incl.pl1 */ 778 779 /* BEGIN INCLUDE FILE ... system_constants.incl.pl1 */ 7 2 7 3 /****^ HISTORY COMMENTS: 7 4* 1) change(86-11-12,GWMay), approve(86-11-12,MCR7445), audit(86-11-19,GDixon), 7 5* install(86-11-21,MR12.0-1223): 7 6* created. 7 7* END HISTORY COMMENTS */ 7 8 7 9 /* format: off */ 7 10 7 11 /* ************************************************************************ */ 7 12 /* */ 7 13 /* Function: Provides constants for commonly used Multics system values. */ 7 14 /* */ 7 15 /* Usage: These values are available for use in place of "magic" numbers */ 7 16 /* (unexplained numbers) in programming applications. */ 7 17 /* */ 7 18 /* Definitions: */ 7 19 /* */ 7 20 /* PER bit character/byte word page segment */ 7 21 /* */ 7 22 /* bits 1 9 36 36864 9400320 */ 7 23 /* characters/bytes 1 4 4096 1044480 */ 7 24 /* words 1 1024 261120 */ 7 25 /* pages 1 255 */ 7 26 /* segments 1 */ 7 27 /* */ 7 28 /* The base values for a bit, char, word and page are determined by the */ 7 29 /* Multics hardware implementation. The other values are calculated from */ 7 30 /* their relation to one another as shown in the matrix above. */ 7 31 /* */ 7 32 /* BITS_PER_CHAR = 9 (defined by the hardware) */ 7 33 /* BITS_PER_WORD = BITS_PER_CHAR * CHARS_PER_WORD */ 7 34 /* = 9 * 4 */ 7 35 /* = 36 */ 7 36 /* BITS_PER_PAGE = BITS_PER_CHAR * CHARS_PER_WORD * CHARS_PER_PAGE */ 7 37 /* = 9 * 4 * 1024 */ 7 38 /* = 36864 */ 7 39 /* BITS_PER_SEGMENT = BITS_PER_CHAR * CHARS_PER_WORD * CHARS_PER_PAGE * */ 7 40 /* PAGES_PER_SEGMENT */ 7 41 /* = 9 * 4 * 1024 * 255 */ 7 42 /* = 9400320 */ 7 43 /* */ 7 44 /* CHARS_PER_WORD = 4 (defined by the hardware) */ 7 45 /* CHARS_PER_PAGE = CHARS_PER_WORD * WORDS_PER_PAGE */ 7 46 /* = 4 * 1024 */ 7 47 /* = 4096 */ 7 48 /* CHARS_PER_SEGMENT = CHARS_PER_WORD * WORDS_PER_PAGE * PAGES_PER_SEGMENT */ 7 49 /* = 4 * 1024 * 255 */ 7 50 /* = 1044480 */ 7 51 /* */ 7 52 /* WORDS_PER_PAGE = 1024 (defined by the hardware) */ 7 53 /* WORDS_PER_SEGMENT = WORDS_PER_PAGE * PAGES_PER_SEGMENT */ 7 54 /* = 1024 * 255 */ 7 55 /* = 261120 */ 7 56 /* */ 7 57 /* PAGES_PER_SEGMENT = 255 (defined by system standard) */ 7 58 /* */ 7 59 /* ************************************************************************ */ 7 60 7 61 declare BITS_PER_CHAR fixed bin (4) internal static 7 62 options (constant) initial (9); 7 63 7 64 declare BITS_PER_WORD fixed bin (6) internal static 7 65 options (constant) initial (36); 7 66 7 67 declare BITS_PER_PAGE fixed bin (16) internal static 7 68 options (constant) initial (36864); 7 69 7 70 declare BITS_PER_SEGMENT fixed bin (24) internal static 7 71 options (constant) initial (9400320); 7 72 7 73 declare CHARS_PER_WORD fixed bin (3) internal static 7 74 options (constant) initial (4); 7 75 7 76 declare CHARS_PER_PAGE fixed bin (13) internal static 7 77 options (constant) initial (4096); 7 78 7 79 declare CHARS_PER_SEGMENT fixed bin (21) internal static 7 80 options (constant) initial (1044480); 7 81 7 82 /* Note: WORDS_PER_PAGE should be equal to sys_info$max_page_size */ 7 83 7 84 declare WORDS_PER_PAGE fixed bin (11) internal static 7 85 options (constant) initial (1024); 7 86 7 87 /* Note: WORDS_PER_SEGMENT should be equal to sys_info$max_seg_size */ 7 88 7 89 declare WORDS_PER_SEGMENT fixed bin (21) internal static 7 90 options (constant) initial (261120); 7 91 7 92 declare PAGES_PER_SEGMENT fixed bin (8) internal static 7 93 options (constant) initial (255); 7 94 7 95 /* END INCLUDE FILE ... system_constants.incl.pl1 */ 7 96 779 780 /* BEGIN INCLUDE FILE tape_mult_boot_info.incl.pl1 */ 8 2 /* Written by J. A. Bush 6/27/81 */ 8 3 8 4 dcl 1 boot_program_info aligned, 8 5 2 version fixed bin, /* Currently 1 */ 8 6 2 boot_program_ptr pointer, /* Pointer to text section of boot program */ 8 7 2 boot_program_text_length fixed bin (21), /* Length of the text section in words */ 8 8 2 boot_program_name char (32) unaligned; /* Name for recording in label */ 8 9 8 10 dcl BOOT_PROGRAM_INFO_VERSION_1 fixed bin internal static options 8 11 (constant) init (1); 8 12 8 13 /* END INCLUDE FILE tape_mult_boot_info.incl.pl1 */ 780 781 /* BEGIN INCLUDE FILE ... terminate_file.incl.pl1 */ 9 2 /* format: style2,^inddcls,idind32 */ 9 3 9 4 declare 1 terminate_file_switches based, 9 5 2 truncate bit (1) unaligned, 9 6 2 set_bc bit (1) unaligned, 9 7 2 terminate bit (1) unaligned, 9 8 2 force_write bit (1) unaligned, 9 9 2 delete bit (1) unaligned; 9 10 9 11 declare TERM_FILE_TRUNC bit (1) internal static options (constant) initial ("1"b); 9 12 declare TERM_FILE_BC bit (2) internal static options (constant) initial ("01"b); 9 13 declare TERM_FILE_TRUNC_BC bit (2) internal static options (constant) initial ("11"b); 9 14 declare TERM_FILE_TERM bit (3) internal static options (constant) initial ("001"b); 9 15 declare TERM_FILE_TRUNC_BC_TERM bit (3) internal static options (constant) initial ("111"b); 9 16 declare TERM_FILE_FORCE_WRITE bit (4) internal static options (constant) initial ("0001"b); 9 17 declare TERM_FILE_DELETE bit (5) internal static options (constant) initial ("00001"b); 9 18 9 19 /* END INCLUDE FILE ... terminate_file.incl.pl1 */ 781 782 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/15/87 1602.4 mst_tools_.pl1 >special_ldd>install>MR12.1-1040>mst_tools_.pl1 773 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 774 2 05/23/83 0916.6 iox_entries.incl.pl1 >ldd>include>iox_dcls.incl.pl1 775 3 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.incl.pl1 776 4 08/05/77 1022.5 object_info.incl.pl1 >ldd>include>object_info.incl.pl1 777 5 05/24/82 1005.0 slt.incl.pl1 >ldd>include>slt.incl.pl1 778 6 07/11/84 0937.3 slte.incl.pl1 >ldd>include>slte.incl.pl1 779 7 11/24/86 1243.9 system_constants.incl.pl1 >ldd>include>system_constants.incl.pl1 780 8 03/27/82 0429.7 tape_mult_boot_info.incl.pl1 >ldd>include>tape_mult_boot_info.incl.pl1 781 9 04/06/83 1239.4 terminate_file.incl.pl1 >ldd>include>terminate_file.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. BOOT_PROGRAM_INFO_VERSION_1 constant fixed bin(17,0) initial dcl 8-10 ref 493 550 CHARS_PER_WORD constant fixed bin(3,0) initial dcl 7-73 ref 496 603 COPY 000022 constant char(32) initial unaligned dcl 152 ref 173 188 233 249 303 333 351 389 434 EXCERPT 000002 constant char(32) initial unaligned dcl 154 ref 177 305 409 IN constant fixed bin(17,0) initial dcl 113 ref 204 278 LIST 000012 constant char(32) initial unaligned dcl 153 ref 175 305 395 OUT constant fixed bin(17,0) initial dcl 113 ref 236 280 RW_ACCESS 000001 constant bit(3) initial unaligned dcl 1-11 set ref 412* Stream_input 000120 constant fixed bin(17,0) initial dcl 3-15 set ref 481* 508* 543* Stream_output 000121 constant fixed bin(17,0) initial dcl 3-15 set ref 592* 657* TERM_FILE_TRUNC_BC_TERM 000000 constant bit(3) initial unaligned dcl 9-15 set ref 422* UNSET constant fixed bin(17,0) initial dcl 113 ref 193 194 220 252 532 636 absolute_pathname_ 000026 constant entry external dcl 61 ref 464 575 addr builtin function dcl 155 ref 19 24 29 344 344 353 353 391 391 400 400 431 431 437 437 438 438 488 488 498 498 552 552 609 609 610 610 649 649 al 000102 automatic fixed bin(21,0) dcl 75 set ref 198* 199 201 201 207 207 217 217 223 223 233 233 239 239 249 249 255 255 265 265 269 269 283 283 290 290 297 297 301 303 307 307 310 310 315 318 318 ap 000100 automatic pointer dcl 74 set ref 198* 199 201 201 207 217 217 223 233 233 239 249 249 255 265 265 269 283 290 297 301 303 307 310 314 318 arg based char unaligned dcl 78 set ref 199 201 201 207* 217 217 223* 233 233 239* 249 249 255* 265 265 269* 283* 290* 297* 301 303 307* 310* 318* arg_count 000562 automatic fixed bin(17,0) dcl 453 in procedure "get_arg_count" set ref 456* 457 arg_count 000104 automatic fixed bin(17,0) dcl 77 in procedure "mst_tools_" set ref 162* 169 188 197 205 221 237 253 267 arg_length 4 000156 automatic fixed bin(21,0) array level 3 dcl 101 set ref 315* 719 719 arg_ptr 2 000156 automatic pointer array level 3 dcl 101 set ref 314* 719 argx 000103 automatic fixed bin(17,0) dcl 76 set ref 197* 198* 205 212* 212 213* 221 228* 228 229* 237 244* 244 245* 253 260* 260 261* 267 274* 274 275* atd 000156 automatic char(256) unaligned dcl 107 set ref 531* 532* 532 535 539* 546* 635* 636* 636 639 bit_count 3(12) based fixed bin(24,0) level 3 packed unsigned unaligned dcl 142 ref 400 422 boot_label 000111 automatic bit(1) dcl 83 set ref 182* 495* 506* 561* 599 647 boot_program_guts_ptr defined pointer dcl 95 set ref 499* 501 564 566 611* boot_program_info 000530 automatic structure level 1 dcl 8-4 set ref 552 552 649 649 boot_program_name 5 000530 automatic char(32) level 2 packed unaligned dcl 8-4 set ref 496 498 498 603 610 610 boot_program_ptr 2 000530 automatic pointer level 2 dcl 8-4 set ref 501* 559 564 566* boot_program_text_length 4 000530 automatic fixed bin(21,0) level 2 dcl 8-4 set ref 503* 562 604 char builtin function dcl 155 ref 532 636 check_star_name_$entry 000010 constant entry external dcl 52 ref 307 cleanup 000426 stack reference condition dcl 130 ref 184 code 000112 automatic fixed bin(35,0) dcl 84 in procedure "mst_tools_" set ref 162* 163 165* 307* 308 308 308 310* 400* 401 412* 416* 464* 465 467* 473* 475 477* 481* 482 484* 535* 537 539* 543* 544 546* 552* 553 555* 575* 576 578* 584* 586 588* 592* 593 595* 639* 641 643* 649* 650 652* 657* 658 660* 672* 673 675* 685* 686 688 690* 719* 721 code 000563 automatic fixed bin(35,0) dcl 453 in procedure "get_arg_count" set ref 456* codeptr builtin function dcl 155 ref 473 473 535 535 584 584 639 639 collection_mark 000435 automatic structure level 1 dcl 136 set ref 431 431 438 438 com_err_ 000020 constant entry external dcl 55 ref 165 207 223 239 255 269 283 290 297 310 318 416 467 477 484 522 539 546 555 578 588 595 626 643 652 660 675 690 733 com_err_$suppress_name 000022 constant entry external dcl 55 ref 173 175 177 compile_time 32 000436 automatic fixed bin(71,0) level 2 dcl 140 set ref 403* compiler 30 000436 automatic char(8) level 2 dcl 140 set ref 404 contents_ptr defined pointer dcl 94 set ref 363* 392* 400* 421 control_word 000434 automatic structure level 1 dcl 132 set ref 344 344 344 344 353 353 353 353 391 391 391 391 437 437 437 437 488 488 488 488 609 609 609 609 convert builtin function dcl 155 ref 278 280 copy based bit(36) array dcl 99 set ref 421* 421 564* 564 copy_mst_severity_ 000054 external static fixed bin(35,0) initial dcl 120 set ref 19 count 0(18) 000434 automatic fixed bin(18,0) level 2 in structure "control_word" packed unsigned unaligned dcl 132 in procedure "mst_tools_" set ref 348 362 392* 407* 497 607* count 000156 automatic fixed bin(17,0) level 2 in structure "select_list" dcl 101 in procedure "mst_tools_" set ref 195* 313* 313 314 315 711 714 cu_$arg_count 000012 constant entry external dcl 53 ref 162 456 cu_$arg_ptr 000014 constant entry external dcl 54 ref 198 213 229 245 261 275 data_ptr parameter pointer dcl 669 set ref 667 672* 682 685* data_words parameter fixed bin(18,0) unsigned unaligned dcl 670 ref 667 672 682 685 date_time_ 000024 constant entry external dcl 60 ref 403 date_time_compiled 000113 automatic char(32) unaligned dcl 85 set ref 403* 404* 404 406* 407* defs 1(29) based bit(1) level 3 packed unaligned dcl 142 ref 376 384 divide builtin function dcl 155 ref 496 603 error_table_$bad_arg 000062 external static fixed bin(35,0) dcl 122 set ref 290* 318* error_table_$badopt 000064 external static fixed bin(35,0) dcl 123 set ref 297* error_table_$end_of_info 000066 external static fixed bin(35,0) dcl 124 ref 686 error_table_$inconsistent 000070 external static fixed bin(35,0) dcl 126 set ref 283* error_table_$noarg 000072 external static fixed bin(35,0) dcl 128 set ref 207* 223* 239* 255* 269* 522* 626* excerpt_mst_severity_ 000056 external static fixed bin(35,0) initial dcl 120 set ref 24 expect_defs 000526 automatic bit(1) dcl 148 set ref 342* 371* 374 379* 429 expect_link 000525 automatic bit(1) dcl 148 set ref 342* 365 370* 386* 429 expect_seg 000524 automatic bit(1) dcl 148 set ref 342* 350* 361* 441* function 000123 automatic char(32) unaligned dcl 86 set ref 18* 23* 28* 165* 173 173* 175 175* 177 177* 188 207* 223* 233 239* 249 255* 269* 283* 290* 297* 303 305 305 310* 318* 325* 333 351 389 395 409 416* 434 467* 477* 484* 522* 539* 546* 555* 578* 588* 595* 626* 643* 652* 660* 675* 690* 733* 750* get_shortest_path_ 000030 constant entry external dcl 62 ref 471 582 get_temp_segments_ 000032 constant entry external dcl 63 ref 325 get_wdir_ 000034 constant entry external dcl 64 ref 411 411 411 411 412 412 416 416 header based structure level 1 dcl 142 header_ptr defined pointer dcl 93 set ref 349* 354* 367 376 384 384 386 400 422 703 header_wc 000154 automatic fixed bin(18,0) unsigned unaligned dcl 98 set ref 348* 349* 354* in 000134 automatic pointer dcl 88 set ref 183* 473* 481* 507* 508* 535* 543* 552* 685* 745 745* 753* in_den 000256 automatic fixed bin(17,0) dcl 108 set ref 193* 278* 278 280 532 532 in_file_name 000260 automatic char(168) unaligned dcl 109 set ref 192* 203* 219* 230* 301 464* 464* 467* 471* 471* 473 477* 484* 517 690 690* in_tape_name 000404 automatic char(32) unaligned dcl 111 set ref 192* 203* 214* 219* 301 301* 519 531* 690 690* index builtin function dcl 155 ref 199 initiate_file_$create 000036 constant entry external dcl 65 ref 412 inout 000424 automatic fixed bin(17,0) dcl 113 set ref 194* 204* 220* 236* 252* 278 280 ioa_ 000016 constant entry external dcl 55 ref 407 411 433 iox_$attach_name 000074 constant entry external dcl 2-8 ref 473 535 584 639 iox_$close 000076 constant entry external dcl 2-8 ref 507 761 iox_$control 000100 constant entry external dcl 2-8 ref 552 649 iox_$detach_iocb 000102 constant entry external dcl 2-8 ref 762 iox_$get_chars 000104 constant entry external dcl 2-8 ref 685 iox_$modes 000106 constant entry external dcl 2-8 ref 663 iox_$open 000110 constant entry external dcl 2-8 ref 481 508 543 592 657 iox_$put_chars 000112 constant entry external dcl 2-8 ref 672 length builtin function dcl 155 ref 496 603 link_provided 1(24) based bit(1) level 3 packed unaligned dcl 142 ref 386 link_sect 1(25) based bit(1) level 3 packed unaligned dcl 142 ref 367 384 list_mst_severity_ 000060 external static fixed bin(35,0) initial dcl 120 set ref 29 ltrim builtin function dcl 155 ref 532 636 major 000435 automatic fixed bin(17,0) level 2 packed unaligned dcl 136 set ref 433* match_star_name_ 000114 constant entry external dcl 709 ref 719 minor 0(18) 000435 automatic fixed bin(17,0) level 2 packed unaligned dcl 136 set ref 433* name 6 based char(32) array level 4 packed unaligned dcl 142 ref 703 name_len 000152 automatic fixed bin(18,0) unsigned unaligned dcl 97 set ref 496* 497 498* 603* 607 610* names 2 000156 automatic structure array level 2 in structure "select_list" dcl 101 in procedure "mst_tools_" names 5 based structure array level 3 in structure "header" dcl 142 in procedure "mst_tools_" null builtin function dcl 155 ref 183 414 559 745 747 750 753 object_info based structure level 1 dcl 4-6 object_info_$display 000040 constant entry external dcl 67 ref 400 oi 000436 automatic structure level 1 dcl 140 set ref 400 400 opt based char unaligned dcl 81 set ref 214 230 246 262 276 276 276 278 280 283* 290* optl 000110 automatic fixed bin(21,0) dcl 80 set ref 213* 214 229* 230 245* 246 261* 262 275* 276 276 276 278 280 283 283 290 290 optp 000106 automatic pointer dcl 79 set ref 213* 214 229* 230 245* 246 261* 262 275* 276 276 276 278 280 283 290 out 000136 automatic pointer dcl 88 set ref 183* 584* 592* 639* 649* 657* 663* 672* 747 747* 753* out_den 000257 automatic fixed bin(17,0) dcl 108 set ref 193* 280* 636 636 out_file_name 000332 automatic char(168) unaligned dcl 109 set ref 192* 235* 251* 262* 303 575* 575* 578* 582* 582* 584 588* 595* 621 675 675* out_seg_ptr 000140 automatic pointer dcl 89 set ref 412* 414 421 422* out_tape_name 000414 automatic char(32) unaligned dcl 111 set ref 192* 235* 246* 251* 303 303* 623 635* 643* 660* 675 675* parse_tape_reel_name_ 000044 constant entry external dcl 69 ref 531 635 pathname_ 000042 constant entry external dcl 68 ref 411 411 release_temp_segments_ 000046 constant entry external dcl 70 ref 750 rtrim builtin function dcl 155 ref 404 532 535 636 639 seg_len 000153 automatic fixed bin(18,0) unsigned unaligned dcl 97 set ref 362* 363* 421 497* 499* 503 562* 564 604* 607 611* segnam based structure level 1 dcl 5-31 in procedure "mst_tools_" segnam 4 based structure level 2 in structure "header" dcl 142 in procedure "mst_tools_" select_list 000156 automatic structure level 1 dcl 101 severity based fixed bin(35,0) dcl 146 set ref 160* 341* 418* 677* 692* 734* severityp 000142 automatic pointer dcl 90 set ref 19* 24* 29* 160 341 418 677 692 734 size builtin function dcl 155 ref 344 344 353 353 391 391 437 437 488 488 609 609 slte based structure level 2 dcl 142 slte_uns based structure level 1 dcl 6-10 starname based char unaligned dcl 716 set ref 719* starx 000652 automatic fixed bin(17,0) dcl 708 set ref 714* 719 719 719 switch parameter pointer dcl 759 set ref 756 761* 762* temp_seg_ptrs 000144 automatic pointer array dcl 92 set ref 183* 325* 349 349 354 354 363 363 367 367 376 376 384 384 384 384 386 386 392 392 400 400 400 400 421 421 422 422 499 499 501 501 564 564 566 566 611 611 703 703 750 750* 753* terminate_file_ 000050 constant entry external dcl 71 ref 422 type 000434 automatic fixed bin(17,0) level 2 packed unaligned dcl 132 set ref 346 359 426 489 606* unique_chars_ 000052 constant entry external dcl 72 ref 473 535 584 639 version 000530 automatic fixed bin(17,0) level 2 dcl 8-4 set ref 493* 550* version_number 000436 automatic fixed bin(17,0) level 2 dcl 140 set ref 399* what parameter char unaligned dcl 731 set ref 729 733* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 BITS_PER_CHAR internal static fixed bin(4,0) initial dcl 7-61 BITS_PER_PAGE internal static fixed bin(16,0) initial dcl 7-67 BITS_PER_SEGMENT internal static fixed bin(24,0) initial dcl 7-70 BITS_PER_WORD internal static fixed bin(6,0) initial dcl 7-64 CHARS_PER_PAGE internal static fixed bin(13,0) initial dcl 7-76 CHARS_PER_SEGMENT internal static fixed bin(21,0) initial dcl 7-79 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-33 Direct_input internal static fixed bin(17,0) initial dcl 3-15 Direct_output internal static fixed bin(17,0) initial dcl 3-15 Direct_update internal static fixed bin(17,0) initial dcl 3-15 E_ACCESS internal static bit(3) initial unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 3-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 3-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 3-15 M_ACCESS internal static bit(3) initial unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 N_ACCESS internal static bit(3) initial unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 PAGES_PER_SEGMENT internal static fixed bin(8,0) initial dcl 7-92 REW_ACCESS internal static bit(3) initial unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS internal static bit(3) initial unaligned dcl 1-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 S_ACCESS internal static bit(3) initial unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 Sequential_input internal static fixed bin(17,0) initial dcl 3-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 3-15 Sequential_output internal static fixed bin(17,0) initial dcl 3-15 Sequential_update internal static fixed bin(17,0) initial dcl 3-15 Stream_input_output internal static fixed bin(17,0) initial dcl 3-15 TERM_FILE_BC internal static bit(2) initial unaligned dcl 9-12 TERM_FILE_DELETE internal static bit(5) initial unaligned dcl 9-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial unaligned dcl 9-16 TERM_FILE_TERM internal static bit(3) initial unaligned dcl 9-14 TERM_FILE_TRUNC internal static bit(1) initial unaligned dcl 9-11 TERM_FILE_TRUNC_BC internal static bit(2) initial unaligned dcl 9-13 WORDS_PER_PAGE internal static fixed bin(11,0) initial dcl 7-84 WORDS_PER_SEGMENT internal static fixed bin(21,0) initial dcl 7-89 W_ACCESS internal static bit(3) initial unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 aclp automatic pointer dcl 5-7 acls based structure level 1 dcl 5-45 iox_$attach_loud 000000 constant entry external dcl 2-8 iox_$attach_ptr 000000 constant entry external dcl 2-8 iox_$close_file 000000 constant entry external dcl 2-8 iox_$delete_record 000000 constant entry external dcl 2-8 iox_$destroy_iocb 000000 constant entry external dcl 2-8 iox_$detach 000000 constant entry external dcl 2-8 iox_$err_no_operation 000000 constant entry external dcl 2-8 iox_$err_not_attached 000000 constant entry external dcl 2-8 iox_$err_not_closed 000000 constant entry external dcl 2-8 iox_$err_not_open 000000 constant entry external dcl 2-8 iox_$error_output external static pointer dcl 2-41 iox_$find_iocb 000000 constant entry external dcl 2-8 iox_$find_iocb_n 000000 constant entry external dcl 2-8 iox_$get_line 000000 constant entry external dcl 2-8 iox_$look_iocb 000000 constant entry external dcl 2-8 iox_$move_attach 000000 constant entry external dcl 2-8 iox_$open_file 000000 constant entry external dcl 2-8 iox_$position 000000 constant entry external dcl 2-8 iox_$propagate 000000 constant entry external dcl 2-8 iox_$read_key 000000 constant entry external dcl 2-8 iox_$read_length 000000 constant entry external dcl 2-8 iox_$read_record 000000 constant entry external dcl 2-8 iox_$rewrite_record 000000 constant entry external dcl 2-8 iox_$seek_key 000000 constant entry external dcl 2-8 iox_$user_input external static pointer dcl 2-41 iox_$user_io external static pointer dcl 2-41 iox_$user_output external static pointer dcl 2-41 iox_$write_record 000000 constant entry external dcl 2-8 iox_modes internal static char(24) initial array dcl 3-6 name_seg based structure level 1 dcl 5-26 namep automatic pointer dcl 5-7 names_ptr automatic pointer dcl 5-7 object_info_version_2 internal static fixed bin(17,0) initial dcl 4-60 path based structure level 1 dcl 5-40 pathp automatic pointer dcl 5-7 short_iox_modes internal static char(4) initial array dcl 3-12 slt based structure level 1 dcl 5-13 slte based structure level 1 dcl 6-48 sltep automatic pointer dcl 6-8 sltp automatic pointer dcl 5-7 terminate_file_switches based structure level 1 packed unaligned dcl 9-4 NAMES DECLARED BY EXPLICIT CONTEXT. DONE 003347 constant label dcl 738 ref 686 MST_format_error 006033 constant entry internal dcl 729 ref 367 376 384 429 444 NAME 005737 constant entry internal dcl 699 ref 407 407 411 411 411 411 412 412 416 416 719 719 NAME_MATCHES 005747 constant entry internal dcl 706 ref 395 RETURN 003347 constant label dcl 738 ref 209 225 241 257 271 286 292 298 311 319 468 478 485 524 540 547 556 579 589 596 628 644 653 661 678 693 735 USAGE 001005 constant label dcl 169 ref 188 clean_up 006103 constant entry internal dcl 743 ref 184 738 clean_up_switch 006206 constant entry internal dcl 756 ref 745 747 copy_mst 000701 constant entry external dcl 16 excerpt_mst 000717 constant entry external dcl 21 get_arg_count 003354 constant entry internal dcl 450 ref 101 get_data 005617 constant entry internal dcl 682 ref 344 349 363 431 488 498 499 get_in_file 003373 constant entry internal dcl 461 ref 517 get_in_medium 003771 constant entry internal dcl 514 ref 329 get_in_tape 004034 constant entry internal dcl 528 ref 519 get_out_file 004460 constant entry internal dcl 572 ref 621 get_out_medium 005002 constant entry internal dcl 618 ref 335 get_out_tape 005045 constant entry internal dcl 633 ref 623 join 000751 constant label dcl 160 ref 20 25 list_mst 000735 constant entry external dcl 26 loop 002425 constant label dcl 344 ref 419 445 mst_tools_ 000671 constant entry external dcl 11 ref 473 473 535 535 584 584 639 639 put_data 005505 constant entry internal dcl 667 ref 353 354 391 392 437 438 609 610 611 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 7036 7154 6360 7046 Length 7646 6360 116 455 456 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mst_tools_ 1192 external procedure is an external procedure. on unit on line 184 64 on unit get_arg_count internal procedure shares stack frame of external procedure mst_tools_. get_in_file internal procedure shares stack frame of external procedure mst_tools_. get_in_medium internal procedure shares stack frame of external procedure mst_tools_. get_in_tape internal procedure shares stack frame of external procedure mst_tools_. get_out_file internal procedure shares stack frame of external procedure mst_tools_. get_out_medium internal procedure shares stack frame of external procedure mst_tools_. get_out_tape internal procedure shares stack frame of external procedure mst_tools_. put_data internal procedure shares stack frame of external procedure mst_tools_. NAME internal procedure shares stack frame of external procedure mst_tools_. NAME_MATCHES internal procedure shares stack frame of external procedure mst_tools_. begin block on line 715 begin block shares stack frame of external procedure mst_tools_. MST_format_error internal procedure shares stack frame of external procedure mst_tools_. clean_up 104 internal procedure is called by several nonquick procedures. clean_up_switch internal procedure shares stack frame of internal procedure clean_up. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME mst_tools_ 000100 ap mst_tools_ 000102 al mst_tools_ 000103 argx mst_tools_ 000104 arg_count mst_tools_ 000106 optp mst_tools_ 000110 optl mst_tools_ 000111 boot_label mst_tools_ 000112 code mst_tools_ 000113 date_time_compiled mst_tools_ 000123 function mst_tools_ 000134 in mst_tools_ 000136 out mst_tools_ 000140 out_seg_ptr mst_tools_ 000142 severityp mst_tools_ 000144 temp_seg_ptrs mst_tools_ 000152 name_len mst_tools_ 000153 seg_len mst_tools_ 000154 header_wc mst_tools_ 000156 atd mst_tools_ 000156 select_list mst_tools_ 000256 in_den mst_tools_ 000257 out_den mst_tools_ 000260 in_file_name mst_tools_ 000332 out_file_name mst_tools_ 000404 in_tape_name mst_tools_ 000414 out_tape_name mst_tools_ 000424 inout mst_tools_ 000434 control_word mst_tools_ 000435 collection_mark mst_tools_ 000436 oi mst_tools_ 000524 expect_seg mst_tools_ 000525 expect_link mst_tools_ 000526 expect_defs mst_tools_ 000530 boot_program_info mst_tools_ 000562 arg_count get_arg_count 000563 code get_arg_count 000652 starx NAME_MATCHES 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 call_int_this call_int_other return_mac alloc_auto_adj enable_op shorten_stack ext_entry int_entry any_to_any_truncate_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_ check_star_name_$entry com_err_ com_err_$suppress_name cu_$arg_count cu_$arg_ptr date_time_ get_shortest_path_ get_temp_segments_ get_wdir_ initiate_file_$create ioa_ iox_$attach_name iox_$close iox_$control iox_$detach_iocb iox_$get_chars iox_$modes iox_$open iox_$put_chars match_star_name_ object_info_$display parse_tape_reel_name_ pathname_ release_temp_segments_ terminate_file_ unique_chars_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. copy_mst_severity_ error_table_$bad_arg error_table_$badopt error_table_$end_of_info error_table_$inconsistent error_table_$noarg excerpt_mst_severity_ list_mst_severity_ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 101 000656 11 000670 16 000677 18 000707 19 000712 20 000715 21 000716 23 000725 24 000730 25 000733 26 000734 28 000743 29 000746 160 000751 162 000753 163 000763 165 000765 166 001002 169 001003 173 001005 175 001037 177 001074 179 001125 182 001126 183 001127 184 001146 188 001170 192 001177 193 001213 194 001216 195 001217 197 001220 198 001227 199 001245 201 001261 203 001271 204 001277 205 001301 207 001304 209 001337 212 001340 213 001341 214 001357 216 001364 217 001365 219 001375 220 001403 221 001405 223 001410 225 001443 228 001444 229 001445 230 001463 232 001470 233 001471 235 001510 236 001516 237 001520 239 001523 241 001556 244 001557 245 001560 246 001576 248 001603 249 001604 251 001617 252 001625 253 001627 255 001632 257 001665 260 001666 261 001667 262 001705 264 001712 265 001713 267 001723 269 001726 271 001761 274 001762 275 001763 276 002001 278 002017 280 002033 283 002046 286 002110 288 002111 290 002112 292 002154 295 002155 297 002156 298 002201 300 002202 301 002203 303 002217 305 002237 307 002247 308 002267 310 002275 311 002327 313 002330 314 002331 315 002336 316 002341 318 002342 319 002366 321 002367 325 002371 329 002413 333 002414 335 002420 341 002421 342 002422 344 002425 346 002433 348 002437 349 002442 350 002452 351 002454 353 002460 354 002466 357 002476 359 002477 361 002501 362 002502 363 002505 365 002515 367 002517 370 002531 371 002532 372 002534 374 002535 376 002537 379 002551 381 002552 384 002553 386 002565 389 002572 391 002576 392 002604 393 002616 395 002617 399 002630 400 002632 401 002655 403 002657 404 002674 405 002726 406 002730 407 002733 408 002772 409 002773 411 002777 412 003052 414 003127 416 003133 418 003200 419 003202 421 003203 422 003213 425 003245 426 003246 429 003250 431 003262 433 003270 434 003315 437 003321 438 003327 441 003335 442 003337 444 003340 445 003346 738 003347 741 003353 450 003354 456 003356 457 003367 461 003373 464 003374 465 003413 467 003415 468 003444 471 003445 473 003460 475 003553 477 003556 478 003606 481 003607 482 003626 484 003630 485 003660 488 003661 489 003667 493 003673 495 003675 496 003677 497 003703 498 003713 499 003717 501 003727 503 003731 504 003734 506 003735 507 003736 508 003750 511 003770 514 003771 517 003772 519 004000 522 004006 524 004032 526 004033 528 004034 531 004035 532 004052 535 004140 537 004244 539 004247 540 004277 543 004300 544 004317 546 004321 547 004351 550 004352 552 004354 553 004406 555 004410 556 004434 559 004435 561 004441 562 004443 564 004446 566 004456 569 004457 572 004460 575 004461 576 004500 578 004502 579 004531 582 004532 584 004545 586 004630 588 004632 589 004662 592 004663 593 004702 595 004704 596 004734 599 004735 603 004737 604 004743 606 004746 607 004750 609 004757 610 004765 611 004771 615 005001 618 005002 621 005003 623 005011 626 005017 628 005043 631 005044 633 005045 635 005046 636 005063 639 005151 641 005265 643 005270 644 005317 647 005320 649 005322 650 005354 652 005356 653 005402 657 005403 658 005422 660 005424 661 005453 663 005454 664 005504 667 005505 672 005507 673 005535 675 005537 677 005613 678 005615 680 005616 682 005617 685 005621 686 005652 688 005656 690 005660 692 005733 693 005735 695 005736 699 005737 703 005741 706 005747 711 005751 714 005756 719 005765 721 006020 724 006026 725 006030 729 006033 733 006044 734 006077 735 006101 743 006102 745 006110 747 006123 750 006136 753 006165 754 006205 756 006206 761 006210 762 006222 764 006235 ----------------------------------------------------------- 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