COMPILATION LISTING OF SEGMENT ssu_request_mgr_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 08/04/87 1638.9 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* *********************************************************** */ 6 7 8 /* Subsystem request table management: includes entries to manipulate the list of request tables used by the subsystem, 9* entries to search the request tables, and the summarize_requests and list_requests request */ 10 11 /* Created: 3 May 1980 by W. Olin Sibert from subsystem_request_mgr_ */ 12 /* Modified: 16 December 1981 by Jay Pattin for new list_requests and to add summarize_requests and find_request_name */ 13 /* Modified: 12 February 1982 by G. Palter to merge in the actual code of the list/summarize_requests requests which were 14* moved from ssu_misc_requests */ 15 /* Modified: 28 February 1982 by G. Palter for new output format for list_requests and the dont_summarize and dont_list 16* request table flags */ 17 /* Modified: 2 August 1982 by Jay Pattin for unknown requests and to eliminate the listing of duplicate request names 18* in list_requests and summarize_requests */ 19 /* Modified: 22 August 1982 by Jay Pattin to make request tables into a hash table */ 20 21 /* format: style4,delnl,insnl,ifthenstmt,ifthen */ 22 23 24 ssu_request_mgr_: 25 procedure (); 26 27 return; /* not an entrypoint */ 28 29 30 /* Parameters */ 31 32 dcl P_sci_ptr pointer parameter; 33 dcl P_code fixed binary (35) parameter; 34 35 dcl P_rqt_ptr pointer parameter; /* add_request_table, delete_request_table: -> the table */ 36 dcl P_position fixed binary parameter; /* add_request_table: where to place the table in the list */ 37 38 dcl P_rtl_ptr pointer parameter; /* list_request_tables, set_requests_tables: -> the list */ 39 dcl P_callers_area_ptr pointer parameter; /* list_request_tables: -> area where list is allocated */ 40 dcl P_request_tables_list_version fixed binary parameter; /* list_request_tables: version of the list user expects */ 41 42 dcl P_request_name character (*) parameter; /* locate_request, find_request_name: a request name */ 43 dcl P_request_data_ptr pointer parameter; /* locate_request: -> request_data structure to be filled in */ 44 dcl P_request_entry entry variable parameter; /* find_request_name: the request whose name is desired */ 45 46 dcl P_info_ptr pointer parameter; /* summarize_requests, list_requests */ 47 48 49 /* The list of request tables being used by this subsystem */ 50 51 dcl 1 request_tables aligned based (sci.request_tables_ptr), 52 2 n_tables fixed binary, 53 2 pad bit (36), 54 2 hash_table_ptr pointer, 55 2 tables (request_tables_n_tables refer (request_tables.n_tables)) like request_tables_list.tables; 56 57 dcl 1 hash_table aligned based (request_tables.hash_table_ptr), 58 2 n_slots fixed binary, 59 2 chains (2000) fixed binary, /* the actual hash table: first slot in each chain */ 60 2 slots (0 refer (hash_table.n_slots)), 61 3 name character (32), 62 3 rq_data_ptr pointer, 63 3 first_name_switch bit (1) aligned, /* ON => first unique name for this request */ 64 3 next_slot fixed binary; 65 66 dcl request_tables_n_tables fixed binary; 67 dcl new_request_tables_ptr pointer; 68 69 70 /* Local copies of parameters */ 71 72 dcl code fixed binary (35); 73 74 dcl position fixed binary; 75 76 dcl callers_area area based (callers_area_ptr); 77 dcl callers_area_ptr pointer; 78 79 dcl request_name character (32); 80 81 82 /* Remaining declarations */ 83 84 dcl 1 summary_info aligned based (summary_info_ptr), 85 2 total_lines fixed binary, 86 2 print_line (0 refer (summary_info.total_lines)), 87 3 continuation bit (1) aligned, 88 3 line char (36) varying; 89 dcl summary_info_ptr ptr; 90 91 dcl 1 entry_variable aligned, /* internal representation of an entry variable */ 92 2 code_ptr pointer, 93 2 env_ptr pointer; 94 95 dcl 1 fdo aligned like format_document_options; 96 97 dcl output_buffer character (4 * sys_info$max_seg_size) based (output_buffer_ptr); 98 dcl output_buffer_ptr pointer; 99 100 dcl (lh_request_name, help_request_name) character (32); 101 102 dcl code2 fixed binary (35); 103 104 dcl (n_arguments, max_request_strings) fixed binary; 105 106 dcl (entry1, entry2) entry variable; 107 108 dcl (rqt_idx, rq_idx, idx, jdx) fixed binary; 109 dcl (one_name_size, two_name_size, max_name_size) fixed binary; 110 dcl line_length fixed binary; 111 112 dcl (columns, col_len, this_line, lines_per_col) fixed binary; 113 dcl col_offset (0:5) fixed binary; 114 115 dcl (match, found_bad_table) bit (1) aligned; 116 117 dcl SUMMARIZE_REQUESTS character (32) static options (constant) initial ("summarize_requests"); 118 dcl LIST_REQUESTS character (32) static options (constant) initial ("list_request"); 119 dcl SSU_REQUEST_MGR_ character (32) static options (constant) initial ("ssu_request_mgr_"); 120 121 dcl WHITESPACE character (2) static options (constant) initial (" "); 122 123 dcl SP character (1) static options (constant) initial (" "); 124 dcl NL character (1) static options (constant) initial (" 125 "); 126 127 dcl DELIMITERS character (5) static options (constant) initial (" .-_$"); 128 /* break chars for request name matching */ 129 130 dcl sys_info$max_seg_size fixed binary (19) external; 131 132 /* format: off */ 133 dcl (error_table_$badopt, error_table_$inconsistent, error_table_$noalloc, error_table_$noarg, 134 error_table_$unimplemented_version, ssu_et_$blank_request_name, ssu_et_$no_matching_requests, 135 ssu_et_$invalid_request_table, ssu_et_$request_name_too_long, ssu_et_$request_not_found, 136 ssu_et_$request_table_not_found, ssu_et_$unimplemented_request, ssu_et_$unknown_request) 137 fixed binary (35) external; 138 /* format: on */ 139 140 dcl iox_$user_output pointer external; 141 142 dcl format_document_$string entry (character (*), character (*), fixed binary (21), pointer, fixed binary (35)); 143 dcl get_line_length_$switch entry (pointer, fixed binary (35)) returns (fixed binary); 144 dcl get_ring_ entry () returns (fixed binary (3)); 145 dcl hash_index_ entry (pointer, fixed binary, fixed binary, fixed binary) returns (fixed binary); 146 dcl hcs_$combine_linkage entry (pointer, fixed binary (3), fixed binary (35)); 147 dcl ioa_ entry () options (variable); 148 dcl ioa_$nnl entry () options (variable); 149 dcl ssu_$abort_line entry () options (variable); 150 dcl ssu_$arg_count entry (pointer, fixed binary); 151 dcl ssu_$arg_ptr entry (pointer, fixed binary, pointer, fixed binary (21)); 152 dcl ssu_$get_default_procedure entry (pointer, character (*), entry, fixed binary (35)); 153 dcl ssu_$get_procedure entry (pointer, character (*), entry, fixed binary (35)); 154 dcl ssu_$get_subsystem_and_request_name entry (pointer) returns (character (72) varying); 155 dcl ssu_$get_temp_segment entry (pointer, character (*), pointer); 156 dcl ssu_$print_message entry () options (variable); 157 dcl ssu_$release_temp_segment entry (pointer, pointer); 158 159 /* format: off */ 160 dcl (ssu_requests_$help, ssu_requests_$list_help, ssu_requests_$list_requests) 161 entry (); 162 /* format: on */ 163 164 dcl (area, cleanup, linkage_error) condition; 165 166 dcl (addr, addrel, baseno, binary, codeptr, divide, environmentptr, index, length, ltrim, max, maxlength, min, mod, null, 167 pointer, rtrim, stackframeptr, substr, unspec, verify) builtin; 168 169 /* Initialize the list of request tables (invoked by ssu_invocation_) */ 170 171 init_request_tables: 172 entry (P_sci_ptr); 173 174 sci_ptr = P_sci_ptr; 175 sci.request_tables_ptr = null (); 176 177 return; 178 179 180 181 /* Release the request tables list (invoked from ssu_invocation_) */ 182 183 term_request_tables: 184 entry (P_sci_ptr); 185 186 sci_ptr = P_sci_ptr; 187 188 if sci.request_tables_ptr ^= null () then do; 189 if request_tables.hash_table_ptr ^= null () then 190 call ssu_$release_temp_segment (sci_ptr, request_tables.hash_table_ptr); 191 free request_tables in (sci_parent_area); 192 end; 193 194 sci.request_tables_ptr = null (); 195 196 return; 197 198 /* Add a request table to the list used by this subsystem */ 199 200 add_request_table: 201 entry (P_sci_ptr, P_rqt_ptr, P_position, P_code); 202 203 call ssu_check_sci (P_sci_ptr); 204 205 sci_ptr = P_sci_ptr; 206 P_code = 0; /* assume success */ 207 208 call validate_request_table (P_rqt_ptr, code); 209 if code ^= 0 then do; 210 P_code = code; 211 return; 212 end; 213 214 if sci.request_tables_ptr = null () then 215 request_tables_n_tables = 1; 216 else request_tables_n_tables = request_tables.n_tables + 1; 217 218 new_request_tables_ptr = null (); /* for cleanup handler */ 219 220 on condition (cleanup) 221 begin; 222 if new_request_tables_ptr ^= null () then 223 free new_request_tables_ptr -> request_tables in (sci_parent_area); 224 end; 225 226 allocate request_tables in (sci_parent_area) set (new_request_tables_ptr); 227 228 if sci.request_tables_ptr = null () then position = 1; 229 /* first table */ 230 else if P_position > request_tables.n_tables then position = request_tables.n_tables + 1; 231 /* add to the end of the list */ 232 else if P_position <= 0 then position = 1; /* add to the beginning */ 233 else position = P_position; /* add in an explicit place */ 234 235 do idx = 1 to position - 1; 236 new_request_tables_ptr -> request_tables.tables (idx) = request_tables.tables (idx); 237 end; 238 new_request_tables_ptr -> request_tables.tables (position).table_ptr = P_rqt_ptr; 239 new_request_tables_ptr -> request_tables.tables (position).table_valid = "1"b; 240 241 do idx = position + 1 to new_request_tables_ptr -> request_tables.n_tables; 242 new_request_tables_ptr -> request_tables.tables (idx) = request_tables.tables (idx - 1); 243 end; 244 245 call build_hash_table (); /* this will swap rtl_ptr in sci and free old copy */ 246 247 return; 248 249 /* Delete a request table from the list used by this subsystem */ 250 251 delete_request_table: 252 entry (P_sci_ptr, P_rqt_ptr, P_code); 253 254 call ssu_check_sci (P_sci_ptr); 255 256 sci_ptr = P_sci_ptr; 257 258 match = "0"b; /* haven't found it yet */ 259 260 if sci.request_tables_ptr = null () then 261 P_code = ssu_et_$request_table_not_found; 262 263 else do; 264 do idx = 1 to request_tables.n_tables while (^match); 265 if request_tables.tables (idx).table_ptr = P_rqt_ptr then match = "1"b; 266 end; 267 268 if match then do; /* found it: idx identifies next entry in list */ 269 if request_tables.n_tables = 1 then do; 270 if request_tables.hash_table_ptr ^= null () then 271 call ssu_$release_temp_segment (sci_ptr, request_tables.hash_table_ptr); 272 free request_tables in (sci_parent_area); 273 sci.request_tables_ptr = null (); 274 end; 275 else do; 276 new_request_tables_ptr = null (); 277 278 on condition (cleanup) 279 begin; 280 if new_request_tables_ptr ^= null () then 281 free new_request_tables_ptr -> request_tables in (sci_parent_area); 282 end; 283 284 request_tables_n_tables = request_tables.n_tables - 1; 285 allocate request_tables in (sci_parent_area) set (new_request_tables_ptr); 286 do jdx = 1 to idx - 2; 287 new_request_tables_ptr -> request_tables.tables (jdx) = request_tables.tables (jdx); 288 end; 289 do jdx = idx to request_tables.n_tables; 290 new_request_tables_ptr -> request_tables.tables (jdx - 1) = request_tables.tables (jdx); 291 end; 292 293 call build_hash_table (); /* recompute hash table */ 294 end; 295 P_code = 0; /* success */ 296 end; 297 else P_code = ssu_et_$request_table_not_found; 298 end; 299 300 return; 301 302 /* Return the list of request tables used by this subsystem */ 303 304 list_request_tables: 305 entry (P_sci_ptr, P_callers_area_ptr, P_request_tables_list_version, P_rtl_ptr, P_code); 306 307 if P_request_tables_list_version ^= REQUEST_TABLES_LIST_VERSION_1 then do; 308 P_code = error_table_$unimplemented_version; 309 return; 310 end; 311 312 call ssu_check_sci (P_sci_ptr); 313 314 sci_ptr = P_sci_ptr; 315 callers_area_ptr = P_callers_area_ptr; 316 317 on condition (area) 318 begin; 319 P_code = error_table_$noalloc; 320 go to RETURN_FROM_LIST_REQUEST_TABLES; 321 end; 322 323 if sci.request_tables_ptr ^= null () then 324 request_tables_list_n_tables = request_tables.n_tables; 325 else request_tables_list_n_tables = 0; /* there are no request tables: return an empty list */ 326 327 allocate request_tables_list in (callers_area) set (rtl_ptr); 328 329 request_tables_list.version = REQUEST_TABLES_LIST_VERSION_1; 330 331 if sci.request_tables_ptr ^= null () then 332 do idx = 1 to request_tables.n_tables; 333 request_tables_list.tables (idx) = request_tables.tables (idx); 334 end; 335 336 P_rtl_ptr = rtl_ptr; 337 P_code = 0; /* success */ 338 339 RETURN_FROM_LIST_REQUEST_TABLES: 340 return; 341 342 /* Replace the list of request tables with that supplied by the caller */ 343 344 set_request_tables: 345 entry (P_sci_ptr, P_rtl_ptr, P_code); 346 347 call ssu_check_sci (P_sci_ptr); 348 349 sci_ptr = P_sci_ptr; 350 rtl_ptr = P_rtl_ptr; 351 352 if request_tables_list.version ^= REQUEST_TABLES_LIST_VERSION_1 then do; 353 P_code = error_table_$unimplemented_version; 354 return; 355 end; 356 357 found_bad_table = "0"b; /* assume user's list is OK */ 358 359 do idx = 1 to request_tables_list.n_tables; 360 request_tables_list.tables (idx).table_valid = "1"b; 361 call validate_request_table (request_tables_list.tables (idx).table_ptr, code); 362 if code ^= 0 then do; /* not a request table */ 363 if ^found_bad_table then P_code = code; 364 found_bad_table = "1"b; /* remember reason for the first bad table */ 365 request_tables_list.tables (idx).table_valid = "0"b; 366 end; 367 end; 368 369 if found_bad_table then return; /* return code is already set */ 370 371 request_tables_n_tables = request_tables_list.n_tables; 372 373 new_request_tables_ptr = null (); 374 375 on condition (cleanup) 376 begin; 377 if new_request_tables_ptr ^= null () then 378 free new_request_tables_ptr -> request_tables in (sci_parent_area); 379 end; 380 381 allocate request_tables in (sci_parent_area) set (new_request_tables_ptr); 382 383 do idx = 1 to new_request_tables_ptr -> request_tables.n_tables; 384 new_request_tables_ptr -> request_tables.tables (idx) = request_tables_list.tables (idx); 385 end; 386 387 call build_hash_table (); 388 389 P_code = 0; /* success */ 390 391 return; 392 393 /* Validate that the caller has a real request table */ 394 395 validate_request_table: 396 procedure (p_rqt_ptr, p_code); 397 398 dcl p_rqt_ptr pointer parameter; 399 dcl p_code fixed binary (35) parameter; 400 401 if (substr (unspec (p_rqt_ptr), 31, 6) ^= "43"b3) then p_code = ssu_et_$invalid_request_table; 402 403 else if (p_rqt_ptr = null ()) then p_code = ssu_et_$invalid_request_table; 404 405 else if (p_rqt_ptr -> rqt.version ^= RQT_VERSION_4) then p_code = ssu_et_$invalid_request_table; 406 407 else p_code = 0; /* it passes */ 408 409 return; 410 411 end validate_request_table; 412 413 /* Makes a hash table of all the request names for fast lookup */ 414 415 build_hash_table: 416 procedure (); 417 418 dcl (old_request_tables_ptr, new_hash_table_ptr) pointer; 419 dcl first_name_switch bit (1) aligned; 420 421 new_hash_table_ptr = null (); /* for cleanup handler */ 422 423 on condition (cleanup) 424 begin; 425 if new_hash_table_ptr ^= null () then call ssu_$release_temp_segment (sci_ptr, new_hash_table_ptr); 426 end; 427 428 call ssu_$get_temp_segment (sci_ptr, SSU_REQUEST_MGR_, new_hash_table_ptr); 429 430 do rqt_idx = 1 to new_request_tables_ptr -> request_tables.n_tables; 431 if new_request_tables_ptr -> request_tables.tables (rqt_idx).table_valid then do; 432 rqt_ptr = new_request_tables_ptr -> request_tables.tables (rqt_idx).table_ptr; 433 do rq_idx = 1 to rqt.n_requests; 434 rq_data_ptr = addr (rqt.requests (rq_idx)); 435 request_name_list_ptr = pointer (rqt_ptr, rq_data.namelist_loc); 436 first_name_switch = "1"b; 437 do idx = 1 to request_name_list.n_names; 438 call check_one_name (request_name_list.name (idx)); 439 end; 440 end; 441 end; 442 end; 443 444 old_request_tables_ptr = sci.request_tables_ptr; 445 446 new_request_tables_ptr -> request_tables.hash_table_ptr = new_hash_table_ptr; 447 sci.request_tables_ptr = new_request_tables_ptr; /* switch to new tables */ 448 new_request_tables_ptr, new_hash_table_ptr = null (); 449 /* don't let the cleanup handlers at now permanent tables */ 450 451 if old_request_tables_ptr ^= null () then do; /* get rid of old request tables list */ 452 if old_request_tables_ptr -> request_tables.hash_table_ptr ^= null then 453 call ssu_$release_temp_segment (sci_ptr, old_request_tables_ptr -> request_tables.hash_table_ptr); 454 free old_request_tables_ptr -> request_tables in (sci_parent_area); 455 end; 456 457 return; 458 459 /* Internal to build_hash_table: checks the given name */ 460 461 check_one_name: 462 procedure (this_name); 463 464 dcl this_name character (32); 465 dcl (chain_idx, slot_idx) fixed binary; 466 467 chain_idx = hash_index_ (addr (this_name), length (rtrim (this_name)), 0, 2000) + 1; 468 469 do slot_idx = new_hash_table_ptr -> hash_table.chains (chain_idx) 470 repeat new_hash_table_ptr -> hash_table.slots.next_slot (slot_idx) while (slot_idx ^= 0); 471 if new_hash_table_ptr -> hash_table.slots (slot_idx).name = this_name then return; 472 end; 473 474 new_hash_table_ptr -> hash_table.n_slots, slot_idx = new_hash_table_ptr -> hash_table.n_slots + 1; 475 /* here iff its unique */ 476 477 new_hash_table_ptr -> hash_table.slots (slot_idx).name = this_name; 478 new_hash_table_ptr -> hash_table.slots (slot_idx).rq_data_ptr = rq_data_ptr; 479 new_hash_table_ptr -> hash_table.slots (slot_idx).first_name_switch = first_name_switch; 480 first_name_switch = "0"b; /* have definitely made first entry for this request */ 481 482 new_hash_table_ptr -> hash_table.slots (slot_idx).next_slot = 483 new_hash_table_ptr -> hash_table.chains (chain_idx); 484 new_hash_table_ptr -> hash_table.chains (chain_idx) = slot_idx; 485 486 return; 487 488 end check_one_name; 489 490 end build_hash_table; 491 492 /* Lookup a request and return all available information on it from the request table */ 493 494 locate_request: 495 entry (P_sci_ptr, P_request_name, P_request_data_ptr, P_code); 496 497 call ssu_check_sci (P_sci_ptr); 498 499 sci_ptr = P_sci_ptr; 500 request_name = P_request_name; 501 request_data_ptr = P_request_data_ptr; 502 503 rq_data_ptr = lookup_request (request_name); /* find name in request tables */ 504 505 if code ^= 0 then do; /* couldn't find it */ 506 P_code = code; 507 return; 508 end; 509 510 request_name_list_ptr = pointer (rq_data_ptr, rq_data.namelist_loc); 511 /* copy all the so-called "permanent" info */ 512 request_data.full_name = request_name_list.name (1); 513 request_data.name_list_ptr = request_name_list_ptr; 514 515 request_data.info_string.ptr = pointer (rq_data_ptr, rq_data.info_string.loc); 516 request_data.info_string.lth = rq_data.info_string.lth; 517 518 request_data.flags = rq_data.flags; 519 unspec (request_data.pad) = ""b; 520 521 request_data.call_info.arg_list_ptr = null (); /* fill this in as blank */ 522 request_data.call_info.arg_count = 0; 523 request_data.call_info.af_sw = "0"b; 524 request_data.call_info.rv_ptr = null (); 525 request_data.call_info.rv_lth = 0; 526 527 if rq_data.unknown then /* catch unknown requests */ 528 P_code = ssu_et_$unknown_request; 529 else if rq_data.unimplemented then /* catch unimplemented requests */ 530 P_code = ssu_et_$unimplemented_request; 531 532 else do; /* see if we can actually access it */ 533 entry_variable.code_ptr = pointer (rq_data_ptr, rq_data.code_loc); 534 /* find the procedure */ 535 entry_variable.env_ptr = null (); /* always an external procedure */ 536 unspec (request_data.entry) = unspec (entry_variable); 537 P_code = 0; /* success */ 538 end; 539 540 return; 541 542 /* Scans the list of request tables for the specified request name */ 543 544 lookup_request: 545 procedure (request_name) returns (pointer); 546 547 dcl request_name character (32); 548 dcl (chain_idx, slot_idx) fixed binary; 549 550 if sci.request_tables_ptr = null () then do; /* no request tables: can't have any requests */ 551 code = ssu_et_$unknown_request; 552 return (null ()); 553 end; 554 555 if length (ltrim (rtrim (request_name, WHITESPACE), WHITESPACE)) > 32 then do; 556 code = ssu_et_$request_name_too_long; 557 return (null ()); 558 end; 559 560 if verify (request_name, WHITESPACE) = 0 then do; 561 code = ssu_et_$blank_request_name; 562 return (null ()); 563 end; 564 565 chain_idx = hash_index_ (addr (request_name), length (rtrim (request_name)), 0, 2000) + 1; 566 567 do slot_idx = hash_table.chains (chain_idx) repeat hash_table.slots.next_slot (slot_idx) while (slot_idx ^= 0); 568 if hash_table.slots (slot_idx).name = request_name then do; 569 code = 0; 570 return (hash_table.slots (slot_idx).rq_data_ptr); 571 end; 572 end; 573 574 code = ssu_et_$unknown_request; /* didn't find it */ 575 return (null ()); 576 577 end lookup_request; 578 579 /* Given an entry variable, returns the primary name of the request which that entry represents (if any) */ 580 581 find_request_name: 582 entry (P_sci_ptr, P_request_entry, P_request_name, P_code); 583 584 sci_ptr = P_sci_ptr; 585 586 call find_request_name_subr (P_request_entry, P_request_name, P_code); 587 588 return; 589 590 591 592 /* Internal procedure which does all the work (called from the summarize_requests and list_requests requests) */ 593 594 find_request_name_subr: 595 procedure (p_request_entry, p_request_name, p_code); 596 597 dcl p_request_entry entry variable parameter; 598 dcl p_request_name character (*) parameter; 599 dcl p_code fixed binary (35) parameter; 600 601 if sci.request_tables_ptr = null () then do; /* no request tables */ 602 p_request_name = ""; 603 p_code = ssu_et_$request_not_found; 604 return; 605 end; 606 607 do rqt_idx = 1 to request_tables.n_tables; /* loop through all tables */ 608 if request_tables.tables (rqt_idx).table_valid then do; 609 /* ... it's a good table */ 610 rqt_ptr = request_tables.tables (rqt_idx).table_ptr; 611 if find_request_name_in_table (p_request_entry, p_request_name) then do; 612 p_code = 0; /* found a match here */ 613 return; 614 end; 615 end; 616 end; 617 618 p_request_name = ""; /* here iff the request wasn't found anywhere */ 619 p_code = ssu_et_$request_not_found; 620 621 return; 622 623 /* Internal to find_request_name_subr: search a single request table for the given entry variable */ 624 625 /* format: off */ 626 627 /* Each request table entry contains the offset of a code sequence of the form: 628* epaq * 629* lprp4 7|stack_header.lot_ptr,*au 630* call6 4|link_offset,* 631* 632* If the request procedure and the request table have been bound together, the last instruction above will be simply: 633* call6 procedure_offset 634* 635* In order to compare the caller's entry variable, we need to look at the link (which we might snap when we reference it) 636* as it is the link that is the actual entry invoked. In order to look at the link, we need a pointer to the linkage of 637* the request table; if necessary, we will combine the request table's linkage. Ugh! */ 638 639 /* format: on */ 640 641 find_request_name_in_table: 642 procedure (p_request_entry, p_request_name) returns (bit (1) aligned); 643 644 dcl p_request_entry entry variable parameter; 645 dcl p_request_name character (*) parameter; 646 647 dcl 1 lot aligned based (stack_header.lot_ptr), /* the LOT */ 648 2 lot_pointers (0:stack_header.cur_lot_size - 1) pointer unaligned; 649 650 dcl 1 lot_pointer aligned based (lot_pointer_ptr), /* have to check for lot faults ... */ 651 2 lot_fault bit (3) unaligned, 652 2 mbz bit (27) unaligned; 653 dcl lot_pointer_ptr pointer; 654 dcl linkage_ptr pointer; 655 656 dcl 1 code_sequence aligned based (cs_ptr), 657 2 epaq_lprp4 bit (72), /* don't actually reference these two */ 658 2 call6, 659 3 link_offset bit (18) unaligned, 660 3 op_code_and_modifiers bit (18) unaligned; 661 dcl cs_ptr pointer; 662 663 dcl ( 664 CALL6_ABSOLUTE initial ("713000"b3), /* call6 offset */ 665 CALL6_PR4_STAR initial ("713120"b3) /* call6 pr4|offset,* */ 666 ) bit (18) static options (constant); 667 668 dcl word bit (36) aligned; 669 dcl based_word based bit (36) aligned; 670 dcl the_entry pointer based (the_entry_ptr); 671 dcl the_entry_ptr pointer; 672 dcl test_rq_data_ptr pointer; 673 674 if environmentptr (p_request_entry) ^= null () then return ("0"b); 675 /* only external entries in the request table */ 676 677 sb = pointer (stackframeptr (), 0); 678 lot_pointer_ptr = addr (lot.lot_pointers (binary (baseno (rqt_ptr), 18, 0))); 679 680 if (lot_pointer.lot_fault = "111"b) & (lot_pointer.mbz = ""b) then do; 681 call hcs_$combine_linkage (rqt_ptr, get_ring_ (), code); 682 if code ^= 0 then /* couldn't combine the linkage (sigh) ... */ 683 return ("0"b); /* ... so claim it's not there */ 684 end; 685 686 linkage_ptr = lot.lot_pointers (binary (baseno (rqt_ptr), 18, 0)); 687 688 do rq_idx = 1 to rqt.n_requests; 689 rq_data_ptr = addr (rqt.requests (rq_idx)); 690 request_name_list_ptr = pointer (rqt_ptr, rq_data.namelist_loc); 691 if ^rq_data.flags.unimplemented & ^rq_data.flags.unknown then do; 692 cs_ptr = pointer (rqt_ptr, rq_data.code_loc); 693 if (code_sequence.op_code_and_modifiers = CALL6_ABSOLUTE) then do; 694 /* bound segment: get entry directly from the instruction */ 695 the_entry_ptr = pointer (rqt_ptr, code_sequence.link_offset); 696 if codeptr (p_request_entry) = the_entry_ptr then do; 697 FOUND_THE_REQUEST: 698 do idx = 1 to request_name_list.n_names; 699 /* If the name is in the hash table, it isn't a duplicate */ 700 test_rq_data_ptr = lookup_request (request_name_list.name (idx)); 701 if test_rq_data_ptr = rq_data_ptr then do; 702 p_request_name = request_name_list.name (idx); 703 return ("1"b); 704 end; 705 end; 706 end; 707 end; 708 else if (code_sequence.op_code_and_modifiers = CALL6_PR4_STAR) then do; 709 /* unbound segment: must indirect through linkage */ 710 the_entry_ptr = addrel (linkage_ptr, "000"b || substr (code_sequence.link_offset, 4, 15)); 711 on condition (linkage_error) /* in case we can't find what it references ... */ 712 go to SKIP_THIS_REQUEST; 713 word = the_entry -> based_word; 714 /* reference through it to snap the link if necessary */ 715 revert condition (linkage_error); 716 if codeptr (p_request_entry) = the_entry then go to FOUND_THE_REQUEST; 717 /* found it! */ 718 end; 719 end; 720 SKIP_THIS_REQUEST: 721 end; 722 723 return ("0"b); /* didn't find it */ 724 725 end find_request_name_in_table; 726 727 end find_request_name_subr; 728 729 /* Standard summarize_requests request: prints a multi-columnar listing of all requests available to the subsystem which 730* have non-null documentation strings */ 731 732 summarize_requests: 733 entry (P_sci_ptr, P_info_ptr); 734 735 sci_ptr = P_sci_ptr; 736 737 call ssu_$arg_count (sci_ptr, n_arguments); 738 if n_arguments ^= 0 then call ssu_$abort_line (sci_ptr, 0, "No arguments may be given."); 739 740 if sci.request_tables_ptr = null () then /* eh? */ 741 call ssu_$abort_line (sci_ptr, 0, "There are no ^a requests.", sci.subsystem_name); 742 743 call ioa_ ("Available ^a requests:^/", sci.subsystem_name); 744 745 746 /* Compute the number of columns to use in the summary: use the longest single request name with a gutter of 4 spaces */ 747 748 call compute_request_name_widths ("1"b, "0"b); /* get length of longest name */ 749 750 line_length = get_line_length_$switch (iox_$user_output, code); 751 if code ^= 0 then line_length = 72; /* enforce the "standard" */ 752 753 columns = divide (line_length, (one_name_size + 4), 17, 0); 754 /* how many columns will fit */ 755 if columns > 5 then columns = 5; /* let's be arbitrary here, too many doesn't look nice */ 756 757 col_len = divide (line_length, columns, 17, 0) - 4; 758 759 760 /* Build the line fragments which will form the content of the columns */ 761 762 summary_info_ptr = null (); /* for cleanup handler */ 763 on condition (cleanup) 764 begin; 765 if summary_info_ptr ^= null () then call ssu_$release_temp_segment (sci_ptr, summary_info_ptr); 766 end; 767 768 call ssu_$get_temp_segment (sci_ptr, SUMMARIZE_REQUESTS, summary_info_ptr); 769 770 summary_info.total_lines = 0; 771 772 idx = 1; 773 do while (idx <= hash_table.n_slots); 774 rq_data_ptr = hash_table.slots (idx).rq_data_ptr; 775 request_name_list_ptr = pointer (rq_data_ptr, rq_data.namelist_loc); 776 if ^rq_data.flags.unimplemented & ^rq_data.flags.dont_summarize & ^rq_data.flags.unknown then 777 call add_request_to_list (); 778 else idx = idx + 1; 779 end; 780 781 782 /* Find the first line fragment to be printed in each column */ 783 784 lines_per_col = divide (summary_info.total_lines, columns, 17, 0); 785 /* approximate number of lines in each column */ 786 787 col_offset (0) = 0; 788 col_offset (columns) = summary_info.total_lines; 789 790 do idx = 1 to columns - 1; 791 col_offset (idx) = idx * lines_per_col; 792 end; 793 794 jdx = mod (summary_info.total_lines, columns); /* distribute the leftover lines evenly */ 795 do idx = 1 to columns - 1; 796 col_offset (idx) = col_offset (idx) + min (idx, jdx); 797 end; 798 799 800 /* Print the lines */ 801 802 do rq_idx = 1 to col_offset (1); 803 do idx = 0 to columns - 1; 804 this_line = rq_idx + col_offset (idx); 805 if this_line <= col_offset (idx + 1) then 806 call ioa_$nnl ("^a^[^s^;^vt^]", summary_info.line (this_line), (idx = columns - 1), col_len + 5); 807 end; 808 call ioa_ (); 809 end; 810 811 call ssu_$release_temp_segment (sci_ptr, summary_info_ptr); 812 813 814 /* If the subsystem defines the list_requests request, point the user at it (using the proper name) */ 815 816 call find_request_name_subr (ssu_requests_$list_requests, request_name, code); 817 if code = 0 then call ioa_ ("^/Type ""^a"" for a short description of the requests.", request_name); 818 819 return; 820 821 /* Put the names of this request into the list of line fragments splitting the names where constrained by column width */ 822 823 add_request_to_list: 824 procedure (); 825 826 dcl (name_idx, name_lth) fixed binary; 827 dcl name_string character (80) varying; 828 dcl this_name character (32) varying; 829 830 name_string = rtrim (hash_table.slots (idx).name); 831 832 do idx = (idx + 1) repeat (idx + 1) 833 while ((idx <= hash_table.n_slots) & ^hash_table.slots (idx).first_name_switch); 834 this_name = rtrim (hash_table.slots (idx).name); 835 name_lth = length (this_name) + 2; /* extra two is for the ', ' */ 836 837 if length (name_string) + name_lth > col_len then do; 838 /* won't fit on this line */ 839 summary_info.total_lines = summary_info.total_lines + 1; 840 summary_info.line (summary_info.total_lines) = name_string || ","; 841 name_string = " " || this_name; 842 end; 843 844 else do; 845 if length (name_string) ^= 0 then name_string = name_string || ", "; 846 name_string = name_string || this_name; 847 end; 848 end; 849 850 if name_string ^= "" then do; /* be sure to output the remainder */ 851 summary_info.total_lines = summary_info.total_lines + 1; 852 summary_info.line (summary_info.total_lines) = name_string; 853 end; 854 855 return; 856 857 end add_request_to_list; 858 859 /* Standard list_requests request: lists the names and brief descriptions of all requests or of those requests whose name 860* contains any of a given set of strings */ 861 862 list_requests: 863 entry (P_sci_ptr, P_info_ptr); 864 865 sci_ptr = P_sci_ptr; 866 867 call ssu_$arg_count (sci_ptr, n_arguments); 868 869 if sci.request_tables_ptr = null () then /* eh? */ 870 call ssu_$abort_line (sci_ptr, 0, "There are no ^a requests.", sci.subsystem_name); 871 872 max_request_strings = max (1, n_arguments); /* PL/I doesn't like zero-length arrays */ 873 874 875 LIST_REQUESTS_BODY: 876 begin; 877 878 dcl request_strings (max_request_strings) character (32) varying; 879 dcl matched_request_string (max_request_strings) bit (1) aligned; 880 dcl n_request_strings fixed binary; /* the actual number present */ 881 882 dcl list_all_requests bit (1) aligned; /* ON => also show requests without documentation strings */ 883 dcl exact_matches_only bit (1) aligned; 884 885 dcl argument character (argument_lth) based (argument_ptr); 886 dcl argument_lth fixed binary (21); 887 dcl argument_ptr pointer; 888 889 dcl (listed_a_request, didnt_find_a_request) bit (1) aligned; 890 dcl arg_idx fixed binary; 891 892 893 n_request_strings = 0; /* haven't seen any yet */ 894 895 list_all_requests, exact_matches_only = "0"b; 896 897 do arg_idx = 1 to n_arguments; 898 call ssu_$arg_ptr (sci_ptr, arg_idx, argument_ptr, argument_lth); 899 if index (argument, "-") = 1 then do; 900 if (argument = "-all") | (argument = "-a") then list_all_requests = "1"b; 901 else if (argument = "-exact") then exact_matches_only = "1"b; 902 else call ssu_$abort_line (sci_ptr, error_table_$badopt, """^a""", argument); 903 end; 904 else do; /* a string to be matched */ 905 if argument_lth > maxlength (request_strings (1)) then 906 call ssu_$abort_line (sci_ptr, ssu_et_$request_name_too_long, "^a", argument); 907 n_request_strings = n_request_strings + 1; 908 request_strings (n_request_strings) = argument; 909 end; 910 end; 911 912 if exact_matches_only & (n_request_strings = 0) then 913 call ssu_$abort_line (sci_ptr, error_table_$noarg, "Request names must be given with ""-exact""."); 914 915 916 /* Print generally usefull information when listing all requests */ 917 918 if n_request_strings = 0 then do; 919 920 call ioa_ ("Summary of ^a requests:^/", sci.subsystem_name); 921 922 call ssu_$get_procedure (sci_ptr, "cpescape", entry1, (0)); 923 call ssu_$get_default_procedure (sci_ptr, "cpescape", entry2, (0)); 924 if entry1 = entry2 then call ioa_ ("Use "".. COMMAND_LINE"" to escape a command line to Multics."); 925 926 call find_request_name_subr (ssu_requests_$list_help, lh_request_name, code); 927 call find_request_name_subr (ssu_requests_$help, help_request_name, code2); 928 if (code = 0) & (code2 = 0) then 929 call ioa_ ("Type ""^a"" for a list of topics available to the ^a request.", lh_request_name, 930 help_request_name); 931 else if (code ^= 0) & (code2 = 0) then 932 call ioa_ ("Type ""^a -topics"" for a list of available topics.", help_request_name); 933 if code2 = 0 then 934 call ioa_ ("Type ""^a TOPIC"" for more information on a given topic.", help_request_name); 935 936 if (entry1 = entry2) | (code = 0) | (code2 = 0) then call ioa_ (""); 937 end; /* separate usefull info from the actual list */ 938 939 940 /* Pass through all the request tables and list all request which match the selection criteria */ 941 942 output_buffer_ptr = null (); /* for cleanup handler */ 943 on condition (cleanup) 944 begin; 945 if output_buffer_ptr ^= null () then call ssu_$release_temp_segment (sci_ptr, output_buffer_ptr); 946 end; 947 948 call ssu_$get_temp_segment (sci_ptr, LIST_REQUESTS, output_buffer_ptr); 949 950 line_length = get_line_length_$switch (iox_$user_output, code); 951 if code ^= 0 then line_length = 72; /* enforce the "standard" */ 952 953 fdo.version_number = format_document_version_1; 954 string (fdo.switches) = ""b; /* fill in constant parts */ 955 fdo.literal_sw = "1"b; /* no embedded controls */ 956 fdo.galley_sw = "1"b; /* no page breaks */ 957 if exact_matches_only then do; /* one request per string ... */ 958 fdo.indentation = 3; /* ... description indented under names ... */ 959 fdo.line_length = line_length; /* ... and uses full terminal width */ 960 end; 961 else do; /* multiple requests ... */ 962 fdo.indentation = 0; /* ... description to right of names ... */ 963 fdo.line_length = 0; /* ... line length varies (see below) ... */ 964 call compute_request_name_widths ("0"b, list_all_requests); 965 if one_name_size < (two_name_size - 6) then 966 max_name_size = one_name_size + 3; 967 else max_name_size = two_name_size + 3; 968 end; /* ... and space for names also varies */ 969 970 listed_a_request = "0"b; 971 matched_request_string (*) = "0"b; 972 973 if exact_matches_only then 974 do idx = 1 to n_request_strings; 975 rq_data_ptr = lookup_request ((request_strings (idx))); 976 if rq_data_ptr ^= null () then do; 977 request_name_list_ptr = pointer (rq_data_ptr, rq_data.namelist_loc); 978 listed_a_request, matched_request_string (idx) = "1"b; 979 call list_single_request (); 980 end; 981 end; 982 983 else do idx = 1 to hash_table.n_slots; 984 if hash_table.slots (idx).first_name_switch then do; 985 rq_data_ptr = hash_table.slots (idx).rq_data_ptr; 986 request_name_list_ptr = pointer (rq_data_ptr, rq_data.namelist_loc); 987 988 if (list_all_requests | (^rq_data.flags.unimplemented & ^rq_data.flags.dont_list)) 989 & ^rq_data.flags.unknown then do; 990 991 request_info_string_ptr = pointer (rq_data_ptr, rq_data.info_string.loc); 992 request_info_string_lth = rq_data.info_string.lth; 993 if matching_name () then do; 994 listed_a_request = "1"b; 995 call list_single_request (); 996 end; 997 end; 998 end; 999 end; 1000 1001 call ssu_$release_temp_segment (sci_ptr, output_buffer_ptr); 1002 output_buffer_ptr = null (); 1003 1004 if exact_matches_only then do; 1005 didnt_find_a_request = "0"b; 1006 do idx = 1 to n_request_strings; 1007 if ^matched_request_string (idx) then do; 1008 didnt_find_a_request = "1"b; 1009 call ssu_$print_message (sci_ptr, 0, "Unknown request ""^a"".", request_strings (idx)); 1010 end; 1011 end; 1012 if didnt_find_a_request then /* rest of the request line may be disastrous */ 1013 call ssu_$abort_line (sci_ptr, 0); 1014 end; 1015 1016 else if ^listed_a_request then call ssu_$abort_line (sci_ptr, ssu_et_$no_matching_requests); 1017 1018 /* Internal to list_requests begin block: returns true if any of this request's names meets the selection criteria. If 1019* exact matches are being sought, check all names (rather than stopping on first match) to insure that any request 1020* matching more than one of the user's names properly marks all those strings as matched */ 1021 1022 matching_name: 1023 procedure () returns (bit (1) aligned); 1024 1025 dcl (name_idx, idx, position) fixed binary; 1026 dcl found_some_matches bit (1) aligned; 1027 dcl test_rq_data_ptr pointer; 1028 1029 if n_request_strings = 0 then /* listing all requests */ 1030 return ("1"b); 1031 1032 found_some_matches = "0"b; 1033 1034 do name_idx = 1 to request_name_list.n_names; 1035 request_name = rtrim (request_name_list.name (name_idx)); 1036 test_rq_data_ptr = lookup_request (request_name); 1037 if rq_data_ptr = test_rq_data_ptr then do; 1038 do idx = 1 to n_request_strings; 1039 position = index (request_name, request_strings (idx)); 1040 if (position ^= 0) then 1041 if (position = 1) then return ("1"b); 1042 else if (position = length (request_name) - length (request_strings (idx)) + 1) then 1043 return ("1"b); 1044 else if (index (DELIMITERS, substr (request_name, (position - 1), 1)) ^= 0) then 1045 return ("1"b); 1046 else if (index (DELIMITERS, 1047 substr (request_name, (position + length (request_strings (idx))), 1)) ^= 0) then 1048 return ("1"b); 1049 end; 1050 end; 1051 end; 1052 1053 return (found_some_matches); 1054 1055 end matching_name; 1056 1057 /* Internal to list_requests begin block: shows a single request */ 1058 1059 list_single_request: 1060 procedure (); 1061 1062 dcl (output_buffer_used, formatted_name_list_position, formatted_name_list_lth, formatted_info_string_position, 1063 formatted_info_string_lth, name_start, name_lth, info_start, info_lth) fixed binary (21); 1064 dcl idx fixed binary; 1065 dcl test_rq_data_ptr pointer; 1066 dcl (first_line, have_names, have_info) bit (1) aligned; 1067 1068 1069 /* Construct the list of request names */ 1070 1071 output_buffer_used = 0; 1072 1073 do idx = 1 to request_name_list.n_names; 1074 request_name = rtrim (request_name_list.name (idx)); 1075 test_rq_data_ptr = lookup_request (request_name); 1076 if rq_data_ptr = test_rq_data_ptr then do; 1077 if output_buffer_used > 0 then do; /* ... a comma separated list */ 1078 substr (output_buffer, (output_buffer_used + 1), 2) = ", "; 1079 output_buffer_used = output_buffer_used + 2; 1080 end; 1081 name_lth = length (rtrim (request_name)); 1082 substr (output_buffer, (output_buffer_used + 1), name_lth) = rtrim (request_name); 1083 output_buffer_used = output_buffer_used + name_lth; 1084 end; 1085 end; 1086 1087 if output_buffer_used = 0 then return; /* No names found */ 1088 1089 1090 /* Only one request matches each string: display at least two lines; the first line contains all the request names; the 1091* second and subsequent lines contains the brief description slightly indented */ 1092 1093 if exact_matches_only then do; 1094 1095 call ioa_ ("^a^[^2x(unimplemented)^]", substr (output_buffer, 1, output_buffer_used), 1096 rq_data.flags.unimplemented); 1097 1098 if length (request_info_string) = 0 then 1099 call ioa_ ("^3x(No brief description available.)"); 1100 1101 else do; 1102 call format_document_$string (request_info_string, output_buffer, output_buffer_used, addr (fdo), (0)) 1103 ; 1104 begin; 1105 dcl formatted_string character (output_buffer_used) defined (output_buffer) position (1); 1106 output_buffer_used = length (rtrim (formatted_string, NL)); 1107 end; /* format_document_ doesn't always add 1 newline */ 1108 begin; 1109 dcl formatted_string character (output_buffer_used) defined (output_buffer) position (1); 1110 call ioa_ ("^a", formatted_string); 1111 end; 1112 end; 1113 end; 1114 1115 1116 /* More than one request matches each string (if any): display the request names and descriptions on a single line if 1117* possible; otherwise, split the appropriate strings and indent subsequent lines by a small amount */ 1118 1119 else do; 1120 1121 formatted_name_list_position = output_buffer_used + 1; 1122 begin; /* now format it */ 1123 dcl unformatted_name_list character (output_buffer_used) defined (output_buffer) position (1); 1124 dcl rest_of_output_buffer character (length (output_buffer) - output_buffer_used) unaligned 1125 defined (output_buffer) position (output_buffer_used + 1); 1126 fdo.line_length = max_name_size - 3; /* ... insure there's room for the overflow */ 1127 call format_document_$string (unformatted_name_list, rest_of_output_buffer, formatted_name_list_lth, 1128 addr (fdo), (0)); 1129 end; 1130 begin; 1131 dcl name_list character (formatted_name_list_lth) unaligned defined (output_buffer) 1132 position (formatted_name_list_position); 1133 formatted_name_list_lth = length (rtrim (name_list, NL)) + 1; 1134 substr (name_list, formatted_name_list_lth, 1) = NL; 1135 end; /* format_document_ sometimes doesn't add trailing newlines */ 1136 1137 output_buffer_used = output_buffer_used + formatted_name_list_lth; 1138 formatted_info_string_position = output_buffer_used + 1; 1139 begin; /* format the documentation string */ 1140 dcl rest_of_output_buffer character (length (output_buffer) - output_buffer_used) unaligned 1141 defined (output_buffer) position (output_buffer_used + 1); 1142 fdo.line_length = line_length - max_name_size - 6; 1143 if fdo.line_length < 21 then /* don't let it get too short ... */ 1144 fdo.line_length = 131071; /* ... so don't split the documentation string */ 1145 call format_document_$string (request_info_string, rest_of_output_buffer, formatted_info_string_lth, 1146 addr (fdo), (0)); 1147 end; 1148 begin; 1149 dcl info_string character (formatted_info_string_lth) unaligned defined (output_buffer) 1150 position (formatted_info_string_position); 1151 formatted_info_string_lth = length (rtrim (info_string, NL)) + 1; 1152 substr (info_string, formatted_info_string_lth, 1) = NL; 1153 end; /* format_document_ sometimes doesn't add trailing newlines */ 1154 1155 begin; /* output the results ... */ 1156 1157 dcl name_list character (formatted_name_list_lth) unaligned defined (output_buffer) 1158 position (formatted_name_list_position); 1159 dcl info_string character (formatted_info_string_lth) unaligned defined (output_buffer) 1160 position (formatted_info_string_position); 1161 1162 first_line, have_names = "1"b; /* requests have to have some names */ 1163 have_info = (info_string ^= NL); /* info string might have been empty */ 1164 name_start, info_start = 1; 1165 1166 do while (have_names | have_info); 1167 if have_names then name_lth = index (substr (name_list, name_start), NL) - 1; 1168 if have_info then info_lth = index (substr (info_string, info_start), NL) - 1; 1169 if have_names & have_info then 1170 call ioa_ ("^[^3x^]^a^vt^[^3x^]^a", ^first_line, substr (name_list, name_start, name_lth), 1171 (max_name_size + 3), ^first_line, substr (info_string, info_start, info_lth)); 1172 else if have_names then do; 1173 call ioa_ ("^[^3x^]^a", ^first_line, translate (substr (name_list, name_start), SP, NL)); 1174 name_lth = length (name_list);/* all the remaining names are on this line */ 1175 end; 1176 else call ioa_ ("^vt^[^3x^]^a", (max_name_size + 3), ^first_line, 1177 substr (info_string, info_start, info_lth)); 1178 name_start = name_start + name_lth + 1; 1179 info_start = info_start + info_lth + 1; 1180 have_names = (name_start < length (name_list)); 1181 have_info = (info_start < length (info_string)); 1182 first_line = "0"b; 1183 end; 1184 end; 1185 end; 1186 1187 return; 1188 1189 end list_single_request; 1190 1191 end LIST_REQUESTS_BODY; 1192 1193 return; 1194 1195 /* Computes the amount of room needed for the longest primary request name and the longest combination of a primary 1196* request name and its first short name */ 1197 1198 compute_request_name_widths: 1199 procedure (p_summarize, p_include_all); 1200 1201 dcl (p_summarize, p_include_all) bit (1) aligned parameter; 1202 dcl exclude bit (1) aligned; 1203 1204 one_name_size = 0; 1205 two_name_size = 0; 1206 1207 do idx = 1 to hash_table.n_slots; 1208 rq_data_ptr = hash_table.slots (idx).rq_data_ptr; 1209 1210 if p_summarize then 1211 exclude = rq_data.flags.dont_summarize; 1212 else exclude = rq_data.flags.dont_list; 1213 1214 if (p_include_all | (^rq_data.flags.unimplemented & ^exclude)) & ^rq_data.flags.unknown then do; 1215 request_name_list_ptr = pointer (rq_data_ptr, rq_data.namelist_loc); 1216 1217 if request_name_list.n_names >= 2 then 1218 two_name_size = 1219 max (two_name_size, 1220 length (rtrim (request_name_list.name (1))) + length (rtrim (request_name_list.name (2))) 1221 + 2); 1222 1223 else two_name_size = max (two_name_size, length (rtrim (request_name_list.name (1)))); 1224 1225 one_name_size = max (one_name_size, length (rtrim (request_name_list.name (1)))); 1226 end; 1227 end; 1228 1229 return; 1230 1231 end compute_request_name_widths; 1232 1 1 /* BEGIN: _ssu_check_sci.incl.pl1 * * * * * */ 1 2 1 3 /* Created: 25 February 1982 by G. Palter */ 1 4 /* Modified: 6 November 1984 by G. Palter for version 3 and new sub_err_ 1 5* calling sequence */ 1 6 1 7 1 8 /****^ HISTORY COMMENTS: 1 9* 1) change(87-02-07,GDixon), approve(87-05-25,MCR7680), 1 10* audit(87-06-02,Parisek), install(87-08-04,MR12.1-1056): 1 11* Modified to verify that p_sci_ptr has proper its modifier by overlaying it 1 12* with the structure in its.incl.pl1, rather than assuming knowledge of 1 13* pointer format. 1 14* END HISTORY COMMENTS */ 1 15 1 16 1 17 /* format: style4,delnl,insnl,ifthenstmt,ifthen */ 1 18 1 19 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 20 /* */ 1 21 /* Validates that the caller's sci_ptr acutally references a valid */ 1 22 /* subsystem control info structure. */ 1 23 /* */ 1 24 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 25 1 26 ssu_check_sci: 1 27 procedure (p_sci_ptr); 1 28 1 29 dcl p_sci_ptr pointer parameter; 1 30 1 31 dcl SSU_ character (32) static options (constant) initial ("ssu_"); 1 32 1 33 dcl error_table_$bad_ptr fixed binary (35) external; 1 34 dcl error_table_$null_info_ptr fixed binary (35) external; 1 35 dcl error_table_$unimplemented_version fixed binary (35) external; 1 36 1 37 dcl sub_err_ entry () options (variable); 1 38 1 39 dcl (null, substr, unspec) builtin; 1 40 1 41 if addr(p_sci_ptr) -> its.its_mod ^= ITS_MODIFIER then do; 1 42 RESIGNAL_BAD_POINTER: 1 43 call sub_err_ (error_table_$bad_ptr, SSU_, ACTION_CANT_RESTART, null (), (0), "^24.3b", unspec (p_sci_ptr)); 1 44 go to RESIGNAL_BAD_POINTER; 1 45 end; 1 46 1 47 if p_sci_ptr = null () then do; 1 48 RESIGNAL_NULL_POINTER: 1 49 call sub_err_ (error_table_$null_info_ptr, SSU_, ACTION_CANT_RESTART, null (), (0), "sci_ptr"); 1 50 go to RESIGNAL_NULL_POINTER; 1 51 end; 1 52 1 53 if p_sci_ptr -> sci.version = SCI_VERSION_3 then /* all is well */ 1 54 return; 1 55 1 56 RESIGNAL_BAD_VERSION: 1 57 call sub_err_ (error_table_$unimplemented_version, SSU_, ACTION_CANT_RESTART, null (), (0), "^24.3b", 1 58 unspec (p_sci_ptr -> sci.version)); 1 59 go to RESIGNAL_BAD_VERSION; 1 60 2 1 /* BEGIN INCLUDE FILE its.incl.pl1 2 2* modified 27 July 79 by JRDavis to add its_unsigned 2 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 2 4 2 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 2 6 2 pad1 bit (3) unaligned, 2 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 2 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 2 9 2 pad2 bit (9) unaligned, 2 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 2 11 2 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 2 13 2 pad3 bit (3) unaligned, 2 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 2 15 2 pad4 bit (3) unaligned, 2 16 2 mod bit (6) unaligned; /* further modification */ 2 17 2 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 2 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 2 20 2 pad1 bit (27) unaligned, 2 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 2 22 2 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 2 24 2 pad2 bit (3) unaligned, 2 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 2 26 2 pad3 bit (3) unaligned, 2 27 2 mod bit (6) unaligned; /* further modification */ 2 28 2 29 2 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 2 31 2 pad1 bit (3) unaligned, 2 32 2 segno fixed bin (15) unsigned unaligned, 2 33 2 ringno fixed bin (3) unsigned unaligned, 2 34 2 pad2 bit (9) unaligned, 2 35 2 its_mod bit (6) unaligned, 2 36 2 37 2 offset fixed bin (18) unsigned unaligned, 2 38 2 pad3 bit (3) unaligned, 2 39 2 bit_offset fixed bin (6) unsigned unaligned, 2 40 2 pad4 bit (3) unaligned, 2 41 2 mod bit (6) unaligned; 2 42 2 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 2 44 2 pr_no fixed bin (3) unsigned unaligned, 2 45 2 pad1 bit (27) unaligned, 2 46 2 itp_mod bit (6) unaligned, 2 47 2 48 2 offset fixed bin (18) unsigned unaligned, 2 49 2 pad2 bit (3) unaligned, 2 50 2 bit_offset fixed bin (6) unsigned unaligned, 2 51 2 pad3 bit (3) unaligned, 2 52 2 mod bit (6) unaligned; 2 53 2 54 2 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 2 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 2 57 2 58 /* END INCLUDE FILE its.incl.pl1 */ 1 61 1 62 3 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 3 2 /* format: style3 */ 3 3 3 4 /* These constants are to be used for the flags argument of sub_err_ */ 3 5 /* They are just "string (condition_info_header.action_flags)" */ 3 6 3 7 declare ( 3 8 ACTION_CAN_RESTART init (""b), 3 9 ACTION_CANT_RESTART init ("1"b), 3 10 ACTION_DEFAULT_RESTART 3 11 init ("01"b), 3 12 ACTION_QUIET_RESTART 3 13 init ("001"b), 3 14 ACTION_SUPPORT_SIGNAL 3 15 init ("0001"b) 3 16 ) bit (36) aligned internal static options (constant); 3 17 3 18 /* End include file */ 1 63 1 64 1 65 end ssu_check_sci; 1 66 1 67 1 68 /* END OF: _ssu_check_sci.incl.pl1 * * * * * */ 1233 1234 4 1 /* BEGIN INCLUDE FILE ... _ssu_sci.incl.pl1 */ 4 2 /* Created: 31 April 1980 by W. Olin Sibert */ 4 3 /* Modified: 17 November 1981 by Jay Pattin to add info_prefix */ 4 4 /* Modified: 10 December 1981 by G. Palter to make arg_count, arg_ptr, return_arg, and arg_list_ptr replaceable */ 4 5 /* Modified: 10 February 1982 by G. Palter to reorganize and make changes required for installation */ 4 6 /* Modified: June 1982 by G. Palter for version 2 (new request processor options and replaceable procedures) */ 4 7 /* Modified: 6 November 1984 by G. Palter for version 3 (get_subsystem_and_request_name is now replaceable) */ 4 8 4 9 /* format: style4,^delnl */ 4 10 4 11 4 12 /* Structure used internally by subsystem utilities to contain control information about a single invocation */ 4 13 4 14 dcl 1 sci aligned based (sci_ptr), 4 15 2 version character (8), 4 16 2 parent_area_ptr pointer, /* -> area holding this data and referenced structures */ 4 17 4 18 2 global_info, /* global information about this subsystem ... */ 4 19 3 subsystem_name char (32) unaligned, /* ... its name (eg: read_mail) */ 4 20 3 subsystem_version char (32) unaligned, /* ... its version numer (eg: 4.3j) */ 4 21 3 info_ptr pointer, /* ... -> data maintained by the subsystem */ 4 22 3 standalone_abort_entry entry () variable, /* ... for standalone invocations: called by ssu_$abort_* */ 4 23 3 flags, 4 24 4 standalone_invocation bit (1) unaligned, /* ... ON => ssu_$standalone_invocation was used */ 4 25 4 in_listener bit (1) unaligned, /* ... ON => in subsystem listener loop */ 4 26 4 executing_request bit (1) unaligned, /* ... ON => executing a request */ 4 27 4 debug_mode bit (1) unaligned, /* ... ON => debugging the subsystem */ 4 28 4 pad bit (32) unaligned, 4 29 4 30 2 recursion_info, /* describes relationship of this invocation to other active 4 31* invocations of the same subsystem ... */ 4 32 3 invocation_data_idx fixed binary, /* ... locates the list of active invocations */ 4 33 3 level fixed binary, /* ... # of active invocations when this one created + 1 */ 4 34 3 previous_sci_ptr pointer, /* ... -> description of previous invocation */ 4 35 3 next_sci_ptr pointer, /* ... -> description of next invocation */ 4 36 4 37 2 request_processor_info, /* information related to request line processing ... */ 4 38 3 request_tables_ptr pointer, /* ... -> list of request tables in use */ 4 39 3 rp_options_ptr pointer, /* ... -> options controlling the processor */ 4 40 3 abort_line_label label variable, 4 41 3 request_data_ptr pointer, /* ... -> request_data structure for current request */ 4 42 4 43 2 prompt_and_ready_info, /* information related to prompts and ready messages ... */ 4 44 3 prompt character (64) varying, /* the prompt (if any): an ioa_ control string */ 4 45 3 prompt_mode, /* controls prompting ... */ 4 46 4 dont_prompt bit (1) unaligned, /* ... ON => never prompt */ 4 47 4 prompt_after_null_lines bit (1) unaligned, /* ... ON => prompt after a blank line if prompts enabled */ 4 48 4 dont_prompt_if_typeahead bit (1) unaligned, /* ... ON => suppress prompts if request line available */ 4 49 4 pad bit (33) unaligned, 4 50 3 ready_enabled bit (1) aligned, /* ... ON => ready procedure should be invoked */ 4 51 4 52 2 listener_info, /* information used by the listener ... */ 4 53 3 abort_subsystem_label label variable, 4 54 3 temp_seg_ptr pointer, /* ... -> temporary segment used for long request lines */ 4 55 4 56 2 temp_info_ptr pointer, /* pointer to data used by ssu_temp_mgr_ */ 4 57 4 58 2 info_info, /* information related to self-documentation ... */ 4 59 3 info_dirs_ptr pointer, /* ... -> list of info directories */ 4 60 3 info_prefix character (32), /* ... prefix used to form info segment names */ 4 61 4 62 2 ec_info, /* data for subsystem exec_com processing ... */ 4 63 3 ec_suffix char (32) unaligned, /* ... suffix of exec_com segments */ 4 64 3 ec_search_list char (32) unaligned, /* ... search list used to find exec_coms */ 4 65 3 subsystem_dir_ptr pointer, /* ... defines referencing_dir rule for above search list */ 4 66 4 67 2 entries, /* all replaceable entries ... */ 4 68 ( 4 69 3 abort_line, /* ... invoked by ssu_$abort_line */ 4 70 3 abort_subsystem, /* ... invoked by ssu_$abort_subsystem */ 4 71 3 print_message, /* ... invoked by ssu_$print_message */ 4 72 3 program_interrupt, /* ... cannot be called externally */ 4 73 3 pre_request_line, /* ... cannot be called externally */ 4 74 3 post_request_line, /* ... cannot be called externally */ 4 75 3 ready, /* ... invoked by ssu_$ready_proc */ 4 76 3 cpescape, /* ... cannot be called externally */ 4 77 3 unknown_request, /* ... invoked by ssu_$unknown_request */ 4 78 3 listen, /* ... invoked by ssu_$listen */ 4 79 3 execute_line, /* ... invoked by ssu_$execute_line */ 4 80 3 evaluate_active_string, /* ... invoked by ssu_$evaluate_active_string */ 4 81 3 invoke_request, /* ... invoked by ssu_$invoke_request */ 4 82 3 locate_request, /* ... invoked by ssu_$locate_request */ 4 83 3 arg_count, /* ... invoked by ssu_$arg_count */ 4 84 3 arg_ptr, /* ... invoked by ssu_$arg_ptr */ 4 85 3 return_arg, /* ... invoked by ssu_$return_arg */ 4 86 3 arg_list_ptr, /* ... invoked by ssu_$arg_list_ptr */ 4 87 3 get_default_rp_options, /* ... invoked by ssu_$get_default_rp_options */ 4 88 3 get_rp_options, /* ... invoked by ssu_$get_request_processor_options */ 4 89 3 set_rp_options, /* ... invoked by ssu_$set_request_processor_options */ 4 90 3 reset_rp_options, /* ... invoked by ssu_$reset_request_processor_options */ 4 91 3 get_subsys_and_request_name /* ... invoked by ssu_$get_subsystem_and_request_name */ 4 92 ) entry () variable options (variable); 4 93 4 94 dcl sci_ptr pointer; 4 95 4 96 dcl sci_parent_area area based (sci.parent_area_ptr); 4 97 4 98 dcl SCI_VERSION_3 character (8) static options (constant) init ("sci_0003"); 4 99 4 100 /* END INCLUDE FILE ... _ssu_sci.incl.pl1 */ 1235 1236 5 1 /* BEGIN INCLUDE FILE ... _ssu_request_table.incl.pl1 */ 5 2 /* Created: by W. Olin Sibert */ 5 3 5 4 /* format: style4,delnl,insnl,ifthenstmt,ifthen */ 5 5 5 6 5 7 /* Definition of a subsystem request table */ 5 8 5 9 dcl 1 rqt aligned based (rqt_ptr), 5 10 2 version character (8), 5 11 2 name character (32), /* name of this table */ 5 12 2 flags, /* this field is completely unused */ 5 13 3 pad2 (6) bit (36) unaligned, 5 14 2 n_requests fixed binary, 5 15 2 requests (0 refer (rqt.n_requests)) like rq_data; 5 16 5 17 dcl rqt_ptr pointer; 5 18 5 19 dcl RQT_VERSION_4 character (8) static options (constant) initial ("srqt_4.0"); 5 20 5 21 5 22 /* Definition of a single request's entry in the table */ 5 23 5 24 dcl 1 rq_data aligned based (rq_data_ptr), 5 25 2 code_loc bit (18) unaligned, /* -> (RTBOS) code sequence to invoke request */ 5 26 2 namelist_loc bit (18) unaligned, /* -> (RTBOS) list of names for this request */ 5 27 2 info_string, 5 28 3 loc bit (18) unaligned, /* -> (RTBOS) short description of request */ 5 29 3 lth fixed binary (17) unaligned, /* length of description (0 if none) */ 5 30 2 flags aligned like request_flags; /* miscellaneous flags */ 5 31 5 32 dcl rq_data_ptr pointer; 5 33 5 34 /* END INCLUDE FILE ... _ssu_request_table.incl.pl1 */ 1237 1238 6 1 /* BEGIN INCLUDE FILE ... _ssu_request_data.incl.pl1 */ 6 2 /* Created: 13 May 1980 by W. Olin Sibert */ 6 3 /* Modified: 28 February 1982 by G. Palter to add dont_summarize and dont_list */ 6 4 /* Modified: 2 August 1982 by Jay Pattin to add unknown flag */ 6 5 6 6 /* format: style4,delnl,insnl,ifthenstmt,ifthen */ 6 7 6 8 6 9 /* Description of a subsystem request returned by ssu_$locate_request */ 6 10 6 11 dcl 1 request_data aligned based (request_data_ptr), 6 12 2 full_name character (32) unaligned, /* its primary name */ 6 13 2 entry entry (pointer, pointer) variable, /* entry to call to implement the request */ 6 14 2 call_info, /* describes current invocation of the request ... */ 6 15 3 arg_list_ptr pointer, /* ... -> argument list */ 6 16 3 arg_count fixed binary, 6 17 3 af_sw bit (1) aligned, /* ... ON => invoked as an active request */ 6 18 3 rv_ptr pointer, /* ... -> active request's return string */ 6 19 3 rv_lth fixed binary (21), /* ... maxlength of the return string */ 6 20 2 flags aligned like request_flags, /* attributes of the request (from the request table) */ 6 21 2 name_list_ptr pointer unaligned, /* -> list of all valid names for the request */ 6 22 2 info_string, /* brief description of the request (if any) */ 6 23 3 ptr pointer unaligned, 6 24 3 lth fixed binary (18), 6 25 2 pad (4) bit (36); 6 26 6 27 dcl request_data_ptr pointer; 6 28 6 29 6 30 /* Request attributes from the request table */ 6 31 6 32 dcl 1 request_flags aligned based, 6 33 2 system_flags unaligned, 6 34 3 allow_command bit (1) unaligned, /* ON => request may be called as a command */ 6 35 3 allow_af bit (1) unaligned, /* ON => request may be called as an active function */ 6 36 3 unimplemented bit (1) unaligned, /* ON => request is not yet implemented */ 6 37 3 multics_request bit (1) unaligned, /* ON => this request is really just a Multics command */ 6 38 3 dont_summarize bit (1) unaligned, /* ON => summarize_requests doesn't list this request */ 6 39 3 dont_list bit (1) unaligned, /* ON => list_requests doesn't match this one without -all */ 6 40 3 unknown bit (1) unaligned, /* ON => return unknown_request, don't list or summarize ever */ 6 41 3 pad bit (11) unaligned, 6 42 2 user_flags bit (18) unaligned; /* no longer used */ 6 43 6 44 6 45 /* List of all names for a given request */ 6 46 6 47 dcl 1 request_name_list aligned based (request_name_list_ptr), 6 48 2 n_names fixed binary, /* structure describing name list */ 6 49 2 name (request_name_list_n_names refer (request_name_list.n_names)) character (32) unaligned; 6 50 6 51 dcl request_name_list_ptr pointer; 6 52 dcl request_name_list_n_names fixed binary; 6 53 6 54 6 55 /* Brief description of a request */ 6 56 6 57 dcl request_info_string character (request_info_string_lth) based (request_info_string_ptr); 6 58 dcl request_info_string_lth fixed binary (21); 6 59 dcl request_info_string_ptr pointer; 6 60 6 61 /* END INCLUDE FILE ... _ssu_request_data.incl.pl1 */ 1239 1240 7 1 /* BEGIN INCLUDE FILE ... ssu_request_tables_list.incl.pl1 */ 7 2 /* Created: 8 December 1981 by G. Palter */ 7 3 7 4 /* The list of request tables in use by a subsystem invocation */ 7 5 7 6 7 7 dcl 1 request_tables_list aligned based (rtl_ptr), 7 8 2 header, 7 9 3 version fixed binary, /* version of this structure */ 7 10 3 n_tables fixed binary, /* # of request tables in the list */ 7 11 2 tables (request_tables_list_n_tables refer (request_tables_list.n_tables)), 7 12 3 table_ptr pointer, /* -> this request table */ 7 13 3 flags, 7 14 4 table_valid bit (1) unaligned, /* "1"b => this request table is valid */ 7 15 4 pad bit (35) unaligned, 7 16 3 pad bit (36); 7 17 7 18 dcl rtl_ptr pointer; 7 19 7 20 dcl request_tables_list_n_tables fixed binary; /* for allocating the above structure */ 7 21 7 22 dcl REQUEST_TABLES_LIST_VERSION_1 fixed binary static options (constant) initial (1); 7 23 7 24 /* END INCLUDE FILE ... ssu_request_tables_list.incl.pl1 */ 1241 1242 8 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 8 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 8 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 8 4 /* Modified April 1983 by C. Hornig for tasking */ 8 5 8 6 /****^ HISTORY COMMENTS: 8 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 8 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 8 9* added the heap_header_ptr definition. 8 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 8 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 8 12* Modified to support control point management. These changes were actually 8 13* made in February 1985 by G. Palter. 8 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 8 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 8 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 8 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 8 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 8 19* (ITS pair). 8 20* END HISTORY COMMENTS */ 8 21 8 22 /* format: style2 */ 8 23 8 24 dcl sb ptr; /* the main pointer to the stack header */ 8 25 8 26 dcl 1 stack_header based (sb) aligned, 8 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 8 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 8 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 8 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 8 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 8 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 8 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 8 34 2 pad4 bit (2) unal, 8 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 8 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 8 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 8 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 8 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 8 40 2 null_ptr ptr, /* (16) */ 8 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 8 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 8 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 8 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 8 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 8 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 8 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 8 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 8 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 8 50 2 return_no_pop_op_ptr 8 51 ptr, /* (36) pointer to standard return / no pop operator */ 8 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 8 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 8 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 8 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 8 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 8 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 8 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 8 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 8 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 8 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 8 62 2 trace, 8 63 3 frames, 8 64 4 count fixed bin, /* (58) number of trace frames */ 8 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 8 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 8 67 2 pad2 bit (36), /* (61) */ 8 68 2 pad5 pointer; /* (62) pointer to future stuff */ 8 69 8 70 /* The following offset refers to a table within the pl1 operator table. */ 8 71 8 72 dcl tv_offset fixed bin init (361) internal static; 8 73 /* (551) octal */ 8 74 8 75 8 76 /* The following constants are offsets within this transfer vector table. */ 8 77 8 78 dcl ( 8 79 call_offset fixed bin init (271), 8 80 push_offset fixed bin init (272), 8 81 return_offset fixed bin init (273), 8 82 return_no_pop_offset fixed bin init (274), 8 83 entry_offset fixed bin init (275) 8 84 ) internal static; 8 85 8 86 8 87 8 88 8 89 8 90 /* The following declaration is an overlay of the whole stack header. Procedures which 8 91* move the whole stack header should use this overlay. 8 92**/ 8 93 8 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 8 95 8 96 8 97 8 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 1243 1244 9 1 /* BEGIN INCLUDE FILE format_document_options.incl.pl1 9 2* 9 3* Modified 82.10.18 by Paul W. Benjamin to add dont_compress_sw and upgrade 9 4* to version_2. 9 5* Modified 83.02.15 by PWB to add break_word_sw and max_line_length_sw. 9 6* Modified 83.03.01 by PWB to add dont_break_indented_lines_sw. 9 7* Modified 83.03.03 by PWB to add sub_err_sw. 9 8* Modified 83.06.07 by PWB to add dont_fill_sw. 9 9* Modified 83.06.09 by PWB to add hyphenation_sw and syllable_size. 9 10**/ 9 11 9 12 dcl 1 format_document_options aligned based (format_document_options_ptr), 9 13 2 version_number fixed bin, /* input */ 9 14 /* must be format_document_version_2 */ 9 15 2 indentation fixed bin, /* input */ 9 16 /* all lines must be indented by this value */ 9 17 2 line_length fixed bin, /* input */ 9 18 /* initial line length */ 9 19 2 switches, 9 20 3 pgno_sw bit (1) unal, /* input */ 9 21 /* end each page with a centered page number */ 9 22 3 adj_sw bit (1) unal, /* input */ 9 23 /* adjust mode initially on */ 9 24 /* only meaningful if dont_fill_sw = "0"b */ 9 25 3 galley_sw bit (1) unal, /* input */ 9 26 /* galley mode -- no page breaks */ 9 27 3 error_sw bit (1) unal, /* input */ 9 28 /* report all errors on error_output */ 9 29 3 literal_sw bit (1) unal, /* input */ 9 30 /* "1"b - interpret all lines as text */ 9 31 /* "0"b - lines that start with "." are controls */ 9 32 3 file_sw bit (1) unal, /* output */ 9 33 /* has meaning for non-zero storage system status codes */ 9 34 /* "1"b code refers to output file */ 9 35 /* "0"b code refers to input file */ 9 36 3 dont_compress_sw bit (1) unal, /* input */ 9 37 /* "1"b - don't compress white space */ 9 38 /* "0"b - compress white space when filling */ 9 39 3 break_word_sw bit (1) unal, /* input */ 9 40 /* "1"b - break a word rather than exceed line_length */ 9 41 /* "0"b - write an overlength line if no spaces found */ 9 42 3 max_line_length_sw bit (1) unal, /* input */ 9 43 /* "1"b - line_length cannot be exceeded */ 9 44 /* "0"b - line_length can be exceeded (by .pdw controls) */ 9 45 3 dont_break_indented_lines_sw /* input */ 9 46 bit (1) unal, /* don't break a line that begins with whitespace */ 9 47 /* when it is the last line, or the next line is */ 9 48 /* null or the next line begins with whitespace */ 9 49 3 sub_err_sw bit (1) unal, /* input */ 9 50 /* quietly call sub_err_ with diagnostic errors */ 9 51 3 dont_fill_sw bit (1) unal, /* input */ 9 52 /* "1"b - fill mode off initially */ 9 53 /* "0"b - fill mode on initially */ 9 54 3 hyphenation_sw bit (1) unal, 9 55 3 mbz bit (23) unal, /* input */ 9 56 /* MUST be zero */ 9 57 2 syllable_size 9 58 fixed bin; /* input */ 9 59 /* smallest portion of word */ 9 60 /* to be left by hyphenation */ 9 61 9 62 dcl format_document_options_ptr ptr; 9 63 dcl format_document_version_2 fixed bin int static options (constant) init (2); 9 64 dcl format_document_version_1 fixed bin int static options (constant) init (1); 9 65 9 66 /* END INCLUDE FILE format_document_options.incl.pl1 */ 1245 1246 1247 end ssu_request_mgr_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 08/04/87 1539.3 ssu_request_mgr_.pl1 >special_ldd>install>MR12.1-1054>ssu_request_mgr_.pl1 1233 1 08/04/87 1140.5 _ssu_check_sci.incl.pl1 >spec>install>1056>_ssu_check_sci.incl.pl1 1-61 2 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.incl.pl1 1-63 3 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.incl.pl1 1235 4 01/21/85 0912.2 _ssu_sci.incl.pl1 >ldd>include>_ssu_sci.incl.pl1 1237 5 04/13/82 1620.2 _ssu_request_table.incl.pl1 >ldd>include>_ssu_request_table.incl.pl1 1239 6 09/28/82 1437.6 _ssu_request_data.incl.pl1 >ldd>include>_ssu_request_data.incl.pl1 1241 7 04/13/82 1620.2 ssu_request_tables_list.incl.pl1 >ldd>include>ssu_request_tables_list.incl.pl1 1243 8 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 1245 9 11/01/84 1514.0 format_document_options.incl.pl1 >ldd>include>format_document_options.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. ACTION_CANT_RESTART 000110 constant bit(36) initial dcl 3-7 set ref 1-42* 1-48* 1-56* CALL6_ABSOLUTE constant bit(18) initial unaligned dcl 663 ref 693 CALL6_PR4_STAR constant bit(18) initial unaligned dcl 663 ref 708 DELIMITERS 000014 constant char(5) initial unaligned dcl 127 ref 1044 1046 ITS_MODIFIER constant bit(6) initial unaligned dcl 2-55 ref 1-41 LIST_REQUESTS 000026 constant char(32) initial unaligned dcl 118 set ref 948* NL 010253 constant char(1) initial unaligned dcl 124 ref 1106 1133 1134 1151 1152 1163 1167 1168 1173 1173 P_callers_area_ptr parameter pointer dcl 39 ref 304 315 P_code parameter fixed bin(35,0) dcl 33 set ref 200 206* 210* 251 260* 295* 297* 304 308* 319* 337* 344 353* 363* 389* 494 506* 527* 529* 537* 581 586* P_info_ptr parameter pointer dcl 46 ref 732 862 P_position parameter fixed bin(17,0) dcl 36 ref 200 230 232 233 P_request_data_ptr parameter pointer dcl 43 ref 494 501 P_request_entry parameter entry variable dcl 44 set ref 581 586* P_request_name parameter char unaligned dcl 42 set ref 494 500 581 586* P_request_tables_list_version parameter fixed bin(17,0) dcl 40 ref 304 307 P_rqt_ptr parameter pointer dcl 35 set ref 200 208* 238 251 265 P_rtl_ptr parameter pointer dcl 38 set ref 304 336* 344 350 P_sci_ptr parameter pointer dcl 32 set ref 171 174 183 186 200 203* 205 251 254* 256 304 312* 314 344 347* 349 494 497* 499 581 584 732 735 862 865 REQUEST_TABLES_LIST_VERSION_1 constant fixed bin(17,0) initial dcl 7-22 ref 307 329 352 RQT_VERSION_4 000010 constant char(8) initial unaligned dcl 5-19 ref 405 SCI_VERSION_3 000012 constant char(8) initial unaligned dcl 4-98 ref 1-53 SP constant char(1) initial unaligned dcl 123 ref 1173 1173 SSU_ 000000 constant char(32) initial unaligned dcl 1-31 set ref 1-42* 1-48* 1-56* SSU_REQUEST_MGR_ 000016 constant char(32) initial unaligned dcl 119 set ref 428* SUMMARIZE_REQUESTS 000036 constant char(32) initial unaligned dcl 117 set ref 768* WHITESPACE constant char(2) initial unaligned dcl 121 ref 555 555 560 addr builtin function dcl 166 ref 434 467 467 565 565 678 689 1102 1102 1127 1127 1145 1145 1-41 addrel builtin function dcl 166 ref 710 af_sw 17 based bit(1) level 3 dcl 6-11 set ref 523* area 000216 stack reference condition dcl 164 ref 317 arg_count 16 based fixed bin(17,0) level 3 dcl 6-11 set ref 522* arg_idx 000110 automatic fixed bin(17,0) dcl 890 set ref 897* 898* arg_list_ptr 14 based pointer level 3 dcl 6-11 set ref 521* argument based char unaligned dcl 885 set ref 899 900 900 901 902* 905* 908 argument_lth 000103 automatic fixed bin(21,0) dcl 886 set ref 898* 899 900 900 901 902 902 905 905 905 908 argument_ptr 000104 automatic pointer dcl 887 set ref 898* 899 900 900 901 902 905 908 based_word based bit(36) dcl 669 ref 713 baseno builtin function dcl 166 ref 678 686 binary builtin function dcl 166 ref 678 686 call6 2 based structure level 2 dcl 656 call_info 14 based structure level 2 dcl 6-11 callers_area based area(1024) dcl 76 ref 327 callers_area_ptr 000106 automatic pointer dcl 77 set ref 315* 327 chain_idx 000126 automatic fixed bin(17,0) dcl 465 in procedure "check_one_name" set ref 467* 469 482 484 chain_idx 000100 automatic fixed bin(17,0) dcl 548 in procedure "lookup_request" set ref 565* 567 chains 1 based fixed bin(17,0) array level 2 dcl 57 set ref 469 482 484* 567 cleanup 000224 stack reference condition dcl 164 ref 220 278 375 423 763 943 code 000104 automatic fixed bin(35,0) dcl 72 set ref 208* 209 210 361* 362 363 505 506 551* 556* 561* 569* 574* 681* 682 750* 751 816* 817 926* 928 931 936 950* 951 code2 000156 automatic fixed bin(35,0) dcl 102 set ref 927* 928 931 933 936 code_loc based bit(18) level 2 packed unaligned dcl 5-24 ref 533 692 code_ptr 000122 automatic pointer level 2 dcl 91 set ref 533* code_sequence based structure level 1 dcl 656 codeptr builtin function dcl 166 ref 696 716 col_len 000203 automatic fixed bin(17,0) dcl 112 set ref 757* 805 837 col_offset 000206 automatic fixed bin(17,0) array dcl 113 set ref 787* 788* 791* 796* 796 802 804 805 columns 000202 automatic fixed bin(17,0) dcl 112 set ref 753* 755 755* 757 784 788 790 794 795 803 805 cs_ptr 000104 automatic pointer dcl 661 set ref 692* 693 695 708 710 didnt_find_a_request 000107 automatic bit(1) dcl 889 set ref 1005* 1008* 1012 divide builtin function dcl 166 ref 753 757 784 dont_list 2(05) based bit(1) level 4 packed unaligned dcl 5-24 ref 988 1212 dont_summarize 2(04) based bit(1) level 4 packed unaligned dcl 5-24 ref 776 1210 entry 10 based entry variable level 2 dcl 6-11 set ref 536* entry1 000162 automatic entry variable dcl 106 set ref 922* 924 936 entry2 000166 automatic entry variable dcl 106 set ref 923* 924 936 entry_variable 000122 automatic structure level 1 dcl 91 set ref 536 env_ptr 2 000122 automatic pointer level 2 dcl 91 set ref 535* environmentptr builtin function dcl 166 ref 674 error_table_$bad_ptr 000110 external static fixed bin(35,0) dcl 1-33 set ref 1-42* error_table_$badopt 000012 external static fixed bin(35,0) dcl 133 set ref 902* error_table_$noalloc 000014 external static fixed bin(35,0) dcl 133 ref 319 error_table_$noarg 000016 external static fixed bin(35,0) dcl 133 set ref 912* error_table_$null_info_ptr 000112 external static fixed bin(35,0) dcl 1-34 set ref 1-48* error_table_$unimplemented_version 000114 external static fixed bin(35,0) dcl 1-35 in procedure "ssu_check_sci" set ref 1-56* error_table_$unimplemented_version 000020 external static fixed bin(35,0) dcl 133 in procedure "ssu_request_mgr_" ref 308 353 exact_matches_only 000102 automatic bit(1) dcl 883 set ref 895* 901* 912 957 973 1004 1093 exclude 000100 automatic bit(1) dcl 1202 set ref 1210* 1212* 1214 fdo 000126 automatic structure level 1 dcl 95 set ref 1102 1102 1127 1127 1145 1145 first_line 000176 automatic bit(1) dcl 1066 set ref 1162* 1169 1169 1173 1176 1182* first_name_switch 000104 automatic bit(1) dcl 419 in procedure "build_hash_table" set ref 436* 479 480* first_name_switch 3734 based bit(1) array level 3 in structure "hash_table" dcl 57 in procedure "ssu_request_mgr_" set ref 479* 832 984 flags 4 based structure array level 3 in structure "request_tables_list" dcl 7-7 in procedure "ssu_request_mgr_" flags 23 based structure level 2 in structure "request_data" dcl 6-11 in procedure "ssu_request_mgr_" set ref 518* flags 6 based structure array level 3 in structure "request_tables" dcl 51 in procedure "ssu_request_mgr_" flags 2 based structure level 2 in structure "rq_data" dcl 5-24 in procedure "ssu_request_mgr_" set ref 518 format_document_$string 000044 constant entry external dcl 142 ref 1102 1127 1145 format_document_options based structure level 1 dcl 9-12 format_document_version_1 constant fixed bin(17,0) initial dcl 9-64 ref 953 formatted_info_string_lth 000166 automatic fixed bin(21,0) dcl 1062 set ref 1145* 1149 1151* 1152 1159 formatted_info_string_position 000165 automatic fixed bin(21,0) dcl 1062 set ref 1138* 1151 1152 1163 1168 1169 1169 1176 1176 1181 formatted_name_list_lth 000164 automatic fixed bin(21,0) dcl 1062 set ref 1127* 1131 1133* 1134 1137 1157 formatted_name_list_position 000163 automatic fixed bin(21,0) dcl 1062 set ref 1121* 1133 1134 1167 1169 1169 1173 1173 1174 1180 formatted_string defined char unaligned dcl 1109 in begin block on line 1108 set ref 1110* formatted_string defined char unaligned dcl 1105 in begin block on line 1104 ref 1106 found_bad_table 000215 automatic bit(1) dcl 115 set ref 357* 363 364* 369 found_some_matches 000147 automatic bit(1) dcl 1026 set ref 1032* 1053 full_name based char(32) level 2 packed unaligned dcl 6-11 set ref 512* galley_sw 3(02) 000126 automatic bit(1) level 3 packed unaligned dcl 95 set ref 956* get_line_length_$switch 000046 constant entry external dcl 143 ref 750 950 get_ring_ 000050 constant entry external dcl 144 ref 681 681 global_info 4 based structure level 2 dcl 4-14 hash_index_ 000052 constant entry external dcl 145 ref 467 565 hash_table based structure level 1 dcl 57 hash_table_ptr 2 based pointer level 2 dcl 51 set ref 189 189* 270 270* 446* 452 452* 567 568 570 572 773 774 830 832 832 834 983 984 985 1207 1208 have_info 000200 automatic bit(1) dcl 1066 set ref 1163* 1166 1168 1169 1181* have_names 000177 automatic bit(1) dcl 1066 set ref 1162* 1166 1167 1169 1172 1180* hcs_$combine_linkage 000054 constant entry external dcl 146 ref 681 header based structure level 2 dcl 7-7 help_request_name 000146 automatic char(32) unaligned dcl 100 set ref 927* 928* 931* 933* idx 000173 automatic fixed bin(17,0) dcl 1064 in procedure "list_single_request" set ref 1073* 1074* idx 000174 automatic fixed bin(17,0) dcl 108 in procedure "ssu_request_mgr_" set ref 235* 236 236* 241* 242 242* 264* 265* 286 289 331* 333 333* 359* 360 361 365* 383* 384 384* 437* 438* 697* 700 702* 772* 773 774 778* 778 790* 791 791* 795* 796 796 796* 803* 804 805 805* 830 832* 832 832 832* 834* 848 973* 975 978* 983* 984 985* 1006* 1007 1009* 1207* 1208* idx 000145 automatic fixed bin(17,0) dcl 1025 in procedure "matching_name" set ref 1038* 1039 1042 1046* indentation 1 000126 automatic fixed bin(17,0) level 2 dcl 95 set ref 958* 962* index builtin function dcl 166 ref 899 1039 1044 1046 1167 1168 info_lth 000172 automatic fixed bin(21,0) dcl 1062 set ref 1168* 1169 1169 1176 1176 1179 info_start 000171 automatic fixed bin(21,0) dcl 1062 set ref 1164* 1168 1169 1169 1176 1176 1179* 1179 1181 info_string 25 based structure level 2 in structure "request_data" dcl 6-11 in procedure "ssu_request_mgr_" info_string 1 based structure level 2 in structure "rq_data" dcl 5-24 in procedure "ssu_request_mgr_" info_string defined char unaligned dcl 1149 in begin block on line 1148 set ref 1151 1152* info_string defined char unaligned dcl 1159 in begin block on line 1155 ref 1163 1168 1169 1169 1176 1176 1181 ioa_ 000056 constant entry external dcl 147 ref 743 808 817 920 924 928 931 933 936 1095 1098 1110 1169 1173 1176 ioa_$nnl 000060 constant entry external dcl 148 ref 805 iox_$user_output 000042 external static pointer dcl 140 set ref 750* 950* its based structure level 1 dcl 2-5 its_mod 0(30) based bit(6) level 2 packed unaligned dcl 2-5 ref 1-41 jdx 000175 automatic fixed bin(17,0) dcl 108 set ref 286* 287 287* 289* 290 290* 794* 796 length builtin function dcl 166 ref 467 467 555 565 565 835 837 845 1042 1042 1046 1081 1098 1106 1124 1133 1140 1151 1174 1180 1181 1217 1217 1223 1225 lh_request_name 000136 automatic char(32) unaligned dcl 100 set ref 926* 928* line 2 based varying char(36) array level 3 dcl 84 set ref 805* 840* 852* line_length 2 000126 automatic fixed bin(17,0) level 2 in structure "fdo" dcl 95 in procedure "ssu_request_mgr_" set ref 959* 963* 1126* 1142* 1143 1143* line_length 000201 automatic fixed bin(17,0) dcl 110 in procedure "ssu_request_mgr_" set ref 750* 751* 753 757 950* 951* 959 1142 lines_per_col 000205 automatic fixed bin(17,0) dcl 112 set ref 784* 791 link_offset 2 based bit(18) level 3 packed unaligned dcl 656 ref 695 710 linkage_error 000000 stack reference condition dcl 164 ref 711 715 linkage_ptr 000102 automatic pointer dcl 654 set ref 686* 710 list_all_requests 000101 automatic bit(1) dcl 882 set ref 895* 900* 964* 988 listed_a_request 000106 automatic bit(1) dcl 889 set ref 970* 978* 994* 1016 literal_sw 3(04) 000126 automatic bit(1) level 3 packed unaligned dcl 95 set ref 955* loc 1 based bit(18) level 3 packed unaligned dcl 5-24 ref 515 991 lot based structure level 1 dcl 647 lot_fault based bit(3) level 2 packed unaligned dcl 650 ref 680 lot_pointer based structure level 1 dcl 650 lot_pointer_ptr 000100 automatic pointer dcl 653 set ref 678* 680 680 lot_pointers based pointer array level 2 packed unaligned dcl 647 set ref 678 686 lot_ptr 26 based pointer level 2 dcl 8-26 ref 678 686 lth 1(18) based fixed bin(17,0) level 3 in structure "rq_data" packed unaligned dcl 5-24 in procedure "ssu_request_mgr_" ref 516 992 lth 26 based fixed bin(18,0) level 3 in structure "request_data" dcl 6-11 in procedure "ssu_request_mgr_" set ref 516* ltrim builtin function dcl 166 ref 555 match 000214 automatic bit(1) dcl 115 set ref 258* 264 265* 268 matched_request_string 000100 automatic bit(1) array dcl 879 set ref 971* 978* 1007 max builtin function dcl 166 ref 872 1217 1223 1225 max_name_size 000200 automatic fixed bin(17,0) dcl 109 set ref 965* 967* 1126 1142 1169 1176 max_request_strings 000160 automatic fixed bin(17,0) dcl 104 set ref 872* 878 879 maxlength builtin function dcl 166 ref 905 mbz 0(03) based bit(27) level 2 packed unaligned dcl 650 ref 680 min builtin function dcl 166 ref 796 mod builtin function dcl 166 ref 794 n_arguments 000157 automatic fixed bin(17,0) dcl 104 set ref 737* 738 867* 872 897 n_names based fixed bin(17,0) level 2 dcl 6-47 ref 437 697 1034 1073 1217 n_request_strings 000100 automatic fixed bin(17,0) dcl 880 set ref 893* 907* 907 908 912 918 973 1006 1029 1038 n_requests 20 based fixed bin(17,0) level 2 dcl 5-9 ref 433 688 n_slots based fixed bin(17,0) level 2 dcl 57 set ref 474 474* 773 832 983 1207 n_tables 1 based fixed bin(17,0) level 3 in structure "request_tables_list" dcl 7-7 in procedure "ssu_request_mgr_" set ref 327* 359 371 n_tables based fixed bin(17,0) level 2 in structure "request_tables" dcl 51 in procedure "ssu_request_mgr_" set ref 191 216 222 226* 230 230 241 264 269 272 280 284 285* 289 323 331 377 381* 383 430 454 607 name 3722 based char(32) array level 3 in structure "hash_table" dcl 57 in procedure "ssu_request_mgr_" set ref 471 477* 568 830 834 name 1 based char(32) array level 2 in structure "request_name_list" packed unaligned dcl 6-47 in procedure "ssu_request_mgr_" set ref 438* 512 700* 702 1035 1074 1217 1217 1223 1225 name_idx 000144 automatic fixed bin(17,0) dcl 1025 set ref 1034* 1035* name_list defined char unaligned dcl 1131 in begin block on line 1130 set ref 1133 1134* name_list defined char unaligned dcl 1157 in begin block on line 1155 ref 1167 1169 1169 1173 1173 1174 1180 name_list_ptr 24 based pointer level 2 packed unaligned dcl 6-11 set ref 513* name_lth 000170 automatic fixed bin(21,0) dcl 1062 in procedure "list_single_request" set ref 1081* 1082 1083 1167* 1169 1169 1174* 1178 name_lth 000316 automatic fixed bin(17,0) dcl 826 in procedure "add_request_to_list" set ref 835* 837 name_start 000167 automatic fixed bin(21,0) dcl 1062 set ref 1164* 1167 1169 1169 1173 1173 1178* 1178 1180 name_string 000317 automatic varying char(80) dcl 827 set ref 830* 837 840 841* 845 845* 845 846* 846 850 852 namelist_loc 0(18) based bit(18) level 2 packed unaligned dcl 5-24 ref 435 510 690 775 977 986 1215 new_hash_table_ptr 000102 automatic pointer dcl 418 set ref 421* 425 425* 428* 446 448* 469 471 472 474 474 477 478 479 482 482 484 new_request_tables_ptr 000102 automatic pointer dcl 67 set ref 218* 222 222 226* 236 238 239 241 242 276* 280 280 285* 287 290 373* 377 377 381* 383 384 430 431 432 446 447 448* next_slot 3735 based fixed bin(17,0) array level 3 dcl 57 set ref 472 482* 572 null builtin function dcl 1-39 in procedure "ssu_check_sci" ref 1-42 1-42 1-47 1-48 1-48 1-56 1-56 null builtin function dcl 166 in procedure "ssu_request_mgr_" ref 175 188 189 194 214 218 222 228 260 270 273 276 280 323 331 373 377 403 421 425 448 451 452 521 524 535 550 552 557 562 575 601 674 740 762 765 869 942 945 976 1002 old_request_tables_ptr 000100 automatic pointer dcl 418 set ref 444* 451 452 452 454 one_name_size 000176 automatic fixed bin(17,0) dcl 109 set ref 753 965 965 1204* 1225* 1225 op_code_and_modifiers 2(18) based bit(18) level 3 packed unaligned dcl 656 ref 693 708 output_buffer based char unaligned dcl 97 set ref 1078* 1082* 1095 1095 1102* 1106 1106 1110 1110 1124 1127 1127 1127 1127 1133 1133 1134 1134 1140 1145 1145 1151 1151 1152 1152 1163 1163 1167 1167 1168 1168 1169 1169 1169 1169 1169 1169 1169 1169 1173 1173 1173 1173 1174 1174 1176 1176 1176 1176 1180 1180 1181 1181 output_buffer_ptr 000134 automatic pointer dcl 98 set ref 942* 945 945* 948* 1001* 1002* 1078 1082 1095 1095 1102 1106 1110 1124 1127 1127 1133 1134 1140 1145 1151 1152 1163 1167 1168 1169 1169 1169 1169 1173 1173 1174 1176 1176 1180 1181 output_buffer_used 000162 automatic fixed bin(21,0) dcl 1062 set ref 1071* 1077 1078 1079* 1079 1082 1083* 1083 1087 1095 1095 1102* 1105 1106* 1109 1121 1123 1124 1127 1137* 1137 1138 1140 1145 p_code parameter fixed bin(35,0) dcl 399 in procedure "validate_request_table" set ref 395 401* 403* 405* 407* p_code parameter fixed bin(35,0) dcl 599 in procedure "find_request_name_subr" set ref 594 603* 612* 619* p_include_all parameter bit(1) dcl 1201 ref 1198 1214 p_request_entry parameter entry variable dcl 644 in procedure "find_request_name_in_table" ref 641 674 696 716 p_request_entry parameter entry variable dcl 597 in procedure "find_request_name_subr" set ref 594 611* p_request_name parameter char unaligned dcl 598 in procedure "find_request_name_subr" set ref 594 602* 611* 618* p_request_name parameter char unaligned dcl 645 in procedure "find_request_name_in_table" set ref 641 702* p_rqt_ptr parameter pointer dcl 398 ref 395 401 403 405 p_sci_ptr parameter pointer dcl 1-29 set ref 1-26 1-41 1-42 1-42 1-47 1-53 1-56 1-56 p_summarize parameter bit(1) dcl 1201 ref 1198 1210 pad 27 based bit(36) array level 2 dcl 6-11 set ref 519* parent_area_ptr 2 based pointer level 2 dcl 4-14 ref 191 222 226 272 280 285 377 381 454 pointer builtin function dcl 166 ref 435 510 515 533 677 690 692 695 775 977 986 991 1215 position 000105 automatic fixed bin(17,0) dcl 74 in procedure "ssu_request_mgr_" set ref 228* 230* 232* 233* 235 238 239 241 position 000146 automatic fixed bin(17,0) dcl 1025 in procedure "matching_name" set ref 1039* 1040 1040 1042 1044 1046 print_line 1 based structure array level 2 dcl 84 ptr 25 based pointer level 3 packed unaligned dcl 6-11 set ref 515* request_data based structure level 1 dcl 6-11 request_data_ptr 000240 automatic pointer dcl 6-27 set ref 501* 512 513 515 516 518 519 521 522 523 524 525 536 request_flags based structure level 1 dcl 6-32 request_info_string based char unaligned dcl 6-57 set ref 1098 1102* 1145* request_info_string_lth 000244 automatic fixed bin(21,0) dcl 6-58 set ref 992* 1098 1102 1102 1145 1145 request_info_string_ptr 000246 automatic pointer dcl 6-59 set ref 991* 1098 1102 1145 request_name parameter char(32) unaligned dcl 547 in procedure "lookup_request" set ref 544 555 560 565 565 565 565 568 request_name 000110 automatic char(32) unaligned dcl 79 in procedure "ssu_request_mgr_" set ref 500* 503* 816* 817* 1035* 1036* 1039 1042 1044 1046 1074* 1075* 1081 1082 request_name_list based structure level 1 dcl 6-47 request_name_list_ptr 000242 automatic pointer dcl 6-51 set ref 435* 437 438 510* 512 513 690* 697 700 702 775* 977* 986* 1034 1035 1073 1074 1215* 1217 1217 1217 1223 1225 request_processor_info 42 based structure level 2 dcl 4-14 request_strings 000100 automatic varying char(32) array dcl 878 set ref 905 908* 975 1009* 1039 1042 1046 request_tables based structure level 1 dcl 51 set ref 191 222 226 272 280 285 377 381 454 request_tables_list based structure level 1 dcl 7-7 set ref 327 request_tables_list_n_tables 000252 automatic fixed bin(17,0) dcl 7-20 set ref 323* 325* 327 327 request_tables_n_tables 000100 automatic fixed bin(17,0) dcl 66 set ref 214* 216* 226 226 284* 285 285 371* 381 381 request_tables_ptr 42 based pointer level 3 dcl 4-14 set ref 175* 188 189 189 191 194* 214 216 228 230 230 236 242 260 264 265 269 270 270 272 273* 284 287 289 290 323 323 331 331 333 444 447* 550 567 568 570 572 601 607 608 610 740 773 774 830 832 832 834 869 983 984 985 1207 1208 requests 21 based structure array level 2 dcl 5-9 set ref 434 689 rest_of_output_buffer defined char unaligned dcl 1140 in begin block on line 1139 set ref 1145* rest_of_output_buffer defined char unaligned dcl 1124 in begin block on line 1122 set ref 1127* rq_data based structure level 1 dcl 5-24 rq_data_ptr 000236 automatic pointer dcl 5-32 in procedure "ssu_request_mgr_" set ref 434* 435 478 503* 510 510 515 515 516 518 527 529 533 533 689* 690 691 691 692 701 774* 775 775 776 776 776 975* 976 977 977 985* 986 986 988 988 988 991 991 992 1037 1076 1095 1208* 1210 1212 1214 1214 1215 1215 rq_data_ptr 3732 based pointer array level 3 in structure "hash_table" dcl 57 in procedure "ssu_request_mgr_" set ref 478* 570 774 985 1208 rq_idx 000173 automatic fixed bin(17,0) dcl 108 set ref 433* 434* 688* 689* 802* 804* rqt based structure level 1 dcl 5-9 rqt_idx 000172 automatic fixed bin(17,0) dcl 108 set ref 430* 431 432* 607* 608 610* rqt_ptr 000234 automatic pointer dcl 5-17 set ref 432* 433 434 435 610* 678 681* 686 688 689 690 692 695 rtl_ptr 000250 automatic pointer dcl 7-18 set ref 327* 329 333 336 350* 352 359 360 361 365 371 384 rtrim builtin function dcl 166 ref 467 467 555 565 565 830 834 1035 1074 1081 1082 1106 1133 1151 1217 1217 1223 1225 rv_lth 22 based fixed bin(21,0) level 3 dcl 6-11 set ref 525* rv_ptr 20 based pointer level 3 dcl 6-11 set ref 524* sb 000254 automatic pointer dcl 8-24 set ref 677* 678 686 sci based structure level 1 dcl 4-14 sci_parent_area based area(1024) dcl 4-96 ref 191 222 226 272 280 285 377 381 454 sci_ptr 000232 automatic pointer dcl 4-94 set ref 174* 175 186* 188 189 189* 189 191 191 194 205* 214 216 222 226 228 230 230 236 242 256* 260 264 265 269 270 270* 270 272 272 273 280 284 285 287 289 290 314* 323 323 331 331 333 349* 377 381 425* 428* 444 447 452* 454 499* 550 567 568 570 572 584* 601 607 608 610 735* 737* 738* 740 740* 740 743 765* 768* 773 774 811* 830 832 832 834 865* 867* 869 869* 869 898* 902* 905* 912* 920 922* 923* 945* 948* 983 984 985 1001* 1009* 1012* 1016* 1207 1208 slot_idx 000127 automatic fixed bin(17,0) dcl 465 in procedure "check_one_name" set ref 469* 469* 471* 472 474* 477 478 479 482 484 slot_idx 000101 automatic fixed bin(17,0) dcl 548 in procedure "lookup_request" set ref 567* 567* 568 570* 572 slots 3722 based structure array level 2 dcl 57 ssu_$abort_line 000062 constant entry external dcl 149 ref 738 740 869 902 905 912 1012 1016 ssu_$arg_count 000064 constant entry external dcl 150 ref 737 867 ssu_$arg_ptr 000066 constant entry external dcl 151 ref 898 ssu_$get_default_procedure 000070 constant entry external dcl 152 ref 923 ssu_$get_procedure 000072 constant entry external dcl 153 ref 922 ssu_$get_temp_segment 000074 constant entry external dcl 155 ref 428 768 948 ssu_$print_message 000076 constant entry external dcl 156 ref 1009 ssu_$release_temp_segment 000100 constant entry external dcl 157 ref 189 270 425 452 765 811 945 1001 ssu_et_$blank_request_name 000022 external static fixed bin(35,0) dcl 133 ref 561 ssu_et_$invalid_request_table 000026 external static fixed bin(35,0) dcl 133 ref 401 403 405 ssu_et_$no_matching_requests 000024 external static fixed bin(35,0) dcl 133 set ref 1016* ssu_et_$request_name_too_long 000030 external static fixed bin(35,0) dcl 133 set ref 556 905* ssu_et_$request_not_found 000032 external static fixed bin(35,0) dcl 133 ref 603 619 ssu_et_$request_table_not_found 000034 external static fixed bin(35,0) dcl 133 ref 260 297 ssu_et_$unimplemented_request 000036 external static fixed bin(35,0) dcl 133 ref 529 ssu_et_$unknown_request 000040 external static fixed bin(35,0) dcl 133 ref 527 551 574 ssu_requests_$help 000102 constant entry external dcl 160 ref 927 927 ssu_requests_$list_help 000104 constant entry external dcl 160 ref 926 926 ssu_requests_$list_requests 000106 constant entry external dcl 160 ref 816 816 stack_header based structure level 1 dcl 8-26 stackframeptr builtin function dcl 166 ref 677 sub_err_ 000116 constant entry external dcl 1-37 ref 1-42 1-48 1-56 substr builtin function dcl 166 set ref 401 710 1044 1046 1078* 1082* 1095 1095 1134* 1152* 1167 1168 1169 1169 1169 1169 1173 1173 1176 1176 subsystem_name 4 based char(32) level 3 packed unaligned dcl 4-14 set ref 740* 743* 869* 920* summary_info based structure level 1 dcl 84 summary_info_ptr 000120 automatic pointer dcl 89 set ref 762* 765 765* 768* 770 784 788 794 805 811* 839 839 840 840 851 851 852 852 switches 3 000126 automatic structure level 2 dcl 95 set ref 954* sys_info$max_seg_size 000010 external static fixed bin(19,0) dcl 130 ref 1078 1082 1095 1095 1102 1102 1106 1110 1124 1127 1127 1133 1134 1140 1145 1151 1152 1163 1167 1168 1169 1169 1169 1169 1173 1173 1174 1176 1176 1180 1181 system_flags 2 based structure level 3 packed unaligned dcl 5-24 table_ptr 2 based pointer array level 3 in structure "request_tables_list" dcl 7-7 in procedure "ssu_request_mgr_" set ref 361* table_ptr 4 based pointer array level 3 in structure "request_tables" dcl 51 in procedure "ssu_request_mgr_" set ref 238* 265 432 610 table_valid 4 based bit(1) array level 4 in structure "request_tables_list" packed unaligned dcl 7-7 in procedure "ssu_request_mgr_" set ref 360* 365* table_valid 6 based bit(1) array level 4 in structure "request_tables" packed unaligned dcl 51 in procedure "ssu_request_mgr_" set ref 239* 431 608 tables 2 based structure array level 2 in structure "request_tables_list" dcl 7-7 in procedure "ssu_request_mgr_" set ref 333* 384 tables 4 based structure array level 2 in structure "request_tables" dcl 51 in procedure "ssu_request_mgr_" set ref 236* 236 242* 242 287* 287 290* 290 333 384* test_rq_data_ptr 000174 automatic pointer dcl 1065 in procedure "list_single_request" set ref 1075* 1076 test_rq_data_ptr 000150 automatic pointer dcl 1027 in procedure "matching_name" set ref 1036* 1037 test_rq_data_ptr 000112 automatic pointer dcl 672 in procedure "find_request_name_in_table" set ref 700* 701 the_entry based pointer dcl 670 ref 713 716 the_entry_ptr 000110 automatic pointer dcl 671 set ref 695* 696 710* 713 716 this_line 000204 automatic fixed bin(17,0) dcl 112 set ref 804* 805 805 this_name 000344 automatic varying char(32) dcl 828 in procedure "add_request_to_list" set ref 834* 835 841 846 this_name parameter char(32) unaligned dcl 464 in procedure "check_one_name" set ref 461 467 467 467 467 471 477 total_lines based fixed bin(17,0) level 2 dcl 84 set ref 770* 784 788 794 839* 839 840 851* 851 852 two_name_size 000177 automatic fixed bin(17,0) dcl 109 set ref 965 967 1205* 1217* 1217 1223* 1223 unformatted_name_list defined char unaligned dcl 1123 set ref 1127* unimplemented 2(02) based bit(1) level 4 packed unaligned dcl 5-24 set ref 529 691 776 988 1095* 1214 unknown 2(06) based bit(1) level 4 packed unaligned dcl 5-24 ref 527 691 776 988 1214 unspec builtin function dcl 1-39 in procedure "ssu_check_sci" ref 1-42 1-42 1-56 1-56 unspec builtin function dcl 166 in procedure "ssu_request_mgr_" set ref 401 519* 536* 536 verify builtin function dcl 166 ref 560 version based char(8) level 2 in structure "sci" dcl 4-14 in procedure "ssu_request_mgr_" ref 1-53 1-56 1-56 version based fixed bin(17,0) level 3 in structure "request_tables_list" dcl 7-7 in procedure "ssu_request_mgr_" set ref 329* 352 version based char(8) level 2 in structure "rqt" dcl 5-9 in procedure "ssu_request_mgr_" ref 405 version_number 000126 automatic fixed bin(17,0) level 2 dcl 95 set ref 953* word 000106 automatic bit(36) dcl 668 set ref 713* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 3-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 3-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 3-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 3-7 ITP_MODIFIER internal static bit(6) initial unaligned dcl 2-56 call_offset internal static fixed bin(17,0) initial dcl 8-78 entry_offset internal static fixed bin(17,0) initial dcl 8-78 error_table_$inconsistent external static fixed bin(35,0) dcl 133 format_document_options_ptr automatic pointer dcl 9-62 format_document_version_2 internal static fixed bin(17,0) initial dcl 9-63 itp based structure level 1 dcl 2-18 itp_unsigned based structure level 1 dcl 2-43 its_unsigned based structure level 1 dcl 2-30 name_idx automatic fixed bin(17,0) dcl 826 push_offset internal static fixed bin(17,0) initial dcl 8-78 request_name_list_n_names automatic fixed bin(17,0) dcl 6-52 return_no_pop_offset internal static fixed bin(17,0) initial dcl 8-78 return_offset internal static fixed bin(17,0) initial dcl 8-78 ssu_$get_subsystem_and_request_name 000000 constant entry external dcl 154 stack_header_overlay based fixed bin(17,0) array dcl 8-94 substr builtin function dcl 1-39 tv_offset internal static fixed bin(17,0) initial dcl 8-72 NAMES DECLARED BY EXPLICIT CONTEXT. FOUND_THE_REQUEST 006654 constant label dcl 697 ref 716 LIST_REQUESTS_BODY 002631 constant label dcl 875 RESIGNAL_BAD_POINTER 007433 constant label dcl 1-42 ref 1-44 RESIGNAL_BAD_VERSION 007565 constant label dcl 1-56 set ref 1-59 RESIGNAL_NULL_POINTER 007513 constant label dcl 1-48 ref 1-50 RETURN_FROM_LIST_REQUEST_TABLES 001335 constant label dcl 339 ref 320 SKIP_THIS_REQUEST 006774 constant label dcl 720 ref 711 add_request_table 000465 constant entry external dcl 200 add_request_to_list 007003 constant entry internal dcl 823 ref 776 build_hash_table 005575 constant entry internal dcl 415 ref 245 293 387 check_one_name 006020 constant entry internal dcl 461 ref 438 compute_request_name_widths 007245 constant entry internal dcl 1198 ref 748 964 delete_request_table 000721 constant entry external dcl 251 find_request_name 001725 constant entry external dcl 581 find_request_name_in_table 006470 constant entry internal dcl 641 ref 611 find_request_name_subr 006347 constant entry internal dcl 594 ref 586 816 926 927 init_request_tables 000375 constant entry external dcl 171 list_request_tables 001175 constant entry external dcl 304 list_requests 002544 constant entry external dcl 862 list_single_request 004330 constant entry internal dcl 1059 ref 979 995 locate_request 001544 constant entry external dcl 494 lookup_request 006145 constant entry internal dcl 544 ref 503 700 975 1036 1075 matching_name 004133 constant entry internal dcl 1022 ref 993 set_request_tables 001340 constant entry external dcl 344 ssu_check_sci 007425 constant entry internal dcl 1-26 ref 203 254 312 347 497 ssu_request_mgr_ 000364 constant entry external dcl 24 summarize_requests 001773 constant entry external dcl 732 term_request_tables 000413 constant entry external dcl 183 validate_request_table 005536 constant entry internal dcl 395 ref 208 361 NAMES DECLARED BY CONTEXT OR IMPLICATION. string builtin function ref 954 translate builtin function ref 1173 1173 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11170 11310 10257 11200 Length 12052 10257 120 525 711 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME ssu_request_mgr_ 338 external procedure is an external procedure. on unit on line 220 64 on unit on unit on line 278 64 on unit on unit on line 317 64 on unit on unit on line 375 64 on unit validate_request_table internal procedure shares stack frame of external procedure ssu_request_mgr_. build_hash_table 122 internal procedure enables or reverts conditions. on unit on line 423 70 on unit check_one_name internal procedure shares stack frame of internal procedure build_hash_table. lookup_request 86 internal procedure is called by several nonquick procedures. find_request_name_subr 84 internal procedure is called by several nonquick procedures. find_request_name_in_table 106 internal procedure enables or reverts conditions. on unit on line 711 64 on unit on unit on line 763 70 on unit add_request_to_list internal procedure shares stack frame of external procedure ssu_request_mgr_. begin block on line 875 366 begin block uses auto adjustable storage, and enables or reverts conditions. on unit on line 943 70 on unit matching_name internal procedure shares stack frame of begin block on line 875. list_single_request internal procedure shares stack frame of begin block on line 875. begin block on line 1104 begin block shares stack frame of begin block on line 875. begin block on line 1108 begin block shares stack frame of begin block on line 875. begin block on line 1122 begin block shares stack frame of begin block on line 875. begin block on line 1130 begin block shares stack frame of begin block on line 875. begin block on line 1139 begin block shares stack frame of begin block on line 875. begin block on line 1148 begin block shares stack frame of begin block on line 875. begin block on line 1155 begin block shares stack frame of begin block on line 875. compute_request_name_widths 68 internal procedure is called by several nonquick procedures. ssu_check_sci internal procedure shares stack frame of external procedure ssu_request_mgr_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 875 000100 request_strings begin block on line 875 000100 matched_request_string begin block on line 875 000100 n_request_strings begin block on line 875 000101 list_all_requests begin block on line 875 000102 exact_matches_only begin block on line 875 000103 argument_lth begin block on line 875 000104 argument_ptr begin block on line 875 000106 listed_a_request begin block on line 875 000107 didnt_find_a_request begin block on line 875 000110 arg_idx begin block on line 875 000144 name_idx matching_name 000145 idx matching_name 000146 position matching_name 000147 found_some_matches matching_name 000150 test_rq_data_ptr matching_name 000162 output_buffer_used list_single_request 000163 formatted_name_list_position list_single_request 000164 formatted_name_list_lth list_single_request 000165 formatted_info_string_position list_single_request 000166 formatted_info_string_lth list_single_request 000167 name_start list_single_request 000170 name_lth list_single_request 000171 info_start list_single_request 000172 info_lth list_single_request 000173 idx list_single_request 000174 test_rq_data_ptr list_single_request 000176 first_line list_single_request 000177 have_names list_single_request 000200 have_info list_single_request build_hash_table 000100 old_request_tables_ptr build_hash_table 000102 new_hash_table_ptr build_hash_table 000104 first_name_switch build_hash_table 000126 chain_idx check_one_name 000127 slot_idx check_one_name compute_request_name_widths 000100 exclude compute_request_name_widths find_request_name_in_table 000100 lot_pointer_ptr find_request_name_in_table 000102 linkage_ptr find_request_name_in_table 000104 cs_ptr find_request_name_in_table 000106 word find_request_name_in_table 000110 the_entry_ptr find_request_name_in_table 000112 test_rq_data_ptr find_request_name_in_table lookup_request 000100 chain_idx lookup_request 000101 slot_idx lookup_request ssu_request_mgr_ 000100 request_tables_n_tables ssu_request_mgr_ 000102 new_request_tables_ptr ssu_request_mgr_ 000104 code ssu_request_mgr_ 000105 position ssu_request_mgr_ 000106 callers_area_ptr ssu_request_mgr_ 000110 request_name ssu_request_mgr_ 000120 summary_info_ptr ssu_request_mgr_ 000122 entry_variable ssu_request_mgr_ 000126 fdo ssu_request_mgr_ 000134 output_buffer_ptr ssu_request_mgr_ 000136 lh_request_name ssu_request_mgr_ 000146 help_request_name ssu_request_mgr_ 000156 code2 ssu_request_mgr_ 000157 n_arguments ssu_request_mgr_ 000160 max_request_strings ssu_request_mgr_ 000162 entry1 ssu_request_mgr_ 000166 entry2 ssu_request_mgr_ 000172 rqt_idx ssu_request_mgr_ 000173 rq_idx ssu_request_mgr_ 000174 idx ssu_request_mgr_ 000175 jdx ssu_request_mgr_ 000176 one_name_size ssu_request_mgr_ 000177 two_name_size ssu_request_mgr_ 000200 max_name_size ssu_request_mgr_ 000201 line_length ssu_request_mgr_ 000202 columns ssu_request_mgr_ 000203 col_len ssu_request_mgr_ 000204 this_line ssu_request_mgr_ 000205 lines_per_col ssu_request_mgr_ 000206 col_offset ssu_request_mgr_ 000214 match ssu_request_mgr_ 000215 found_bad_table ssu_request_mgr_ 000232 sci_ptr ssu_request_mgr_ 000234 rqt_ptr ssu_request_mgr_ 000236 rq_data_ptr ssu_request_mgr_ 000240 request_data_ptr ssu_request_mgr_ 000242 request_name_list_ptr ssu_request_mgr_ 000244 request_info_string_lth ssu_request_mgr_ 000246 request_info_string_ptr ssu_request_mgr_ 000250 rtl_ptr ssu_request_mgr_ 000252 request_tables_list_n_tables ssu_request_mgr_ 000254 sb ssu_request_mgr_ 000316 name_lth add_request_to_list 000317 name_string add_request_to_list 000344 this_name add_request_to_list THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_l_a r_e_as r_ne_as alloc_char_temp enter_begin_block leave_begin_block call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 alloc_auto_adj mdfx1 enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc set_chars_eis index_chars_eis op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. format_document_$string get_line_length_$switch get_ring_ hash_index_ hcs_$combine_linkage ioa_ ioa_$nnl ssu_$abort_line ssu_$arg_count ssu_$arg_ptr ssu_$get_default_procedure ssu_$get_procedure ssu_$get_temp_segment ssu_$print_message ssu_$release_temp_segment ssu_requests_$help ssu_requests_$list_help ssu_requests_$list_requests sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_ptr error_table_$badopt error_table_$noalloc error_table_$noarg error_table_$null_info_ptr error_table_$unimplemented_version error_table_$unimplemented_version iox_$user_output ssu_et_$blank_request_name ssu_et_$invalid_request_table ssu_et_$no_matching_requests ssu_et_$request_name_too_long ssu_et_$request_not_found ssu_et_$request_table_not_found ssu_et_$unimplemented_request ssu_et_$unknown_request sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 24 000363 27 000371 171 000372 174 000402 175 000406 177 000410 183 000411 186 000420 188 000424 189 000430 191 000446 194 000454 196 000457 200 000460 203 000475 205 000504 206 000510 208 000511 209 000521 210 000523 211 000524 214 000525 216 000535 218 000540 220 000542 222 000556 224 000570 226 000571 228 000603 230 000613 232 000623 233 000630 235 000631 236 000641 237 000652 238 000654 239 000662 241 000665 242 000675 243 000706 245 000710 247 000714 251 000715 254 000731 256 000740 258 000744 260 000745 264 000755 265 000767 266 001000 268 001002 269 001004 270 001010 272 001026 273 001034 274 001037 276 001040 278 001042 280 001056 282 001070 284 001071 285 001075 286 001107 287 001117 288 001130 289 001132 290 001143 291 001154 293 001156 295 001162 296 001163 297 001164 300 001167 304 001170 307 001207 308 001213 309 001216 312 001217 314 001225 315 001231 317 001234 319 001250 320 001253 323 001256 325 001266 327 001267 329 001300 331 001302 333 001317 334 001330 336 001332 337 001334 339 001335 344 001336 347 001352 349 001361 350 001365 352 001370 353 001373 354 001376 357 001377 359 001400 360 001407 361 001412 362 001423 363 001425 364 001430 365 001432 367 001436 369 001440 371 001442 373 001445 375 001447 377 001463 379 001475 381 001476 383 001510 384 001517 385 001527 387 001531 389 001535 391 001536 494 001537 497 001561 499 001570 500 001574 501 001604 503 001607 505 001617 506 001621 507 001622 510 001623 512 001630 513 001634 515 001635 516 001643 518 001647 519 001651 521 001654 522 001656 523 001657 524 001660 525 001661 527 001662 529 001672 533 001701 535 001706 536 001710 537 001716 540 001717 581 001720 584 001742 586 001746 588 001766 732 001767 735 002000 737 002004 738 002015 740 002044 743 002102 748 002126 750 002142 751 002155 753 002161 755 002167 757 002173 762 002177 763 002201 765 002215 766 002232 768 002233 770 002253 772 002254 773 002256 774 002263 775 002267 776 002274 778 002301 779 002302 784 002303 787 002306 788 002307 790 002312 791 002323 792 002326 794 002330 795 002334 796 002345 797 002352 802 002354 803 002363 804 002373 805 002377 807 002450 808 002452 809 002457 811 002461 816 002472 817 002517 819 002541 862 002542 865 002551 867 002555 869 002566 872 002624 875 002631 878 002634 879 002643 1009 002647 893 002651 895 002652 897 002654 898 002663 899 002701 900 002715 901 002730 902 002737 903 002772 905 002773 907 003030 908 003031 910 003047 912 003051 918 003102 920 003104 922 003126 923 003157 924 003210 926 003235 927 003264 928 003313 931 003346 933 003372 936 003415 942 003443 943 003446 945 003462 946 003500 948 003501 950 003522 951 003536 953 003543 954 003545 955 003546 956 003550 957 003552 958 003554 959 003556 960 003560 962 003561 963 003562 964 003563 965 003576 967 003607 970 003612 971 003613 973 003625 975 003640 976 003660 977 003665 978 003672 979 003677 981 003700 983 003704 984 003720 985 003726 986 003730 988 003735 991 003746 992 003753 993 003757 994 003764 995 003766 999 003767 1001 003772 1002 004004 1004 004007 1005 004011 1006 004012 1007 004022 1008 004025 1009 004027 1011 004066 1012 004071 1014 004111 1016 004112 1191 004131 1022 004133 1029 004135 1032 004142 1034 004143 1035 004153 1036 004201 1037 004212 1038 004217 1039 004227 1040 004242 1042 004252 1044 004263 1046 004301 1049 004320 1051 004322 1053 004324 1059 004330 1071 004331 1073 004332 1074 004343 1075 004371 1076 004402 1077 004407 1078 004411 1079 004415 1081 004417 1082 004431 1083 004445 1085 004446 1087 004450 1093 004453 1095 004455 1098 004517 1102 004540 1105 004603 1106 004605 1109 004626 1110 004630 1113 004654 1121 004655 1123 004657 1124 004661 1126 004667 1127 004673 1131 004736 1133 004740 1134 004763 1137 004770 1138 004772 1140 004775 1142 005003 1143 005010 1145 005014 1149 005057 1151 005061 1152 005104 1157 005111 1159 005113 1162 005115 1163 005120 1164 005134 1166 005137 1167 005144 1168 005175 1169 005226 1172 005343 1173 005346 1174 005425 1175 005430 1176 005431 1178 005511 1179 005516 1180 005522 1181 005526 1182 005532 1183 005533 1187 005534 1193 005535 395 005536 401 005540 403 005550 405 005560 407 005572 409 005573 415 005574 421 005602 423 005604 425 005620 426 005636 428 005637 430 005660 431 005672 432 005677 433 005701 434 005712 435 005716 436 005723 437 005725 438 005736 439 005746 440 005751 442 005753 444 005755 446 005760 447 005763 448 005765 451 005770 452 005774 454 006012 457 006017 461 006020 467 006022 469 006065 471 006072 472 006105 474 006111 477 006115 478 006125 479 006131 480 006134 482 006135 484 006141 486 006143 544 006144 550 006152 551 006160 552 006162 555 006166 556 006215 557 006217 560 006222 561 006234 562 006236 565 006241 567 006301 568 006310 569 006325 570 006327 572 006333 574 006336 575 006342 594 006346 601 006362 602 006370 603 006376 604 006400 607 006401 608 006412 610 006420 611 006422 612 006447 613 006451 616 006452 618 006455 619 006463 621 006466 641 006467 674 006503 677 006515 678 006522 680 006527 681 006537 682 006562 686 006571 688 006577 689 006611 690 006615 691 006622 692 006625 693 006632 695 006637 696 006644 697 006654 700 006667 701 006702 702 006710 703 006722 705 006725 707 006727 708 006730 710 006732 711 006741 713 006760 715 006763 716 006764 720 006774 723 007000 823 007003 830 007004 832 007041 834 007053 835 007105 837 007110 839 007113 840 007114 841 007144 842 007166 845 007170 846 007204 848 007216 850 007220 851 007225 852 007226 855 007243 1198 007244 1204 007252 1205 007254 1207 007255 1208 007270 1210 007276 1212 007307 1214 007313 1215 007326 1217 007333 1223 007370 1225 007405 1227 007422 1229 007424 1 26 007425 1 41 007427 1 42 007433 1 44 007506 1 47 007507 1 48 007513 1 50 007555 1 53 007556 1 56 007565 1 59 007641 ----------------------------------------------------------- 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