COMPILATION LISTING OF SEGMENT bft_main_ Compiled by: Multics PL/I Compiler, Release 30, of February 16, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 02/24/88 0847.3 mst Wed Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1987 * 6* * * 7* *********************************************************** */ 8 9 bft_main_: 10 proc () options (main); 11 12 /* PROGRAM FUNCTION 13* 14*This program is the Multics side of the MOWSE application BFT. This program in 15*conjunction with the PC portion, allows a user to transfer files to and from 16*Multics through commands entered on either the PC or at Multics command level. 17*Because this code is designed to run in the "background", all messages are 18*printed out via the MOWSE put_background_message facility, and MUST be used in 19*conjunction with MOWSE and the terminal emulator. For a description of 20*commands see bft.info. 21**/ 22 23 /* NOTES 24**/ 25 26 /****^ HISTORY COMMENTS: 27* 1) change(86-07-22,Eichele), approve(87-06-30,MCR7580), 28* audit(87-07-30,RBarstad), install(87-08-07,MR12.1-1075): 29* Created. 30* 2) change(87-10-23,Flegel), approve(87-10-23,MCR7787), 31* audit(88-01-27,RWaters), install(88-02-24,MR12.2-1028): 32* Converted to use new queueing strategy which handles multiple entries. 33* END HISTORY COMMENTS */ 34 35 /* PARAMETERS */ 36 dcl p_minor_cap fixed bin parameter; /* Minor function number */ 37 dcl p_major_sender fixed bin parameter; /* Source of message */ 38 dcl p_arg_ptr ptr parameter; /* Pointer to message */ 39 dcl p_arg_len fixed bin parameter; /* Length of message */ 40 dcl p_mcb_ptr ptr parameter; /* MOWSE control block */ 41 dcl p_data_block_ptr ptr parameter; /* Data kept around */ 42 43 /* MISC VARIABLES */ 44 dcl command_id fixed bin; /* ID of execute command */ 45 dcl my_major fixed bin; /* Capability number of bft_main_ */ 46 dcl major_num fixed bin; /* Capability number */ 47 dcl mcb_ptr ptr; /* MOWSE control block */ 48 dcl code fixed bin (35); /* Error code */ 49 50 /* STRUCTURES */ 51 52 /* SYSTEM CALLS */ 53 dcl get_equal_name_ entry (char(*), char(*), char(32), fixed bin(35)); 54 dcl hcs_$star_ entry (char(*), char(*), fixed bin(2), ptr, fixed bin, ptr, ptr, fixed bin(35)); 55 dcl absolute_pathname_ entry (char(*), char(*), fixed bin(35)); 56 dcl iox_$get_chars entry (ptr, ptr, fixed bin(21), fixed bin(21), fixed bin(35)); 57 dcl iox_$position entry (ptr, fixed bin, fixed bin(21), fixed bin(35)); 58 dcl convert_status_code_ entry (fixed bin(35), char(8) aligned, char(100) aligned); 59 dcl iox_$put_chars entry (ptr, ptr, fixed bin(21), fixed bin(35)); 60 dcl iox_$open entry (ptr, fixed bin, bit(1) aligned, fixed bin(35)); 61 dcl iox_$attach_name entry (char(*), ptr, char(*), ptr, fixed bin(35)); 62 dcl expand_pathname_ entry (char(*), char(*), char(*), fixed bin(35)); 63 dcl clock_ entry() returns(fixed bin(71)); 64 dcl iox_$destroy_iocb entry (ptr, fixed bin(35)); 65 dcl iox_$detach_iocb entry (ptr, fixed bin(35)); 66 dcl iox_$close entry (ptr, fixed bin(35)); 67 dcl iox_$find_iocb entry (char(*), ptr, fixed bin(35)); 68 dcl com_err_ entry() options(variable); 69 dcl get_system_free_area_ entry() returns(ptr); 70 71 /* SYSTEM CALL SUPPORT */ 72 dcl error_table_$bad_conversion fixed bin(35) ext static; 73 dcl error_table_$short_record fixed bin(35) ext static; 74 dcl error_table_$end_of_info fixed bin(35) ext static; 75 76 /* EXTERNAL CALLS */ 77 dcl bft_queue_$cancel entry (ptr, char(*), fixed bin, fixed bin(35)); 78 dcl bft_queue_$remove entry (ptr, fixed bin, fixed bin(35)); 79 dcl ws_$disconnect_response entry (fixed bin, fixed bin, ptr, fixed bin(35)); 80 dcl ws_$connect_response entry (fixed bin, fixed bin, ptr, fixed bin(35)); 81 dcl ws_$execute_capability entry (fixed bin, fixed bin, ptr, fixed bin, ptr, fixed bin(35)); 82 dcl bft_queue_$add entry (ptr, ptr, fixed bin, fixed bin, fixed bin(35)); 83 dcl ws_$disconnect_request entry (fixed bin, ptr, fixed bin(35)); 84 dcl ws_$execute_command entry (char(*), fixed bin, fixed bin, ptr, fixed bin(35)); 85 dcl ws_$destroy_instance entry (ptr, fixed bin(35)); 86 dcl ws_$put_background_message entry() options(variable); 87 dcl ws_$find_capability_number entry (char(*), fixed bin, fixed bin, fixed bin(35)); 88 dcl ws_$create_instance entry (char(*), char(*), fixed bin, fixed bin, ptr, ptr, fixed bin(35)); 89 dcl bft_queue_$initiate entry (ptr, fixed bin(35)); 90 91 /* EXTERNAL CALL SUPPORT */ 92 dcl bft_error_table_$store_in_progress fixed bin(35) ext static; 93 dcl bft_error_table_$no_entries fixed bin(35) ext static; 94 dcl bft_error_table_$fetch_in_progress fixed bin(35) ext static; 95 dcl bft_error_table_$illegal_minor_capability fixed bin(35) ext static; 96 dcl ws_error_$invalid_minor_capability fixed bin(35) ext static; 97 dcl ws_error_$invalid_capability_name fixed bin(35) ext static; 98 99 /* BUILTINS */ 100 dcl sum builtin; 101 dcl search builtin; 102 dcl rtrim builtin; 103 dcl rank builtin; 104 dcl byte builtin; 105 dcl addr builtin; 106 dcl reverse builtin; 107 dcl convert builtin; 108 dcl ltrim builtin; 109 dcl length builtin; 110 dcl substr builtin; 111 dcl index builtin; 112 dcl unspec builtin; 113 dcl null builtin; 114 115 /* CONDITIONS */ 116 dcl cleanup condition; 117 118 /* CONSTANTS */ 119 dcl NAME char (9) int static options (constant) init ("bft_main_"); 120 dcl fixedbin21 fixed bin (21) based; 121 dcl fixedbin17 fixed bin (17) based; 122 dcl char128var char (128) var based; 123 124 /* */ 125 126 /* INITIALIZATION */ 127 128 code = 0; 129 queue_ptr = null; 130 data_block_ptr = null; 131 132 /* MAIN */ 133 134 /* The first section of code is executed when the bft load command is used. It 135*initializes the necessary variables and notifies MOWSE that it is to be 136*registered as a major cability. */ 137 138 /* Initialize the necessary structures and queues */ 139 140 call initialize_bft (code); 141 if code ^= 0 then do; 142 call com_err_ (code, NAME, "Initializing."); 143 return; 144 end; 145 146 /* : Register as a MOWSE major capability */ 147 148 call ws_$create_instance (NAME, "main_entry", 149 data_block.inbuff_len, data_block.outbuff_len, data_block_ptr, 150 mcb_ptr, code); 151 if code ^= 0 then do; 152 call com_err_ (code, NAME, "Creating MOWSE instance."); 153 return; 154 end; 155 156 /* Check to see if this is more than the first instance of BFT that MOWSE knows 157* about. Multiple instances of BFT are not allowed */ 158 159 major_num = 0; 160 call ws_$find_capability_number (NAME, LOCAL_SYSTEM, major_num, code); 161 if code ^= 0 then do; 162 call ws_$put_background_message (mcb_ptr, code, "bft", 163 "Failed to locate one instance of BFT"); 164 call bft_shut_down (); 165 return; 166 end; 167 168 /* If there exists more than one instance of BFT then delete the current one */ 169 170 my_major = major_num; 171 call ws_$find_capability_number (NAME, LOCAL_SYSTEM, my_major, code); 172 if code = 0 then do; 173 call ws_$put_background_message (mcb_ptr, code, "bft", "Already loaded."); 174 call ws_$destroy_instance (mcb_ptr, code); 175 call cleanup_data_block (); 176 return; 177 end; 178 179 /* Check to see if the PC BFT is loaded */ 180 181 major_num = find_pc_bft (mcb_ptr, "0"b); 182 if major_num ^= 0 then 183 return; 184 185 /* Load PC BFT by executing the proper command */ 186 187 else do; 188 call ws_$execute_command ("bft_load", REMOTE_SYSTEM, command_id, 189 mcb_ptr, code); 190 if code ^= 0 then do; 191 call ws_$put_background_message (mcb_ptr, code, "bft", 192 "Excuting ""PC:bft_load"" command."); 193 call bft_shut_down (); 194 return; 195 end; 196 end; 197 198 return; 199 200 /* */ 201 202 /* INTERNAL ENTRIES */ 203 204 205 /* *** Entry: main_entry - Internal entry for bft_main_ *** */ 206 207 main_entry: 208 entry (p_minor_cap, p_major_sender, p_arg_ptr, p_arg_len, p_mcb_ptr, p_data_block_ptr); 209 210 211 /* ENTRY FUNCTION 212* 213*This is the entry point where all other major capabilities access BFT via 214*MOWSE. The minor capability number determines which of the procedures is 215*called. 216**/ 217 218 /* NOTES 219**/ 220 221 /* Set up addressing */ 222 223 data_block_ptr = p_data_block_ptr; 224 queue_ptr = data_block.queue_ptr; 225 mcb_ptr = p_mcb_ptr; 226 227 /* If we are shutting down, ignore most messages */ 228 229 if data_block.flags.shut_down_sw 230 & p_minor_cap ^= TERMINATE_APPLICATION 231 & p_minor_cap ^= RESPONSE_DISCONNECT 232 & p_minor_cap ^= bft_minor_$bft_shut_down 233 then 234 return; 235 236 /* Verify that the minor capability number is acceptable */ 237 238 if ((p_minor_cap < 32 | p_minor_cap > 50) & (p_minor_cap < 64 | p_minor_cap > 81)) 239 | p_minor_cap = 79 | p_minor_cap = 80 240 241 then do; 242 call ws_$put_background_message (mcb_ptr, 243 ws_error_$invalid_minor_capability, "bft", " ^d.", p_minor_cap); 244 call bft_shut_down (); 245 return; 246 end; 247 248 /* Handle the minor capability */ 249 250 goto case (p_minor_cap); 251 252 case (32): 253 call execute_command_reply (); 254 return; 255 256 case (36): 257 call no_handler ("execute_capability_reply", "1"b); 258 return; 259 260 case (37): 261 call no_handler ("suspend_application", "0"b); 262 return; 263 264 case (38): 265 call no_handler ("resume_application", "0"b); 266 return; 267 268 case (39): 269 call terminate_application (); 270 return; 271 272 case (40): 273 call no_handler ("reset_application", "0"b); 274 return; 275 276 case (41): 277 call no_handler ("reset_reply", "0"b); 278 return; 279 280 case (42): 281 call no_handler ("wake_up", "0"b); 282 return; 283 284 case (43): 285 call no_handler ("status", "0"b); 286 return; 287 288 case (44): 289 call no_handler ("buffer_overflow", "1"b); 290 return; 291 292 case (45): 293 call no_handler ("fail_capability", "1"b); 294 return; 295 296 case (46): 297 call no_handler ("query_reply", "0"b); 298 return; 299 300 case (47): 301 call no_handler ("response_connect", "0"b); 302 return; 303 304 case (48): 305 call response_disconnect (); 306 return; 307 308 case (49): 309 call request_connect (p_major_sender); 310 return; 311 312 case (50): 313 call request_disconnect (p_major_sender); 314 return; 315 316 case (64): 317 call add_to_fetch_queue (p_arg_ptr, p_arg_len, p_major_sender); 318 return; 319 320 case (65): 321 call add_to_store_queue (p_arg_ptr, p_arg_len, p_major_sender); 322 return; 323 324 case (66): /* CHECK_FILE_LENGTH */ 325 return; 326 327 case (67): 328 call initiate_fetch (); 329 return; 330 331 case (68): 332 call bft_shut_down (); 333 return; 334 335 case (69): 336 call position_file_pointer (p_arg_ptr, p_arg_len); 337 return; 338 339 case (70): 340 call receive_data (p_arg_ptr, p_arg_len); 341 return; 342 343 case (71): 344 call receive_eof (); 345 return; 346 347 case (72): 348 call recover_fetch (); 349 return; 350 351 case (73): 352 call recover_store (); 353 return; 354 355 case (74): 356 call read_error (p_arg_ptr, p_arg_len); 357 return; 358 359 case (75): 360 call initiate_store (); 361 return; 362 363 case (76): 364 call write_error (p_arg_ptr, p_arg_len); 365 return; 366 367 case (77): 368 call send_data (); 369 return; 370 371 case (78): 372 call cancel (p_arg_ptr, p_arg_len); 373 return; 374 375 case (79): /* unused */ 376 return; 377 378 case (80): /* EXPAND_PC_PATH */ 379 return; 380 381 case (81): 382 call full_pc_path (p_mcb_ptr, p_arg_ptr, p_arg_len); 383 return; 384 385 /* */ 386 387 /* INTERNAL PROCEDURES */ 388 389 390 /* *** Procedure: add_to_fetch_queue - Internal proc for bft_main_ *** */ 391 392 add_to_fetch_queue: 393 proc (p_arg_ptr, p_arg_len, p_major_sender); 394 395 396 /* PROCEDURE FUNCTION 397* 398*Add the request to the fetch (PC->Multics) queue. 399**/ 400 401 /* NOTES 402**/ 403 404 /* PARAMETERS */ 405 dcl p_arg_ptr ptr parameter; /* Message */ 406 dcl p_arg_len fixed bin parameter; /* Length of message */ 407 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 408 dcl p_major_sender fixed bin parameter; /* Source of message */ 409 410 /* MISC VARIABLES */ 411 dcl priority fixed bin; /* Transfer priority */ 412 dcl flags bit(36) aligned; /* Transfer modes */ 413 dcl pc_path char (66); /* PC path */ 414 dcl mu_path char (168); /* Multics path */ 415 416 /* STRUCTURES */ 417 418 /* INITIALIZATION */ 419 420 /* MAIN */ 421 422 call extract_requests (p_arg_data, mu_path, pc_path, flags, priority); 423 424 call add_to_queue (mu_path, pc_path, flags, priority, p_major_sender, BFT_PC_to_MULTICS); 425 426 end add_to_fetch_queue; 427 428 /* */ 429 430 /* *** Procedure: add_to_queue - Internal proc for bft_main_ *** */ 431 432 add_to_queue: 433 proc (p_mu_path, p_pc_path, p_flags, p_priority, p_sender, p_direction); 434 435 436 /* PROCEDURE FUNCTION 437* 438*This minor capability is responsible for adding elements to the fetch or store 439*queue (PC to Multics transfers). If the request initiated from the local 440*system (Multics), then EXPAND_PC_PATH is called on the PC:BFT to expand the 441*provided PC pathname to an absolute value. Which then returns control to 442*FULL_PC_PATH on MU:BFT continuing the addition of the transfer request to the 443*queue. Otherwise, it is assumed that the remote (PC) sent the full path and 444*the request is entered into the queue. 445* 446*If no fetch is in progress, then a fetch is initiated. 447**/ 448 449 /* NOTES 450* 451*The message data is assumed to be correct: 452* 453* MU_PATH;PC_PATH;FLAGS;PRIORITY; 454**/ 455 456 /* PARAMETERS */ 457 dcl p_mu_path char (*) parameter; /* Multics path */ 458 dcl p_pc_path char (*) parameter; /* PC path */ 459 dcl p_priority fixed bin parameter; /* Priority of request */ 460 dcl p_flags bit(36) aligned parameter; /* Transfer modes */ 461 dcl p_direction fixed bin parameter; /* Direction (store / fetch) */ 462 dcl p_sender fixed bin parameter; /* Sender of message */ 463 464 /* MISC VARIABLES */ 465 dcl code fixed bin (35); 466 dcl pending_ptr ptr; /* Pending structure */ 467 dcl system_free_area area based (data_block.system_free_area_ptr); 468 469 /* STRUCTURES */ 470 dcl 01 element like queue_element automatic; 471 472 /* INITIALIZATION */ 473 unspec (element) = ""b; 474 475 /* MAIN */ 476 element.multics_path = p_mu_path; 477 element.pc_path = p_pc_path; 478 unspec (element.flags) = p_flags; 479 480 /* If the source of the request was from Multics system, then we need to 481* expand the PC path to its fullest */ 482 483 if get_system_id (p_sender) = LOCAL_SYSTEM | p_direction = BFT_PC_to_MULTICS then do; 484 pending_ptr = null; 485 on cleanup call cleanup_pending (pending_ptr); 486 allocate pending set (pending_ptr) in (system_free_area); 487 pending_ptr -> pending.next = null; 488 489 /* Insert the request into the "to-be-completed" list */ 490 491 pending_ptr -> pending.multics_path = rtrim (element.multics_path); 492 pending_ptr -> pending.pc_path = rtrim (element.pc_path); 493 pending_ptr -> pending.flags = unspec (element.flags); 494 pending_ptr -> pending.switches.processing_sw = "0"b; 495 pending_ptr -> pending.switches.first_sw = "1"b; 496 pending_ptr -> pending.switches.pad = ""b; 497 pending_ptr -> pending.priority = p_priority; 498 pending_ptr -> pending.id = 0; 499 call insert_pending (p_direction, pending_ptr); 500 501 revert cleanup; 502 503 call get_pc_path (); 504 end; 505 506 /* Otherwise, add the request to the appropriate queue */ 507 508 else do; 509 element.time_id = clock_ (); 510 call bft_queue_$add (queue_ptr, addr (element), p_priority, 511 p_direction, code); 512 if code ^= 0 then do; 513 call ws_$put_background_message (p_mcb_ptr, code, "bft", 514 "Adding element to ^[store^;fetch^] queue ^d.", 515 (p_direction = BFT_MULTICS_to_PC), p_priority); 516 return; 517 end; 518 end; 519 520 /* Let's start something going if it isn't already */ 521 522 if p_direction = BFT_PC_to_MULTICS then 523 call initiate_fetch (); 524 else 525 call initiate_store (); 526 527 end add_to_queue; 528 529 /* */ 530 531 /* *** Procedure: add_to_store_queue - Internal proc for bft_main_ *** */ 532 533 add_to_store_queue: 534 proc (p_arg_ptr, p_arg_len, p_major_sender); 535 536 537 /* PROCEDURE FUNCTION 538* 539*Add the element to the store queue, if it needs starname expansion for the 540*Multics Path, go ahead and do it. But for every request, there is a high 541*chance that each one must go to the PC for PC expansion to an absolute path of 542*the destination. 543**/ 544 545 /* NOTES 546**/ 547 548 /* PARAMETERS */ 549 dcl p_arg_ptr ptr parameter; /* Message */ 550 dcl p_arg_len fixed bin parameter; /* Length of message */ 551 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 552 dcl p_major_sender fixed bin parameter; /* Sender of request */ 553 554 /* MISC VARIABLES */ 555 dcl pc_entry_name char (11); /* Entry component */ 556 dcl pc_dir_name char (66); /* Directory component */ 557 dcl pc_equal1 char (32); /* For expanding equalnames */ 558 dcl pc_equal char (66); /* Equal name for PC entry */ 559 dcl path_name char (168); /* Full path of request */ 560 dcl entry_name char (32); 561 dcl code fixed bin (35); 562 dcl dir_name char (168); 563 dcl priority fixed bin; /* Priority of request */ 564 dcl flags bit(36) aligned; /* Transfer modes */ 565 dcl pc_path char (66); 566 dcl mu_path char (168); 567 dcl i fixed bin; 568 569 /* STRUCTURES */ 570 571 /* INITIALIZATION */ 572 573 /* MAIN */ 574 call extract_requests (p_arg_data, mu_path, pc_path, flags, priority); 575 576 call expand_pathname_ (mu_path, dir_name, entry_name, code); 577 if code ^= 0 then do; 578 call ws_$put_background_message (mcb_ptr, code, "bft", 579 "Expanding ^a for storing.", mu_path); 580 return; 581 end; 582 583 on cleanup begin; 584 free star_names_ptr -> star_names; 585 free star_entry_ptr -> star_entries; 586 end; 587 588 call hcs_$star_ (dir_name, entry_name, star_ALL_ENTRIES, 589 data_block.system_free_area_ptr, star_entry_count, star_entry_ptr, 590 star_names_ptr, code); 591 if code ^= 0 then do; 592 call ws_$put_background_message (mcb_ptr, code, "bft", 593 "Matching starnames for ^a.", mu_path); 594 return; 595 end; 596 597 do i = 1 to star_entry_count; 598 pc_equal = pc_path; 599 if star_entries (i).type = star_LINK 600 | star_entries (i).type = star_SEGMENT 601 then do; 602 if index (pc_path, "=") ^= 0 then do; 603 call expand_pc_pathname (pc_path, pc_dir_name, pc_entry_name, code); 604 if code ^= 0 then do; 605 call ws_$put_background_message (mcb_ptr, code, "bft", 606 "Expanding ^a for equal name.", pc_path); 607 return; 608 end; 609 610 call get_equal_name_ (star_names (i), pc_entry_name, pc_equal1, 611 code); 612 if code ^= 0 then do; 613 call ws_$put_background_message (mcb_ptr, code, "bft", 614 "Getting equal name for ^a.", star_names (i)); 615 return; 616 end; 617 618 pc_equal = ""; 619 if length (rtrim (pc_dir_name)) > 0 then 620 pc_equal = rtrim (pc_dir_name) || "\"; 621 pc_equal = rtrim (pc_equal) || rtrim (pc_equal1); 622 end; 623 624 path_name = rtrim (dir_name) || ">" || rtrim (star_names (i)); 625 call add_to_queue (path_name, pc_equal, flags, priority, 626 p_major_sender, BFT_MULTICS_to_PC); 627 end; 628 end; 629 630 free star_names_ptr -> star_names; 631 free star_entry_ptr -> star_entries; 632 end add_to_store_queue; 633 634 /* */ 635 636 /* *** Procedure: add_token - Internal proc for bft_main_ *** */ 637 638 add_token: 639 proc (p_message, p_message_len, p_token); 640 641 642 /* PROCEDURE FUNCTION 643* 644*Add the token to the message. 645**/ 646 647 /* NOTES 648**/ 649 650 /* PARAMETERS */ 651 dcl p_message char (*) parameter; /* Message being created */ 652 dcl p_message_len fixed bin parameter; /* Current length of message */ 653 dcl p_token char (*) parameter; /* Token to add */ 654 655 /* MISC VARIABLES */ 656 657 /* STRUCTURES */ 658 659 /* INITIALIZATION */ 660 661 /* MAIN */ 662 663 substr (p_message, p_message_len + 1) = p_token; 664 p_message_len = p_message_len + length (p_token); 665 666 substr (p_message, p_message_len + 1) = DELIM_CHAR; 667 p_message_len = p_message_len + length (DELIM_CHAR); 668 669 end add_token; 670 671 /* */ 672 673 /* *** Procedure: bft_shut_down - Internal proc for bft_main_ *** */ 674 675 bft_shut_down: 676 proc (); 677 678 /* PROCEDURE FUNCTION 679* 680*This routine is called when BFT is to be shut down. A message to this effect 681*ist printed, and then the disconnect request minor is called on the remote 682*machine. When the disconnect_reply is called, this side of bft will shut down. 683**/ 684 685 /* NOTES 686**/ 687 688 /* PARAMETERS */ 689 690 /* MISC VARIABLES */ 691 dcl code fixed bin (35); /* Error code */ 692 dcl major_num fixed bin; /* Capability number */ 693 694 /* STRUCTURES */ 695 696 /* INITIALIZATION */ 697 698 /* MAIN */ 699 700 data_block.flags.shut_down_sw = "1"b; 701 702 /* Close and detach all opened IOCBs */ 703 704 call cleanup_iocb_switches (); 705 706 /* Release all of the pending transfers waiting for pc_path expansion */ 707 708 call cleanup_pending_chain (); 709 710 /* Generate the shutdown message */ 711 712 call ws_$put_background_message (mcb_ptr, 0, "bft", 713 "BFT is shutting down and removing itself from MOWSE."); 714 715 major_num = 0; 716 call ws_$find_capability_number ("BFT", REMOTE_SYSTEM, major_num, code); 717 if code ^= 0 then do; 718 call ws_$put_background_message (mcb_ptr, code, "bft", 719 "Finding PC counterpart in bft_shut_down."); 720 return; 721 end; 722 723 call ws_$disconnect_request (major_num, mcb_ptr, code); 724 if code ^= 0 then do; 725 call ws_$put_background_message (mcb_ptr, code, "bft", 726 "Requesting disconnect in bft_shut_down."); 727 return; 728 end; 729 730 end bft_shut_down; 731 732 /* */ 733 734 /* *** Procedure: cancel - Internal proc for bft_main_ *** */ 735 736 cancel: 737 proc (p_arg_ptr, p_arg_len); 738 739 740 /* PROCEDURE FUNCTION 741* 742*This minor capability cancels the specified request from the queue. The 743*provided request_id is either a path (PC or Multics) or an ID of an entry 744*in the queue. 745**/ 746 747 /* NOTES 748* 749*The message data is assumed tro be correct: 750* 751* ID_SW;REQUEST_ID; 752**/ 753 754 /* PARAMETERS */ 755 dcl p_arg_ptr ptr parameter; /* Message */ 756 dcl p_arg_len fixed bin parameter; /* Message length */ 757 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 758 759 /* MISC VARIABLES */ 760 dcl id_type fixed bin; /* Type of request_id */ 761 dcl request_id char (168); /* Actual request id */ 762 dcl token char (p_arg_len) var; 763 dcl code fixed bin (35); 764 765 /* STRUCTURES */ 766 767 /* INITIALIZATION */ 768 code = 0; 769 770 /* MAIN */ 771 772 /* Strip the request type */ 773 774 call strip_token (p_arg_data, token); 775 id_type = rank (substr (token, 1, 1)); 776 if ^(id_type = BFT_PATH_ID | id_type = BFT_TIME_ID | id_type = BFT_ENTRY_ID) then do; 777 call ws_$put_background_message (mcb_ptr, error_table_$bad_conversion, 778 "bft", "Extracting request_id type."); 779 return; 780 end; 781 782 /* Strip the request id */ 783 784 call strip_token (p_arg_data, token); 785 request_id = ltrim (token); 786 787 /* Cancel the request */ 788 789 call bft_queue_$cancel (queue_ptr, request_id, id_type, code); 790 if code ^= 0 then do; 791 call ws_$put_background_message (mcb_ptr, code, "bft", 792 "Cancelling ^a.", request_id); 793 return; 794 end; 795 796 end cancel; 797 798 /* */ 799 800 /* *** Procedure: chars_to_bits - Internal proc for bft_main_ *** */ 801 802 chars_to_bits: 803 proc (p_precision, p_string) returns (bit(*)); 804 805 806 /* PROCEDURE FUNCTION 807* 808*Convert a character string to a continuous bit representation. 809**/ 810 811 /* NOTES 812**/ 813 814 /* PARAMETERS */ 815 dcl p_precision fixed bin parameter; /* Number of bits to extract */ 816 dcl p_string char (*) parameter; /* Chars to convert */ 817 818 /* MISC VARIABLES */ 819 dcl i fixed bin; 820 dcl ret_string bit(p_precision); /* Return bit string */ 821 822 /* STRUCTURES */ 823 824 /* INITIALIZATION */ 825 826 /* MAIN */ 827 828 ret_string = ""b; 829 do i = 1 to length (p_string); 830 substr (ret_string, p_precision - (i*8)) 831 = unspec (substr (p_string, i, 1)); 832 end; 833 834 return (ret_string); 835 836 end chars_to_bits; 837 838 /* */ 839 840 /* *** Procedure: cleanup_data_block - Internal proc for bft_main_ *** */ 841 842 cleanup_data_block: 843 proc (); 844 845 846 /* PROCEDURE FUNCTION 847* 848*Free the data block structure back to the system. 849**/ 850 851 /* NOTES 852**/ 853 854 /* PARAMETERS */ 855 856 /* MISC VARIABLES */ 857 858 /* STRUCTURES */ 859 860 /* INITIALIZATION */ 861 862 /* MAIN */ 863 864 if data_block_ptr ^= null then do; 865 free data_block_ptr -> data_block; 866 data_block_ptr = null; 867 end; 868 869 end cleanup_data_block; 870 871 /* */ 872 873 /* *** Procedure: cleanup_pending_chain - Internal proc for bft_main_ *** */ 874 875 cleanup_pending_chain: 876 proc (); 877 878 879 /* PROCEDURE FUNCTION 880* 881*Release all of the elements in the chain of pending requests. 882**/ 883 884 /* NOTES 885**/ 886 887 /* PARAMETERS */ 888 889 /* MISC VARIABLES */ 890 dcl temp_ptr ptr; 891 892 /* STRUCTURES */ 893 894 /* INITIALIZATION */ 895 896 /* MAIN */ 897 898 /* Release all of the pending transfers waiting for pc_path expansion */ 899 900 do while (data_block.fetch_pending ^= null); 901 temp_ptr = data_block.fetch_pending -> pending.next; 902 call cleanup_pending (data_block.fetch_pending); 903 data_block.fetch_pending = temp_ptr; 904 end; 905 do while (data_block.store_pending ^= null); 906 temp_ptr = data_block.store_pending -> pending.next; 907 call cleanup_pending (data_block.store_pending); 908 data_block.store_pending = temp_ptr; 909 end; 910 911 end cleanup_pending_chain; 912 913 /* */ 914 915 /* *** Procedure: expand_pc_pathname - Internal proc for bft_main_ *** */ 916 917 expand_pc_pathname: 918 proc (p_source, p_dir_name, p_entry_name, p_code); 919 920 921 /* PROCEDURE FUNCTION 922* 923*Parse apart the PC pathname into its directory and entry components. 924**/ 925 926 /* NOTES 927**/ 928 929 /* PARAMETERS */ 930 dcl p_code fixed bin (35) parameter; 931 dcl p_source char (*) parameter; /* Path to expand */ 932 dcl p_dir_name char (*) parameter; /* Directory component */ 933 dcl p_entry_name char (*) parameter; /* Entry component */ 934 935 /* MISC VARIABLES */ 936 dcl done bit(1); /* Loop control */ 937 dcl i fixed bin; 938 dcl indx fixed bin; 939 940 /* STRUCTURES */ 941 942 /* INITIALIZATION */ 943 p_code = 0; 944 945 /* MAIN */ 946 947 indx = 1; 948 p_dir_name = ""; 949 p_entry_name = ""; 950 done = "0"b; 951 do while (^done & indx < length (rtrim (p_source))); 952 i = index (substr (p_source, indx), "\"); 953 if i > 0 then 954 indx = indx + i; 955 else 956 done = "1"b; 957 end; 958 959 if indx > 1 then 960 p_dir_name = substr (p_source, 1, indx - 2); 961 p_entry_name = substr (rtrim (p_source), indx); 962 963 end expand_pc_pathname; 964 965 /* */ 966 967 /* *** Procedure: extract_requests - Internal proc for bft_main_ *** */ 968 969 extract_requests: 970 proc (p_message, p_mu_path, p_pc_path, p_flags, p_priority); 971 972 973 /* PROCEDURE FUNCTION 974* 975*Extract requests from the message. This is a STORE or FETCH request 976*message with the format: 977* 978* MU_PATH;PC_PATH;FLAGS;PRIORITY; 979**/ 980 981 /* NOTES 982**/ 983 984 /* PARAMETERS */ 985 dcl p_message char (*) parameter; /* Message to extract from */ 986 dcl p_priority fixed bin parameter; 987 dcl p_flags bit(36) aligned parameter; 988 dcl p_pc_path char (*) parameter; 989 dcl p_mu_path char (*) parameter; 990 991 /* MISC VARIABLES */ 992 dcl i fixed bin; 993 dcl ch_flags char (4); /* Character representation of flags */ 994 dcl code fixed bin (35); 995 dcl dir_name char (168); /* Directory of path */ 996 dcl token char (length (p_message)) var; 997 998 /* STRUCTURES */ 999 1000 /* INITIALIZATION */ 1001 1002 /* MAIN */ 1003 1004 /* Get the Multics path, PC path, and flags, in THAT order from the message */ 1005 1006 call strip_token (p_message, token); 1007 dir_name = ltrim (substr (token, 1, length (token))); 1008 call absolute_pathname_ (dir_name, p_mu_path, code); 1009 if code ^= 0 then do; 1010 call ws_$put_background_message (mcb_ptr, code, "bft", 1011 "Expanding ^a.", rtrim (p_mu_path)); 1012 return; 1013 end; 1014 1015 call strip_token (p_message, token); 1016 p_pc_path = ltrim (substr (token, 1, length (token))); 1017 1018 call strip_token (p_message, token); 1019 ch_flags = substr (token, 1, length (token)); 1020 p_flags = ""b; 1021 do i = 1 to 4; 1022 substr (p_flags, (8*(i-1))+1, 8) 1023 = substr (unspec (substr (ch_flags, i, 1)), 2, 8); 1024 end; 1025 substr (unspec (p_flags), 5, 32) = p_flags; 1026 1027 call strip_token (p_message, token); 1028 p_priority = rank (substr (token, 1, 1)); 1029 1030 end extract_requests; 1031 1032 /* */ 1033 1034 /* *** Procedure: find_pending - Internal proc for bft_main_ *** */ 1035 1036 find_pending: 1037 proc (p_pending_ptr, p_start_ptr, p_request_id, p_remove); 1038 1039 1040 /* PROCEDURE FUNCTION 1041* 1042*Lovcate the element corresponding to the request ID. 1043**/ 1044 1045 /* NOTES 1046**/ 1047 1048 /* PARAMETERS */ 1049 dcl p_remove bit(1) parameter; /* Remove the element? */ 1050 dcl p_request_id fixed bin parameter; /* ID of element to be matched */ 1051 dcl p_start_ptr ptr parameter; /* Start of list */ 1052 dcl p_pending_ptr ptr parameter; /* Found element */ 1053 1054 /* MISC VARIABLES */ 1055 dcl prev_ptr ptr; /* Previous element pointer */ 1056 dcl search_ptr ptr; /* Pointer to look with */ 1057 1058 /* STRUCTURES */ 1059 1060 /* INITIALIZATION */ 1061 1062 /* MAIN */ 1063 1064 p_pending_ptr = null; 1065 search_ptr = p_start_ptr; 1066 prev_ptr = null; 1067 1068 if p_start_ptr = null then 1069 return; 1070 1071 do while (search_ptr -> pending.id ^= p_request_id); 1072 prev_ptr = search_ptr; 1073 search_ptr = prev_ptr -> pending.next; 1074 if search_ptr = null then 1075 return; 1076 end; 1077 1078 if search_ptr = null then do; 1079 p_pending_ptr = null; 1080 return; 1081 end; 1082 1083 p_pending_ptr = search_ptr; 1084 1085 if ^p_remove then 1086 return; 1087 1088 if prev_ptr = null then 1089 p_start_ptr = search_ptr -> pending.next; 1090 else 1091 prev_ptr -> pending.next = search_ptr -> pending.next; 1092 p_pending_ptr -> pending.next = null; 1093 1094 end find_pending; 1095 1096 /* */ 1097 1098 /* *** Procedure: full_pc_path - Internal proc for bft_main_ *** */ 1099 1100 full_pc_path: 1101 proc (p_mcb_ptr, p_arg_ptr, p_arg_len); 1102 1103 1104 /* PROCEDURE FUNCTION 1105* 1106*The PC has expanded a path to its full name, the ID of the request is matched 1107*with a pending request and extracted to be inserted into the queue. 1108**/ 1109 1110 /* NOTES 1111* 1112*The argument data is: 1113* 1114* PC_PATH;MAJOR_ID;DIRECTION 1115**/ 1116 1117 /* PARAMETERS */ 1118 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 1119 dcl p_mcb_ptr ptr parameter; /* MOWSE control block */ 1120 dcl p_arg_ptr ptr parameter; /* Message */ 1121 dcl p_arg_len fixed bin parameter; /* Length of message */ 1122 1123 /* MISC VARIABLES */ 1124 dcl equalname char (32); /* Equalname created */ 1125 dcl mu_entryname char (32); /* Multics entry component */ 1126 dcl mu_dirname char (168); /* Multics directory component */ 1127 dcl pc_entryname char (12); /* PC entry componenet */ 1128 dcl pc_dirname char (66); /* PC directory componenet */ 1129 dcl remove_sw bit(1); /* If removal required */ 1130 dcl code fixed bin (35); 1131 dcl pending_ptr ptr; /* Matching element */ 1132 dcl direction fixed bin; /* Direction of transfer */ 1133 dcl major fixed bin; /* Major request id */ 1134 dcl major_id_over fixed bin (17) unal based (addr (major_bit_id)); 1135 dcl major_bit_id bit(18) unal; 1136 dcl token char (p_arg_len) var; 1137 1138 /* STRUCTURES */ 1139 dcl 01 element like queue_element auto; 1140 1141 /* INITIALIZATION */ 1142 1143 /* MAIN */ 1144 1145 call strip_token (p_arg_data, token); 1146 element.pc_path = token; 1147 1148 call strip_token (p_arg_data, token); 1149 major_bit_id = ""b; 1150 substr (major_bit_id, 1, 9 * length (token)) 1151 = reverse (chars_to_bits (9 * length (token), substr (token, 1))); 1152 major_bit_id 1153 = reverse (major_bit_id); 1154 major = major_id_over; 1155 1156 call strip_token (p_arg_data, token); 1157 direction = rank (substr (token, 1, 1)); 1158 1159 /* If the returned path length is 0, no match so remove the element */ 1160 1161 remove_sw = (length (rtrim (element.pc_path)) = 0); 1162 1163 /* Locate the matching element */ 1164 1165 if direction = BFT_PC_to_MULTICS then 1166 call find_pending (pending_ptr, data_block.fetch_pending, major, remove_sw); 1167 else 1168 call find_pending (pending_ptr, data_block.store_pending, major, remove_sw); 1169 if pending_ptr = null then 1170 return; 1171 1172 /* If this was a first request response, and there is no match, then error */ 1173 1174 if pending_ptr -> pending.switches.first_sw & remove_sw 1175 & search (pending_ptr -> pending.pc_path, "?*") > 0 1176 then 1177 call ws_$put_background_message (mcb_ptr, 0, "bft", 1178 "No PC match for ^a.", pending_ptr -> pending.pc_path); 1179 1180 /* Fill out the queue element and add it to the appropriate queue */ 1181 1182 if ^remove_sw then do; 1183 pending_ptr -> pending.switches.processing_sw = "0"b; 1184 pending_ptr ->pending.switches.first_sw = "0"b; 1185 1186 if index (pending_ptr -> pending.multics_path, "=") > 0 then do; 1187 call expand_pc_pathname (element.pc_path, pc_dirname, 1188 pc_entryname, code); 1189 call expand_pathname_ (pending_ptr -> pending.multics_path, 1190 mu_dirname, mu_entryname, code); 1191 if code ^= 0 then do; 1192 call ws_$put_background_message (mcb_ptr, code, "bft", 1193 "Expanding ^a to add to queue.", 1194 pending_ptr -> pending.multics_path); 1195 return; 1196 end; 1197 1198 call get_equal_name_ (pc_entryname, mu_entryname, equalname, code); 1199 if code ^= 0 then do; 1200 call ws_$put_background_message (mcb_ptr, code, "bft", 1201 "Getting equalname ^a to add to queue.",pc_entryname); 1202 return; 1203 end; 1204 1205 element.multics_path = rtrim (mu_dirname) || ">" || equalname; 1206 end; 1207 else 1208 element.multics_path = pending_ptr -> pending.multics_path; 1209 1210 element.next = 0; 1211 element.time_id = clock_ (); 1212 unspec (element.flags) = pending_ptr -> pending.flags; 1213 1214 call bft_queue_$add (queue_ptr, addr (element), 1215 pending_ptr -> pending.priority, direction, code); 1216 if code ^= 0 then do; 1217 call ws_$put_background_message (p_mcb_ptr, code, "bft", 1218 "Adding element to ^[store^;fetch^] queue ^d.", 1219 (direction = BFT_MULTICS_to_PC), pending_ptr -> pending.priority); 1220 return; 1221 end; 1222 end; 1223 else 1224 call cleanup_pending (pending_ptr); 1225 1226 /* Lets get another name expanded, if necessary */ 1227 1228 call get_pc_path (); 1229 1230 /* Lets try for a transfer */ 1231 1232 if ^remove_sw then do; 1233 if direction = BFT_PC_to_MULTICS then 1234 call initiate_fetch (); 1235 else 1236 call initiate_store (); 1237 end; 1238 1239 end full_pc_path; 1240 1241 /* */ 1242 1243 /* *** Procedure: bits_to_chars - Internal proc for bft_main_ *** */ 1244 1245 bits_to_chars: 1246 proc (p_n_bytes, p_bits) returns (char (*)); 1247 1248 1249 /* PROCEDURE FUNCTION 1250* 1251*Convert a continuous bit string to series of characters where 8 bits 1252*are stuffed into each character. 1253**/ 1254 1255 /* NOTES 1256**/ 1257 1258 /* PARAMETERS */ 1259 dcl p_n_bytes fixed bin parameter; /* Number of bytes in number */ 1260 dcl p_bits bit (*); /* Conversion number */ 1261 1262 /* MISC VARIABLES */ 1263 dcl out_string char (p_n_bytes); /* Output string */ 1264 dcl i fixed bin; 1265 1266 /* STRUCTURES */ 1267 1268 /* INITIALIZATION */ 1269 1270 /* MAIN */ 1271 1272 unspec (out_string) = ""b; 1273 do i = 1 to p_n_bytes; 1274 substr (unspec (substr (out_string, i, 1)), 2, 8) 1275 = reverse (substr (reverse (p_bits), (8*(i-1))+1, 8)); 1276 end; 1277 1278 return (reverse (out_string)); 1279 1280 end bits_to_chars; 1281 1282 /* */ 1283 1284 /* *** Procedure: cleanup_iocb_switches - Internal proc for bft_main_ *** */ 1285 1286 cleanup_iocb_switches: 1287 proc (); 1288 1289 1290 /* PROCEDURE FUNCTION 1291* 1292*Close and detach all opend bft switches. This must be done by name. 1293**/ 1294 1295 /* NOTES 1296**/ 1297 1298 /* PARAMETERS */ 1299 1300 /* MISC VARIABLES */ 1301 dcl code fixed bin (35); 1302 dcl iocb_ptr ptr; 1303 1304 /* STRUCTURES */ 1305 1306 /* INITIALIZATION */ 1307 1308 /* MAIN */ 1309 1310 call iox_$find_iocb ("bft_send", iocb_ptr, code); 1311 if code = 0 then 1312 call close_data_file (iocb_ptr); 1313 1314 call iox_$find_iocb ("bft_receive", iocb_ptr, code); 1315 if code = 0 then 1316 call close_data_file (iocb_ptr); 1317 1318 end cleanup_iocb_switches; 1319 1320 /* */ 1321 1322 /* *** Procedure: cleanup_pending - Internal proc for bft_main_ *** */ 1323 1324 cleanup_pending: 1325 proc (p_pending_ptr); 1326 1327 1328 /* PROCEDURE FUNCTION 1329* 1330*Release the structure pointed at by the pointer. 1331**/ 1332 1333 /* NOTES 1334**/ 1335 1336 /* PARAMETERS */ 1337 dcl p_pending_ptr ptr parameter; /* The structure to be cleaned */ 1338 1339 /* MISC VARIABLES */ 1340 1341 /* STRUCTURES */ 1342 1343 /* INITIALIZATION */ 1344 1345 /* MAIN */ 1346 1347 if p_pending_ptr ^= null then do; 1348 free p_pending_ptr -> pending; 1349 p_pending_ptr = null; 1350 end; 1351 1352 end cleanup_pending; 1353 1354 /* */ 1355 1356 /* *** Procedure: close_data_file - Internal proc for bft_main_ *** */ 1357 1358 close_data_file: 1359 proc (p_iocb_ptr); 1360 1361 1362 /* PROCEDURE FUNCTION 1363* 1364*Close the file specified by the iocb. 1365**/ 1366 1367 /* NOTES 1368**/ 1369 1370 /* PARAMETERS */ 1371 dcl p_iocb_ptr ptr parameter; /* IOCB to close */ 1372 1373 /* MISC VARIABLES */ 1374 1375 /* STRUCTURES */ 1376 1377 /* INITIALIZATION */ 1378 1379 /* MAIN */ 1380 1381 call iox_$close (p_iocb_ptr, (0)); 1382 call iox_$detach_iocb (p_iocb_ptr, (0)); 1383 call iox_$destroy_iocb (p_iocb_ptr, (0)); 1384 1385 p_iocb_ptr = null; 1386 1387 end close_data_file; 1388 1389 /* */ 1390 1391 /* *** Procedure: execute_command_reply - Internal proc for bft_main_ *** */ 1392 1393 execute_command_reply: 1394 proc (); 1395 1396 1397 /* PROCEDURE FUNCTION 1398* 1399*This is called by MOWSE as a reply to the excecute command call in the loading 1400*section (main) of this program. There is no code here because it is only used 1401*when MOWSE makes this reply. BFT does not require any information or perform 1402*any function upon receipt of this call. 1403**/ 1404 1405 /* NOTES 1406**/ 1407 1408 /* PARAMETERS */ 1409 1410 /* MISC VARIABLES */ 1411 1412 /* STRUCTURES */ 1413 1414 /* INITIALIZATION */ 1415 1416 /* MAIN */ 1417 1418 end execute_command_reply; 1419 1420 /* */ 1421 1422 /* *** Procedure: execute_pc_bft - Internal proc for bft_main_ *** */ 1423 1424 execute_pc_bft: 1425 proc (p_arg_ptr, p_arg_len, p_minor, p_mcb_ptr, p_code); 1426 1427 1428 /* PROCEDURE FUNCTION 1429* 1430*Execute PC counterpart of BFT. 1431**/ 1432 1433 /* NOTES 1434* 1435*If an error occured, then here is where the shutdown is generated and 1436*the offending error code is passed back up. The code should merely be used 1437*to indicate some error occurred, nothing should be done with it. 1438**/ 1439 1440 /* PARAMETERS */ 1441 dcl p_arg_ptr ptr parameter; /* Message */ 1442 dcl p_arg_len fixed bin parameter; /* Length of message */ 1443 dcl p_minor fixed bin parameter; /* Minor to execute */ 1444 dcl p_mcb_ptr ptr parameter; /* MOWSE control block */ 1445 dcl p_code fixed bin (35) parameter; 1446 1447 /* MISC VARIABLES */ 1448 1449 /* STRUCTURES */ 1450 1451 /* INITIALIZATION */ 1452 1453 /* MAIN */ 1454 1455 if data_block.pc_bft_num = 0 then 1456 if find_pc_bft (p_mcb_ptr, "1"b) = 0 then 1457 return; 1458 1459 call ws_$execute_capability (data_block.pc_bft_num, p_minor, p_arg_ptr, 1460 p_arg_len, p_mcb_ptr, p_code); 1461 if p_code ^= 0 then do; 1462 call ws_$put_background_message (p_mcb_ptr, p_code, "bft", 1463 "Executing PC:BFT, minor ^d.", p_minor); 1464 call bft_shut_down (); 1465 end; 1466 1467 end execute_pc_bft; 1468 1469 /* */ 1470 1471 /* *** Procedure: find_pc_bft - Internal proc for bft_main_ *** */ 1472 1473 find_pc_bft: 1474 proc (p_mcb_ptr, p_shut_down_sw) returns (fixed bin); 1475 1476 1477 /* PROCEDURE FUNCTION 1478* 1479*Locate the PC counterpart of bft. If found, return the major number and 1480*insert it into the data_block. If not found, thenn shut_down (if asked for). 1481**/ 1482 1483 /* NOTES 1484**/ 1485 1486 /* PARAMETERS */ 1487 dcl p_shut_down_sw bit(1) parameter; /* Shut down if true */ 1488 dcl p_mcb_ptr ptr parameter; /* MOWSE control block */ 1489 1490 /* MISC VARIABLES */ 1491 dcl code fixed bin (35); 1492 dcl major_num fixed bin; 1493 1494 /* STRUCTURES */ 1495 1496 /* INITIALIZATION */ 1497 1498 /* MAIN */ 1499 1500 major_num = 0; 1501 call ws_$find_capability_number ("BFT", REMOTE_SYSTEM, major_num, code); 1502 1503 if code ^= 0 & code ^= ws_error_$invalid_capability_name then do; 1504 call ws_$put_background_message (p_mcb_ptr, code, "bft", "Locating PC:BFT."); 1505 if p_shut_down_sw then 1506 call bft_shut_down (); 1507 return (0); 1508 end; 1509 1510 data_block.pc_bft_num = major_num; 1511 1512 return (major_num); 1513 1514 end find_pc_bft; 1515 1516 /* */ 1517 1518 /* *** Procedure: get_pc_path - Internal proc for bft_main_ *** */ 1519 1520 get_pc_path: 1521 proc (); 1522 1523 1524 /* PROCEDURE FUNCTION 1525* 1526*If the top element in the pending list is NOT being processed for a PC path, 1527*then submit the request for an expansion on that PC pathname. 1528**/ 1529 1530 /* NOTES 1531**/ 1532 1533 /* PARAMETERS */ 1534 1535 /* MISC VARIABLES */ 1536 dcl direction fixed bin; /* Direction of transfer request */ 1537 dcl id_token char (2); /* Char conversion if ID */ 1538 dcl pending_ptr ptr; /* Pointer to element to be processed */ 1539 dcl message char (128); /* Message to transmit */ 1540 dcl message_len fixed bin; /* Length of transmitted message */ 1541 1542 /* STRUCTURES */ 1543 1544 /* INITIALIZATION */ 1545 1546 /* MAIN */ 1547 1548 /* If the top request is in process, return */ 1549 1550 if data_block.store_pending ^= null then do; 1551 if data_block.store_pending -> pending.switches.processing_sw then 1552 return; 1553 end; 1554 else if data_block.fetch_pending ^= null then do; 1555 if data_block.fetch_pending -> pending.switches.processing_sw then 1556 return; 1557 end; 1558 else 1559 return; 1560 1561 /* Lets give STORE expansion priority, there will probably be fewer */ 1562 1563 pending_ptr = data_block.store_pending; 1564 direction = BFT_MULTICS_to_PC; 1565 if pending_ptr = null then do; 1566 pending_ptr = data_block.fetch_pending; 1567 direction = BFT_PC_to_MULTICS; 1568 end; 1569 pending_ptr -> pending.switches.processing_sw = "1"b; 1570 1571 /* Send out the message */ 1572 1573 message_len = 0; 1574 if pending_ptr -> pending.switches.first_sw then do; 1575 call add_token (message, message_len, BFT_FIRST); 1576 call add_token (message, message_len, 1577 rtrim (pending_ptr -> pending.pc_path)); 1578 end; 1579 else do; 1580 call add_token (message, message_len, BFT_NEXT); 1581 call add_token (message, message_len, ""); 1582 end; 1583 1584 id_token = bits_to_chars (2, unspec (pending_ptr -> pending.id)); 1585 if substr (id_token, 1, 1) = "" then 1586 call add_token (message, message_len, substr (id_token, 2, 1)); 1587 else 1588 call add_token (message, message_len, id_token); 1589 1590 call add_token (message, message_len, byte (direction)); 1591 1592 call execute_pc_bft (addr (message), message_len, 1593 bft_minor_$expand_pc_path, mcb_ptr, (0)); 1594 1595 end get_pc_path; 1596 1597 /* */ 1598 1599 /* *** Procedure: get_system_id - Internal proc for bft_main_ *** */ 1600 1601 get_system_id: 1602 proc (p_major) returns (fixed bin); 1603 1604 1605 /* PROCEDURE FUNCTION 1606* 1607*Extract the system ID from the capability number. 1608**/ 1609 1610 /* NOTES 1611**/ 1612 1613 /* PARAMETERS */ 1614 dcl p_major fixed bin parameter; /* Capability number to extract from */ 1615 1616 /* MISC VARIABLES */ 1617 1618 /* STRUCTURES */ 1619 dcl 01 major_overlay unaligned based (addr (p_major)), 1620 02 pad bit (18), 1621 02 system fixed bin (8), 1622 02 index fixed bin (8); 1623 1624 /* INITIALIZATION */ 1625 1626 /* MAIN */ 1627 1628 return (major_overlay.system); 1629 1630 end get_system_id; 1631 1632 /* */ 1633 1634 /* *** Procedure: initialize_bft - Internal proc for bft_main_ *** */ 1635 1636 initialize_bft: 1637 proc (p_code); 1638 1639 1640 /* PROCEDURE FUNCTION 1641* 1642*This sets all of the variables that BFT needs to access when it is called up. 1643**/ 1644 1645 /* NOTES 1646**/ 1647 1648 /* PARAMETERS */ 1649 dcl p_code fixed bin (35) parameter; /* Error code */ 1650 1651 /* MISC VARIABLES */ 1652 dcl system_free_area area based (system_free_area_ptr); 1653 dcl system_free_area_ptr ptr; 1654 1655 /* STRUCTURES */ 1656 1657 /* INITIALIZATION */ 1658 p_code = 0; 1659 1660 /* MAIN */ 1661 1662 system_free_area_ptr = get_system_free_area_ (); 1663 allocate data_block in (system_free_area) set (data_block_ptr); 1664 unspec (data_block) = ""b; 1665 1666 data_block.version = BFT_DATA_BLOCK_VERSION_1; 1667 data_block.pc_bft_num = 0; 1668 data_block.inbuff_len = BFT_INBUFF_LENGTH; 1669 data_block.outbuff_len = BFT_OUTBUFF_LENGTH; 1670 data_block.receive_iocb_ptr = null; 1671 data_block.send_iocb_ptr = null; 1672 data_block.system_free_area_ptr = system_free_area_ptr; 1673 data_block.fetch_pending = null; 1674 data_block.store_pending = null; 1675 data_block.flags.shut_down_sw = "0"b; 1676 1677 call bft_queue_$initiate (queue_ptr, p_code); 1678 if p_code ^= 0 then 1679 return; 1680 data_block.queue_ptr = queue_ptr; 1681 1682 end initialize_bft; 1683 1684 /* */ 1685 1686 /* *** Procedure: initiate_fetch - Internal proc for bft_main_ *** */ 1687 1688 initiate_fetch: 1689 proc (); 1690 1691 1692 /* PROCEDURE FUNCTION 1693* 1694*This procedure / minor capability, examines the PC_to_MULTICS (fetch) queue 1695*and determines if it is possible to begin transfer of another file. Conditions 1696*are acceptable only when a PC_to_MULTICS (fetch) is not currently in progress 1697*and there exists an element in the PC_to_MULTICS (fetch) queue. 1698**/ 1699 1700 /* NOTES 1701**/ 1702 1703 /* PARAMETERS */ 1704 1705 /* MISC VARIABLES */ 1706 dcl message_len fixed bin; /* Length of message */ 1707 dcl message char (128); /* Message sent out */ 1708 dcl code fixed bin (35); 1709 1710 /* STRUCTURES */ 1711 1712 /* INITIALIZATION */ 1713 1714 /* MAIN */ 1715 1716 /* Extract the next element from the fetch queue, repeat until we got one */ 1717 1718 do while ("1"b); 1719 call bft_queue_$remove (queue_ptr, BFT_PC_to_MULTICS, code); 1720 if code = bft_error_table_$fetch_in_progress | code = bft_error_table_$no_entries then 1721 return; 1722 else if code ^= 0 then do; 1723 call ws_$put_background_message (mcb_ptr, code, "bft", 1724 "Getting next entry from fetch queue."); 1725 call bft_shut_down (); 1726 return; 1727 end; 1728 1729 /* Open the destination (Multics) file */ 1730 1731 call open_receive_data_file (rtrim (queue.header.fetching.multics_path), 1732 "0"b, code); 1733 if code ^= 0 then do; 1734 queue.header.fetching.flags.initiated = "0"b; 1735 queue.header.fetch_file_pos = 0; 1736 call ws_$put_background_message (mcb_ptr, code, "bft", 1737 "Opening ^a.", rtrim (queue.header.fetching.multics_path)); 1738 end; 1739 else do; 1740 message_len = 0; 1741 call add_token (message, message_len, 1742 rtrim (queue.header.fetching.pc_path)); 1743 call add_token (message, message_len, 1744 bits_to_chars (4, unspec (queue.header.fetching.flags))); 1745 call execute_pc_bft (addr (message), message_len, 1746 bft_minor_$initiate_fetch, mcb_ptr, code); 1747 if code ^= 0 then 1748 return; 1749 end; 1750 end; 1751 1752 end initiate_fetch; 1753 1754 /* */ 1755 1756 /* *** Procedure: initiate_store - Internal proc for bft_main_ *** */ 1757 1758 initiate_store: 1759 proc (); 1760 1761 1762 /* PROCEDURE FUNCTION 1763* 1764*This procedure / minor capability, examines the MULTICS_to_PC (store) queue 1765*and determines if it is possible to begin transfer of another file. Conditions 1766*are acceptable only when a MULTICS_to_PC (store) is not currently in progress 1767*and there exists an element in the MULTICS_to_PC (store) queue. 1768**/ 1769 1770 /* NOTES 1771**/ 1772 1773 /* PARAMETERS */ 1774 1775 /* MISC VARIABLES */ 1776 dcl message char (256); 1777 dcl message_len fixed bin; /* Length of message to send */ 1778 dcl code fixed bin (35); 1779 1780 /* STRUCTURES */ 1781 1782 /* INITIALIZATION */ 1783 1784 /* MAIN */ 1785 1786 /* Extract the next element from the store queue, repeat until we got one */ 1787 1788 do while ("1"b); 1789 call bft_queue_$remove (queue_ptr, BFT_MULTICS_to_PC, code); 1790 if code = bft_error_table_$store_in_progress | code = bft_error_table_$no_entries then 1791 return; 1792 else if code ^= 0 then do; 1793 call ws_$put_background_message (mcb_ptr, code, "bft", 1794 "Getting next entry from store queue."); 1795 call bft_shut_down (); 1796 return; 1797 end; 1798 1799 /* Open the source (Multics) file */ 1800 1801 call open_send_data_file (rtrim (queue.header.storing.multics_path), 1802 code); 1803 if code ^= 0 then do; 1804 queue.header.storing.flags.initiated = "0"b; 1805 queue.header.store_file_pos = 0; 1806 call ws_$put_background_message (mcb_ptr, code, "bft", 1807 "Opening ^a.", rtrim (queue.header.storing.multics_path)); 1808 end; 1809 else do; 1810 message_len = 0; 1811 call add_token (message, message_len, 1812 rtrim (queue.header.storing.pc_path)); 1813 call add_token (message, message_len, 1814 bits_to_chars (4, unspec (queue.header.storing.flags))); 1815 call execute_pc_bft (addr (message), message_len, 1816 bft_minor_$initiate_store, mcb_ptr, code); 1817 if code ^= 0 then 1818 return; 1819 end; 1820 end; 1821 1822 end initiate_store; 1823 1824 /* */ 1825 1826 /* *** Procedure: insert_pending - Internal proc for bft_main_ *** */ 1827 1828 insert_pending: 1829 proc (p_direction, p_pending_ptr); 1830 1831 1832 /* PROCEDURE FUNCTION 1833* 1834*Insert the pending request into the appropriate chain. 1835**/ 1836 1837 /* NOTES 1838**/ 1839 1840 /* PARAMETERS */ 1841 dcl p_direction fixed bin parameter; /* Which direction */ 1842 dcl p_pending_ptr ptr parameter; /* Structure to insert */ 1843 1844 /* MISC VARIABLES */ 1845 dcl start_ptr ptr; 1846 1847 /* STRUCTURES */ 1848 1849 /* INITIALIZATION */ 1850 1851 /* MAIN */ 1852 1853 if p_direction = BFT_PC_to_MULTICS then do; 1854 if data_block.fetch_pending = null then do; 1855 data_block.fetch_pending = p_pending_ptr; 1856 p_pending_ptr -> pending.id = 1; 1857 return; 1858 end; 1859 else 1860 start_ptr = data_block.fetch_pending; 1861 end; 1862 else do; 1863 if data_block.store_pending = null then do; 1864 data_block.store_pending = p_pending_ptr; 1865 p_pending_ptr -> pending.id = 1; 1866 return; 1867 end; 1868 else 1869 start_ptr = data_block.store_pending; 1870 end; 1871 1872 /* Traverse the list */ 1873 1874 do while (start_ptr -> pending.next ^= null); 1875 start_ptr = start_ptr -> pending.next; 1876 end; 1877 start_ptr -> pending.next = p_pending_ptr; 1878 1879 p_pending_ptr -> pending.id = start_ptr -> pending.id + 1; 1880 1881 end insert_pending; 1882 1883 /* */ 1884 1885 /* *** Procedure: no_handler - Internal proc for bft_main_ *** */ 1886 1887 no_handler: 1888 proc (p_message, p_shut_down_sw); 1889 1890 1891 /* PROCEDURE FUNCTION 1892* 1893*This procedure displays an error message indicating that the called minor 1894*capability is NOT supported. 1895**/ 1896 1897 /* NOTES 1898**/ 1899 1900 /* PARAMETERS */ 1901 dcl p_shut_down_sw bit(1) parameter; /* If shut down is required */ 1902 dcl p_message char (*) parameter; /* Message to accompany error. */ 1903 1904 /* MISC VARIABLES */ 1905 1906 /* STRUCTURES */ 1907 1908 /* INITIALIZATION */ 1909 1910 /* MAIN */ 1911 1912 call ws_$put_background_message (mcb_ptr, 1913 bft_error_table_$illegal_minor_capability, "bft", p_message); 1914 if p_shut_down_sw then 1915 call bft_shut_down (); 1916 1917 end no_handler; 1918 1919 /* */ 1920 1921 /* *** Procedure: open_receive_data_file - Internal proc for bft_main_ *** */ 1922 1923 open_receive_data_file: 1924 proc (p_path, p_append_sw, p_code); 1925 1926 1927 /* PROCEDURE FUNCTION 1928* 1929*Open the receive data file for writing. If the p_append flag is true, then the 1930*file is being recovered and we need to open it and set the file position to the 1931*character specified in the value segment. Otherwise the file will be destroyed 1932*if it already exists. 1933**/ 1934 1935 /* NOTES 1936**/ 1937 1938 /* PARAMETERS */ 1939 dcl p_path char (*) parameter; /* Path to open */ 1940 dcl p_append_sw bit(1) parameter; /* Open for append */ 1941 dcl p_code fixed bin (35) parameter; /* Error code */ 1942 1943 /* MISC VARIABLES */ 1944 dcl iocb_ptr ptr; /* IOCB being opened */ 1945 dcl open_descrip char (256); /* Opening modes */ 1946 1947 /* STRUCTURES */ 1948 1949 /* INITIALIZATION */ 1950 p_code = 0; 1951 1952 /* MAIN */ 1953 1954 /* If the file is already open, then close it */ 1955 1956 if data_block.receive_iocb_ptr ^= null then 1957 call close_data_file (data_block.receive_iocb_ptr); 1958 1959 /* Close and detach the bft_receive IOCB if it exists */ 1960 1961 call iox_$find_iocb ("bft_receive", iocb_ptr, p_code); 1962 if p_code = 0 then 1963 call close_data_file (iocb_ptr); 1964 1965 /* Open the file and attach the iocb pointer */ 1966 1967 open_descrip = "vfile_ " || rtrim (p_path); 1968 if p_append_sw then 1969 open_descrip = rtrim (open_descrip) || " -append"; 1970 1971 call iox_$attach_name ("bft_receive", iocb_ptr, open_descrip, null, p_code); 1972 if p_code ^= 0 then 1973 return; 1974 1975 call iox_$open (iocb_ptr, Stream_input_output, ("0"b), p_code); 1976 if p_code ^= 0 then 1977 return; 1978 1979 /* Return with the new IOCB and set the data_block value to it */ 1980 1981 data_block.receive_iocb_ptr = iocb_ptr; 1982 1983 end open_receive_data_file; 1984 1985 /* */ 1986 1987 /* *** Procedure: open_send_data_file - Internal proc for bft_main_ *** */ 1988 1989 open_send_data_file: 1990 proc (p_path, p_code); 1991 1992 1993 /* PROCEDURE FUNCTION 1994* 1995*Open the specified file for sending data. 1996**/ 1997 1998 /* NOTES 1999**/ 2000 2001 /* PARAMETERS */ 2002 dcl p_path char (*) parameter; /* Path to open */ 2003 dcl p_code fixed bin (35) parameter; 2004 2005 /* MISC VARIABLES */ 2006 dcl open_descrip char (256); /* Opening modes */ 2007 dcl iocb_ptr ptr; 2008 2009 /* STRUCTURES */ 2010 2011 /* INITIALIZATION */ 2012 p_code = 0; 2013 2014 /* MAIN */ 2015 2016 /* If we have already opened the send file, then close it */ 2017 2018 if data_block.send_iocb_ptr ^= null then 2019 call close_data_file (data_block.send_iocb_ptr); 2020 2021 /* Close and detach the bft_send IOCB if it exists */ 2022 2023 call iox_$find_iocb ("bft_send", iocb_ptr, p_code); 2024 if p_code = 0 then 2025 call close_data_file (iocb_ptr); 2026 2027 /* Lets get ahold of it and store it in the data block */ 2028 2029 open_descrip = "vfile_ " || rtrim (p_path); 2030 call iox_$attach_name ("bft_send", iocb_ptr, open_descrip, null, p_code); 2031 if p_code ^= 0 then 2032 return; 2033 2034 call iox_$open (iocb_ptr, Stream_input, ("0"b), p_code); 2035 if p_code ^= 0 then 2036 return; 2037 2038 /* Return with the new IOCB and set the data_block value to it */ 2039 2040 data_block.send_iocb_ptr = iocb_ptr; 2041 2042 end open_send_data_file; 2043 2044 /* */ 2045 2046 /* *** Procedure: position_file_pointer - Internal proc for bft_main_ *** */ 2047 2048 position_file_pointer: 2049 proc (p_arg_ptr, p_arg_len); 2050 2051 2052 /* PROCEDURE FUNCTION 2053* 2054*This minor capability is called during the recovery process to set the output 2055*file pointer to correspond with the size of the file that has already been 2056*received by the remote (during a store). This value is passed via the argument 2057*list from CHECK_FILE_LENGTH. If all goes well, the transfer is continued from 2058*the position specified. 2059**/ 2060 2061 /* NOTES 2062* 2063*The argument data is: 2064* 2065* FILE_LENGTH 2066**/ 2067 2068 /* PARAMETERS */ 2069 dcl p_arg_ptr ptr parameter; /* Message */ 2070 dcl p_arg_len fixed bin parameter; /* Message length */ 2071 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 2072 2073 /* MISC VARIABLES */ 2074 dcl mode fixed bin; /* Positioning mode */ 2075 dcl byte_count fixed bin (21); /* File position */ 2076 dcl token char (p_arg_len) var; 2077 2078 /* STRUCTURES */ 2079 2080 /* INITIALIZATION */ 2081 2082 /* MAIN */ 2083 2084 /* Get the file position from the argument list */ 2085 2086 call strip_token (p_arg_data, token); 2087 byte_count = convert (byte_count, token); 2088 2089 /* Open the file that was in transfer */ 2090 2091 call open_send_data_file (rtrim (queue.header.storing.multics_path), code); 2092 if code ^= 0 then do; 2093 queue.header.storing.flags.initiated = "0"b; 2094 queue.header.store_file_pos = 0; 2095 call ws_$put_background_message (mcb_ptr, code, "bft", 2096 "Opening ^a for positioning.", 2097 rtrim (queue.header.storing.multics_path)); 2098 call initiate_store (); 2099 return; 2100 end; 2101 2102 /* Position in the file to the appropriate byte / line position */ 2103 2104 queue.header.store_file_pos = byte_count; 2105 if queue.header.storing.flags.binary_sw then 2106 mode = 2; 2107 else 2108 mode = 0; 2109 2110 call iox_$position (data_block.send_iocb_ptr, -1, 0, code); 2111 call iox_$position (data_block.send_iocb_ptr, mode, 2112 queue.header.store_file_pos, code); 2113 if code ^= 0 then do; 2114 queue.header.storing.flags.initiated = "0"b; 2115 queue.header.store_file_pos = 0; 2116 call ws_$put_background_message (mcb_ptr, code, "bft", 2117 "Positioning file ^a.", 2118 rtrim (queue.header.storing.multics_path)); 2119 call initiate_store (); 2120 return; 2121 end; 2122 2123 /* Begin the transfer from the new file position */ 2124 2125 call send_data (); 2126 2127 end position_file_pointer; 2128 2129 /* */ 2130 2131 /* *** Procedure: read_error - Internal proc for bft_main_ *** */ 2132 2133 read_error: 2134 proc (p_arg_ptr, p_arg_len); 2135 2136 2137 /* PROCEDURE FUNCTION 2138* 2139*This procedure is called by the remote machine to signal an error occurred 2140*while the remote machine was sending a file. The proper cleanup is done and 2141*the queues are checked to see if there are any pending requests. 2142**/ 2143 2144 /* NOTES 2145**/ 2146 2147 /* PARAMETERS */ 2148 dcl p_arg_ptr ptr parameter; /* Message */ 2149 dcl p_arg_len fixed bin parameter; /* Message length */ 2150 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 2151 2152 /* MISC VARIABLES */ 2153 dcl error_string char (128) var; 2154 2155 /* STRUCTURES */ 2156 2157 /* INITIALIZATION */ 2158 2159 /* MAIN */ 2160 2161 /* Extract the error message from the argument string */ 2162 2163 call strip_token (p_arg_data, error_string); 2164 call ws_$put_background_message (mcb_ptr, 0, "bft", error_string); 2165 2166 /* Remove the current fetch from the queue */ 2167 2168 queue.header.fetching.flags.initiated = "0"b; 2169 queue.header.fetch_file_pos = 0; 2170 call close_data_file (data_block.receive_iocb_ptr); 2171 2172 /* Try for another request from the fetch queue */ 2173 2174 call initiate_fetch (); 2175 2176 end read_error; 2177 2178 /* */ 2179 2180 /* *** Procedure: receive_data - Internal proc for bft_main_ *** */ 2181 2182 receive_data: 2183 proc (p_arg_ptr, p_arg_len); 2184 2185 2186 /* PROCEDURE FUNCTION 2187* 2188*This is the minor capability responsible for writing the data it receives as an 2189*argument to the destination file. The name of the is kept in the value 2190*segment. The file is opened , and the data is written out. Then SEND_DATA is 2191*called on the remote machine to send the next piece of the file. 2192**/ 2193 2194 /* NOTES 2195**/ 2196 2197 /* PARAMETERS */ 2198 dcl p_arg_ptr ptr parameter; /* Message */ 2199 dcl p_arg_len fixed bin parameter; /* Message length */ 2200 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 2201 2202 /* MISC VARIABLES */ 2203 dcl mu_entryname char (32); 2204 dcl mu_dirname char (168); 2205 dcl line_len fixed bin; 2206 dcl line_start fixed bin; /* Position of in data */ 2207 dcl message char (128); /* Message to send */ 2208 dcl long_info char (100) aligned; /* Long error */ 2209 dcl short_info char (8) aligned; /* Short error */ 2210 dcl code fixed bin (35); 2211 2212 /* STRUCTURES */ 2213 2214 /* INITIALIZATION */ 2215 2216 /* MAIN */ 2217 2218 /* Verify that this transfer has NOT been cancelled midestream */ 2219 2220 if ^queue.header.fetching.flags.initiated then do; 2221 queue.header.fetch_file_pos = 0; 2222 call close_data_file (data_block.receive_iocb_ptr); 2223 2224 call expand_pathname_ (rtrim (queue.header.fetching.multics_path), 2225 mu_dirname, mu_entryname, code); 2226 message = "Fetch request " || rtrim (mu_entryname); 2227 message = rtrim (message) || " cancelled in progress."; 2228 call execute_pc_bft (addr (message), length (rtrim (message)), 2229 bft_minor_$write_error, mcb_ptr, (0)); 2230 return; 2231 end; 2232 2233 /* Write the bytes that were passed into the file */ 2234 2235 call iox_$put_chars (data_block.receive_iocb_ptr, p_arg_ptr, 2236 convert (fixedbin21, p_arg_len), code); 2237 if code ^= 0 then do; 2238 queue.header.fetching.flags.initiated = "0"b; 2239 queue.header.fetch_file_pos = 0; 2240 call close_data_file (data_block.receive_iocb_ptr); 2241 2242 call convert_status_code_ (code, short_info, long_info); 2243 message = rtrim (long_info) || ". Receiving data."; 2244 call execute_pc_bft (addr (message), length (rtrim (message)), 2245 bft_minor_$write_error, mcb_ptr, (0)); 2246 return; 2247 end; 2248 2249 /* Increment the count of received chars/lines */ 2250 2251 if queue.header.fetching.flags.binary_sw then 2252 queue.header.fetch_file_pos 2253 = queue.header.fetch_file_pos + convert (fixedbin21, p_arg_len); 2254 else do; 2255 line_len = index (substr (p_arg_data, 1), byte (10)); 2256 line_start = line_len; 2257 do while (line_len > 0); 2258 queue.header.fetch_file_pos = queue.header.fetch_file_pos + 1; 2259 line_len = index (substr (p_arg_data, line_start + 1), byte (10)); 2260 line_start = line_start + line_len; 2261 end; 2262 end; 2263 2264 /* Prod PC:BFT for another chunk */ 2265 2266 call execute_pc_bft (null, 0, bft_minor_$send_data, mcb_ptr, code); 2267 if code ^= 0 then 2268 return; 2269 2270 end receive_data; 2271 2272 /* */ 2273 2274 /* *** Procedure: receive_eof - Internal proc for bft_main_ *** */ 2275 2276 receive_eof: 2277 proc (); 2278 2279 2280 /* PROCEDURE FUNCTION 2281* 2282*This routine performs the proper cleanup after the local machine receives an 2283*end of file. 2284**/ 2285 2286 /* NOTES 2287**/ 2288 2289 /* PARAMETERS */ 2290 2291 /* MISC VARIABLES */ 2292 2293 /* STRUCTURES */ 2294 2295 /* INITIALIZATION */ 2296 2297 /* MAIN */ 2298 2299 /* Clear the flags indicating that a fetch was in progress */ 2300 2301 queue.header.fetching.flags.initiated = "0"b; 2302 queue.header.fetch_file_pos = 0; 2303 2304 /* Close the IOCB and notify completion */ 2305 2306 call close_data_file (data_block.receive_iocb_ptr); 2307 if queue.header.fetching.flags.notify_sw then 2308 call ws_$put_background_message (mcb_ptr, 0, "bft", 2309 "Completed transfer of ^a to Multics.", 2310 rtrim (queue.header.fetching.multics_path)); 2311 2312 /* Try for another fetch */ 2313 2314 call initiate_fetch (); 2315 2316 end receive_eof; 2317 2318 /* */ 2319 2320 /* *** Procedure: recover_fetch - Internal proc for bft_main_ *** */ 2321 2322 recover_fetch: 2323 proc (); 2324 2325 2326 /* PROCEDURE FUNCTION 2327* 2328*The fetch (PC_to_MULTICS) queue is examined for an interrupted request. If one 2329*exists, then it is resumed by calling POSITION_FILE_POINTER on PC:BFT to set 2330*the continuation mark of the fetch. If there is no interrupted reqest, then 2331*the rest of the queue is attempted to be started through initiateing a store. 2332**/ 2333 2334 /* NOTES 2335* 2336*No arguments are required as it is automatic. 2337**/ 2338 2339 /* PARAMETERS */ 2340 2341 /* MISC VARIABLES */ 2342 dcl code fixed bin (35); 2343 dcl message char (128); 2344 dcl message_len fixed bin; 2345 2346 /* STRUCTURES */ 2347 2348 /* INITIALIZATION */ 2349 2350 /* MAIN */ 2351 2352 /* If there is no current request (ie. interrupted) then initiate a new fetch */ 2353 2354 if ^queue.header.fetching.initiated then do; 2355 call initiate_fetch (); 2356 return; 2357 end; 2358 2359 /* Open the file */ 2360 2361 call open_receive_data_file (rtrim (queue.header.fetching.multics_path), 2362 "1"b, code); 2363 if code ^= 0 then do; 2364 queue.header.fetching.flags.initiated = "0"b; 2365 queue.header.fetch_file_pos = 0; 2366 call ws_$put_background_message (mcb_ptr, code, "bft", 2367 "Opening ^a.", rtrim (queue.header.fetching.multics_path)); 2368 call initiate_fetch (); 2369 return; 2370 end; 2371 2372 /* If the file_type is "ascii", then position to the next char after last LF */ 2373 2374 if ^queue.header.fetching.flags.binary_sw then do; 2375 call iox_$position (data_block.receive_iocb_ptr, -1, 0, code); 2376 call iox_$position (data_block.receive_iocb_ptr, 0, 2377 queue.header.fetch_file_pos, code); 2378 if code ^= 0 then do; 2379 queue.header.fetching.flags.initiated = "0"b; 2380 queue.header.fetch_file_pos = 0; 2381 call ws_$put_background_message (mcb_ptr, code, "bft", 2382 "Line positioning ^a.", 2383 rtrim (queue.header.fetching.multics_path)); 2384 call initiate_fetch (); 2385 return; 2386 end; 2387 end; 2388 2389 /* Position the source file_pointer on the remote */ 2390 2391 message_len = 0; 2392 call add_token (message, message_len, rtrim (queue.header.fetching.pc_path)); 2393 call add_token (message, message_len, convert (char128var, queue.header.fetch_file_pos)); 2394 call add_token (message, message_len, 2395 bits_to_chars (4, unspec (queue.header.fetching.flags))); 2396 call execute_pc_bft (addr (message), message_len, 2397 bft_minor_$position_file_pointer, mcb_ptr, code); 2398 if code ^= 0 then 2399 return; 2400 2401 end recover_fetch; 2402 2403 /* */ 2404 2405 /* *** Procedure: recover_store - Internal proc for bft_main_ *** */ 2406 2407 recover_store: 2408 proc (); 2409 2410 2411 /* PROCEDURE FUNCTION 2412* 2413*The store (MULTICS_to_PC) queue is examined for an interrupted request. If 2414*one exists, then it is resumed by calling CHECK_FILE_LENGTH on PC:BFT to see 2415*where it is to continue from. If there is no interrupted reqest, then the 2416*rest of the queue is attempted to be started through initiateing a store. 2417**/ 2418 2419 /* NOTES 2420* 2421*No arguments are required as all is automatic. 2422**/ 2423 2424 /* PARAMETERS */ 2425 2426 /* MISC VARIABLES */ 2427 dcl code fixed bin (35); 2428 dcl message_len fixed bin; /* Length of message */ 2429 dcl message char (128); 2430 2431 /* STRUCTURES */ 2432 2433 /* INITIALIZATION */ 2434 2435 /* MAIN */ 2436 2437 /* If there is no current request (ie. interrupted) then initiate a new store */ 2438 2439 if ^queue.header.storing.initiated then do; 2440 call initiate_store (); 2441 return; 2442 end; 2443 2444 /* Otherwise, get the interrupted request back on track */ 2445 2446 message_len = 0; 2447 call add_token (message, message_len, rtrim (queue.header.storing.pc_path)); 2448 call add_token (message, message_len, 2449 bits_to_chars (4, unspec (queue.header.storing.flags))); 2450 call execute_pc_bft (addr (message), message_len, 2451 bft_minor_$check_file_length, mcb_ptr, code); 2452 if code ^= 0 then 2453 return; 2454 2455 end recover_store; 2456 2457 /* */ 2458 2459 /* *** Procedure: request_connect - Internal proc for bft_main_ *** */ 2460 2461 request_connect: 2462 proc (p_sender); 2463 2464 2465 /* PROCEDURE FUNCTION 2466* 2467*An application is requesting connection to bft_main_, this is not to be 2468*allowed so bft will respond with a REJECT code. 2469**/ 2470 2471 /* NOTES 2472**/ 2473 2474 /* PARAMETERS */ 2475 dcl p_sender fixed bin parameter; /* Sender of request */ 2476 2477 /* MISC VARIABLES */ 2478 dcl code fixed bin (35); 2479 2480 /* STRUCTURES */ 2481 2482 /* INITIALIZATION */ 2483 2484 /* MAIN */ 2485 2486 call ws_$connect_response (REJECT, p_sender, mcb_ptr, code); 2487 if code ^= 0 then do; 2488 call ws_$put_background_message (mcb_ptr, code, "bft", 2489 "Responding to connect_request from ^d.", p_sender); 2490 return; 2491 end; 2492 2493 end request_connect; 2494 2495 /* */ 2496 2497 /* *** Procedure: request_disconnect - Internal proc for bft_main_ *** */ 2498 2499 request_disconnect: 2500 proc (p_sender); 2501 2502 2503 /* PROCEDURE FUNCTION 2504* 2505*This minor capability is not to be called under normal circumstances. It will 2506*return and error and terminate BFT if it is called. 2507**/ 2508 2509 /* NOTES 2510**/ 2511 2512 /* PARAMETERS */ 2513 dcl p_sender fixed bin parameter; /* Capability disconnecting */ 2514 2515 /* MISC VARIABLES */ 2516 dcl code fixed bin (35); 2517 2518 /* STRUCTURES */ 2519 2520 /* INITIALIZATION */ 2521 2522 /* MAIN */ 2523 2524 call cleanup_iocb_switches (); 2525 2526 call cleanup_pending_chain (); 2527 2528 call ws_$disconnect_response (ACCEPT, p_sender, mcb_ptr, code); 2529 if code ^= 0 then do; 2530 call ws_$put_background_message (mcb_ptr, code, "bft", 2531 "Disconnecting from ^d.", p_sender); 2532 return; 2533 end; 2534 2535 call ws_$destroy_instance (mcb_ptr, (0)); 2536 call cleanup_data_block (); 2537 2538 end request_disconnect; 2539 2540 /* */ 2541 2542 /* *** Procedure: response_disconnect - Internal proc for bft_main_ *** */ 2543 2544 response_disconnect: 2545 proc (); 2546 2547 2548 /* PROCEDURE FUNCTION 2549* 2550*This minor capability is not to be called under normal circumstances. It will 2551*return and error and terminate BFT if it is called. 2552**/ 2553 2554 /* NOTES 2555**/ 2556 2557 /* PARAMETERS */ 2558 2559 /* MISC VARIABLES */ 2560 2561 /* STRUCTURES */ 2562 2563 /* INITIALIZATION */ 2564 2565 /* MAIN */ 2566 2567 data_block.flags.shut_down_sw = "1"b; 2568 2569 call cleanup_iocb_switches (); 2570 2571 call ws_$destroy_instance (mcb_ptr, (0)); 2572 2573 call cleanup_data_block (); 2574 2575 end response_disconnect; 2576 2577 /* */ 2578 2579 /* *** Procedure: send_data - Internal proc for bft_main_ *** */ 2580 2581 send_data: 2582 proc (); 2583 2584 2585 /* PROCEDURE FUNCTION 2586* 2587*This minor capability reads from the file that is specified in the value 2588*segment from the byte position that is also stored in the value segment. It 2589*updates the byte count, and then sends the data that it if any, to RECEIVE_DATA 2590*on the remote machine. If it reads the end of file, then it calls RECEIVE_EOF 2591*on the remote machine. 2592**/ 2593 2594 /* NOTES 2595**/ 2596 2597 /* PARAMETERS */ 2598 2599 /* MISC VARIABLES */ 2600 dcl mu_entryname char (32); 2601 dcl mu_dirname char (168); 2602 dcl line_start fixed bin (21); /* Start position in search for LFs */ 2603 dcl line_len fixed bin (21); /* Determines lengths of lines */ 2604 dcl bytes_read fixed bin (21); /* Characters from file */ 2605 dcl inbuffer char (120) aligned; 2606 dcl message char (128); /* Message */ 2607 dcl long_info char (100) aligned; 2608 dcl code fixed bin (35); 2609 dcl short_info char (8) aligned; 2610 2611 /* STRUCTURES */ 2612 2613 /* INITIALIZATION */ 2614 2615 /* MAIN */ 2616 2617 /* Verify that this transfer has NOT been cancelled midestream */ 2618 2619 if ^queue.header.storing.flags.initiated then do; 2620 queue.header.store_file_pos = 0; 2621 call close_data_file (data_block.send_iocb_ptr); 2622 2623 call expand_pathname_ (rtrim (queue.header.storing.multics_path), 2624 mu_dirname, mu_entryname, code); 2625 message = "Store request " || rtrim (mu_entryname); 2626 message = rtrim (message) || " cancelled in progress."; 2627 call execute_pc_bft (addr (message), length (rtrim (message)), 2628 bft_minor_$read_error, mcb_ptr, (0)); 2629 return; 2630 end; 2631 2632 /* Read up to the maximum number of bytes from the file*/ 2633 2634 call iox_$get_chars (data_block.send_iocb_ptr, addr (inbuffer), 2635 BFT_BLOCK_SIZE, bytes_read, code); 2636 2637 /* If it is the end of file, then call RECEIVE_EOF on the remote machine */ 2638 2639 if code = error_table_$end_of_info then do; 2640 call close_data_file (data_block.send_iocb_ptr); 2641 2642 call execute_pc_bft (null, 0, bft_minor_$receive_eof, mcb_ptr, code); 2643 if code ^= 0 then 2644 return; 2645 2646 queue.header.storing.flags.initiated = "0"b; 2647 queue.header.store_file_pos = 0; 2648 2649 call initiate_store (); 2650 return; 2651 end; 2652 2653 /* If some unknown error occurred then generate a read_error */ 2654 2655 if code ^= 0 & code ^= error_table_$short_record then do; 2656 queue.header.storing.flags.initiated = "0"b; 2657 queue.header.store_file_pos = 0; 2658 call close_data_file (data_block.send_iocb_ptr); 2659 2660 call convert_status_code_ (code, short_info, long_info); 2661 message = rtrim (long_info) || " Sending data."; 2662 call execute_pc_bft (addr (message), length (rtrim (message)), 2663 bft_minor_$read_error, mcb_ptr, (0)); 2664 return; 2665 end; 2666 2667 /* Update the byte / line count */ 2668 2669 if queue.header.storing.flags.binary_sw then 2670 queue.header.store_file_pos 2671 = queue.header.store_file_pos + bytes_read; 2672 else do; 2673 line_len = index (substr (inbuffer, 1, bytes_read), byte (10)); 2674 line_start = line_len + 1; 2675 do while (line_len > 0 & line_start <= bytes_read); 2676 queue.header.store_file_pos = queue.header.store_file_pos + 1; 2677 line_len = index (substr (inbuffer, line_start, 2678 bytes_read - line_start), byte (10)); 2679 line_start = line_start + line_len; 2680 end; 2681 end; 2682 2683 /* Put the data read into the arg_list and call RECEIVE_DATA on the remote system*/ 2684 2685 call execute_pc_bft (addr (inbuffer), convert (fixedbin17, bytes_read), 2686 bft_minor_$receive_data, mcb_ptr, code); 2687 if code ^= 0 then 2688 return; 2689 2690 end send_data; 2691 2692 /* */ 2693 2694 /* *** Procedure: strip_token - Internal proc for bft_main_ *** */ 2695 2696 strip_token: 2697 proc (p_arg_data, p_token); 2698 2699 2700 /* PROCEDURE FUNCTION 2701* 2702*This is a utility routine designed to remove the first token in in a list that 2703*is separated by a delimiter. It returns the token, and the remainder of the 2704*list with up to and including the first delimiter stripped off. 2705**/ 2706 2707 /* NOTES 2708**/ 2709 2710 /* PARAMETERS */ 2711 dcl p_arg_data char (*) parameter; /* Data to extract from */ 2712 dcl p_token char (*) var parameter; /* Token extracted */ 2713 2714 /* MISC VARIABLES */ 2715 dcl delim_position fixed bin; /* length of token */ 2716 2717 /* STRUCTURES */ 2718 2719 /* INITIALIZATION */ 2720 2721 /* MAIN */ 2722 2723 delim_position = index (p_arg_data, DELIM_CHAR); 2724 if delim_position = 0 then 2725 delim_position = length (p_arg_data); 2726 2727 p_token = substr (p_arg_data, 1, delim_position - 1); 2728 p_arg_data = substr (p_arg_data, delim_position + 1); 2729 2730 end strip_token; 2731 2732 /* */ 2733 2734 /* *** Procedure: terminate_application - Internal proc for bft_main_ *** */ 2735 2736 terminate_application: 2737 proc (); 2738 2739 2740 /* PROCEDURE FUNCTION 2741* 2742*Terminate BFT - ie. shutdown immediately. 2743**/ 2744 2745 /* NOTES 2746**/ 2747 2748 /* PARAMETERS */ 2749 2750 /* MISC VARIABLES */ 2751 2752 /* STRUCTURES */ 2753 2754 /* INITIALIZATION */ 2755 2756 /* MAIN */ 2757 2758 call bft_shut_down (); 2759 2760 end terminate_application; 2761 2762 /* */ 2763 2764 /* *** Procedure: write_error - Internal proc for bft_main_ *** */ 2765 2766 write_error: 2767 proc (p_arg_ptr, p_arg_len); 2768 2769 2770 /* PROCEDURE FUNCTION 2771* 2772*This procedure is called by the remote machine to signal an error occurred 2773*while the remote machine was receiving a file. The proper cleanup is done and 2774*the queues are checked to see if there are any pending requests. 2775**/ 2776 2777 /* NOTES 2778**/ 2779 2780 /* PARAMETERS */ 2781 dcl p_arg_ptr ptr parameter; /* Message */ 2782 dcl p_arg_len fixed bin parameter; /* Message length */ 2783 dcl p_arg_data char (p_arg_len) based (p_arg_ptr); 2784 2785 /* MISC VARIABLES */ 2786 dcl error_string char (128) var; /* Error message sentr */ 2787 2788 /* STRUCTURES */ 2789 2790 /* INITIALIZATION */ 2791 2792 /* MAIN */ 2793 2794 /* Extract the error message from the arg_list */ 2795 2796 call strip_token (p_arg_data, error_string); 2797 call ws_$put_background_message (mcb_ptr, 0, "bft", error_string); 2798 2799 /* Remove the current store from the queue */ 2800 2801 queue.header.storing.flags.initiated = "0"b; 2802 queue.header.store_file_pos = 0; 2803 call close_data_file (data_block.send_iocb_ptr); 2804 2805 /* Try for another request from the store queue */ 2806 2807 call initiate_store (); 2808 2809 end write_error; 2810 2811 /* */ 2812 2813 /* INCLUDE FILES */ 1 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 1 2 1 3 /* This include file contains structures for the hcs_$star_, 1 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 1 5* 1 6* Written 23 October 1978 by Monte Davidoff. 1 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 1 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 1 9**/ 1 10 1 11 /* automatic */ 1 12 1 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 1 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 1 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 1 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 1 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 1 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 1 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 1 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 1 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 1 22 1 23 /* based */ 1 24 1 25 /* hcs_$star_ entry structure */ 1 26 1 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 1 28 2 type fixed binary (2) unsigned unaligned, 1 29 /* storage system type */ 1 30 2 nnames fixed binary (16) unsigned unaligned, 1 31 /* number of names of entry that match star_name */ 1 32 2 nindex fixed binary (18) unsigned unaligned; 1 33 /* index of first name in star_names */ 1 34 1 35 /* hcs_$star_ name structure */ 1 36 1 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 1 38 1 39 /* hcs_$star_list_ branch structure */ 1 40 1 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 42 2 type fixed binary (2) unsigned unaligned, 1 43 /* storage system type */ 1 44 2 nnames fixed binary (16) unsigned unaligned, 1 45 /* number of names of entry that match star_name */ 1 46 2 nindex fixed binary (18) unsigned unaligned, 1 47 /* index of first name in star_list_names */ 1 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 1 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 1 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 1 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 1 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 1 53 2 pad bit (7) unaligned, 1 54 2 records fixed binary (18) unsigned unaligned; 1 55 /* records used by branch */ 1 56 1 57 /* hcs_$star_dir_list_ branch structure */ 1 58 1 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 60 2 type fixed binary (2) unsigned unaligned, 1 61 /* storage system type */ 1 62 2 nnames fixed binary (16) unsigned unaligned, 1 63 /* number of names of entry that match star_name */ 1 64 2 nindex fixed binary (18) unsigned unaligned, 1 65 /* index of first name in star_list_names */ 1 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 1 67 2 pad bit (36) unaligned, 1 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 1 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 1 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 1 71 2 bit_count fixed binary (24) unaligned; 1 72 /* bit count of the branch */ 1 73 1 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 1 75 1 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 77 2 type fixed binary (2) unsigned unaligned, 1 78 /* storage system type */ 1 79 2 nnames fixed binary (16) unsigned unaligned, 1 80 /* number of names of entry that match star_name */ 1 81 2 nindex fixed binary (18) unsigned unaligned, 1 82 /* index of first name in star_list_names */ 1 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 1 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 1 85 2 pathname_len fixed binary (18) unsigned unaligned, 1 86 /* length of the pathname of the link */ 1 87 2 pathname_index fixed binary (18) unsigned unaligned; 1 88 /* index of start of pathname in star_list_names */ 1 89 1 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 1 91 1 92 declare star_list_names char (32) based (star_list_names_ptr) 1 93 dimension (star_links (star_branch_count + star_link_count).nindex 1 94 + star_links (star_branch_count + star_link_count).nnames 1 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 1 96 * binary ( 1 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 1 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 1 99 1 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 1 101 1 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 1 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 1 104 1 105 /* internal static */ 1 106 1 107 /* star_select_sw values */ 1 108 1 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 1 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 1 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 1 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 1 113 fixed binary (3) internal static options (constant) initial (5); 1 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 1 115 fixed binary (3) internal static options (constant) initial (7); 1 116 1 117 /* storage system types */ 1 118 1 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 1 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 1 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 1 122 1 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 2814 2 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 2 2* 2 3* Values for the "access mode" argument so often used in hardcore 2 4* James R. Davis 26 Jan 81 MCR 4844 2 5* Added constants for SM access 4/28/82 Jay Pattin 2 6* Added text strings 03/19/85 Chris Jones 2 7**/ 2 8 2 9 2 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 2 11 dcl ( 2 12 N_ACCESS init ("000"b), 2 13 R_ACCESS init ("100"b), 2 14 E_ACCESS init ("010"b), 2 15 W_ACCESS init ("001"b), 2 16 RE_ACCESS init ("110"b), 2 17 REW_ACCESS init ("111"b), 2 18 RW_ACCESS init ("101"b), 2 19 S_ACCESS init ("100"b), 2 20 M_ACCESS init ("010"b), 2 21 A_ACCESS init ("001"b), 2 22 SA_ACCESS init ("101"b), 2 23 SM_ACCESS init ("110"b), 2 24 SMA_ACCESS init ("111"b) 2 25 ) bit (3) internal static options (constant); 2 26 2 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 2 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 2 29 2 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 2 31 static options (constant); 2 32 2 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 2 34 static options (constant); 2 35 2 36 dcl ( 2 37 N_ACCESS_BIN init (00000b), 2 38 R_ACCESS_BIN init (01000b), 2 39 E_ACCESS_BIN init (00100b), 2 40 W_ACCESS_BIN init (00010b), 2 41 RW_ACCESS_BIN init (01010b), 2 42 RE_ACCESS_BIN init (01100b), 2 43 REW_ACCESS_BIN init (01110b), 2 44 S_ACCESS_BIN init (01000b), 2 45 M_ACCESS_BIN init (00010b), 2 46 A_ACCESS_BIN init (00001b), 2 47 SA_ACCESS_BIN init (01001b), 2 48 SM_ACCESS_BIN init (01010b), 2 49 SMA_ACCESS_BIN init (01011b) 2 50 ) fixed bin (5) internal static options (constant); 2 51 2 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 2815 3 1 /* 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 */ 2816 4 1 /* BEGIN INCLUDE FILE: mowse.incl.pl1 * * * * * * * * * * * * */ 4 2 4 3 /****^ HISTORY COMMENTS: 4 4* 1) change(86-09-17,Flegel), approve(86-12-16,MCR7580), 4 5* audit(86-12-15,Gilcrease), install(87-01-06,MR12.0-1255): 4 6* Created. 4 7* 2) change(86-10-03,Flegel), approve(86-12-16,MCR7580), 4 8* audit(86-12-15,Gilcrease), install(87-01-06,MR12.0-1255): 4 9* Combined mowse_minor_caps.incl.pl1 and 4 10* mowse.incl.pl1 so that programmer only needs include mowse.incl.pl1 4 11* 3) change(86-11-27,Flegel), approve(86-11-27,MCR7580), 4 12* audit(86-12-15,Gilcrease), install(87-01-06,MR12.0-1255): 4 13* Approved. 4 14* 4) change(87-07-31,Flegel), approve(87-07-31,MCR7580), 4 15* audit(87-07-31,RBarstad), install(87-08-07,MR12.1-1075): 4 16* Changes to support async call channels. 4 17* END HISTORY COMMENTS */ 4 18 4 19 /* Name of MOWSE temp seg for data */ 4 20 4 21 /* format: style4,indattr,ifthen,^indcomtxt,thendo,^indproc,^indblkcom,initcol1,declareind8,dclind4,struclvlind3,comcol55 */ 4 22 dcl temp_seg_name char (6) init ("MOWSE_"); 4 23 4 24 /* Version number */ 4 25 4 26 dcl MOWSE_VERSION_ char (8) int static options (constant) init ("version1"); 4 27 4 28 /* System identification */ 4 29 4 30 dcl LOCAL_SYSTEM fixed bin int static options (constant) init (32); 4 31 dcl REMOTE_SYSTEM fixed bin int static options (constant) init (33); 4 32 4 33 /* Status request return codes */ 4 34 4 35 dcl STATUS_SUCCESS fixed bin (8) int static options (constant) 4 36 init (32); 4 37 dcl STATUS_FAILED fixed bin (8) int static options (constant) 4 38 init (33); 4 39 4 40 /* Input/output capability buffer size limits */ 4 41 4 42 dcl MINIMUM_BUFFER_SIZE fixed bin int static options (constant) init (128); 4 43 dcl MAXIMUM_BUFFER_SIZE fixed bin int static options (constant) init (65536); 4 44 dcl MAXIMUM_BG_SIZE fixed bin int static options (constant) init (512); 4 45 4 46 /* Packet size (communication) constants */ 4 47 4 48 dcl PACKET_SIZE fixed bin int static options (constant) init (124); 4 49 dcl MAXIMUM_PACKET_SIZE fixed bin int static options (constant) init (118); 4 50 4 51 /* Query message constants */ 4 52 4 53 dcl SEND_QUERY fixed bin int static options (constant) init (128); 4 54 dcl ACCEPT fixed bin int static options (constant) init (32); 4 55 dcl REJECT fixed bin int static options (constant) init (33); 4 56 4 57 /* Trace information constants */ 4 58 4 59 dcl RECEIVE fixed bin int static options (constant) init (1); 4 60 dcl SEND fixed bin int static options (constant) init (0); 4 61 4 62 /* Limits on dedicated minor capabilities */ 4 63 4 64 dcl MINIMUM_SYSTEM_MINOR fixed bin int static options (constant) init (32); 4 65 dcl MAXIMUM_SYSTEM_MINOR fixed bin int static options (constant) init (63); 4 66 dcl MINIMUM_USER_MINOR fixed bin int static options (constant) init (64); 4 67 dcl MAXIMUM_USER_MINOR fixed bin int static options (constant) init (127); 4 68 4 69 /* Dedicated Minor Capabilities */ 4 70 4 71 dcl LAST fixed bin int static options (constant) init (0); 4 72 dcl EXECUTE_COMMAND_REPLY fixed bin int static options (constant) init (32); 4 73 dcl EXECUTE_CAPABILITY_REPLY 4 74 fixed bin int static options (constant) init (33); 4 75 dcl FAIL_CAPABILITY fixed bin int static options (constant) init (33); 4 76 dcl INTERNAL fixed bin int static options (constant) init (32); 4 77 dcl EXECUTE_COMMAND fixed bin int static options (constant) init (34); 4 78 dcl ADD_TO_REMOTE_CAT fixed bin int static options (constant) init (35); 4 79 dcl DELETE_FROM_REMOTE_CAT fixed bin int static options (constant) init (36); 4 80 dcl SUSPEND_APPLICATION fixed bin int static options (constant) init (37); 4 81 dcl RESUME_APPLICATION fixed bin int static options (constant) init (38); 4 82 dcl TERMINATE_APPLICATION fixed bin int static options (constant) init (39); 4 83 dcl RESET_APPLICATION fixed bin int static options (constant) init (40); 4 84 dcl RESET_REPLY fixed bin int static options (constant) init (41); 4 85 dcl WAKE_UP fixed bin int static options (constant) init (42); 4 86 dcl STATUS fixed bin int static options (constant) init (43); 4 87 dcl OVERFLOWED_BUFFER fixed bin int static options (constant) init (44); 4 88 dcl SYSTEM_ERROR fixed bin int static options (constant) init (45); 4 89 dcl QUERY_REPLY fixed bin int static options (constant) init (46); 4 90 dcl RESPONSE_CONNECT fixed bin int static options (constant) init (47); 4 91 dcl RESPONSE_DISCONNECT fixed bin int static options (constant) init (48); 4 92 dcl REQUEST_CONNECT fixed bin int static options (constant) init (49); 4 93 dcl REQUEST_DISCONNECT fixed bin int static options (constant) init (50); 4 94 dcl CONTINUE fixed bin int static options (constant) init (51); 4 95 dcl MORE fixed bin int static options (constant) init (52); 4 96 dcl SET_SLEEP_FLAG fixed bin int static options (constant) init (53); 4 97 dcl RESET_SLEEP_FLAG fixed bin int static options (constant) init (54); 4 98 dcl SET_SUSPEND fixed bin int static options (constant) init (55); 4 99 dcl RESET_SUSPEND fixed bin int static options (constant) init (56); 4 100 dcl STATUS_REPLY fixed bin int static options (constant) init (57); 4 101 4 102 /* Foreground */ 4 103 4 104 dcl FG_CONTROL_MESSAGE fixed bin int static options (constant) init (33); 4 105 dcl FG_BREAK fixed bin int static options (constant) init (34); 4 106 dcl FG_TERMINAL_DATA fixed bin int static options (constant) init (35); 4 107 dcl FG_MORE_DATA fixed bin int static options (constant) init (36); 4 108 dcl PUT_TO_BACKGROUND_BUFFER 4 109 fixed bin int static options (constant) init (37); 4 110 dcl PUT_TO_QUERY_MESSAGE_BUFFER 4 111 fixed bin int static options (constant) init (38); 4 112 4 113 /* END INCLUDE FILE: mowse.incl.pl1 * * * * * * * * * * * * */ 2817 5 1 /* BEGIN INCLUDE FILE: bft_queue.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 5 2 5 3 /****^ HISTORY COMMENTS: 5 4* 1) change(87-10-06,Flegel), approve(87-10-23,MCR7787), 5 5* audit(88-01-27,RWaters), install(88-02-24,MR12.2-1028): 5 6* Created. 5 7* END HISTORY COMMENTS */ 5 8 5 9 5 10 /* format: style4,indattr,ifthen,^indcomtxt,thendo,^indproc,^indblkcom,^indprocbody,initcol1,declareind8,dclind4,struclvlind3,comcol55 */ 5 11 5 12 dcl BFT_QUEUE_VERSION_1 char (8) internal static options (constant) 5 13 init ("VERSION1"); 5 14 dcl BFT_QUEUE_PRIORITIES fixed bin internal static options (constant) 5 15 init (4); 5 16 dcl BFT_QUEUE_WAIT_TIME fixed bin internal static options (constant) 5 17 init (30); 5 18 5 19 /* Queue */ 5 20 5 21 dcl queue_ptr ptr; 5 22 dcl 01 queue based (queue_ptr) aligned, 5 23 02 header like queue_header, 5 24 02 array (queue.header.segment_size) like queue_element; 5 25 5 26 /* Queue header */ 5 27 5 28 dcl 01 queue_header based, 5 29 02 version char (8), /* Segment ID */ 5 30 02 lockword bit (36) aligned, /* Segment lock */ 5 31 02 store_queue (4), /* Multics -> PC */ 5 32 03 last fixed bin (35), /* Last element */ 5 33 03 first fixed bin (35), /* Entry transferring */ 5 34 03 flags, 5 35 04 pad bit (36) unal, 5 36 02 fetch_queue (4), /* PC -> Multics */ 5 37 03 last fixed bin (35), /* Last element */ 5 38 03 first fixed bin (35), /* Entry transferring */ 5 39 03 flags, 5 40 04 pad bit (36) unal, 5 41 02 storing like queue_element, /* Current store */ 5 42 02 store_file_pos fixed bin (21), /* Position is send */ 5 43 02 fetching like queue_element, /* Current fetch */ 5 44 02 fetch_file_pos fixed bin (21), /* Positin in fetch */ 5 45 02 free_list fixed bin (35), /* Free entries in Q */ 5 46 02 segment_size fixed bin (35); /* Records in segment */ 5 47 5 48 /* Queue element definition */ 5 49 5 50 dcl 01 queue_element based, 5 51 02 next fixed bin (35), /* Next in Q */ 5 52 02 multics_path char (168), /* Path on Multics */ 5 53 02 pc_path char (66), /* Drive:Path on PC */ 5 54 02 time_id fixed bin (71), /* Time stamp id */ 5 55 02 flags like bft_queue_flags, /* Entry switches */ 5 56 02 mbz bit (18); /* Word boundary size */ 5 57 5 58 /* We need the definitions for the queue flags */ 5 59 6 1 /* BEGIN INCLUDE FILE: bft.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 6 2 6 3 6 4 /****^ HISTORY COMMENTS: 6 5* 1) change(87-11-16,Flegel), approve(87-11-16,MCR7787), 6 6* audit(88-01-27,RWaters), install(88-02-24,MR12.2-1028): 6 7* Created to provide access to flags structure for programs which call the 6 8* bft_$(fetch store) entrypoints. 6 9* END HISTORY COMMENTS */ 6 10 6 11 dcl BFT_MIN_PRIORITY fixed bin int static options (constant) init (1); 6 12 dcl BFT_MAX_PRIORITY fixed bin int static options (constant) init (4); 6 13 dcl BFT_PATH_ID fixed bin int static options (constant) init (32); 6 14 dcl BFT_TIME_ID fixed bin int static options (constant) init (33); 6 15 dcl BFT_ENTRY_ID fixed bin int static options (constant) init (34); 6 16 6 17 /* BFT queue flags / switches; 6 18* NOTE that the pad and mbz are first, this is because a conversion routine 6 19* to convert significant bits to a respective character string assumes that 6 20* the bit string is RIGHT JUSTIFIED (this is to allow the accepting of 6 21* numerical values - eg. fixed bin */ 6 22 6 23 dcl 01 bft_queue_flags based, 6 24 02 mbz bit (4) unal, /* System word adjust */ 6 25 02 pad bit (28) unal, /* Future expansion */ 6 26 02 allocated bit (1) unal, /* Is this an entry? */ 6 27 02 initiated bit (1) unal, /* Transfer in progress */ 6 28 02 binary_sw bit (1) unal, /* Binary file_type */ 6 29 02 notify_sw bit (1) unal; /* If a notify is to be done */ 6 30 6 31 /* END INCLUDE FILE: bft.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 5 60 5 61 5 62 /* END INCLUDE FILE: bft_queue.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 2818 7 1 /* BEGIN INCLUDE FILE: bft_values.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 7 2 7 3 7 4 /****^ HISTORY COMMENTS: 7 5* 1) change(87-07-15,Flegel), approve(87-07-15,MCR7580), 7 6* audit(87-07-30,RBarstad), install(87-08-07,MR12.1-1075): 7 7* Created. 7 8* 2) change(87-10-23,Flegel), approve(87-10-23,MCR7787), 7 9* audit(88-01-27,RWaters), install(88-02-24,MR12.2-1028): 7 10* Converted to use with new queueing strategy; added data_block structure; 7 11* END HISTORY COMMENTS */ 7 12 7 13 /* format: style4,indattr,ifthen,^indcomtxt,thendo,^indproc,^indblkcom,initcol1,declareind8,dclind4,struclvlind3,comcol55 */ 7 14 7 15 dcl bft_minor_$add_to_fetch_queue fixed bin int static options (constant) init (64); 7 16 dcl bft_minor_$add_to_store_queue fixed bin int static options (constant) init (65); 7 17 dcl bft_minor_$check_file_length fixed bin int static options (constant) init (66); 7 18 dcl bft_minor_$initiate_fetch fixed bin int static options (constant) init (67); 7 19 dcl bft_minor_$bft_shut_down fixed bin int static options (constant) init (68); 7 20 dcl bft_minor_$position_file_pointer fixed bin int static options (constant) init (69); 7 21 dcl bft_minor_$receive_data fixed bin int static options (constant) init (70); 7 22 dcl bft_minor_$receive_eof fixed bin int static options (constant) init (71); 7 23 dcl bft_minor_$recover_fetch fixed bin int static options (constant) init (72); 7 24 dcl bft_minor_$recover_store fixed bin int static options (constant) init (73); 7 25 dcl bft_minor_$read_error fixed bin int static options (constant) init (74); 7 26 dcl bft_minor_$initiate_store fixed bin int static options (constant) init (75); 7 27 dcl bft_minor_$write_error fixed bin int static options (constant) init (76); 7 28 dcl bft_minor_$send_data fixed bin int static options (constant) init (77); 7 29 dcl bft_minor_$cancel_request fixed bin int static options (constant) init (78); 7 30 dcl bft_minor_$expand_pc_path fixed bin int static options (constant) init (80); 7 31 dcl bft_minor_$full_pc_path fixed bin int static options (constant) init (81); 7 32 7 33 7 34 dcl BFT_MINOR_CAPS fixed bin int static options (constant) init (13); 7 35 dcl BFT_INBUFFER_SIZE fixed bin int static options (constant) init (128); 7 36 dcl BFT_OUTBUFFER_SIZE fixed bin int static options (constant) init (128); 7 37 dcl BFT_BLOCK_SIZE fixed bin (21) int static options (constant) init (110); 7 38 dcl BFT_FIRST char (1) int static options (constant) init (" "); 7 39 dcl BFT_NEXT char (1) int static options (constant) init ("!"); 7 40 dcl DELIM_CHAR char (1) based (addr (DEL)); 7 41 dcl DEL bit (9) unaligned internal static 7 42 options (constant) init ("011111111"b); 7 43 7 44 dcl 01 bft_values_struct, 7 45 02 destination_filename char (164), 7 46 02 source_filename char (164); 7 47 7 48 /* New declarations for queueing */ 7 49 7 50 dcl BFT_PC_to_MULTICS fixed bin internal static options (constant) 7 51 init (32); 7 52 dcl BFT_MULTICS_to_PC fixed bin internal static options (constant) 7 53 init (33); 7 54 dcl BFT_DATA_BLOCK_VERSION_1 char (8) internal static options (constant) 7 55 init ("VERSION1"); 7 56 dcl BFT_INBUFF_LENGTH fixed bin internal static options (constant) 7 57 init (128); 7 58 dcl BFT_OUTBUFF_LENGTH fixed bin internal static options (constant) 7 59 init (128); 7 60 7 61 dcl data_block_ptr ptr; /* Data to be kept around */ 7 62 dcl 01 data_block based (data_block_ptr), 7 63 02 version char (8), /* Version ID */ 7 64 02 pc_bft_num fixed bin, /* Major of PC:BFT */ 7 65 02 inbuff_len fixed bin, /* Input buffer length */ 7 66 02 outbuff_len fixed bin, /* Output buffer length */ 7 67 02 receive_iocb_ptr ptr, /* IOCB of receiving file */ 7 68 02 send_iocb_ptr ptr, /* IOCB of sending file */ 7 69 02 system_free_area_ptr ptr, /* Pointer to sys free */ 7 70 02 fetch_pending ptr, /* Fetch waiting for PC path */ 7 71 02 store_pending ptr, /* Store waiting for PC path */ 7 72 02 queue_ptr ptr, /* BFT queue segment */ 7 73 02 flags, 7 74 03 shut_down_sw bit (1) unal, /* BFT is shutting down */ 7 75 03 pad bit (35) unal; 7 76 7 77 /* Structure to contain transfer requests awaiting a PC path expansion */ 7 78 7 79 dcl 01 pending based, 7 80 02 multics_path char (168), /* Multics path */ 7 81 02 pc_path char (66), /* PC path */ 7 82 02 flags bit(36), /* Transfer modes */ 7 83 02 switches, 7 84 03 processing_sw bit (1) unal, /* Waiting for PC answer */ 7 85 03 first_sw bit (1) unal, /* First match requested */ 7 86 03 pad bit (34) unal, 7 87 02 priority fixed bin, /* Priority */ 7 88 02 id fixed bin, /* Request ID */ 7 89 02 next ptr; /* Next in chain */ 7 90 7 91 /* END INCLUDE FILE: bft_values.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 2819 2820 2821 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/24/88 0843.6 bft_main_.pl1 >special_ldd>install>MR12.2-1028>bft_main_.pl1 2814 1 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 2815 2 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 2816 3 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.incl.pl1 2817 4 08/10/87 1336.7 mowse.incl.pl1 >ldd>include>mowse.incl.pl1 2818 5 02/24/88 0843.7 bft_queue.incl.pl1 >special_ldd>install>MR12.2-1028>bft_queue.incl.pl1 5-60 6 02/24/88 0843.9 bft.incl.pl1 >special_ldd>install>MR12.2-1028>bft.incl.pl1 2819 7 02/24/88 0846.4 bft_values.incl.pl1 >special_ldd>install>MR12.2-1028>bft_values.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. ACCEPT 000164 constant fixed bin(17,0) initial dcl 4-54 set ref 2528* BFT_BLOCK_SIZE 000066 constant fixed bin(21,0) initial dcl 7-37 set ref 2634* BFT_DATA_BLOCK_VERSION_1 000062 constant char(8) initial packed unaligned dcl 7-54 ref 1666 BFT_ENTRY_ID constant fixed bin(17,0) initial dcl 6-15 ref 776 BFT_FIRST 000143 constant char(1) initial packed unaligned dcl 7-38 set ref 1575* BFT_INBUFF_LENGTH constant fixed bin(17,0) initial dcl 7-56 ref 1668 BFT_MULTICS_to_PC 000077 constant fixed bin(17,0) initial dcl 7-52 set ref 513 625* 1217 1564 1789* BFT_NEXT 000065 constant char(1) initial packed unaligned dcl 7-39 set ref 1580* BFT_OUTBUFF_LENGTH constant fixed bin(17,0) initial dcl 7-58 ref 1669 BFT_PATH_ID constant fixed bin(17,0) initial dcl 6-13 ref 776 BFT_PC_to_MULTICS 000164 constant fixed bin(17,0) initial dcl 7-50 set ref 424* 483 522 1165 1233 1567 1719* 1853 BFT_TIME_ID constant fixed bin(17,0) initial dcl 6-14 ref 776 DEL 000064 constant bit(9) initial packed unaligned dcl 7-41 set ref 666 667 2723 DELIM_CHAR based char(1) packed unaligned dcl 7-40 ref 666 667 2723 LOCAL_SYSTEM 000164 constant fixed bin(17,0) initial dcl 4-30 set ref 160* 171* 483 NAME 000100 constant char(9) initial packed unaligned dcl 119 set ref 142* 148* 152* 160* 171* REJECT 000077 constant fixed bin(17,0) initial dcl 4-55 set ref 2486* REMOTE_SYSTEM 000077 constant fixed bin(17,0) initial dcl 4-31 set ref 188* 716* 1501* RESPONSE_DISCONNECT constant fixed bin(17,0) initial dcl 4-91 ref 229 Stream_input 000203 constant fixed bin(17,0) initial dcl 3-15 set ref 2034* Stream_input_output 000201 constant fixed bin(17,0) initial dcl 3-15 set ref 1975* TERMINATE_APPLICATION constant fixed bin(17,0) initial dcl 4-82 ref 229 absolute_pathname_ 000014 constant entry external dcl 55 ref 1008 addr builtin function dcl 105 ref 510 510 666 667 1154 1214 1214 1592 1592 1628 1745 1745 1815 1815 2228 2228 2244 2244 2396 2396 2450 2450 2627 2627 2634 2634 2662 2662 2685 2685 2723 bft_error_table_$fetch_in_progress 000116 external static fixed bin(35,0) dcl 94 ref 1720 bft_error_table_$illegal_minor_capability 000120 external static fixed bin(35,0) dcl 95 set ref 1912* bft_error_table_$no_entries 000114 external static fixed bin(35,0) dcl 93 ref 1720 1790 bft_error_table_$store_in_progress 000112 external static fixed bin(35,0) dcl 92 ref 1790 bft_minor_$bft_shut_down constant fixed bin(17,0) initial dcl 7-19 ref 229 bft_minor_$check_file_length 000144 constant fixed bin(17,0) initial dcl 7-17 set ref 2450* bft_minor_$expand_pc_path 000163 constant fixed bin(17,0) initial dcl 7-30 set ref 1592* bft_minor_$initiate_fetch 000076 constant fixed bin(17,0) initial dcl 7-18 set ref 1745* bft_minor_$initiate_store 000071 constant fixed bin(17,0) initial dcl 7-26 set ref 1815* bft_minor_$position_file_pointer 000075 constant fixed bin(17,0) initial dcl 7-20 set ref 2396* bft_minor_$read_error 000072 constant fixed bin(17,0) initial dcl 7-25 set ref 2627* 2662* bft_minor_$receive_data 000074 constant fixed bin(17,0) initial dcl 7-21 set ref 2685* bft_minor_$receive_eof 000073 constant fixed bin(17,0) initial dcl 7-22 set ref 2642* bft_minor_$send_data 000067 constant fixed bin(17,0) initial dcl 7-28 set ref 2266* bft_minor_$write_error 000070 constant fixed bin(17,0) initial dcl 7-27 set ref 2228* 2244* bft_queue_$add 000072 constant entry external dcl 82 ref 510 1214 bft_queue_$cancel 000060 constant entry external dcl 77 ref 789 bft_queue_$initiate 000110 constant entry external dcl 89 ref 1677 bft_queue_$remove 000062 constant entry external dcl 78 ref 1719 1789 bft_queue_flags based structure level 1 packed packed unaligned dcl 6-23 binary_sw 234(34) based bit(1) level 5 in structure "queue" packed packed unaligned dcl 5-22 in procedure "bft_main_" ref 2251 2374 binary_sw 132(34) based bit(1) level 5 in structure "queue" packed packed unaligned dcl 5-22 in procedure "bft_main_" ref 2105 2669 byte builtin function dcl 104 ref 1590 1590 2255 2259 2673 2677 byte_count 000101 automatic fixed bin(21,0) dcl 2075 set ref 2087* 2087 2104 bytes_read 000164 automatic fixed bin(21,0) dcl 2604 set ref 2634* 2669 2673 2675 2677 2685 2685 ch_flags 000101 automatic char(4) packed unaligned dcl 993 set ref 1019* 1022 char128var based varying char(128) dcl 122 ref 2393 2393 cleanup 000000 stack reference condition dcl 116 ref 485 501 583 clock_ 000034 constant entry external dcl 63 ref 509 1211 code 000314 automatic fixed bin(35,0) dcl 2608 in procedure "send_data" set ref 2623* 2634* 2639 2642* 2643 2655 2655 2660* 2685* 2687 code 000100 automatic fixed bin(35,0) dcl 691 in procedure "bft_shut_down" set ref 716* 717 718* 723* 724 725* code 000141 automatic fixed bin(35,0) dcl 1708 in procedure "initiate_fetch" set ref 1719* 1720 1720 1722 1723* 1731* 1733 1736* 1745* 1747 code 000524 automatic fixed bin(35,0) dcl 2210 in procedure "receive_data" set ref 2224* 2235* 2237 2242* 2266* 2267 code 000237 automatic fixed bin(35,0) dcl 561 in procedure "add_to_store_queue" set ref 576* 577 578* 588* 591 592* 603* 604 605* 610* 612 613* code 000102 automatic fixed bin(35,0) dcl 994 in procedure "extract_requests" set ref 1008* 1009 1010* code 000100 automatic fixed bin(35,0) dcl 465 in procedure "add_to_queue" set ref 510* 512 513* code 000100 automatic fixed bin(35,0) dcl 1491 in procedure "find_pc_bft" set ref 1501* 1503 1503 1504* code 000612 automatic fixed bin(35,0) dcl 2427 in procedure "recover_store" set ref 2450* 2452 code 000153 automatic fixed bin(35,0) dcl 763 in procedure "cancel" set ref 768* 789* 790 791* code 000662 automatic fixed bin(35,0) dcl 2478 in procedure "request_connect" set ref 2486* 2487 2488* code 000231 automatic fixed bin(35,0) dcl 1130 in procedure "full_pc_path" set ref 1187* 1189* 1191 1192* 1198* 1199 1200* 1214* 1216 1217* code 000100 automatic fixed bin(35,0) dcl 1301 in procedure "cleanup_iocb_switches" set ref 1310* 1311 1314* 1315 code 000672 automatic fixed bin(35,0) dcl 2516 in procedure "request_disconnect" set ref 2528* 2529 2530* code 000201 automatic fixed bin(35,0) dcl 1778 in procedure "initiate_store" set ref 1789* 1790 1790 1792 1793* 1801* 1803 1806* 1815* 1817 code 000106 automatic fixed bin(35,0) dcl 48 in procedure "bft_main_" set ref 128* 140* 141 142* 148* 151 152* 160* 161 162* 171* 172 173* 174* 188* 190 191* 2091* 2092 2095* 2110* 2111* 2113 2116* code 000542 automatic fixed bin(35,0) dcl 2342 in procedure "recover_fetch" set ref 2361* 2363 2366* 2375* 2376* 2378 2381* 2396* 2398 com_err_ 000046 constant entry external dcl 68 ref 142 152 command_id 000100 automatic fixed bin(17,0) dcl 44 set ref 188* convert builtin function dcl 107 ref 2087 2235 2235 2251 2393 2393 2685 2685 convert_status_code_ 000022 constant entry external dcl 58 ref 2242 2660 data_block based structure level 1 unaligned dcl 7-62 set ref 865 1663 1664* data_block_ptr 000120 automatic pointer dcl 7-61 set ref 130* 148 148 148* 223* 224 229 486 588 700 864 865 866* 900 901 902 903 905 906 907 908 1165 1167 1455 1459 1510 1550 1551 1554 1555 1563 1566 1663* 1664 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1680 1854 1855 1859 1863 1864 1868 1956 1956 1981 2018 2018 2040 2110 2111 2170 2222 2235 2240 2306 2375 2376 2567 2621 2634 2640 2658 2803 delim_position 000100 automatic fixed bin(17,0) dcl 2715 set ref 2723* 2724 2724* 2727 2728 dir_name 000103 automatic char(168) packed unaligned dcl 995 in procedure "extract_requests" set ref 1007* 1008* dir_name 000240 automatic char(168) packed unaligned dcl 562 in procedure "add_to_store_queue" set ref 576* 588* 624 direction 000100 automatic fixed bin(17,0) dcl 1536 in procedure "get_pc_path" set ref 1564* 1567* 1590 1590 direction 000234 automatic fixed bin(17,0) dcl 1132 in procedure "full_pc_path" set ref 1157* 1165 1214* 1217 1233 done 000100 automatic bit(1) packed unaligned dcl 936 set ref 950* 951 955* element 000240 automatic structure level 1 unaligned dcl 1139 in procedure "full_pc_path" set ref 1214 1214 element 000104 automatic structure level 1 unaligned dcl 470 in procedure "add_to_queue" set ref 473* 510 510 entry_name 000227 automatic char(32) packed unaligned dcl 560 set ref 576* 588* equalname 000112 automatic char(32) packed unaligned dcl 1124 set ref 1198* 1205 error_string 000274 automatic varying char(128) dcl 2153 in procedure "read_error" set ref 2163* 2164* error_string 000716 automatic varying char(128) dcl 2786 in procedure "write_error" set ref 2796* 2797* error_table_$bad_conversion 000052 external static fixed bin(35,0) dcl 72 set ref 777* error_table_$end_of_info 000056 external static fixed bin(35,0) dcl 74 ref 2639 error_table_$short_record 000054 external static fixed bin(35,0) dcl 73 ref 2655 expand_pathname_ 000032 constant entry external dcl 62 ref 576 1189 2224 2623 fetch_file_pos 236 based fixed bin(21,0) level 3 dcl 5-22 set ref 1735* 2169* 2221* 2239* 2251* 2251 2258* 2258 2302* 2365* 2376* 2380* 2393 2393 fetch_pending 14 based pointer level 2 dcl 7-62 set ref 900 901 902* 903* 1165* 1554 1555 1566 1673* 1854 1855* 1859 fetching 136 based structure level 3 dcl 5-22 first_sw 73(19) based bit(1) level 3 packed packed unaligned dcl 7-79 set ref 495* 1174 1184* 1574 fixedbin17 based fixed bin(17,0) dcl 121 ref 2685 2685 fixedbin21 based fixed bin(21,0) dcl 120 ref 2235 2235 2251 flags 000137 automatic bit(36) dcl 412 in procedure "add_to_fetch_queue" set ref 422* 424* flags 000313 automatic bit(36) dcl 564 in procedure "add_to_store_queue" set ref 574* 625* flags 22 based structure level 2 in structure "data_block" packed packed unaligned dcl 7-62 in procedure "bft_main_" flags 76 000104 automatic structure level 2 in structure "element" packed packed unaligned dcl 470 in procedure "add_to_queue" set ref 478* 493 flags 72(18) based bit(36) level 2 in structure "pending" packed packed unaligned dcl 7-79 in procedure "bft_main_" set ref 493* 1212 flags 132 based structure level 4 in structure "queue" dcl 5-22 in procedure "bft_main_" set ref 1813 1813 2448 2448 flags 76 000240 automatic structure level 2 in structure "element" packed packed unaligned dcl 1139 in procedure "full_pc_path" set ref 1212* flags 234 based structure level 4 in structure "queue" dcl 5-22 in procedure "bft_main_" set ref 1743 1743 2394 2394 get_equal_name_ 000010 constant entry external dcl 53 ref 610 1198 get_system_free_area_ 000050 constant entry external dcl 69 ref 1662 hcs_$star_ 000012 constant entry external dcl 54 ref 588 header based structure level 2 dcl 5-22 i 000100 automatic fixed bin(17,0) dcl 819 in procedure "chars_to_bits" set ref 829* 830 830* i 000100 automatic fixed bin(17,0) dcl 992 in procedure "extract_requests" set ref 1021* 1022 1022* i 000407 automatic fixed bin(17,0) dcl 567 in procedure "add_to_store_queue" set ref 597* 599 599 610 613 624* i 000100 automatic fixed bin(17,0) dcl 1264 in procedure "bits_to_chars" set ref 1273* 1274 1274* i 000101 automatic fixed bin(17,0) dcl 937 in procedure "expand_pc_pathname" set ref 952* 953 953 id 76 based fixed bin(17,0) level 2 dcl 7-79 set ref 498* 1071 1584 1584 1856* 1865* 1879* 1879 id_token 000101 automatic char(2) packed unaligned dcl 1537 set ref 1584* 1585 1585 1585 1587* id_type 000100 automatic fixed bin(17,0) dcl 760 set ref 775* 776 776 776 789* inbuff_len 3 based fixed bin(17,0) level 2 dcl 7-62 set ref 148* 1668* inbuffer 000165 automatic char(120) dcl 2605 set ref 2634 2634 2673 2677 2685 2685 index builtin function dcl 111 ref 602 952 1186 2255 2259 2673 2677 2723 indx 000102 automatic fixed bin(17,0) dcl 938 set ref 947* 951 952 953* 953 959 959 961 initiated 132(33) based bit(1) level 5 in structure "queue" packed packed unaligned dcl 5-22 in procedure "bft_main_" set ref 1804* 2093* 2114* 2439 2619 2646* 2656* 2801* initiated 234(33) based bit(1) level 5 in structure "queue" packed packed unaligned dcl 5-22 in procedure "bft_main_" set ref 1734* 2168* 2220 2238* 2301* 2354 2364* 2379* iocb_ptr 000100 automatic pointer dcl 1944 in procedure "open_receive_data_file" set ref 1961* 1962* 1971* 1975* 1981 iocb_ptr 000102 automatic pointer dcl 1302 in procedure "cleanup_iocb_switches" set ref 1310* 1311* 1314* 1315* iocb_ptr 000200 automatic pointer dcl 2007 in procedure "open_send_data_file" set ref 2023* 2024* 2030* 2034* 2040 iox_$attach_name 000030 constant entry external dcl 61 ref 1971 2030 iox_$close 000042 constant entry external dcl 66 ref 1381 iox_$destroy_iocb 000036 constant entry external dcl 64 ref 1383 iox_$detach_iocb 000040 constant entry external dcl 65 ref 1382 iox_$find_iocb 000044 constant entry external dcl 67 ref 1310 1314 1961 2023 iox_$get_chars 000016 constant entry external dcl 56 ref 2634 iox_$open 000026 constant entry external dcl 60 ref 1975 2034 iox_$position 000020 constant entry external dcl 57 ref 2110 2111 2375 2376 iox_$put_chars 000024 constant entry external dcl 59 ref 2235 length builtin function dcl 109 ref 619 664 667 829 951 996 1007 1016 1019 1150 1150 1161 2228 2228 2244 2244 2627 2627 2662 2662 2724 line_len 000426 automatic fixed bin(17,0) dcl 2205 in procedure "receive_data" set ref 2255* 2256 2257 2259* 2260 line_len 000163 automatic fixed bin(21,0) dcl 2603 in procedure "send_data" set ref 2673* 2674 2675 2677* 2679 line_start 000162 automatic fixed bin(21,0) dcl 2602 in procedure "send_data" set ref 2674* 2675 2677 2677 2679* 2679 line_start 000427 automatic fixed bin(17,0) dcl 2206 in procedure "receive_data" set ref 2256* 2259 2260* 2260 long_info 000470 automatic char(100) dcl 2208 in procedure "receive_data" set ref 2242* 2243 long_info 000263 automatic char(100) dcl 2607 in procedure "send_data" set ref 2660* 2661 ltrim builtin function dcl 108 ref 785 1007 1016 major 000235 automatic fixed bin(17,0) dcl 1133 set ref 1154* 1165* 1167* major_bit_id 000236 automatic bit(18) packed unaligned dcl 1135 set ref 1149* 1150* 1152* 1152 1154 major_id_over based fixed bin(17,0) packed unaligned dcl 1134 ref 1154 major_num 000101 automatic fixed bin(17,0) dcl 1492 in procedure "find_pc_bft" set ref 1500* 1501* 1510 1512 major_num 000101 automatic fixed bin(17,0) dcl 692 in procedure "bft_shut_down" set ref 715* 716* 723* major_num 000102 automatic fixed bin(17,0) dcl 46 in procedure "bft_main_" set ref 159* 160* 170 181* 182 major_overlay based structure level 1 packed packed unaligned dcl 1619 mcb_ptr 000104 automatic pointer dcl 47 set ref 148* 162* 173* 174* 181* 188* 191* 225* 242* 578* 592* 605* 613* 712* 718* 723* 725* 777* 791* 1010* 1174* 1192* 1200* 1592* 1723* 1736* 1745* 1793* 1806* 1815* 1912* 2095* 2116* 2164* 2228* 2244* 2266* 2307* 2366* 2381* 2396* 2450* 2486* 2488* 2528* 2530* 2535* 2571* 2627* 2642* 2662* 2685* 2797* message 000430 automatic char(128) packed unaligned dcl 2207 in procedure "receive_data" set ref 2226* 2227* 2227 2228 2228 2228 2228 2243* 2244 2244 2244 2244 message 000543 automatic char(128) packed unaligned dcl 2343 in procedure "recover_fetch" set ref 2392* 2393* 2394* 2396 2396 message 000104 automatic char(128) packed unaligned dcl 1539 in procedure "get_pc_path" set ref 1575* 1576* 1580* 1581* 1585* 1587* 1590* 1592 1592 message 000223 automatic char(128) packed unaligned dcl 2606 in procedure "send_data" set ref 2625* 2626* 2626 2627 2627 2627 2627 2661* 2662 2662 2662 2662 message 000614 automatic char(128) packed unaligned dcl 2429 in procedure "recover_store" set ref 2447* 2448* 2450 2450 message 000100 automatic char(256) packed unaligned dcl 1776 in procedure "initiate_store" set ref 1811* 1813* 1815 1815 message 000101 automatic char(128) packed unaligned dcl 1707 in procedure "initiate_fetch" set ref 1741* 1743* 1745 1745 message_len 000144 automatic fixed bin(17,0) dcl 1540 in procedure "get_pc_path" set ref 1573* 1575* 1576* 1580* 1581* 1585* 1587* 1590* 1592* message_len 000200 automatic fixed bin(17,0) dcl 1777 in procedure "initiate_store" set ref 1810* 1811* 1813* 1815* message_len 000603 automatic fixed bin(17,0) dcl 2344 in procedure "recover_fetch" set ref 2391* 2392* 2393* 2394* 2396* message_len 000100 automatic fixed bin(17,0) dcl 1706 in procedure "initiate_fetch" set ref 1740* 1741* 1743* 1745* message_len 000613 automatic fixed bin(17,0) dcl 2428 in procedure "recover_store" set ref 2446* 2447* 2448* 2450* mode 000100 automatic fixed bin(17,0) dcl 2074 set ref 2105* 2107* 2111* mu_dirname 000132 automatic char(168) packed unaligned dcl 1126 in procedure "full_pc_path" set ref 1189* 1205 mu_dirname 000354 automatic char(168) packed unaligned dcl 2204 in procedure "receive_data" set ref 2224* mu_dirname 000110 automatic char(168) packed unaligned dcl 2601 in procedure "send_data" set ref 2623* mu_entryname 000122 automatic char(32) packed unaligned dcl 1125 in procedure "full_pc_path" set ref 1189* 1198* mu_entryname 000100 automatic char(32) packed unaligned dcl 2600 in procedure "send_data" set ref 2623* 2625 mu_entryname 000344 automatic char(32) packed unaligned dcl 2203 in procedure "receive_data" set ref 2224* 2226 mu_path 000335 automatic char(168) packed unaligned dcl 566 in procedure "add_to_store_queue" set ref 574* 576* 578* 592* mu_path 000161 automatic char(168) packed unaligned dcl 414 in procedure "add_to_fetch_queue" set ref 422* 424* multics_path 1 000240 automatic char(168) level 2 in structure "element" packed packed unaligned dcl 1139 in procedure "full_pc_path" set ref 1205* 1207* multics_path based char(168) level 2 in structure "pending" packed packed unaligned dcl 7-79 in procedure "bft_main_" set ref 491* 1186 1189* 1192* 1207 multics_path 35 based char(168) level 4 in structure "queue" dcl 5-22 in procedure "bft_main_" ref 1801 1801 1806 1806 2091 2091 2095 2095 2116 2116 2623 2623 multics_path 137 based char(168) level 4 in structure "queue" dcl 5-22 in procedure "bft_main_" ref 1731 1731 1736 1736 2224 2224 2307 2307 2361 2361 2366 2366 2381 2381 multics_path 1 000104 automatic char(168) level 2 in structure "element" packed packed unaligned dcl 470 in procedure "add_to_queue" set ref 476* 491 my_major 000101 automatic fixed bin(17,0) dcl 45 set ref 170* 171* next 100 based pointer level 2 in structure "pending" dcl 7-79 in procedure "bft_main_" set ref 487* 901 906 1073 1088 1090* 1090 1092* 1874 1875 1877* next 000240 automatic fixed bin(35,0) level 2 in structure "element" dcl 1139 in procedure "full_pc_path" set ref 1210* nnames 0(02) based fixed bin(16,0) array level 2 packed packed unsigned unaligned dcl 1-27 ref 584 630 notify_sw 234(35) based bit(1) level 5 packed packed unaligned dcl 5-22 ref 2307 null builtin function dcl 113 ref 129 130 484 487 864 866 900 905 1064 1066 1068 1074 1078 1079 1088 1092 1169 1347 1349 1385 1550 1554 1565 1670 1671 1673 1674 1854 1863 1874 1956 1971 1971 2018 2030 2030 2266 2266 2642 2642 open_descrip 000102 automatic char(256) packed unaligned dcl 1945 in procedure "open_receive_data_file" set ref 1967* 1968* 1968 1971* open_descrip 000100 automatic char(256) packed unaligned dcl 2006 in procedure "open_send_data_file" set ref 2029* 2030* out_string 000100 automatic char packed unaligned dcl 1263 set ref 1272* 1274 1278 outbuff_len 4 based fixed bin(17,0) level 2 dcl 7-62 set ref 148* 1669* p_append_sw parameter bit(1) packed unaligned dcl 1940 ref 1923 1968 p_arg_data based char packed unaligned dcl 2071 in procedure "position_file_pointer" set ref 2086* p_arg_data based char packed unaligned dcl 2200 in procedure "receive_data" ref 2255 2259 p_arg_data based char packed unaligned dcl 551 in procedure "add_to_store_queue" set ref 574* p_arg_data parameter char packed unaligned dcl 2711 in procedure "strip_token" set ref 2696 2723 2724 2727 2728* 2728 p_arg_data based char packed unaligned dcl 2783 in procedure "write_error" set ref 2796* p_arg_data based char packed unaligned dcl 1118 in procedure "full_pc_path" set ref 1145* 1148* 1156* p_arg_data based char packed unaligned dcl 407 in procedure "add_to_fetch_queue" set ref 422* p_arg_data based char packed unaligned dcl 2150 in procedure "read_error" set ref 2163* p_arg_data based char packed unaligned dcl 757 in procedure "cancel" set ref 774* 784* p_arg_len parameter fixed bin(17,0) dcl 2070 in procedure "position_file_pointer" ref 2048 2076 2086 2086 p_arg_len parameter fixed bin(17,0) dcl 39 in procedure "bft_main_" set ref 207 316* 320* 335* 339* 355* 363* 371* 381* p_arg_len parameter fixed bin(17,0) dcl 406 in procedure "add_to_fetch_queue" ref 392 422 422 p_arg_len parameter fixed bin(17,0) dcl 756 in procedure "cancel" ref 736 762 774 774 784 784 p_arg_len parameter fixed bin(17,0) dcl 2782 in procedure "write_error" ref 2766 2796 2796 p_arg_len parameter fixed bin(17,0) dcl 2149 in procedure "read_error" ref 2133 2163 2163 p_arg_len parameter fixed bin(17,0) dcl 2199 in procedure "receive_data" ref 2182 2235 2235 2251 2255 2259 p_arg_len parameter fixed bin(17,0) dcl 1121 in procedure "full_pc_path" ref 1100 1136 1145 1145 1148 1148 1156 1156 p_arg_len parameter fixed bin(17,0) dcl 1442 in procedure "execute_pc_bft" set ref 1424 1459* p_arg_len parameter fixed bin(17,0) dcl 550 in procedure "add_to_store_queue" ref 533 574 574 p_arg_ptr parameter pointer dcl 1120 in procedure "full_pc_path" ref 1100 1145 1148 1156 p_arg_ptr parameter pointer dcl 755 in procedure "cancel" ref 736 774 784 p_arg_ptr parameter pointer dcl 2198 in procedure "receive_data" set ref 2182 2235* 2255 2259 p_arg_ptr parameter pointer dcl 38 in procedure "bft_main_" set ref 207 316* 320* 335* 339* 355* 363* 371* 381* p_arg_ptr parameter pointer dcl 2148 in procedure "read_error" ref 2133 2163 p_arg_ptr parameter pointer dcl 2069 in procedure "position_file_pointer" ref 2048 2086 p_arg_ptr parameter pointer dcl 405 in procedure "add_to_fetch_queue" ref 392 422 p_arg_ptr parameter pointer dcl 1441 in procedure "execute_pc_bft" set ref 1424 1459* p_arg_ptr parameter pointer dcl 2781 in procedure "write_error" ref 2766 2796 p_arg_ptr parameter pointer dcl 549 in procedure "add_to_store_queue" ref 533 574 p_bits parameter bit packed unaligned dcl 1260 ref 1245 1274 p_code parameter fixed bin(35,0) dcl 1649 in procedure "initialize_bft" set ref 1636 1658* 1677* 1678 p_code parameter fixed bin(35,0) dcl 2003 in procedure "open_send_data_file" set ref 1989 2012* 2023* 2024 2030* 2031 2034* 2035 p_code parameter fixed bin(35,0) dcl 930 in procedure "expand_pc_pathname" set ref 917 943* p_code parameter fixed bin(35,0) dcl 1445 in procedure "execute_pc_bft" set ref 1424 1459* 1461 1462* p_code parameter fixed bin(35,0) dcl 1941 in procedure "open_receive_data_file" set ref 1923 1950* 1961* 1962 1971* 1972 1975* 1976 p_data_block_ptr parameter pointer dcl 41 ref 207 223 p_dir_name parameter char packed unaligned dcl 932 set ref 917 948* 959* p_direction parameter fixed bin(17,0) dcl 1841 in procedure "insert_pending" ref 1828 1853 p_direction parameter fixed bin(17,0) dcl 461 in procedure "add_to_queue" set ref 432 483 499* 510* 513 522 p_entry_name parameter char packed unaligned dcl 933 set ref 917 949* 961* p_flags parameter bit(36) dcl 987 in procedure "extract_requests" set ref 969 1020* 1022* 1025 1025 p_flags parameter bit(36) dcl 460 in procedure "add_to_queue" ref 432 478 p_iocb_ptr parameter pointer dcl 1371 set ref 1358 1381* 1382* 1383* 1385* p_major parameter fixed bin(17,0) dcl 1614 set ref 1601 1628 p_major_sender parameter fixed bin(17,0) dcl 552 in procedure "add_to_store_queue" set ref 533 625* p_major_sender parameter fixed bin(17,0) dcl 408 in procedure "add_to_fetch_queue" set ref 392 424* p_major_sender parameter fixed bin(17,0) dcl 37 in procedure "bft_main_" set ref 207 308* 312* 316* 320* p_mcb_ptr parameter pointer dcl 40 in procedure "bft_main_" set ref 207 225 381* 513* p_mcb_ptr parameter pointer dcl 1444 in procedure "execute_pc_bft" set ref 1424 1455* 1459* 1462* p_mcb_ptr parameter pointer dcl 1488 in procedure "find_pc_bft" set ref 1473 1504* p_mcb_ptr parameter pointer dcl 1119 in procedure "full_pc_path" set ref 1100 1217* p_message parameter char packed unaligned dcl 651 in procedure "add_token" set ref 638 663* 666* p_message parameter char packed unaligned dcl 985 in procedure "extract_requests" set ref 969 996 1006* 1015* 1018* 1027* p_message parameter char packed unaligned dcl 1902 in procedure "no_handler" set ref 1887 1912* p_message_len parameter fixed bin(17,0) dcl 652 set ref 638 663 664* 664 666 667* 667 p_minor parameter fixed bin(17,0) dcl 1443 set ref 1424 1459* 1462* p_minor_cap parameter fixed bin(17,0) dcl 36 set ref 207 229 229 229 238 238 238 238 238 238 242* 250 p_mu_path parameter char packed unaligned dcl 989 in procedure "extract_requests" set ref 969 1008* 1010 1010 p_mu_path parameter char packed unaligned dcl 457 in procedure "add_to_queue" ref 432 476 p_n_bytes parameter fixed bin(17,0) dcl 1259 ref 1245 1263 1273 p_path parameter char packed unaligned dcl 1939 in procedure "open_receive_data_file" ref 1923 1967 p_path parameter char packed unaligned dcl 2002 in procedure "open_send_data_file" ref 1989 2029 p_pc_path parameter char packed unaligned dcl 458 in procedure "add_to_queue" ref 432 477 p_pc_path parameter char packed unaligned dcl 988 in procedure "extract_requests" set ref 969 1016* p_pending_ptr parameter pointer dcl 1842 in procedure "insert_pending" ref 1828 1855 1856 1864 1865 1877 1879 p_pending_ptr parameter pointer dcl 1337 in procedure "cleanup_pending" set ref 1324 1347 1348 1349* p_pending_ptr parameter pointer dcl 1052 in procedure "find_pending" set ref 1036 1064* 1079* 1083* 1092 p_precision parameter fixed bin(17,0) dcl 815 ref 802 820 830 p_priority parameter fixed bin(17,0) dcl 986 in procedure "extract_requests" set ref 969 1028* p_priority parameter fixed bin(17,0) dcl 459 in procedure "add_to_queue" set ref 432 497 510* 513* p_remove parameter bit(1) packed unaligned dcl 1049 ref 1036 1085 p_request_id parameter fixed bin(17,0) dcl 1050 ref 1036 1071 p_sender parameter fixed bin(17,0) dcl 2475 in procedure "request_connect" set ref 2461 2486* 2488* p_sender parameter fixed bin(17,0) dcl 2513 in procedure "request_disconnect" set ref 2499 2528* 2530* p_sender parameter fixed bin(17,0) dcl 462 in procedure "add_to_queue" set ref 432 483* p_shut_down_sw parameter bit(1) packed unaligned dcl 1487 in procedure "find_pc_bft" ref 1473 1505 p_shut_down_sw parameter bit(1) packed unaligned dcl 1901 in procedure "no_handler" ref 1887 1914 p_source parameter char packed unaligned dcl 931 ref 917 951 952 959 961 p_start_ptr parameter pointer dcl 1051 set ref 1036 1065 1068 1088* p_string parameter char packed unaligned dcl 816 ref 802 829 830 p_token parameter char packed unaligned dcl 653 in procedure "add_token" ref 638 663 664 p_token parameter varying char dcl 2712 in procedure "strip_token" set ref 2696 2727* pad 73(20) based bit(34) level 3 packed packed unaligned dcl 7-79 set ref 496* path_name 000155 automatic char(168) packed unaligned dcl 559 set ref 624* 625* pc_bft_num 2 based fixed bin(17,0) level 2 dcl 7-62 set ref 1455 1459* 1510* 1667* pc_dir_name 000103 automatic char(66) packed unaligned dcl 556 set ref 603* 619 619 pc_dirname 000207 automatic char(66) packed unaligned dcl 1128 set ref 1187* pc_entry_name 000100 automatic char(11) packed unaligned dcl 555 set ref 603* 610* pc_entryname 000204 automatic char(12) packed unaligned dcl 1127 set ref 1187* 1198* 1200* pc_equal 000134 automatic char(66) packed unaligned dcl 558 set ref 598* 618* 619* 621* 621 625* pc_equal1 000124 automatic char(32) packed unaligned dcl 557 set ref 610* 621 pc_path 53 000104 automatic char(66) level 2 in structure "element" packed packed unaligned dcl 470 in procedure "add_to_queue" set ref 477* 492 pc_path 211 based char(66) level 4 in structure "queue" dcl 5-22 in procedure "bft_main_" ref 1741 1741 2392 2392 pc_path 52 based char(66) level 2 in structure "pending" packed packed unaligned dcl 7-79 in procedure "bft_main_" set ref 492* 1174 1174* 1576 1576 pc_path 107 based char(66) level 4 in structure "queue" dcl 5-22 in procedure "bft_main_" ref 1811 1811 2447 2447 pc_path 000314 automatic char(66) packed unaligned dcl 565 in procedure "add_to_store_queue" set ref 574* 598 602 603* 605* pc_path 000140 automatic char(66) packed unaligned dcl 413 in procedure "add_to_fetch_queue" set ref 422* 424* pc_path 53 000240 automatic char(66) level 2 in structure "element" packed packed unaligned dcl 1139 in procedure "full_pc_path" set ref 1146* 1161 1187* pending based structure level 1 unaligned dcl 7-79 set ref 486 1348 pending_ptr 000232 automatic pointer dcl 1131 in procedure "full_pc_path" set ref 1165* 1167* 1169 1174 1174 1174 1183 1184 1186 1189 1192 1207 1212 1214 1217 1223* pending_ptr 000102 automatic pointer dcl 466 in procedure "add_to_queue" set ref 484* 485* 486* 487 491 492 493 494 495 496 497 498 499* pending_ptr 000102 automatic pointer dcl 1538 in procedure "get_pc_path" set ref 1563* 1565 1566* 1569 1574 1576 1576 1584 1584 prev_ptr 000106 automatic pointer dcl 1055 set ref 1066* 1072* 1073 1088 1090 priority 000312 automatic fixed bin(17,0) dcl 563 in procedure "add_to_store_queue" set ref 574* 625* priority 000136 automatic fixed bin(17,0) dcl 411 in procedure "add_to_fetch_queue" set ref 422* 424* priority 75 based fixed bin(17,0) level 2 in structure "pending" dcl 7-79 in procedure "bft_main_" set ref 497* 1214* 1217* processing_sw 73(18) based bit(1) level 3 packed packed unaligned dcl 7-79 set ref 494* 1183* 1551 1555 1569* queue based structure level 1 dcl 5-22 queue_element based structure level 1 unaligned dcl 5-50 queue_header based structure level 1 unaligned dcl 5-28 queue_ptr 20 based pointer level 2 in structure "data_block" dcl 7-62 in procedure "bft_main_" set ref 224 1680* queue_ptr 000116 automatic pointer dcl 5-21 in procedure "bft_main_" set ref 129* 224* 510* 789* 1214* 1677* 1680 1719* 1731 1731 1734 1735 1736 1736 1741 1741 1743 1743 1789* 1801 1801 1804 1805 1806 1806 1811 1811 1813 1813 2091 2091 2093 2094 2095 2095 2104 2105 2111 2114 2115 2116 2116 2168 2169 2220 2221 2224 2224 2238 2239 2251 2251 2251 2258 2258 2301 2302 2307 2307 2307 2354 2361 2361 2364 2365 2366 2366 2374 2376 2379 2380 2381 2381 2392 2392 2393 2393 2394 2394 2439 2447 2447 2448 2448 2619 2620 2623 2623 2646 2647 2656 2657 2669 2669 2669 2676 2676 2801 2802 rank builtin function dcl 103 ref 775 1028 1157 receive_iocb_ptr 6 based pointer level 2 dcl 7-62 set ref 1670* 1956 1956* 1981* 2170* 2222* 2235* 2240* 2306* 2375* 2376* remove_sw 000230 automatic bit(1) packed unaligned dcl 1129 set ref 1161* 1165* 1167* 1174 1182 1232 request_id 000101 automatic char(168) packed unaligned dcl 761 set ref 785* 789* 791* ret_string 000101 automatic bit packed unaligned dcl 820 set ref 828* 830* 834 reverse builtin function dcl 106 ref 1150 1152 1274 1274 1278 rtrim builtin function dcl 102 ref 491 492 619 619 621 621 624 624 951 961 1010 1010 1161 1205 1576 1576 1731 1731 1736 1736 1741 1741 1801 1801 1806 1806 1811 1811 1967 1968 2029 2091 2091 2095 2095 2116 2116 2224 2224 2226 2227 2228 2228 2243 2244 2244 2307 2307 2361 2361 2366 2366 2381 2381 2392 2392 2447 2447 2623 2623 2625 2626 2627 2627 2661 2662 2662 search builtin function dcl 101 ref 1174 search_ptr 000110 automatic pointer dcl 1056 set ref 1065* 1071 1072 1073* 1074 1078 1083 1088 1090 send_iocb_ptr 10 based pointer level 2 dcl 7-62 set ref 1671* 2018 2018* 2040* 2110* 2111* 2621* 2634* 2640* 2658* 2803* short_info 000316 automatic char(8) dcl 2609 in procedure "send_data" set ref 2660* short_info 000522 automatic char(8) dcl 2209 in procedure "receive_data" set ref 2242* shut_down_sw 22 based bit(1) level 3 packed packed unaligned dcl 7-62 set ref 229 700* 1675* 2567* star_ALL_ENTRIES 000201 constant fixed bin(2,0) initial dcl 1-111 set ref 588* star_LINK constant fixed bin(2,0) initial unsigned dcl 1-119 ref 599 star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 1-120 ref 599 star_entries based structure array level 1 dcl 1-27 ref 585 631 star_entry_count 000107 automatic fixed bin(17,0) dcl 1-14 set ref 584 585 588* 597 630 631 star_entry_ptr 000110 automatic pointer dcl 1-15 set ref 584 585 588* 599 599 630 631 star_names based char(32) array packed unaligned dcl 1-37 set ref 584 610* 613* 624 630 star_names_ptr 000112 automatic pointer dcl 1-19 set ref 584 588* 610 613 624 630 start_ptr 000226 automatic pointer dcl 1845 set ref 1859* 1868* 1874 1875* 1875 1877 1879 store_file_pos 134 based fixed bin(21,0) level 3 dcl 5-22 set ref 1805* 2094* 2104* 2111* 2115* 2620* 2647* 2657* 2669* 2669 2676* 2676 2802* store_pending 16 based pointer level 2 dcl 7-62 set ref 905 906 907* 908* 1167* 1550 1551 1563 1674* 1863 1864* 1868 storing 34 based structure level 3 dcl 5-22 substr builtin function dcl 110 set ref 663* 666* 775 830* 830 952 959 961 1007 1016 1019 1022* 1022 1022 1025* 1028 1150* 1150 1150 1157 1274* 1274 1274 1585 1585 1585 2255 2259 2673 2677 2727 2728 sum builtin function dcl 100 ref 584 630 switches 73(18) based structure level 2 packed packed unaligned dcl 7-79 system 0(18) based fixed bin(8,0) level 2 packed packed unaligned dcl 1619 ref 1628 system_free_area based area(1024) dcl 1652 in procedure "initialize_bft" ref 1663 system_free_area based area(1024) dcl 467 in procedure "add_to_queue" ref 486 system_free_area_ptr 000256 automatic pointer dcl 1653 in procedure "initialize_bft" set ref 1662* 1663 1672 system_free_area_ptr 12 based pointer level 2 in structure "data_block" dcl 7-62 in procedure "bft_main_" set ref 486 588* 1672* temp_ptr 000100 automatic pointer dcl 890 set ref 901* 903 906* 908 temp_seg_name 000114 automatic char(6) initial packed unaligned dcl 4-22 set ref 4-22* time_id 74 000240 automatic fixed bin(71,0) level 2 in structure "element" dcl 1139 in procedure "full_pc_path" set ref 1211* time_id 74 000104 automatic fixed bin(71,0) level 2 in structure "element" dcl 470 in procedure "add_to_queue" set ref 509* token 000155 automatic varying char dcl 996 in procedure "extract_requests" set ref 1006* 1007 1007 1015* 1016 1016 1018* 1019 1019 1027* 1028 token 000102 automatic varying char dcl 2076 in procedure "position_file_pointer" set ref 2086* 2087 token 000237 automatic varying char dcl 1136 in procedure "full_pc_path" set ref 1145* 1146 1148* 1150 1150 1150 1150 1156* 1157 token 000153 automatic varying char dcl 762 in procedure "cancel" set ref 774* 775 784* 785 type based fixed bin(2,0) array level 2 packed packed unsigned unaligned dcl 1-27 ref 599 599 unspec builtin function dcl 112 set ref 473* 478* 493 830 1022 1025 1212* 1272* 1274 1584 1584 1664* 1743 1743 1813 1813 2394 2394 2448 2448 version based char(8) level 2 packed packed unaligned dcl 7-62 set ref 1666* ws_$connect_response 000066 constant entry external dcl 80 ref 2486 ws_$create_instance 000106 constant entry external dcl 88 ref 148 ws_$destroy_instance 000100 constant entry external dcl 85 ref 174 2535 2571 ws_$disconnect_request 000074 constant entry external dcl 83 ref 723 ws_$disconnect_response 000064 constant entry external dcl 79 ref 2528 ws_$execute_capability 000070 constant entry external dcl 81 ref 1459 ws_$execute_command 000076 constant entry external dcl 84 ref 188 ws_$find_capability_number 000104 constant entry external dcl 87 ref 160 171 716 1501 ws_$put_background_message 000102 constant entry external dcl 86 ref 162 173 191 242 513 578 592 605 613 712 718 725 777 791 1010 1174 1192 1200 1217 1462 1504 1723 1736 1793 1806 1912 2095 2116 2164 2307 2366 2381 2488 2530 2797 ws_error_$invalid_capability_name 000124 external static fixed bin(35,0) dcl 97 ref 1503 ws_error_$invalid_minor_capability 000122 external static fixed bin(35,0) dcl 96 set ref 242* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ADD_TO_REMOTE_CAT internal static fixed bin(17,0) initial dcl 4-78 A_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 BFT_INBUFFER_SIZE internal static fixed bin(17,0) initial dcl 7-35 BFT_MAX_PRIORITY internal static fixed bin(17,0) initial dcl 6-12 BFT_MINOR_CAPS internal static fixed bin(17,0) initial dcl 7-34 BFT_MIN_PRIORITY internal static fixed bin(17,0) initial dcl 6-11 BFT_OUTBUFFER_SIZE internal static fixed bin(17,0) initial dcl 7-36 BFT_QUEUE_PRIORITIES internal static fixed bin(17,0) initial dcl 5-14 BFT_QUEUE_VERSION_1 internal static char(8) initial packed unaligned dcl 5-12 BFT_QUEUE_WAIT_TIME internal static fixed bin(17,0) initial dcl 5-16 CONTINUE internal static fixed bin(17,0) initial dcl 4-94 DELETE_FROM_REMOTE_CAT internal static fixed bin(17,0) initial dcl 4-79 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 2-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 EXECUTE_CAPABILITY_REPLY internal static fixed bin(17,0) initial dcl 4-73 EXECUTE_COMMAND internal static fixed bin(17,0) initial dcl 4-77 EXECUTE_COMMAND_REPLY internal static fixed bin(17,0) initial dcl 4-72 E_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 FAIL_CAPABILITY internal static fixed bin(17,0) initial dcl 4-75 FG_BREAK internal static fixed bin(17,0) initial dcl 4-105 FG_CONTROL_MESSAGE internal static fixed bin(17,0) initial dcl 4-104 FG_MORE_DATA internal static fixed bin(17,0) initial dcl 4-107 FG_TERMINAL_DATA internal static fixed bin(17,0) initial dcl 4-106 INTERNAL internal static fixed bin(17,0) initial dcl 4-76 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 LAST internal static fixed bin(17,0) initial dcl 4-71 MAXIMUM_BG_SIZE internal static fixed bin(17,0) initial dcl 4-44 MAXIMUM_BUFFER_SIZE internal static fixed bin(17,0) initial dcl 4-43 MAXIMUM_PACKET_SIZE internal static fixed bin(17,0) initial dcl 4-49 MAXIMUM_SYSTEM_MINOR internal static fixed bin(17,0) initial dcl 4-65 MAXIMUM_USER_MINOR internal static fixed bin(17,0) initial dcl 4-67 MINIMUM_BUFFER_SIZE internal static fixed bin(17,0) initial dcl 4-42 MINIMUM_SYSTEM_MINOR internal static fixed bin(17,0) initial dcl 4-64 MINIMUM_USER_MINOR internal static fixed bin(17,0) initial dcl 4-66 MORE internal static fixed bin(17,0) initial dcl 4-95 MOWSE_VERSION_ internal static char(8) initial packed unaligned dcl 4-26 M_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 N_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 OVERFLOWED_BUFFER internal static fixed bin(17,0) initial dcl 4-87 PACKET_SIZE internal static fixed bin(17,0) initial dcl 4-48 PUT_TO_BACKGROUND_BUFFER internal static fixed bin(17,0) initial dcl 4-108 PUT_TO_QUERY_MESSAGE_BUFFER internal static fixed bin(17,0) initial dcl 4-110 QUERY_REPLY internal static fixed bin(17,0) initial dcl 4-89 RECEIVE internal static fixed bin(17,0) initial dcl 4-59 REQUEST_CONNECT internal static fixed bin(17,0) initial dcl 4-92 REQUEST_DISCONNECT internal static fixed bin(17,0) initial dcl 4-93 RESET_APPLICATION internal static fixed bin(17,0) initial dcl 4-83 RESET_REPLY internal static fixed bin(17,0) initial dcl 4-84 RESET_SLEEP_FLAG internal static fixed bin(17,0) initial dcl 4-97 RESET_SUSPEND internal static fixed bin(17,0) initial dcl 4-99 RESPONSE_CONNECT internal static fixed bin(17,0) initial dcl 4-90 RESUME_APPLICATION internal static fixed bin(17,0) initial dcl 4-81 REW_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RW_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 R_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SA_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 2-30 SEND internal static fixed bin(17,0) initial dcl 4-60 SEND_QUERY internal static fixed bin(17,0) initial dcl 4-53 SET_SLEEP_FLAG internal static fixed bin(17,0) initial dcl 4-96 SET_SUSPEND internal static fixed bin(17,0) initial dcl 4-98 SMA_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 STATUS internal static fixed bin(17,0) initial dcl 4-86 STATUS_FAILED internal static fixed bin(8,0) initial dcl 4-37 STATUS_REPLY internal static fixed bin(17,0) initial dcl 4-100 STATUS_SUCCESS internal static fixed bin(8,0) initial dcl 4-35 SUSPEND_APPLICATION internal static fixed bin(17,0) initial dcl 4-80 SYSTEM_ERROR internal static fixed bin(17,0) initial dcl 4-88 S_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-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_output internal static fixed bin(17,0) initial dcl 3-15 WAKE_UP internal static fixed bin(17,0) initial dcl 4-85 W_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 bft_minor_$add_to_fetch_queue internal static fixed bin(17,0) initial dcl 7-15 bft_minor_$add_to_store_queue internal static fixed bin(17,0) initial dcl 7-16 bft_minor_$cancel_request internal static fixed bin(17,0) initial dcl 7-29 bft_minor_$full_pc_path internal static fixed bin(17,0) initial dcl 7-31 bft_minor_$recover_fetch internal static fixed bin(17,0) initial dcl 7-23 bft_minor_$recover_store internal static fixed bin(17,0) initial dcl 7-24 bft_values_struct automatic structure level 1 packed packed unaligned dcl 7-44 iox_modes internal static char(24) initial array dcl 3-6 short_iox_modes internal static char(4) initial array dcl 3-12 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 1-114 star_BRANCHES_ONLY internal static fixed bin(2,0) initial dcl 1-110 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 1-121 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 1-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 1-112 star_branch_count automatic fixed bin(17,0) dcl 1-13 star_dir_list_branch based structure array level 1 dcl 1-59 star_link_count automatic fixed bin(17,0) dcl 1-17 star_link_pathname based char packed unaligned dcl 1-102 star_links based structure array level 1 dcl 1-76 star_linkx automatic fixed bin(17,0) dcl 1-18 star_list_branch based structure array level 1 dcl 1-41 star_list_branch_ptr automatic pointer dcl 1-16 star_list_names based char(32) array packed unaligned dcl 1-92 star_list_names_ptr automatic pointer dcl 1-20 star_select_sw automatic fixed bin(3,0) dcl 1-21 NAMES DECLARED BY EXPLICIT CONTEXT. add_to_fetch_queue 002043 constant entry internal dcl 392 ref 316 add_to_queue 002136 constant entry internal dcl 432 ref 424 625 add_to_store_queue 002473 constant entry internal dcl 533 ref 320 add_token 003514 constant entry internal dcl 638 ref 1575 1576 1580 1581 1585 1587 1590 1741 1743 1811 1813 2392 2393 2394 2447 2448 bft_main_ 000675 constant entry external dcl 9 bft_shut_down 003561 constant entry internal dcl 675 ref 164 193 244 331 1464 1505 1725 1795 1914 2758 bits_to_chars 006342 constant entry internal dcl 1245 ref 1584 1743 1813 2394 2448 cancel 004001 constant entry internal dcl 736 ref 371 case 000000 constant label array(32:81) dcl 252 ref 250 chars_to_bits 004254 constant entry internal dcl 802 ref 1150 cleanup_data_block 004360 constant entry internal dcl 842 ref 175 2536 2573 cleanup_iocb_switches 006453 constant entry internal dcl 1286 ref 704 2524 2569 cleanup_pending 006554 constant entry internal dcl 1324 ref 485 902 907 1223 cleanup_pending_chain 004373 constant entry internal dcl 875 ref 708 2526 close_data_file 006575 constant entry internal dcl 1358 ref 1311 1315 1956 1962 2018 2024 2170 2222 2240 2306 2621 2640 2658 2803 execute_command_reply 006646 constant entry internal dcl 1393 ref 252 execute_pc_bft 006651 constant entry internal dcl 1424 ref 1592 1745 1815 2228 2244 2266 2396 2450 2627 2642 2662 2685 expand_pc_pathname 004455 constant entry internal dcl 917 ref 603 1187 extract_requests 004632 constant entry internal dcl 969 ref 422 574 find_pc_bft 006776 constant entry internal dcl 1473 ref 181 1455 find_pending 005227 constant entry internal dcl 1036 ref 1165 1167 full_pc_path 005321 constant entry internal dcl 1100 ref 381 get_pc_path 007121 constant entry internal dcl 1520 ref 503 1228 get_system_id 007510 constant entry internal dcl 1601 ref 483 initialize_bft 007517 constant entry internal dcl 1636 ref 140 initiate_fetch 007613 constant entry internal dcl 1688 ref 327 522 1233 2174 2314 2355 2368 2384 initiate_store 010207 constant entry internal dcl 1758 ref 359 524 1235 2098 2119 2440 2649 2807 insert_pending 010574 constant entry internal dcl 1828 ref 499 main_entry 001350 constant entry external dcl 207 no_handler 010664 constant entry internal dcl 1887 ref 256 260 264 272 276 280 284 288 292 296 300 open_receive_data_file 010742 constant entry internal dcl 1923 ref 1731 2361 open_send_data_file 011215 constant entry internal dcl 1989 ref 1801 2091 position_file_pointer 011426 constant entry internal dcl 2048 ref 335 read_error 012013 constant entry internal dcl 2133 ref 355 receive_data 012105 constant entry internal dcl 2182 ref 339 receive_eof 012553 constant entry internal dcl 2276 ref 343 recover_fetch 012660 constant entry internal dcl 2322 ref 347 recover_store 013354 constant entry internal dcl 2407 ref 351 request_connect 013522 constant entry internal dcl 2461 ref 308 request_disconnect 013605 constant entry internal dcl 2499 ref 312 response_disconnect 013716 constant entry internal dcl 2544 ref 304 send_data 013743 constant entry internal dcl 2581 ref 367 2125 strip_token 014502 constant entry internal dcl 2696 ref 774 784 1006 1015 1018 1027 1145 1148 1156 2086 2163 2796 terminate_application 014561 constant entry internal dcl 2736 ref 268 write_error 014567 constant entry internal dcl 2766 ref 363 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 16222 16350 15234 16232 Length 17076 15234 126 511 766 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME bft_main_ 908 external procedure is an external procedure. add_to_fetch_queue internal procedure shares stack frame of external procedure bft_main_. add_to_queue 204 internal procedure enables or reverts conditions. on unit on line 485 70 on unit add_to_store_queue 355 internal procedure enables or reverts conditions. on unit on line 583 64 on unit add_token 66 internal procedure is called during a stack extension. bft_shut_down 100 internal procedure is called by several nonquick procedures. cancel 168 internal procedure uses auto adjustable storage. chars_to_bits 74 internal procedure uses auto adjustable storage, uses returns(char(*)) or returns(bit(*)), and is called during a stack extension. cleanup_data_block internal procedure shares stack frame of external procedure bft_main_. cleanup_pending_chain 72 internal procedure is called by several nonquick procedures. expand_pc_pathname 72 internal procedure is called by several nonquick procedures. extract_requests 174 internal procedure uses auto adjustable storage. find_pending internal procedure shares stack frame of internal procedure full_pc_path. full_pc_path 316 internal procedure uses auto adjustable storage. bits_to_chars 76 internal procedure uses auto adjustable storage, and uses returns(char(*)) or returns(bit(*)). cleanup_iocb_switches 98 internal procedure is called by several nonquick procedures. cleanup_pending 64 internal procedure is called by several nonquick procedures. close_data_file 72 internal procedure is called by several nonquick procedures. execute_command_reply internal procedure shares stack frame of external procedure bft_main_. execute_pc_bft 112 internal procedure is called by several nonquick procedures. find_pc_bft 104 internal procedure is called by several nonquick procedures. get_pc_path 122 internal procedure is called by several nonquick procedures. get_system_id internal procedure shares stack frame of internal procedure add_to_queue. initialize_bft internal procedure shares stack frame of external procedure bft_main_. initiate_fetch 160 internal procedure is called by several nonquick procedures. initiate_store 192 internal procedure is called by several nonquick procedures. insert_pending internal procedure shares stack frame of internal procedure add_to_queue. no_handler internal procedure shares stack frame of external procedure bft_main_. open_receive_data_file 176 internal procedure is called during a stack extension. open_send_data_file 178 internal procedure is called during a stack extension. position_file_pointer 246 internal procedure uses auto adjustable storage. read_error internal procedure shares stack frame of external procedure bft_main_. receive_data internal procedure shares stack frame of external procedure bft_main_. receive_eof internal procedure shares stack frame of external procedure bft_main_. recover_fetch internal procedure shares stack frame of external procedure bft_main_. recover_store internal procedure shares stack frame of external procedure bft_main_. request_connect internal procedure shares stack frame of external procedure bft_main_. request_disconnect internal procedure shares stack frame of external procedure bft_main_. response_disconnect internal procedure shares stack frame of external procedure bft_main_. send_data 236 internal procedure is called by several nonquick procedures. strip_token 67 internal procedure is called by several nonquick procedures. terminate_application internal procedure shares stack frame of external procedure bft_main_. write_error internal procedure shares stack frame of external procedure bft_main_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME add_to_queue 000100 code add_to_queue 000102 pending_ptr add_to_queue 000104 element add_to_queue 000226 start_ptr insert_pending add_to_store_queue 000100 pc_entry_name add_to_store_queue 000103 pc_dir_name add_to_store_queue 000124 pc_equal1 add_to_store_queue 000134 pc_equal add_to_store_queue 000155 path_name add_to_store_queue 000227 entry_name add_to_store_queue 000237 code add_to_store_queue 000240 dir_name add_to_store_queue 000312 priority add_to_store_queue 000313 flags add_to_store_queue 000314 pc_path add_to_store_queue 000335 mu_path add_to_store_queue 000407 i add_to_store_queue bft_main_ 000100 command_id bft_main_ 000101 my_major bft_main_ 000102 major_num bft_main_ 000104 mcb_ptr bft_main_ 000106 code bft_main_ 000107 star_entry_count bft_main_ 000110 star_entry_ptr bft_main_ 000112 star_names_ptr bft_main_ 000114 temp_seg_name bft_main_ 000116 queue_ptr bft_main_ 000120 data_block_ptr bft_main_ 000136 priority add_to_fetch_queue 000137 flags add_to_fetch_queue 000140 pc_path add_to_fetch_queue 000161 mu_path add_to_fetch_queue 000256 system_free_area_ptr initialize_bft 000274 error_string read_error 000344 mu_entryname receive_data 000354 mu_dirname receive_data 000426 line_len receive_data 000427 line_start receive_data 000430 message receive_data 000470 long_info receive_data 000522 short_info receive_data 000524 code receive_data 000542 code recover_fetch 000543 message recover_fetch 000603 message_len recover_fetch 000612 code recover_store 000613 message_len recover_store 000614 message recover_store 000662 code request_connect 000672 code request_disconnect 000716 error_string write_error bft_shut_down 000100 code bft_shut_down 000101 major_num bft_shut_down bits_to_chars 000100 out_string bits_to_chars 000100 i bits_to_chars cancel 000100 id_type cancel 000101 request_id cancel 000153 code cancel 000153 token cancel chars_to_bits 000100 i chars_to_bits 000101 ret_string chars_to_bits cleanup_iocb_switches 000100 code cleanup_iocb_switches 000102 iocb_ptr cleanup_iocb_switches cleanup_pending_chain 000100 temp_ptr cleanup_pending_chain expand_pc_pathname 000100 done expand_pc_pathname 000101 i expand_pc_pathname 000102 indx expand_pc_pathname extract_requests 000100 i extract_requests 000101 ch_flags extract_requests 000102 code extract_requests 000103 dir_name extract_requests 000155 token extract_requests find_pc_bft 000100 code find_pc_bft 000101 major_num find_pc_bft full_pc_path 000106 prev_ptr find_pending 000110 search_ptr find_pending 000112 equalname full_pc_path 000122 mu_entryname full_pc_path 000132 mu_dirname full_pc_path 000204 pc_entryname full_pc_path 000207 pc_dirname full_pc_path 000230 remove_sw full_pc_path 000231 code full_pc_path 000232 pending_ptr full_pc_path 000234 direction full_pc_path 000235 major full_pc_path 000236 major_bit_id full_pc_path 000237 token full_pc_path 000240 element full_pc_path get_pc_path 000100 direction get_pc_path 000101 id_token get_pc_path 000102 pending_ptr get_pc_path 000104 message get_pc_path 000144 message_len get_pc_path initiate_fetch 000100 message_len initiate_fetch 000101 message initiate_fetch 000141 code initiate_fetch initiate_store 000100 message initiate_store 000200 message_len initiate_store 000201 code initiate_store open_receive_data_file 000100 iocb_ptr open_receive_data_file 000102 open_descrip open_receive_data_file open_send_data_file 000100 open_descrip open_send_data_file 000200 iocb_ptr open_send_data_file position_file_pointer 000100 mode position_file_pointer 000101 byte_count position_file_pointer 000102 token position_file_pointer send_data 000100 mu_entryname send_data 000110 mu_dirname send_data 000162 line_start send_data 000163 line_len send_data 000164 bytes_read send_data 000165 inbuffer send_data 000223 message send_data 000263 long_info send_data 000314 code send_data 000316 short_info send_data strip_token 000100 delim_position strip_token THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac alloc_auto_adj mpfx2 enable_op shorten_stack ext_entry int_entry int_entry_desc fetch_bits reverse_cs reverse_bs set_chars_eis set_bits_eis return_chars_eis return_bits_eis any_to_any_truncate_op_alloc_ op_freen_ return_main set_main_flag THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_ bft_queue_$add bft_queue_$cancel bft_queue_$initiate bft_queue_$remove clock_ com_err_ convert_status_code_ expand_pathname_ get_equal_name_ get_system_free_area_ hcs_$star_ iox_$attach_name iox_$close iox_$destroy_iocb iox_$detach_iocb iox_$find_iocb iox_$get_chars iox_$open iox_$position iox_$put_chars ws_$connect_response ws_$create_instance ws_$destroy_instance ws_$disconnect_request ws_$disconnect_response ws_$execute_capability ws_$execute_command ws_$find_capability_number ws_$put_background_message THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. bft_error_table_$fetch_in_progress bft_error_table_$illegal_minor_capability bft_error_table_$no_entries bft_error_table_$store_in_progress error_table_$bad_conversion error_table_$end_of_info error_table_$short_record ws_error_$invalid_capability_name ws_error_$invalid_minor_capability LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 4 22 000670 9 000674 128 000704 129 000705 130 000707 140 000710 141 000712 142 000714 143 000743 148 000744 151 001010 152 001012 153 001041 159 001042 160 001043 161 001067 162 001071 164 001123 165 001127 170 001130 171 001132 172 001156 173 001160 174 001215 175 001226 176 001227 181 001230 182 001244 188 001246 190 001300 191 001302 193 001334 194 001340 198 001341 207 001342 223 001356 224 001362 225 001364 229 001367 238 001401 242 001416 244 001453 245 001457 250 001460 252 001461 254 001462 256 001463 258 001476 260 001477 262 001507 264 001510 266 001523 268 001524 270 001525 272 001526 274 001536 276 001537 278 001551 280 001552 282 001561 284 001562 286 001571 288 001572 290 001605 292 001606 294 001621 296 001622 298 001633 300 001634 302 001647 304 001650 306 001651 308 001652 310 001660 312 001661 314 001667 316 001670 318 001702 320 001703 322 001715 324 001716 327 001717 329 001723 331 001724 333 001730 335 001731 337 001741 339 001742 341 001752 343 001753 345 001754 347 001755 349 001756 351 001757 353 001760 355 001761 357 001771 359 001772 361 001776 363 001777 365 002007 367 002010 369 002014 371 002015 373 002025 375 002026 378 002027 381 002030 383 002042 392 002043 422 002045 424 002101 426 002134 432 002135 473 002156 476 002161 477 002167 478 002173 483 002175 484 002216 485 002220 486 002245 487 002254 491 002256 492 002272 493 002306 494 002312 495 002314 496 002316 497 002321 498 002324 499 002325 501 002335 503 002336 504 002343 509 002344 510 002353 512 002376 513 002400 516 002451 522 002452 524 002464 527 002471 533 002472 574 002500 576 002536 577 002562 578 002564 580 002623 583 002624 584 002640 585 002672 586 002676 588 002677 591 002744 592 002746 594 003005 597 003006 598 003017 599 003022 602 003032 603 003043 604 003067 605 003071 607 003130 610 003131 612 003164 613 003166 615 003232 618 003233 619 003236 621 003265 622 003331 624 003332 625 003420 628 003455 630 003457 631 003507 632 003512 638 003513 663 003534 664 003546 666 003550 667 003556 669 003557 675 003560 700 003566 704 003572 708 003577 712 003604 715 003640 716 003641 717 003667 718 003671 720 003724 723 003725 724 003741 725 003743 727 003776 730 003777 736 004000 762 004006 774 004017 784 004022 768 004025 774 004026 775 004050 776 004054 777 004062 779 004115 784 004116 785 004140 789 004157 790 004205 791 004207 793 004251 796 004252 802 004253 820 004267 828 004277 829 004305 830 004317 832 004346 834 004350 842 004360 864 004361 865 004365 866 004367 869 004371 875 004372 900 004400 901 004406 902 004411 903 004420 904 004424 905 004425 906 004434 907 004437 908 004446 909 004452 911 004453 917 004454 943 004502 947 004504 948 004506 949 004513 950 004520 951 004521 952 004542 953 004561 955 004564 957 004566 959 004567 961 004602 963 004630 969 004631 996 004657 1006 004672 1015 004675 1018 004700 1027 004703 1006 004706 1007 004725 1008 004744 1009 004767 1010 004771 1012 005056 1015 005060 1016 005100 1018 005126 1019 005144 1020 005151 1021 005153 1022 005161 1024 005172 1025 005174 1027 005202 1028 005221 1030 005226 1036 005227 1064 005231 1065 005233 1066 005236 1068 005237 1071 005243 1072 005251 1073 005252 1074 005255 1076 005262 1078 005263 1079 005267 1080 005271 1083 005272 1085 005273 1088 005301 1090 005310 1092 005313 1094 005317 1100 005320 1136 005326 1145 005337 1148 005342 1156 005345 1145 005350 1146 005372 1148 005377 1149 005421 1150 005422 1152 005476 1154 005505 1156 005511 1157 005534 1161 005540 1165 005553 1167 005575 1169 005613 1174 005617 1182 005703 1183 005706 1184 005711 1186 005713 1187 005724 1189 005750 1191 005774 1192 005776 1195 006035 1198 006036 1199 006062 1200 006064 1202 006123 1205 006124 1206 006163 1207 006165 1210 006170 1211 006171 1212 006200 1214 006205 1216 006227 1217 006231 1220 006301 1222 006302 1223 006303 1228 006312 1232 006317 1233 006322 1235 006333 1239 006340 1245 006341 1263 006355 1272 006365 1273 006372 1274 006401 1276 006434 1278 006437 1286 006452 1310 006460 1311 006502 1314 006513 1315 006541 1318 006552 1324 006553 1347 006561 1348 006566 1349 006570 1352 006573 1358 006574 1381 006602 1382 006614 1383 006627 1385 006642 1387 006645 1393 006646 1418 006647 1424 006650 1455 006656 1459 006702 1461 006726 1462 006731 1464 006767 1467 006774 1473 006775 1500 007003 1501 007004 1503 007031 1504 007036 1505 007073 1507 007106 1510 007111 1512 007115 1520 007120 1550 007126 1551 007134 1553 007140 1554 007141 1555 007145 1557 007151 1558 007152 1563 007153 1564 007155 1565 007157 1566 007163 1567 007165 1569 007167 1573 007172 1574 007173 1575 007176 1576 007217 1578 007261 1580 007263 1581 007304 1584 007325 1585 007364 1587 007417 1590 007440 1592 007464 1595 007507 1601 007510 1628 007512 1636 007517 1658 007521 1662 007522 1663 007531 1664 007536 1666 007541 1667 007545 1668 007546 1669 007550 1670 007552 1671 007554 1672 007556 1673 007561 1674 007563 1675 007565 1677 007570 1678 007602 1680 007606 1682 007611 1688 007612 1719 007620 1720 007634 1722 007642 1723 007644 1725 007676 1726 007703 1731 007704 1733 007751 1734 007754 1735 007760 1736 007761 1738 010040 1740 010042 1741 010043 1743 010106 1745 010157 1747 010202 1750 010204 1752 010205 1758 010206 1789 010214 1790 010230 1792 010236 1793 010240 1795 010272 1796 010277 1801 010300 1803 010337 1804 010342 1805 010346 1806 010347 1808 010426 1810 010430 1811 010431 1813 010474 1815 010545 1817 010570 1820 010572 1822 010573 1828 010574 1853 010576 1854 010601 1855 010607 1856 010612 1857 010616 1859 010617 1861 010621 1863 010622 1864 010630 1865 010633 1866 010637 1868 010640 1874 010642 1875 010647 1876 010651 1877 010652 1879 010656 1881 010663 1887 010664 1912 010675 1914 010726 1917 010740 1923 010741 1950 010755 1956 010757 1961 010774 1962 011023 1967 011035 1968 011066 1971 011122 1972 011162 1975 011165 1976 011204 1981 011207 1983 011213 1989 011214 2012 011230 2018 011232 2023 011247 2024 011273 2029 011305 2030 011336 2031 011373 2034 011376 2035 011415 2040 011420 2042 011424 2048 011425 2076 011433 2086 011444 2087 011471 2091 011502 2092 011541 2093 011545 2094 011550 2095 011551 2098 011627 2099 011635 2104 011636 2105 011641 2107 011647 2110 011650 2111 011671 2113 011711 2114 011714 2115 011717 2116 011720 2119 011776 2120 012004 2125 012005 2127 012012 2133 012013 2163 012015 2164 012035 2168 012065 2169 012070 2170 012071 2174 012100 2176 012104 2182 012105 2220 012107 2221 012113 2222 012114 2224 012123 2226 012171 2227 012220 2228 012247 2230 012303 2235 012304 2237 012325 2238 012327 2239 012332 2240 012333 2242 012342 2243 012355 2244 012403 2246 012437 2251 012440 2255 012450 2256 012472 2257 012473 2258 012476 2259 012500 2260 012524 2261 012525 2266 012526 2267 012547 2270 012552 2276 012553 2301 012554 2302 012557 2306 012560 2307 012567 2314 012652 2316 012657 2322 012660 2354 012661 2355 012665 2356 012671 2361 012672 2363 012734 2364 012737 2365 012742 2366 012743 2368 013022 2369 013027 2374 013030 2375 013034 2376 013055 2378 013075 2379 013077 2380 013102 2381 013103 2384 013161 2385 013166 2391 013167 2392 013170 2393 013231 2394 013262 2396 013327 2398 013350 2401 013353 2407 013354 2439 013355 2440 013361 2441 013365 2446 013366 2447 013367 2448 013427 2450 013475 2452 013516 2455 013521 2461 013522 2486 013524 2487 013542 2488 013544 2490 013603 2493 013604 2499 013605 2524 013607 2526 013613 2528 013617 2529 013635 2530 013637 2532 013701 2535 013702 2536 013714 2538 013715 2544 013716 2567 013717 2569 013722 2571 013726 2573 013740 2575 013741 2581 013742 2619 013750 2620 013755 2621 013756 2623 013766 2625 014035 2626 014064 2627 014113 2629 014151 2634 014152 2639 014173 2640 014177 2642 014210 2643 014233 2646 014235 2647 014241 2649 014242 2650 014247 2655 014250 2656 014254 2657 014260 2658 014261 2660 014271 2661 014304 2662 014332 2664 014370 2669 014371 2673 014401 2674 014416 2675 014420 2676 014425 2677 014430 2679 014450 2680 014451 2685 014452 2687 014476 2690 014500 2696 014501 2723 014522 2724 014536 2727 014541 2728 014552 2730 014560 2736 014561 2758 014562 2760 014566 2766 014567 2796 014571 2797 014611 2801 014641 2802 014644 2803 014645 2807 014654 2809 014660 ----------------------------------------------------------- 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