COMPILATION LISTING OF SEGMENT entries Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 12/01/86 1257.5 mst Mon Options: optimize map 1 /****^ ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1983 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* ************************************************************** */ 9 10 11 12 13 /****^ HISTORY COMMENTS: 14* 1) change(78-04-06,Palter), approve(), audit(), install(): 15* Written. 16* 2) change(79-02-02,MJordan), approve(), audit(), install(): 17* Extensively modified. 18* 3) change(81-01-12,Herbst), approve(81-01-12,MCR5511), audit(), install(): 19* Changed to format output based on line length. 20* 4) change(83-02-26,Pattin), approve(), audit(), install(): 21* Added extended object support to entries and files. 22* 5) change(84-01-12,Lippard), approve(84-03-06,MCR6781), audit(), install(): 23* Fixed output formatting, corrected to not return the same name twice, 24* and made command invocation print an error when no matches are found. 25* 6) change(84-09-11,Lippard), approve(84-09-18,MCR7010), audit(), install(): 26* Changed to properly return matching link and change -type to 27* -select_entry_type (-slet). 28* 7) change(85-02-12,Lippard), approve(), audit(), install(): 29* Changed to call Cleanup procedure when no entries are found. 30* 8) change(86-01-23,KFleming), approve(86-01-23,MCR7333), 31* audit(86-08-05,Lippard), install(86-08-06,MR12.0-1116): 32* Combined exists and entries into one module, since they have so much code 33* in common. Also added the object_segments/nonobject_segments keywords and 34* commands. 35* 9) change(86-11-10,GDixon), approve(86-11-24,MCR7579), 36* audit(86-11-17,Lippard), install(86-12-01,MR12.0-1229): 37* Added object_files/nonobject_files and object_msfs/nonobject_msfs 38* entrypoints and keywords for exists. 39* END HISTORY COMMENTS */ 40 41 42 /* format: style4,indattr */ 43 entries: procedure () options (variable); 44 45 /* This command/active-function returns the entrynames (or pathnames) which match a given 46* set of pathnames containing starnames, or if called as exists, returns true/false, 47* if there were any matching names found. 48**/ 49 50 /* Automatic */ 51 52 dcl active_function bit (1) aligned; 53 dcl archive_bc fixed binary (24); 54 dcl archive_ptr pointer; 55 dcl arg_count fixed binary; 56 dcl argument character (argument_lth) based (argument_ptr); 57 dcl argument_lth fixed binary (21); 58 dcl argument_ptr pointer; 59 dcl c_ptr pointer; 60 dcl char_168 character (168); 61 dcl chars_left fixed bin; 62 dcl chase bit (1); 63 dcl code fixed binary (35); 64 dcl command_name character (32) varying; 65 dcl component character (32); 66 dcl dir character (168) unaligned; 67 dcl dir_dname character (168) unaligned; 68 dcl dir_ename character (32) unaligned; 69 dcl ename character (32); 70 dcl entry_index fixed bin; 71 dcl entry_type_count fixed bin; 72 dcl entry_type_no fixed bin; 73 dcl entry_type_ptr pointer; 74 dcl error entry () options (variable) variable; 75 dcl first_arg fixed binary; 76 dcl found_something bit (1) aligned; 77 dcl found_uid bit (1) aligned; 78 dcl fs_type character (32); 79 dcl get_argument entry (fixed binary, pointer, fixed binary (21), fixed binary (35)) variable; 80 dcl got_key bit (1) aligned; 81 dcl idx fixed binary; 82 dcl inhibit_error bit (1) aligned; 83 dcl jdx fixed binary; 84 dcl kdx fixed binary; 85 dcl kname_index fixed binary; 86 dcl line_length fixed bin; 87 dcl link_array_ptr ptr; 88 dcl n_link_names fixed bin (21); 89 dcl n_uids fixed bin (21); 90 dcl old_ename character (32); 91 dcl return_absolute_pathnames bit (1) aligned; 92 dcl return_names bit (1) aligned; 93 dcl return_value character (return_value_lth) varying based (return_value_ptr); 94 dcl return_value_lth fixed binary (21); 95 dcl return_value_ptr pointer; 96 dcl seg_ptr pointer; 97 dcl select_entry_type bit (1) aligned; 98 dcl space character (2) varying; 99 dcl starname_count fixed binary; 100 dcl starnames (20) character (168); 101 dcl system_area area based (system_area_ptr); 102 dcl system_area_ptr ptr; 103 dcl table_index fixed binary; 104 dcl 1 type_info aligned like suffix_info; 105 dcl uid_array_ptr ptr; 106 dcl unique_id bit (36) aligned; 107 108 /* Based */ 109 110 dcl link_array (sys_info$max_seg_size / 8) char (32) aligned based (link_array_ptr); 111 dcl uid_array (sys_info$max_seg_size) bit (36) aligned based (uid_array_ptr); 112 dcl 1 entry_type aligned based (entry_type_ptr), 113 2 count fixed bin, 114 2 suffix (entry_type_count refer (entry_type.count)) char (32) unaligned; 115 116 /* External Data */ 117 118 dcl iox_$user_output ptr ext; 119 dcl active_fnc_err_ entry options (variable); 120 dcl archive_$get_component entry (ptr, fixed bin (24), char (*), ptr, fixed bin (24), fixed bin (35)); 121 dcl archive_$next_component entry (ptr, fixed bin (24), ptr, fixed bin (24), char (*), fixed bin (35)); 122 dcl com_err_ entry options (variable); 123 dcl check_star_name_$entry entry (char (*), fixed bin (35)); 124 dcl cu_$af_arg_ptr entry (fixed binary, pointer, fixed binary (21), fixed binary (35)); 125 dcl cu_$af_return_arg entry (fixed binary, pointer, fixed binary (21), fixed binary (35)); 126 dcl cu_$arg_count entry (fixed binary); 127 dcl cu_$arg_ptr entry (fixed binary, pointer, fixed binary (21), fixed binary (35)); 128 dcl error_table_$archive_fmt_err fixed bin (35) ext static; 129 dcl error_table_$archive_pathname fixed bin (35) ext static; 130 dcl error_table_$bad_arg fixed bin (35) ext static; 131 dcl error_table_$badopt fixed binary (35) external; 132 dcl error_table_$no_s_permission fixed binary (35) external; 133 dcl error_table_$noarg fixed binary (35) external; 134 dcl error_table_$no_dir fixed bin (35) ext static; 135 dcl error_table_$noentry fixed bin (35) ext static; 136 dcl error_table_$nomatch fixed binary (35) external; 137 dcl error_table_$not_act_fnc fixed binary (35) external; 138 dcl error_table_$not_archive fixed bin (35) ext static; 139 dcl error_table_$too_many_args fixed bin (35) ext static; 140 dcl expand_pathname_ entry (character (*), character (*), character (*), fixed binary (35)); 141 dcl expand_pathname_$add_suffix entry (char (*), char (*), char (*), char (*), fixed bin (35)); 142 dcl expand_pathname_$component entry (char (*), char (*), char (*), char (*), fixed bin (35)); 143 dcl fs_util_$get_type entry (char (*), char (*), char (*), fixed bin (35)); 144 dcl fs_util_$suffix_info_for_type entry (char (*), ptr, fixed bin (35)); 145 dcl get_line_length_$switch entry (ptr, fixed bin (35)) returns (fixed bin); 146 dcl get_system_free_area_ entry () returns (pointer); 147 dcl get_temp_segment_ entry (char (*), ptr, fixed bin (35)); 148 dcl hcs_$get_uid_file entry (char (*), char (*), bit (36) aligned, fixed bin (35)); 149 dcl hcs_$star_dir_list_ entry (char (*), char (*), fixed bin (3), ptr, fixed bin, fixed bin, ptr, ptr, fixed bin (35)); 150 dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), fixed bin (35)); 151 dcl initiate_file_ entry (char (*), char (*), bit (*), ptr, fixed bin (24), fixed bin (35)); 152 dcl ioa_ entry () options (variable); 153 dcl ioa_$nnl entry () options (variable); 154 dcl match_star_name_ entry (char (*), char (*), fixed bin (35)); 155 dcl object_lib_$initiate entry (char(*), char(*), char(*), bit(1), ptr, fixed bin(24), bit(1), fixed bin(35)); 156 dcl pathname_ entry (char(*), char(*)) returns(char(168)); 157 dcl release_temp_segment_ entry (char (*), ptr, fixed bin (35)); 158 dcl requote_string_ entry (character (*)) returns (character (*)); 159 dcl sys_info$max_seg_size fixed bin (35) ext static; 160 dcl terminate_file_ entry (ptr, fixed bin (24), bit (*), fixed bin (35)); 161 162 /* Conditions */ 163 164 dcl cleanup condition; 165 166 /* Builtins */ 167 168 dcl (addr, after, before, binary, divide, hbound, index, length, max, null, rtrim, substr) builtin; 169 170 /* 171* The following are manifest constants used in this procedure. The following descriptions should help in reading this 172* code: 173* 174* I_D_ D_E_S_C_R_I_P_T_I_O_N_ 175* 176* MSF the missing storage system entry type 177* XXXX_EI the "entry index" for the XXXX type 178* COMMAND_NAME the command name used in error messages 179* SELECT_SW the star_select_sw that is appropriate 180**/ 181 182 183 dcl MSF fixed bin static internal options (constant) init (3); 184 185 dcl SEGMENTS_EI static internal options (constant) init (1); 186 dcl DIRECTORIES_EI static internal options (constant) init (2); 187 dcl MSFS_EI static internal options (constant) init (3); 188 dcl LINKS_EI static internal options (constant) init (4); 189 dcl ENTRIES_EI static internal options (constant) init (5); 190 dcl BRANCHES_EI static internal options (constant) init (6); 191 dcl FILES_EI static internal options (constant) init (7); 192 dcl ZERO_SEGMENTS_EI static internal options (constant) init (8); 193 dcl MASTER_DIRECTORIES_EI static internal options (constant) init (9); 194 dcl NULL_LINKS_EI static internal options (constant) init (10); 195 dcl NONSEGMENTS_EI static internal options (constant) init (11); 196 dcl NONDIRECTORIES_EI static internal options (constant) init (12); 197 dcl NONMSFS_EI static internal options (constant) init (13); 198 dcl NONFILES_EI static internal options (constant) init (14); 199 dcl NONZERO_SEGMENTS_EI static internal options (constant) init (15); 200 dcl NONMASTER_DIRECTORIES_EI static internal options (constant) init (16); 201 dcl NONNULL_LINKS_EI static internal options (constant) init (17); 202 dcl NONZERO_FILES_EI static internal options (constant) init (18); 203 dcl NONZERO_MSFS_EI static internal options (constant) init (19); 204 dcl NONBRANCHES_EI static internal options (constant) init (20); 205 dcl NONLINKS_EI static internal options (constant) init (21); 206 dcl OBJECT_FILES_EI static internal options (constant) init (22); 207 dcl NONOBJECT_FILES_EI static internal options (constant) init (23); 208 dcl OBJECT_MSFS_EI static internal options (constant) init (24); 209 dcl NONOBJECT_MSFS_EI static internal options (constant) init (25); 210 dcl OBJECT_SEGMENTS_EI static internal options (constant) init (26); 211 dcl NONOBJECT_SEGMENTS_EI static internal options (constant) init (27); 212 /* 213*dcl COMPONENTS_EI static internal options (constant) init (28); 214* "exists components" has no corresponding 215* entrypoint in the entries family of commands */ 216 dcl EXISTS_EI static internal options (constant) init (29); 217 218 dcl COMMAND_NAME (29) char (24) static internal options (constant) init ( 219 "segments", 220 "directories", 221 "msfs", 222 "links", 223 "entries", 224 "branches", 225 "files", 226 "zero_segments", 227 "master_directories", 228 "null_links", 229 "nonsegments", 230 "nondirectories", 231 "nonmsfs", 232 "nonfiles", 233 "nonzero_segments", 234 "nonmaster_directories", 235 "nonnull_links", 236 "nonzero_files", 237 "nonzero_msfs", 238 "nonbranches", 239 "nonlinks", 240 "object_files", 241 "nonobject_files", 242 "object_msfs", 243 "nonobject_msfs", 244 "object_segments", 245 "nonobject_segments", 246 *, /* Place holder for 247* exists component */ 248 "exists"); 249 250 dcl SELECT_SW (29) fixed bin static internal options (constant) init ( 251 2, 2, 2, 1, 3, 2, 2, 2, 2, 5, 252 3, 3, 3, 3, 3, 2, 5, 2, 2, 1, 253 2, 2, 2, 2, 2, 2, 2, 2, *); 254 /* Note: the above SELECT_SW 255* value for EXISTS_EI is 256* not used. */ 257 dcl TRUE bit (1) internal static options (constant) initial ("1"b); 258 dcl FALSE bit (1) internal static options (constant) initial ("0"b); 259 dcl KEY_NAME (47) char (24) int static options (constant) init ( 260 "branch", "nonbranch", 261 "component", 262 "directory", "dir", "nondirectory", "nondir", 263 "entry", 264 "file", "nonfile", 265 "link", "nonlink", 266 "master_directory", "mdir", "nonmaster_directory", "nmdir", 267 "msf", "nonmsf", 268 "null_link", "nlink", "non_null_link", "nonnull_link", "nnlink", 269 "object_file", "obfile", "nonobject_file", "nobfile", 270 "object_msf", "obmsf", "nonobject_msf", "nobmsf", 271 "object_segment", "obseg", "nonobject_segment", "nobseg", 272 "segment", "seg", "nonsegment", "nonseg", 273 "nonzero_file", "nzfile", 274 "nonzero_msf", "nzmsf", 275 "zero_segment", "zseg", "nonzero_segment", "nzseg"); 276 dcl INDEX_TAB (47) fixed bin static internal options (constant) init ( 277 6, /* branch */ 20, /* nonbranch */ 278 28, /* component */ 279 2, 2, /* directory */ 12, 12, /* nondirectory */ 280 5, /* entry */ 281 7, /* file */ 14, /* nonfile */ 282 4, /* link */ 21, /* nonlink */ 283 9, 9, /* master_directory */ 16, 16, /* nonmaster_directory */ 284 3, /* msf */ 13, /* nonmsf */ 285 10, 10, /* null_link */ 17, 17, 17, /* non_null_link */ 286 22, 22, /* object_file */ 23, 23, /* nonobject_file */ 287 24, 24, /* object_msf */ 25, 25, /* nonobject_msf */ 288 26, 26, /* object_segment */ 27, 27, /* nonobject_segment */ 289 1, 1, /* segment */ 11, 11, /* nonsegment */ 290 18, 18, /* nonzero_file */ 291 19, 19, /* nonzero_msf */ 292 8, 8, /* zero_segment */ 15, 15); /* nonzero_segment */ 293 dcl CHASE_OK (29) bit (1) unaligned internal static options (constant) initial ( 294 "1"b, "1"b, "1"b, "0"b, "1"b, "1"b, "1"b, "1"b, "1"b, "0"b, 295 "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "0"b, "1"b, "1"b, "0"b, 296 "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b); 297 dcl ROOT (29) bit (1) unaligned internal static options (constant) initial ( 298 "0"b, "1"b, "0"b, "0"b, "1"b, "1"b, "0"b, "0"b, "1"b, "0"b, 299 "1"b, "0"b, "1"b, "1"b, "0"b, "0"b, "0"b, "0"b, "0"b, "0"b, 300 "1"b, "0"b, "1"b, "0"b, "1"b, "0"b, "1"b, "0"b, "0"b); 301 302 /* 303* 304* The following are all of the entries to this command/active function. At each entry the entry_index is set using 305* the constants declared above and control is passed to the common code below. 306* 307**/ 308 309 310 /* entries: proc() options (variable); */ 311 312 entry_index = ENTRIES_EI; 313 goto COMMON; 314 315 files: 316 entry () options (variable); 317 318 entry_index = FILES_EI; 319 go to COMMON; 320 321 segments: 322 segs: 323 entry () options (variable); 324 325 entry_index = SEGMENTS_EI; 326 go to COMMON; 327 328 directories: 329 dirs: 330 entry () options (variable); 331 332 entry_index = DIRECTORIES_EI; 333 go to COMMON; 334 335 links: 336 entry () options (variable); 337 338 entry_index = LINKS_EI; 339 go to COMMON; 340 341 branches: 342 entry () options (variable); 343 344 entry_index = BRANCHES_EI; 345 go to COMMON; 346 347 nonsegments: 348 nonsegs: 349 entry () options (variable); 350 351 entry_index = NONSEGMENTS_EI; 352 go to COMMON; 353 354 nondirectories: 355 nondirs: 356 entry () options (variable); 357 358 entry_index = NONDIRECTORIES_EI; 359 go to COMMON; 360 361 msfs: 362 entry options (variable); 363 364 entry_index = MSFS_EI; 365 goto COMMON; 366 367 zero_segments: 368 zsegs: 369 entry options (variable); 370 371 entry_index = ZERO_SEGMENTS_EI; 372 goto COMMON; 373 374 master_directories: 375 mdirs: 376 entry () options (variable); 377 378 entry_index = MASTER_DIRECTORIES_EI; 379 goto COMMON; 380 381 null_links: 382 nlinks: 383 entry () options (variable); 384 385 entry_index = NULL_LINKS_EI; 386 goto COMMON; 387 388 nonmsfs: 389 entry () options (variable); 390 391 entry_index = NONMSFS_EI; 392 goto COMMON; 393 394 nonfiles: 395 entry () options (variable); 396 397 entry_index = NONFILES_EI; 398 goto COMMON; 399 400 nonzero_segments: 401 nzsegs: 402 entry () options (variable); 403 404 entry_index = NONZERO_SEGMENTS_EI; 405 goto COMMON; 406 407 nonmaster_directories: 408 nmdirs: 409 entry () options (variable); 410 411 entry_index = NONMASTER_DIRECTORIES_EI; 412 goto COMMON; 413 414 nonnull_links: 415 nnlinks: 416 entry () options (variable); 417 418 entry_index = NONNULL_LINKS_EI; 419 goto COMMON; 420 421 nonzero_files: 422 nzfiles: 423 entry () options (variable); 424 425 entry_index = NONZERO_FILES_EI; 426 goto COMMON; 427 428 nonzero_msfs: 429 nzmsfs: 430 entry () options (variable); 431 432 entry_index = NONZERO_MSFS_EI; 433 goto COMMON; 434 435 object_files: 436 obfiles: 437 entry () options (variable); 438 439 entry_index = OBJECT_FILES_EI; 440 goto COMMON; 441 442 nonobject_files: 443 nobfiles: 444 entry () options (variable); 445 446 entry_index = NONOBJECT_FILES_EI; 447 goto COMMON; 448 449 object_msfs: 450 obmsfs: 451 entry () options (variable); 452 453 entry_index = OBJECT_MSFS_EI; 454 goto COMMON; 455 456 nonobject_msfs: 457 nobmsfs: 458 entry () options (variable); 459 460 entry_index = NONOBJECT_MSFS_EI; 461 goto COMMON; 462 463 object_segments: 464 obsegs: 465 entry () options (variable); 466 467 entry_index = OBJECT_SEGMENTS_EI; 468 goto COMMON; 469 470 nonobject_segments: 471 nobsegs: 472 entry () options (variable); 473 474 entry_index = NONOBJECT_SEGMENTS_EI; 475 goto COMMON; 476 477 nonbranches: 478 entry () options (variable); 479 480 entry_index = NONBRANCHES_EI; 481 goto COMMON; 482 483 nonlinks: 484 entry () options (variable); 485 486 entry_index = NONLINKS_EI; 487 goto COMMON; 488 489 exists: 490 entry () options (variable); 491 492 entry_index = EXISTS_EI; 493 goto COMMON; 494 495 /* 496* The following is code common to all entries. 497**/ 498 COMMON: 499 system_area_ptr = get_system_free_area_ (); 500 501 star_list_branch_ptr, 502 star_list_names_ptr = null (); 503 504 space = ""; /* no space before first pathname */ 505 506 entry_type_ptr, seg_ptr, archive_ptr, link_array_ptr, uid_array_ptr = null (); 507 508 on condition (cleanup) 509 call Cleanup (); 510 511 command_name = COMMAND_NAME (entry_index); /* get the proper command name */ 512 found_something = FALSE; 513 514 call cu_$af_return_arg (arg_count, return_value_ptr, return_value_lth, code); 515 516 if code = error_table_$not_act_fnc 517 then do; /* not an active function */ 518 active_function = FALSE; 519 call cu_$arg_count (arg_count); /* get proper argument count */ 520 get_argument = cu_$arg_ptr; 521 error = com_err_; 522 end; 523 524 else do; /* active function */ 525 active_function = TRUE; 526 get_argument = cu_$af_arg_ptr; 527 error = active_fnc_err_; 528 end; 529 530 if entry_index = EXISTS_EI then do; 531 return_names = FALSE; 532 first_arg = 2; 533 if arg_count < 1 then do; 534 USAGE: call error (error_table_$noarg, command_name, "Usage: ^[[^]^a key star_name(s) {-control_arg(s)} ^[]^]", active_function, command_name, active_function); 535 return; 536 end; 537 call get_argument (1, argument_ptr, argument_lth, code); 538 if code ^= 0 then goto ARGERR; 539 540 if argument = "argument" then do; 541 found_something = (arg_count > 1); 542 goto DONE; 543 end; 544 else if arg_count < 2 then goto USAGE; 545 546 got_key = FALSE; 547 do kname_index = 1 to hbound (KEY_NAME, 1) while (^got_key); 548 got_key = (argument = KEY_NAME (kname_index)); 549 end; 550 if ^got_key then do; 551 call error (0, command_name, "Invalid key ^a.", argument); 552 return; 553 end; 554 555 kname_index = kname_index - 1; 556 table_index = INDEX_TAB (kname_index); 557 end; 558 else do; 559 kname_index = 1; 560 return_names = TRUE; 561 first_arg = 1; 562 table_index = entry_index; 563 end; 564 565 star_select_sw = SELECT_SW (table_index); /* select switch for this entry */ 566 567 /* 568* Scan the command arguments to make sure we have at least one starname and that only valid control arguments are 569* specified by the user. 570**/ 571 starname_count = 0; 572 inhibit_error, chase, select_entry_type, return_absolute_pathnames = FALSE; 573 574 do idx = first_arg to arg_count; 575 call get_argument (idx, argument_ptr, argument_lth, code); 576 if code ^= 0 then do; 577 ARGERR: call error (code, command_name); 578 return; 579 end; 580 if substr (argument, 1, 1) = "-" then do; 581 if ((argument = "-absolute_pathname") | (argument = "-absp")) & return_names then return_absolute_pathnames = TRUE; 582 else if (argument = "-chase") & CHASE_OK (table_index) 583 then chase = TRUE; 584 else if (argument = "-no_chase") & CHASE_OK (table_index) 585 then chase = FALSE; 586 else if (argument = "-inhibit_error" | argument = "-ihe") 587 then inhibit_error = TRUE; 588 else if (argument = "-no_inhibit_error" | argument = "-nihe") 589 then inhibit_error = FALSE; 590 else if (table_index = ENTRIES_EI | table_index = FILES_EI | table_index = EXISTS_EI) & ((argument = "-select_entry_type") | (argument = "-slet")) then do; 591 if idx = arg_count then do; 592 call error (error_table_$noarg, command_name, "^a requires an entry type list.", argument); 593 return; 594 end; 595 idx = idx + 1; 596 call get_argument (idx, argument_ptr, argument_lth, code); 597 if code ^= 0 then goto ARGERR; 598 call process_entry_type_list (argument, entry_type_ptr, select_entry_type); 599 if ^select_entry_type then do; 600 call error (error_table_$bad_arg, command_name, "Invalid entry type selected. ^a", argument); 601 return; 602 end; 603 end; 604 else do; /* unknown control */ 605 call error (error_table_$badopt, command_name, "^a", argument); 606 return; 607 end; 608 end; 609 else do; 610 if starname_count = 20 then do; 611 call error (error_table_$too_many_args, command_name, "Only 20 starnames may be specified."); 612 goto ABORT; 613 end; 614 starname_count = starname_count + 1; 615 starnames (starname_count) = argument; 616 end; 617 end; 618 619 if starname_count = 0 then do; 620 call error (error_table_$noarg, command_name, 621 "^/ Usage: ^[[^;^]^a starnames {-control_arg^[s^]}^[]^;^]", 622 active_function, command_name, (CHASE_OK (table_index)), active_function); 623 goto ABORT; 624 end; 625 626 if star_select_sw = star_BRANCHES_ONLY & chase 627 then star_select_sw = star_ALL_ENTRIES; 628 629 /* 630* Now that we are all set, process the starnames in order. 631**/ 632 633 if return_names then do; 634 if ^active_function then line_length, chars_left = get_line_length_$switch (iox_$user_output, (0)); 635 636 call get_temp_segment_ ((command_name), link_array_ptr, code); 637 638 if code ^= 0 then do; 639 call error (code, command_name, "While getting temp segment."); 640 go to ABORT; 641 end; 642 643 n_link_names = 0; 644 645 call get_temp_segment_ ((command_name), uid_array_ptr, code); 646 647 if code ^= 0 then do; 648 call error (code, command_name, "While getting temp segment."); 649 go to ABORT; 650 end; 651 652 n_uids = 0; 653 end; 654 655 do idx = 1 to starname_count; 656 657 found_something = found_something | Process_Pathname (starnames (idx)); 658 if found_something & ^return_names then goto DONE; 659 end; 660 661 DONE: if ^return_names then do; 662 if found_something then do; 663 if active_function then return_value = "true"; 664 else call ioa_ ("true"); 665 end; 666 else do; 667 if active_function then return_value = "false"; 668 else call ioa_ ("false"); 669 end; 670 end; 671 else do; 672 if ^found_something then do; 673 if active_function then return_value = ""; 674 else call error ((0), command_name, "No entries found."); 675 end; 676 else if ^active_function then call ioa_ (""); 677 end; 678 679 ABORT: 680 call Cleanup (); 681 return; 682 683 /* This procedure processes one starname which has been specified in the command line. */ 684 Process_Pathname: 685 procedure (pathname) returns (bit (1)); 686 687 dcl pathname character (*) parameter; 688 dcl result bit (1) aligned; 689 dcl idx fixed binary; 690 691 result = FALSE; 692 693 call expand_pathname_$component (pathname, dir, ename, component, code); 694 if code ^= 0 then goto PATH_ERR; 695 696 if component = "" & KEY_NAME (kname_index) = "component" then do; 697 code = error_table_$not_archive; 698 goto PATH_ERR; 699 end; 700 701 if component ^= "" & KEY_NAME (kname_index) ^= "component" then do; 702 code = error_table_$archive_pathname; 703 goto PATH_ERR; 704 end; 705 706 if (dir = ">") & (ename = "") then do; 707 if table_index = ENTRIES_EI then do; /* entry */ 708 if select_entry_type then 709 if entry_type_selected (entry_type_ptr, FS_OBJECT_TYPE_DIRECTORY) then call Return_Entry (ename, FALSE); 710 else return (FALSE); 711 else call Return_Entry (ename, FALSE); 712 end; 713 else if ROOT (table_index) then call Return_Entry (ename, FALSE); 714 else return (FALSE); 715 end; 716 else do; 717 call check_star_name_$entry (ename, code); 718 if ^((code = 0) | (code = 1) | (code = 2)) then goto PATH_ERR; 719 if table_index ^= ENTRIES_EI then do; 720 call Get_Star_Names (); 721 if code ^= 0 & code ^= error_table_$no_s_permission then do; 722 if code = error_table_$noentry | code = error_table_$no_dir | code = error_table_$nomatch then return (FALSE); 723 else goto PATH_ERR; 724 end; 725 do idx = star_branch_count + star_link_count to 1 by -1 while (return_names | ^result); 726 if Process_A_Name (table_index, addr (star_dir_list_branch (idx))) 727 then call Return_Entry (star_list_names (star_dir_list_branch (idx).nindex), ((star_dir_list_branch (idx).type) = Link)); 728 end; 729 end; 730 else do; 731 result = Process_A_Name (table_index, null ()); 732 end; 733 end; 734 735 call free_star_structures (); 736 737 return (result); 738 739 PATH_ERR: 740 if (length (space) ^= 0) & ^active_function then call ioa_ (""); 741 if ^inhibit_error then do; 742 call error (code, command_name, "^a", pathname); 743 goto ABORT; 744 end; 745 else return (FALSE); 746 747 Return_Entry: procedure (ename, is_link); 748 749 dcl ename char (*) parameter; 750 dcl is_link bit (1) parameter; 751 dcl temp_string character (256) varying; 752 753 if return_names then do; 754 if is_link then do; 755 call expand_pathname_ (dir, dir_dname, dir_ename, (0)); 756 call hcs_$get_uid_file (dir_dname, dir_ename, unique_id, (0)); 757 found_uid = FALSE; 758 do jdx = 1 to n_uids while (^found_uid); 759 if unique_id = uid_array (jdx) then do; 760 found_uid = TRUE; 761 do kdx = 1 to n_link_names; 762 if link_array (kdx) = ename then return; 763 end; 764 n_link_names = n_link_names + 1; 765 if n_link_names > hbound (link_array, 1) then do; 766 call error (0, command_name, "Too many links for internal array."); 767 goto ABORT; 768 end; 769 link_array (n_link_names) = ename; 770 end; 771 end; 772 if ^found_uid then do; 773 n_uids = n_uids + 1; 774 if n_uids > hbound (uid_array, 1) then do; 775 call error (0, command_name, "Too many entries for internal array."); 776 goto ABORT; 777 end; 778 uid_array (n_uids) = unique_id; 779 n_link_names = n_link_names + 1; 780 if n_link_names > hbound (link_array, 1) then do; 781 call error (0, command_name, "Too many links for internal array."); 782 goto ABORT; 783 end; 784 link_array (n_link_names) = ename; 785 end; 786 end; 787 else do; 788 call hcs_$get_uid_file (dir, ename, unique_id, (0)); 789 do jdx = 1 to n_uids; 790 if unique_id = uid_array (jdx) then return; 791 end; 792 n_uids = n_uids + 1; 793 if n_uids > hbound (uid_array, 1) then do; 794 call error (0, command_name, "Too many entries for internal array."); 795 goto ABORT; 796 end; 797 uid_array (n_uids) = unique_id; 798 end; 799 if return_absolute_pathnames then if dir = ">" then temp_string = ">"; 800 else temp_string = rtrim (dir) || ">"; 801 else temp_string = ""; 802 803 temp_string = temp_string || rtrim (ename); 804 805 if active_function then do; 806 return_value = return_value || space; 807 return_value = return_value || requote_string_ ((temp_string)); 808 end; 809 else if chars_left > length (temp_string) + length (space) then do; 810 call ioa_$nnl (space || "^a", temp_string); 811 chars_left = chars_left - length (temp_string) - length (space); 812 end; 813 else do; 814 call ioa_$nnl ("^/^a", temp_string); 815 chars_left = max (0, line_length - length (temp_string)); 816 end; 817 818 if active_function then space = " "; 819 else space = " "; 820 821 end; 822 823 result = TRUE; 824 825 end Return_Entry; 826 827 Process_A_Name: procedure (table_index, entry_ptr) returns (bit (1)); 828 829 dcl table_index fixed binary parameter; 830 dcl entry_ptr pointer parameter; 831 dcl 1 entry aligned like star_dir_list_branch based (entry_ptr); 832 dcl type fixed bin (2); 833 dcl bit_count fixed bin (24); 834 dcl null_link bit (1); 835 dcl idx fixed binary; 836 837 if table_index ^= ENTRIES_EI then do; 838 type = entry.type; 839 bit_count = entry.bit_count; 840 if type = Link then do; 841 if ^chase then do; 842 call hcs_$status_minf (dir, star_list_names (entry.nindex), 1, (0), (0), code); /* Check target by chasing link */ 843 null_link = ^(code = 0); 844 end; 845 else call hcs_$status_minf (dir, star_list_names (entry.nindex), 1, type, bit_count, code); 846 end; 847 if type = Directory & bit_count > 0 then type = MSF; 848 end; 849 850 go to PROCESS (table_index); 851 852 PROCESS (1): /* segment */ 853 return ((type = Segment)); 854 855 PROCESS (2): /* directory */ 856 return ((type = Directory & bit_count = 0)); 857 858 PROCESS (3): /* MSF */ 859 return ((type = MSF)); 860 861 PROCESS (4): /* link */ 862 PROCESS (20): 863 return ((type = Link)); 864 865 PROCESS (5): /* entry = segment, MSF, directory, or link */ 866 star_select_sw = star_ALL_ENTRIES; 867 if select_entry_type then do; 868 do entry_type_no = 1 to entry_type.count; 869 old_ename = ename; 870 if substr (entry_type.suffix (entry_type_no), 1, 1) = "-" then ; /* standard non-suffixed entry */ 871 else call expand_pathname_$add_suffix (old_ename, entry_type.suffix (entry_type_no), char_168, ename, code); 872 call Get_Star_Names; 873 do idx = star_branch_count + star_link_count to 1 by -1; 874 if star_dir_list_branch (idx).type = Link then do; 875 if ^chase then if entry_type_selected (entry_type_ptr, FS_OBJECT_TYPE_LINK) 876 then call Return_Entry (star_list_names (star_dir_list_branch (idx).nindex), TRUE); 877 else ; 878 else do; 879 call fs_util_$get_type (dir, star_list_names (star_dir_list_branch (idx).nindex), fs_type, code); 880 if fs_type = entry_type.suffix (entry_type_no) 881 then call Return_Entry (star_list_names (star_dir_list_branch (idx).nindex), FALSE); 882 end; 883 end; 884 else do; 885 call fs_util_$get_type (dir, star_list_names (star_dir_list_branch (idx).nindex), fs_type, code); 886 if fs_type = entry_type.suffix (entry_type_no) 887 then call Return_Entry (star_list_names (star_dir_list_branch (idx).nindex), FALSE); 888 end; 889 end; 890 if star_list_names_ptr ^= null () then do; 891 free star_list_names_ptr -> star_list_names; 892 free star_list_branch_ptr -> star_dir_list_branch; 893 end; 894 ename = old_ename; 895 end; 896 end; 897 else do; 898 call Get_Star_Names; 899 if ^return_names 900 then if star_branch_count + star_link_count > 0 then return (TRUE); 901 else ; 902 else do idx = star_branch_count + star_link_count to 1 by -1; 903 call Return_Entry (star_list_names (star_dir_list_branch (idx).nindex), (star_dir_list_branch (idx).type = Link)); 904 end; 905 end; 906 return (result); 907 908 PROCESS (6): /* branch = segment, MSF, or directory */ 909 PROCESS (21): 910 return ((type ^= Link)); 911 912 PROCESS (7): /* file = MSF or segment */ 913 return ((type = Segment) | (type = MSF)); 914 915 PROCESS (8): /* zero-length segment */ 916 return ((type = Segment) & (bit_count = 0)); 917 918 PROCESS (9): /* master directory */ 919 return ((entry.master_dir)); 920 921 PROCESS (10): /* null link */ 922 return ((type = Link) & null_link); 923 924 PROCESS (11): /* nonsegment */ 925 return ((type ^= Segment)); 926 927 PROCESS (12): /* nondirectory */ 928 return (^((type = Directory) & (bit_count = 0))); 929 930 PROCESS (13): /* nonMSF */ 931 return (^(type = MSF)); 932 933 PROCESS (14): /* nonfile */ 934 return (^((type = Segment) | (type = MSF))); 935 936 PROCESS (15): /* nonzero segment */ 937 return ((type = Segment) & (bit_count ^= 0)); 938 939 PROCESS (16): /* nonmaster directory */ 940 return ((type = Directory) & ^entry.master_dir); 941 942 PROCESS (17): /* nonnull link */ 943 return ((type = Link) & ^(null_link)); 944 945 PROCESS (18): /* nonzero file */ 946 if (type = Segment) then 947 return (bit_count ^= 0); 948 else if (type = MSF) then 949 return (Msf_Nonzero (dir, star_list_names (entry.nindex), bit_count)); 950 else return (FALSE); 951 952 PROCESS (19): /* nonzero MSF */ 953 if (type = MSF) then 954 return (Msf_Nonzero (dir, star_list_names (entry.nindex), bit_count)); 955 else return (FALSE); 956 957 PROCESS (22): /* object file */ 958 if (type = Segment | type = MSF) then 959 return (Check_Object_Segment (dir, star_list_names (entry.nindex))); 960 else return (FALSE); 961 962 PROCESS (23): /* nonobject file */ 963 if (type = Segment | type = MSF) then 964 return (^Check_Object_Segment (dir, star_list_names (entry.nindex))); 965 else return (FALSE); 966 967 PROCESS (24): /* object msf */ 968 if type = MSF then 969 return (Check_Object_Segment (dir, star_list_names (entry.nindex))); 970 else return (FALSE); 971 972 PROCESS (25): /* nonobject msf */ 973 if type = MSF then 974 return (^Check_Object_Segment (dir, star_list_names (entry.nindex))); 975 else return (FALSE); 976 977 PROCESS (26): /* object segment */ 978 if type = Segment then 979 return (Check_Object_Segment (dir, star_list_names (entry.nindex))); 980 else return (FALSE); 981 982 PROCESS (27): /* nonobject segment */ 983 if type = Segment then 984 return (^Check_Object_Segment (dir, star_list_names (entry.nindex))); 985 else return (FALSE); 986 987 PROCESS (28): /* exists component */ 988 call initiate_file_ (dir, star_list_names (entry.nindex), R_ACCESS, archive_ptr, archive_bc, code); 989 if archive_ptr = null () then goto PATH_ERR; 990 991 call check_star_name_$entry (component, code); 992 if code = 1 | code = 2 then return (process_component_starname (archive_ptr, archive_bc, component)); 993 else do; 994 call archive_$get_component (archive_ptr, archive_bc, component, (null ()), (0), code); 995 if code = 0 then return (TRUE); 996 else if (code = error_table_$not_archive) | (code = error_table_$archive_fmt_err) then goto PATH_ERR; 997 else return (FALSE); 998 end; 999 1000 end Process_A_Name; 1001 1002 /* This procedure will call hcs_$star_dir_list_ on ename. */ 1003 Get_Star_Names: procedure; 1004 1005 star_branch_count, star_link_count = 0; 1006 call hcs_$star_dir_list_ (dir, ename, star_select_sw, system_area_ptr, star_branch_count, star_link_count, star_list_branch_ptr, star_list_names_ptr, code); 1007 1008 end Get_Star_Names; 1009 1010 Check_Object_Segment: procedure (dir, ename) returns (bit (1)); 1011 1012 dcl (dir, ename) character (*) parameter; 1013 1014 seg_ptr = null (); 1015 call object_lib_$initiate (dir, ename, "", "1"b, seg_ptr, (0), (""b), code); 1016 call terminate_file_ (seg_ptr, (0), TERM_FILE_TERM, (0)); 1017 return (code = 0); 1018 1019 end Check_Object_Segment; 1020 1021 1022 Msf_Nonzero: procedure (dir, ename, msf_indicator) returns (bit(1)); 1023 1024 dcl (dir, ename) character (*) parameter; 1025 dcl msf_indicator fixed bin(24) parameter; /* MSF comp count */ 1026 dcl code fixed bin(35); 1027 dcl comp fixed bin; 1028 dcl comp_bit_count fixed bin(24); 1029 dcl msf_bit_count fixed bin(35); 1030 dcl msf_dir char(168); 1031 1032 msf_dir = pathname_ (dir, ename); 1033 msf_bit_count = 0; 1034 do comp = 0 to msf_indicator - 1; 1035 call hcs_$status_minf (msf_dir, ltrim(char(comp)), 1036 1, (0), comp_bit_count, code); 1037 if code = 0 then 1038 msf_bit_count = msf_bit_count + comp_bit_count; 1039 end; 1040 return (msf_bit_count > 0); 1041 1042 end Msf_Nonzero; 1043 1044 /* The process_component_starname function determines if any components in the specified archive 1045* match the component starname given. If so, TRUE is returned. */ 1046 process_component_starname: proc (archive_ptr, archive_bc, c_starname) returns (bit (1)); 1047 1048 dcl archive_bc fixed bin (24), 1049 archive_ptr ptr, 1050 c_name char (32), 1051 c_starname char (32); 1052 1053 c_ptr = null (); 1054 do while ("1"b); 1055 call archive_$next_component (archive_ptr, archive_bc, c_ptr, (0), c_name, code); 1056 if code ^= 0 then return (FALSE); 1057 if c_ptr = null () then return ("0"b); /* no components remaining in the archive */ 1058 call match_star_name_ (c_name, c_starname, code); 1059 if code = 0 then return ("1"b); 1060 end; 1061 1062 end process_component_starname; 1063 1064 end Process_Pathname; 1065 1066 /* This entry releases the temp segment and frees the star structures. */ 1067 Cleanup: procedure (); 1068 1069 if link_array_ptr ^= null () 1070 then call release_temp_segment_ ((command_name), link_array_ptr, (0)); 1071 if uid_array_ptr ^= null () 1072 then call release_temp_segment_ ((command_name), uid_array_ptr, (0)); 1073 call free_star_structures (); 1074 if seg_ptr ^= null () then call terminate_file_ (seg_ptr, (0), TERM_FILE_TERM, (0)); 1075 if archive_ptr ^= null () then call terminate_file_ (seg_ptr, (0), TERM_FILE_TERM, (0)); 1076 if entry_type_ptr ^= null () then free entry_type in (system_area); 1077 1078 end Cleanup; 1079 1080 /* This procedure is called to clean up allocated storage. */ 1081 free_star_structures: 1082 procedure (); 1083 1084 if star_list_names_ptr ^= null () 1085 then free star_list_names; 1086 1087 if star_list_branch_ptr ^= null () 1088 then free star_dir_list_branch; 1089 1090 star_list_branch_ptr, 1091 star_list_names_ptr = null (); 1092 1093 end free_star_structures; 1094 1095 /* The process_entry_type_list procedure parses a comma delimited list of both 1096* standard and extended entry types into an array of type names. */ 1097 process_entry_type_list: procedure (entry_type_list, entry_type_struct_ptr, limit_entry_selections); 1098 1099 dcl entry_type_list char (*) parameter; 1100 dcl entry_type_struct_ptr pointer parameter; 1101 dcl limit_entry_selections 1102 bit (1) aligned parameter; 1103 dcl types_len fixed bin (24); 1104 dcl types_ptr pointer; 1105 dcl types char (types_len) based (types_ptr); 1106 dcl entry_type_no fixed bin; 1107 dcl this_type char (32); 1108 1109 1110 /* copy entry_type_list into "real" storage */ 1111 1112 types_ptr = null (); 1113 on cleanup begin; 1114 if types_ptr ^= null () then free types in (system_area); 1115 end; 1116 1117 types_len = length (entry_type_list); 1118 allocate types set (types_ptr) in (system_area); 1119 types = entry_type_list; 1120 1121 /* to start off, get a count of the number of types in the string */ 1122 1123 do entry_type_count = 1 1124 repeat (entry_type_count + 1) 1125 while (index (types, ",") > 0); 1126 types = after (types, ","); 1127 end; 1128 1129 /* allocate the entry_type structure, to be used later in this command */ 1130 1131 allocate entry_type 1132 set (entry_type_struct_ptr) 1133 in (system_area); 1134 1135 entry_type_struct_ptr -> entry_type.suffix (*) = ""; 1136 1137 /* for each potential entry type, validate it and add it to the structure */ 1138 1139 types = entry_type_list; 1140 type_info.version = SUFFIX_INFO_VERSION_1; 1141 entry_type_no = 1; 1142 do while (types ^= ""); 1143 this_type = before (types, ","); 1144 if substr (this_type, 1, 1) ^= "-" then do; 1145 if this_type = "link" then this_type = FS_OBJECT_TYPE_LINK; 1146 else if this_type = "segment" then this_type = FS_OBJECT_TYPE_SEGMENT; 1147 else if this_type = "directory" then this_type = FS_OBJECT_TYPE_DIRECTORY; 1148 else if this_type = "multisegment_file" then this_type = FS_OBJECT_TYPE_MSF; 1149 else if this_type = "data_management_file" then this_type = FS_OBJECT_TYPE_DM_FILE; 1150 entry_type_struct_ptr -> entry_type.suffix (entry_type_no) = this_type; 1151 if this_type = FS_OBJECT_TYPE_LINK then entry_type_no = entry_type_no + 1; 1152 /* fs_util_ does not support links */ 1153 else do; 1154 call fs_util_$suffix_info_for_type (this_type, addr (type_info), code); 1155 if code = 0 then entry_type_no = entry_type_no + 1; /* complaining here is also */ 1156 end; 1157 end; /* a viable alternative. */ 1158 types = after (types, ","); 1159 end; 1160 1161 /* free the types variable and set the limit_entry_selections flag */ 1162 1163 free types_ptr -> types 1164 in (system_area); 1165 1166 entry_type_struct_ptr -> entry_type.count = entry_type_no - 1; 1167 if entry_type_struct_ptr -> entry_type.count > 0 then limit_entry_selections = "1"b; 1168 else limit_entry_selections = "0"b; 1169 1170 return; 1171 1172 end process_entry_type_list; 1173 1174 1175 /* The entry_type_selected function searches the entry_type structure for a given 1176* type. 1177**/ 1178 1179 entry_type_selected: proc (entry_type_struct_ptr, fs_type) returns (bit (1) aligned); 1180 1181 1182 dcl entry_type_struct_ptr pointer parameter; 1183 dcl fs_type char (32) parameter; 1184 dcl entry_type_no fixed bin; 1185 1186 do entry_type_no = 1 to entry_type_struct_ptr -> entry_type.count; 1187 if entry_type_struct_ptr -> entry_type.suffix (entry_type_no) = fs_type then return ("1"b); 1188 end; 1189 return ("0"b); 1190 1191 end entry_type_selected; 1192 1 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 1 2* 1 3* Values for the "access mode" argument so often used in hardcore 1 4* James R. Davis 26 Jan 81 MCR 4844 1 5* Added constants for SM access 4/28/82 Jay Pattin 1 6* Added text strings 03/19/85 Chris Jones 1 7**/ 1 8 1 9 1 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 1 11 dcl ( 1 12 N_ACCESS init ("000"b), 1 13 R_ACCESS init ("100"b), 1 14 E_ACCESS init ("010"b), 1 15 W_ACCESS init ("001"b), 1 16 RE_ACCESS init ("110"b), 1 17 REW_ACCESS init ("111"b), 1 18 RW_ACCESS init ("101"b), 1 19 S_ACCESS init ("100"b), 1 20 M_ACCESS init ("010"b), 1 21 A_ACCESS init ("001"b), 1 22 SA_ACCESS init ("101"b), 1 23 SM_ACCESS init ("110"b), 1 24 SMA_ACCESS init ("111"b) 1 25 ) bit (3) internal static options (constant); 1 26 1 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 1 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 1 29 1 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 1 31 static options (constant); 1 32 1 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 1 34 static options (constant); 1 35 1 36 dcl ( 1 37 N_ACCESS_BIN init (00000b), 1 38 R_ACCESS_BIN init (01000b), 1 39 E_ACCESS_BIN init (00100b), 1 40 W_ACCESS_BIN init (00010b), 1 41 RW_ACCESS_BIN init (01010b), 1 42 RE_ACCESS_BIN init (01100b), 1 43 REW_ACCESS_BIN init (01110b), 1 44 S_ACCESS_BIN init (01000b), 1 45 M_ACCESS_BIN init (00010b), 1 46 A_ACCESS_BIN init (00001b), 1 47 SA_ACCESS_BIN init (01001b), 1 48 SM_ACCESS_BIN init (01010b), 1 49 SMA_ACCESS_BIN init (01011b) 1 50 ) fixed bin (5) internal static options (constant); 1 51 1 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 1193 1194 2 1 /* BEGIN INCLUDE FILE: copy_flags.incl.pl1 */ 2 2 2 3 /* Flags for attributes that should/may be copied by the copy_ subroutine. This include file is 2 4* required by suffix_info.incl.pl1 and copy_options.incl.pl1 2 5* 2 6* Jay Pattin 6/23/83 */ 2 7 2 8 declare 1 copy_flags aligned based, /* ON means that this attribute may be copied by copy_ */ 2 9 2 names bit (1) unaligned, 2 10 2 acl bit (1) unaligned, 2 11 2 ring_brackets bit (1) unaligned, 2 12 2 max_length bit (1) unaligned, 2 13 2 copy_switch bit (1) unaligned, 2 14 2 safety_switch bit (1) unaligned, 2 15 2 dumper_switches bit (1) unaligned, 2 16 2 entry_bound bit (1) unaligned, /* only for vanilla object segments */ 2 17 2 extend bit (1) unaligned, /* copy_ may append to end of existing object */ 2 18 2 update bit (1) unaligned, /* copy_ may replace contents of existing object */ 2 19 2 mbz bit (26) unaligned; 2 20 2 21 /* END INCLUDE FILE: copy_flags.incl.pl1 */ 1195 1196 3 1 /* Begin include file file_system_operations.incl.pl1 BIM 8309 */ 3 2 /* format: style3,indcomtxt,idind30 */ 3 3 3 4 /**** Operation names to be passed to fs_util_$make_entry */ 3 5 3 6 declare ( 3 7 FS_ADD_ACL_ENTRIES init ("add_acl_entries"), 3 8 FS_ADD_EXTENDED_ACL_ENTRIES init ("add_extended_acl_entries"), 3 9 FS_CHNAME_FILE init ("chname_file"), 3 10 FS_COPY init ("copy"), 3 11 FS_DELENTRY_FILE init ("delentry_file"), 3 12 FS_DELETE_ACL_ENTRIES init ("delete_acl_entries"), 3 13 FS_GET_BIT_COUNT init ("get_bit_count"), 3 14 FS_GET_MAX_LENGTH init ("get_max_length"), 3 15 FS_GET_RING_BRACKETS init ("get_ring_brackets"), 3 16 FS_GET_SWITCH init ("get_switch"), 3 17 FS_GET_USER_ACCESS_MODES init ("get_user_access_modes"), 3 18 FS_LIST_ACL init ("list_acl"), 3 19 FS_LIST_EXTENDED_ACL init ("list_extended_acl"), 3 20 FS_LIST_SWITCHES init ("list_switches"), 3 21 FS_REPLACE_ACL init ("replace_acl"), 3 22 FS_REPLACE_EXTENDED_ACL init ("replace_extended_acl"), 3 23 FS_SET_BIT_COUNT init ("set_bit_count"), 3 24 FS_SET_MAX_LENGTH init ("set_max_length"), 3 25 FS_SET_RING_BRACKETS init ("set_ring_brackets"), 3 26 FS_SET_SWITCH init ("set_switch"), 3 27 FS_SUFFIX_INFO init ("suffix_info"), 3 28 FS_VALIDATE init ("validate") 3 29 ) char (64) int static options (constant); 3 30 3 31 /* End include file file_system_operations.incl.pl1 */ 1197 1198 4 1 /* BEGIN INCLUDE FILE ... object_info.incl.pl1 4 2*coded February 8, 1972 by Michael J. Spier */ 4 3 /* modified May 26, 1972 by M. Weaver */ 4 4 /* modified 15 April, 1975 by M. Weaver */ 4 5 4 6 declare 1 object_info aligned based, /* structure containing object info based, returned by object_info_ */ 4 7 2 version_number fixed bin, /* version number of current structure format (=2) */ 4 8 2 textp pointer, /* pointer to beginning of text section */ 4 9 2 defp pointer, /* pointer to beginning of definition section */ 4 10 2 linkp pointer, /* pointer to beginning of linkage section */ 4 11 2 statp pointer, /* pointer to beginning of static section */ 4 12 2 symbp pointer, /* pointer to beginning of symbol section */ 4 13 2 bmapp pointer, /* pointer to beginning of break map (may be null) */ 4 14 2 tlng fixed bin, /* length in words of text section */ 4 15 2 dlng fixed bin, /* length in words of definition section */ 4 16 2 llng fixed bin, /* length in words of linkage section */ 4 17 2 ilng fixed bin, /* length in words of static section */ 4 18 2 slng fixed bin, /* length in words of symbol section */ 4 19 2 blng fixed bin, /* length in words of break map */ 4 20 2 format, /* word containing bit flags about object type */ 4 21 3 old_format bit(1) unaligned, /* on if segment isn't in new format, i.e. has old style object map */ 4 22 3 bound bit(1) unaligned, /* on if segment is bound */ 4 23 3 relocatable bit(1) unaligned, /* on if seg has relocation info in its first symbol block */ 4 24 3 procedure bit(1) unaligned, /* on if segment is an executable object program */ 4 25 3 standard bit(1) unaligned, /* on if seg is in standard format (more than just standard map) */ 4 26 3 gate bit(1) unaligned, /* on if segment is a gate */ 4 27 3 separate_static bit(1) unaligned, /* on if static not in linkage */ 4 28 3 links_in_text bit(1) unaligned, /* on if there are threaded links in text */ 4 29 3 perprocess_static bit (1) unaligned, /* on if static is not to be per run unit */ 4 30 3 pad bit(27) unaligned, 4 31 2 entry_bound fixed bin, /* entry bound if segment is a gate */ 4 32 2 textlinkp pointer, /* ptr to first link in text */ 4 33 4 34 /* LIMIT OF BRIEF STRUCTURE */ 4 35 4 36 2 compiler char(8) aligned, /* name of processor which generated segment */ 4 37 2 compile_time fixed bin(71), /* clock reading of date/time object was generated */ 4 38 2 userid char(32) aligned, /* standard Multics id of creator of object segment */ 4 39 2 cvers aligned, /* generator version name in printable char string form */ 4 40 3 offset bit(18) unaligned, /* offset of name in words relative to base of symbol section */ 4 41 3 length bit(18) unaligned, /* length of name in characters */ 4 42 2 comment aligned, /* printable comment concerning generator or generation of segment */ 4 43 3 offset bit(18) unaligned, /* offset of comment in words relative to base of symbol section */ 4 44 3 length bit(18) unaligned, /* length of comment in characters */ 4 45 2 source_map fixed bin, /* offset, relative to base of symbol section, of source map structure */ 4 46 4 47 /* LIMIT OF DISPLAY STRUCTURE */ 4 48 4 49 2 rel_text pointer, /* pointer to text section relocation info */ 4 50 2 rel_def pointer, /* pointer to definition section relocation info */ 4 51 2 rel_link pointer, /* pointer to linkage section relocation info */ 4 52 2 rel_static pointer, /* pointer to static section relocation info */ 4 53 2 rel_symbol pointer, /* pointer to symbol section relocation info */ 4 54 2 text_boundary fixed bin, /* specifies mod of text section base boundary */ 4 55 2 static_boundary fixed bin, /* specifies mod of internal static base boundary */ 4 56 /* currently not used by system */ 4 57 2 default_truncate fixed bin, /* offset rel to symbp for binder to automatically trunc. symb sect. */ 4 58 2 optional_truncate fixed bin; /* offset rel to symbp for binder to optionally trunc. symb sect. */ 4 59 4 60 declare object_info_version_2 fixed bin int static init(2); 4 61 4 62 /* END INCLUDE FILE ... object_info.incl.pl1 */ 1199 1200 5 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 5 2 5 3 /* This include file contains structures for the hcs_$star_, 5 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 5 5* 5 6* Written 23 October 1978 by Monte Davidoff. 5 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 5 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 5 9**/ 5 10 5 11 /* automatic */ 5 12 5 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 5 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 5 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 5 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 5 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 5 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 5 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 5 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 5 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 5 22 5 23 /* based */ 5 24 5 25 /* hcs_$star_ entry structure */ 5 26 5 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 5 28 2 type fixed binary (2) unsigned unaligned, 5 29 /* storage system type */ 5 30 2 nnames fixed binary (16) unsigned unaligned, 5 31 /* number of names of entry that match star_name */ 5 32 2 nindex fixed binary (18) unsigned unaligned; 5 33 /* index of first name in star_names */ 5 34 5 35 /* hcs_$star_ name structure */ 5 36 5 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 5 38 5 39 /* hcs_$star_list_ branch structure */ 5 40 5 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 5 42 2 type fixed binary (2) unsigned unaligned, 5 43 /* storage system type */ 5 44 2 nnames fixed binary (16) unsigned unaligned, 5 45 /* number of names of entry that match star_name */ 5 46 2 nindex fixed binary (18) unsigned unaligned, 5 47 /* index of first name in star_list_names */ 5 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 5 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 5 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 5 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 5 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 5 53 2 pad bit (7) unaligned, 5 54 2 records fixed binary (18) unsigned unaligned; 5 55 /* records used by branch */ 5 56 5 57 /* hcs_$star_dir_list_ branch structure */ 5 58 5 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 5 60 2 type fixed binary (2) unsigned unaligned, 5 61 /* storage system type */ 5 62 2 nnames fixed binary (16) unsigned unaligned, 5 63 /* number of names of entry that match star_name */ 5 64 2 nindex fixed binary (18) unsigned unaligned, 5 65 /* index of first name in star_list_names */ 5 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 5 67 2 pad bit (36) unaligned, 5 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 5 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 5 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 5 71 2 bit_count fixed binary (24) unaligned; 5 72 /* bit count of the branch */ 5 73 5 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 5 75 5 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 5 77 2 type fixed binary (2) unsigned unaligned, 5 78 /* storage system type */ 5 79 2 nnames fixed binary (16) unsigned unaligned, 5 80 /* number of names of entry that match star_name */ 5 81 2 nindex fixed binary (18) unsigned unaligned, 5 82 /* index of first name in star_list_names */ 5 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 5 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 5 85 2 pathname_len fixed binary (18) unsigned unaligned, 5 86 /* length of the pathname of the link */ 5 87 2 pathname_index fixed binary (18) unsigned unaligned; 5 88 /* index of start of pathname in star_list_names */ 5 89 5 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 5 91 5 92 declare star_list_names char (32) based (star_list_names_ptr) 5 93 dimension (star_links (star_branch_count + star_link_count).nindex 5 94 + star_links (star_branch_count + star_link_count).nnames 5 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 5 96 * binary ( 5 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 5 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 5 99 5 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 5 101 5 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 5 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 5 104 5 105 /* internal static */ 5 106 5 107 /* star_select_sw values */ 5 108 5 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 5 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 5 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 5 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 5 113 fixed binary (3) internal static options (constant) initial (5); 5 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 5 115 fixed binary (3) internal static options (constant) initial (7); 5 116 5 117 /* storage system types */ 5 118 5 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 5 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 5 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 5 122 5 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 1201 1202 6 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 6 2 6 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 6 4 6 5 /* This include file contains branch and link structures returned by 6 6* hcs_$status_ and hcs_$status_long. */ 6 7 6 8 dcl 1 status_branch aligned based (status_ptr), 6 9 2 short aligned, 6 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 6 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 6 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 6 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 6 14 3 dtu bit (36) unaligned, /* date/time last used */ 6 15 3 mode bit (5) unaligned, /* caller's effective access */ 6 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 6 17 3 pad1 bit (8) unaligned, 6 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 6 19 6 20 /* Limit of information returned by hcs_$status_ */ 6 21 6 22 2 long aligned, 6 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 6 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 6 25 3 lvid bit (36) unaligned, /* logical volume ID */ 6 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 6 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 6 28 3 pad2 bit (8) unaligned, 6 29 3 copy_switch bit (1) unaligned, /* copy switch */ 6 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 6 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 6 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 6 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 6 34 3 pad3 bit (5) unaligned, 6 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 6 36 3 uid bit (36) unaligned; /* unique ID */ 6 37 6 38 dcl 1 status_link aligned based (status_ptr), 6 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 6 40 2 nnames fixed bin (16) unaligned unsigned, 6 41 2 names_relp bit (18) unaligned, 6 42 2 dtem bit (36) unaligned, 6 43 2 dtd bit (36) unaligned, 6 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 6 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 6 46 6 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 6 48 based (pointer (status_area_ptr, status_branch.names_relp)), 6 49 /* array of names returned */ 6 50 status_pathname character (status_link.pathname_length) aligned 6 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 6 52 /* link target path */ 6 53 status_area_ptr pointer, 6 54 status_ptr pointer; 6 55 6 56 dcl (Link initial (0), 6 57 Segment initial (1), 6 58 Directory initial (2)) fixed bin internal static options (constant); 6 59 /* values for type fields declared above */ 6 60 6 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 1203 1204 7 1 /* BEGIN INCLUDE FILE: suffix_info.incl.pl1 */ 7 2 /* format: style3,indcomtxt,idind30 */ 7 3 /**** Jay Pattin 2/13/83 7 4* M. Pandolf 1984.11.30 to set FS_OBJECT_TYPE_MSF to -multisegment_file 7 5* 7 6* The include file copy_flags.incl.pl1 must be included in any program using this include file. 7 7* 7 8* This structure is returned by the suffix_XXX_$suffix_info subroutines */ 7 9 7 10 declare suffix_info_ptr ptr; 7 11 7 12 declare 1 suffix_info aligned based (suffix_info_ptr), 7 13 2 version char (8), 7 14 2 type char (32) unaligned, 7 15 2 type_name char (32) unaligned, /* Singular name of the object type, e.g. "mailbox" */ 7 16 2 plural_name char (32) unaligned, /* Plural of above, e.g. "mailboxes" */ 7 17 2 flags unaligned, 7 18 3 standard_object bit (1) unaligned, /* ON if not an extended object (no suffix_XXX_) */ 7 19 3 extended_acl bit (1) unaligned, /* ON if uses extended ACLs, off if regular ACLs */ 7 20 3 has_switches bit (1) unaligned, /* ON if supports switches for objects */ 7 21 3 mbz1 bit (33) unaligned, 7 22 2 modes char (36), /* correspondence between bits and chars for extended modes */ 7 23 2 max_mode_len fixed bin, /* maximum number of modes on an object */ 7 24 2 num_ring_brackets fixed bin, /* number of ring brackets on object */ 7 25 2 copy_flags like copy_flags, /* See copy_flags.incl.pl1 */ 7 26 2 info_pathname char (168) unaligned; 7 27 /* pathname of info segment containing more info */ 7 28 7 29 declare SUFFIX_INFO_VERSION_1 char (8) static options (constant) init ("SUFFIX01"); 7 30 7 31 /* This information is returned by the suffix_XXX_$list_switches subroutines */ 7 32 7 33 declare switch_list_ptr ptr, 7 34 alloc_switch_count fixed bin, 7 35 alloc_switch_name_count fixed bin; 7 36 7 37 declare 1 switch_list aligned based (switch_list_ptr), 7 38 2 version char (8), /* SWITCH_LIST_VERSION_1 */ 7 39 2 switch_count fixed bin, /* total number of switches */ 7 40 2 switch_name_count fixed bin, /* total number of names */ 7 41 2 switches (alloc_switch_count refer (switch_list.switch_count)), 7 42 3 name_index fixed bin, /* index of first name for this switch */ 7 43 3 name_count fixed bin, /* number of names for this switch */ 7 44 3 default_value bit (1) aligned, /* default setting for this switch */ 7 45 3 mbz1 bit (36) aligned, /* reserved for future use */ 7 46 2 names (alloc_switch_name_count refer (switch_list.switch_name_count)) char (32); 7 47 7 48 declare SWITCH_LIST_VERSION_1 char (8) static options (constant) init ("SWLIST01"); 7 49 7 50 declare ( 7 51 FS_OBJECT_TYPE_SEGMENT init ("-segment"), 7 52 FS_OBJECT_TYPE_DIRECTORY init ("-directory"), 7 53 FS_OBJECT_TYPE_MSF init ("-multisegment_file"), 7 54 FS_OBJECT_TYPE_DM_FILE init ("-dm_file"), 7 55 FS_OBJECT_TYPE_LINK init ("-link") 7 56 ) char (32) unaligned int static options (constant); 7 57 7 58 /* END INCLUDE FILE: suffix_info.incl.pl1 */ 1205 1206 8 1 /* BEGIN INCLUDE FILE ... terminate_file.incl.pl1 */ 8 2 /* format: style2,^inddcls,idind32 */ 8 3 8 4 declare 1 terminate_file_switches based, 8 5 2 truncate bit (1) unaligned, 8 6 2 set_bc bit (1) unaligned, 8 7 2 terminate bit (1) unaligned, 8 8 2 force_write bit (1) unaligned, 8 9 2 delete bit (1) unaligned; 8 10 8 11 declare TERM_FILE_TRUNC bit (1) internal static options (constant) initial ("1"b); 8 12 declare TERM_FILE_BC bit (2) internal static options (constant) initial ("01"b); 8 13 declare TERM_FILE_TRUNC_BC bit (2) internal static options (constant) initial ("11"b); 8 14 declare TERM_FILE_TERM bit (3) internal static options (constant) initial ("001"b); 8 15 declare TERM_FILE_TRUNC_BC_TERM bit (3) internal static options (constant) initial ("111"b); 8 16 declare TERM_FILE_FORCE_WRITE bit (4) internal static options (constant) initial ("0001"b); 8 17 declare TERM_FILE_DELETE bit (5) internal static options (constant) initial ("00001"b); 8 18 8 19 /* END INCLUDE FILE ... terminate_file.incl.pl1 */ 1207 1208 1209 end entries; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 12/01/86 1257.5 entries.pl1 >spec>install>1229>entries.pl1 1193 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 1195 2 10/14/83 1606.7 copy_flags.incl.pl1 >ldd>include>copy_flags.incl.pl1 1197 3 10/14/83 1606.7 file_system_operations.incl.pl1 >ldd>include>file_system_operations.incl.pl1 1199 4 08/05/77 1022.5 object_info.incl.pl1 >ldd>include>object_info.incl.pl1 1201 5 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 1203 6 11/22/82 0955.7 status_structures.incl.pl1 >ldd>include>status_structures.incl.pl1 1205 7 03/05/85 1807.3 suffix_info.incl.pl1 >ldd>include>suffix_info.incl.pl1 1207 8 04/06/83 1239.4 terminate_file.incl.pl1 >ldd>include>terminate_file.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. BRANCHES_EI constant fixed bin(17,0) initial dcl 190 ref 344 CHASE_OK 000111 constant bit(1) initial array unaligned dcl 293 ref 582 584 620 COMMAND_NAME 000660 constant char(24) initial array unaligned dcl 218 ref 511 DIRECTORIES_EI constant fixed bin(17,0) initial dcl 186 ref 332 Directory constant fixed bin(17,0) initial dcl 6-56 ref 847 855 927 939 ENTRIES_EI constant fixed bin(17,0) initial dcl 189 ref 312 590 707 719 837 EXISTS_EI constant fixed bin(17,0) initial dcl 216 ref 492 530 590 FALSE 001172 constant bit(1) initial unaligned dcl 258 set ref 512 518 531 546 572 584 588 691 708* 710 711* 713* 714 722 745 757 880* 886* 950 955 960 965 970 975 980 985 997 1056 FILES_EI constant fixed bin(17,0) initial dcl 191 ref 318 590 FS_OBJECT_TYPE_DIRECTORY 000065 constant char(32) initial unaligned dcl 7-50 set ref 708* 1147 FS_OBJECT_TYPE_DM_FILE 000045 constant char(32) initial unaligned dcl 7-50 ref 1149 FS_OBJECT_TYPE_LINK 000035 constant char(32) initial unaligned dcl 7-50 set ref 875* 1145 1151 FS_OBJECT_TYPE_MSF 000055 constant char(32) initial unaligned dcl 7-50 ref 1148 FS_OBJECT_TYPE_SEGMENT 000075 constant char(32) initial unaligned dcl 7-50 ref 1146 INDEX_TAB 000112 constant fixed bin(17,0) initial array dcl 276 ref 556 KEY_NAME 000171 constant char(24) initial array unaligned dcl 259 ref 547 548 696 701 LINKS_EI constant fixed bin(17,0) initial dcl 188 ref 338 Link constant fixed bin(17,0) initial dcl 6-56 ref 726 840 861 874 903 908 921 942 MASTER_DIRECTORIES_EI constant fixed bin(17,0) initial dcl 193 ref 378 MSF constant fixed bin(17,0) initial dcl 183 ref 847 858 912 930 933 948 952 957 962 967 972 MSFS_EI constant fixed bin(17,0) initial dcl 187 ref 364 NONBRANCHES_EI constant fixed bin(17,0) initial dcl 204 ref 480 NONDIRECTORIES_EI constant fixed bin(17,0) initial dcl 196 ref 358 NONFILES_EI constant fixed bin(17,0) initial dcl 198 ref 397 NONLINKS_EI constant fixed bin(17,0) initial dcl 205 ref 486 NONMASTER_DIRECTORIES_EI constant fixed bin(17,0) initial dcl 200 ref 411 NONMSFS_EI constant fixed bin(17,0) initial dcl 197 ref 391 NONNULL_LINKS_EI constant fixed bin(17,0) initial dcl 201 ref 418 NONOBJECT_FILES_EI constant fixed bin(17,0) initial dcl 207 ref 446 NONOBJECT_MSFS_EI constant fixed bin(17,0) initial dcl 209 ref 460 NONOBJECT_SEGMENTS_EI constant fixed bin(17,0) initial dcl 211 ref 474 NONSEGMENTS_EI constant fixed bin(17,0) initial dcl 195 ref 351 NONZERO_FILES_EI constant fixed bin(17,0) initial dcl 202 ref 425 NONZERO_MSFS_EI constant fixed bin(17,0) initial dcl 203 ref 432 NONZERO_SEGMENTS_EI constant fixed bin(17,0) initial dcl 199 ref 404 NULL_LINKS_EI constant fixed bin(17,0) initial dcl 194 ref 385 OBJECT_FILES_EI constant fixed bin(17,0) initial dcl 206 ref 439 OBJECT_MSFS_EI constant fixed bin(17,0) initial dcl 208 ref 453 OBJECT_SEGMENTS_EI constant fixed bin(17,0) initial dcl 210 ref 467 ROOT 000110 constant bit(1) initial array unaligned dcl 297 ref 713 R_ACCESS 001137 constant bit(3) initial unaligned dcl 1-11 set ref 987* SEGMENTS_EI constant fixed bin(17,0) initial dcl 185 ref 325 SELECT_SW 000623 constant fixed bin(17,0) initial array dcl 250 ref 565 SUFFIX_INFO_VERSION_1 000106 constant char(8) initial unaligned dcl 7-29 ref 1140 Segment constant fixed bin(17,0) initial dcl 6-56 ref 852 912 915 924 933 936 945 957 962 977 982 TERM_FILE_TERM 000034 constant bit(3) initial unaligned dcl 8-14 set ref 1016* 1074* 1075* TRUE 001137 constant bit(1) initial unaligned dcl 257 set ref 525 560 581 582 586 760 823 875* 899 995 ZERO_SEGMENTS_EI constant fixed bin(17,0) initial dcl 192 ref 371 active_fnc_err_ 000012 constant entry external dcl 119 ref 527 active_function 000100 automatic bit(1) dcl 52 set ref 518* 525* 534* 534* 620* 620* 634 663 667 673 676 739 805 818 addr builtin function dcl 168 ref 726 726 1154 1154 after builtin function dcl 168 ref 1126 1158 archive_$get_component 000014 constant entry external dcl 120 ref 994 archive_$next_component 000016 constant entry external dcl 121 ref 1055 archive_bc 000101 automatic fixed bin(24,0) dcl 53 in procedure "entries" set ref 987* 992* 994* archive_bc parameter fixed bin(24,0) dcl 1048 in procedure "process_component_starname" set ref 1046 1055* archive_ptr 000102 automatic pointer dcl 54 in procedure "entries" set ref 506* 987* 989 992* 994* 1075 archive_ptr parameter pointer dcl 1048 in procedure "process_component_starname" set ref 1046 1055* arg_count 000104 automatic fixed bin(17,0) dcl 55 set ref 514* 519* 533 541 544 574 591 argument based char unaligned dcl 56 set ref 540 548 551* 580 581 581 582 584 586 586 588 588 590 590 592* 598* 600* 605* 615 argument_lth 000105 automatic fixed bin(21,0) dcl 57 set ref 537* 540 548 551 551 575* 580 581 581 582 584 586 586 588 588 590 590 592 592 596* 598 598 600 600 605 605 615 argument_ptr 000106 automatic pointer dcl 58 set ref 537* 540 548 551 575* 580 581 581 582 584 586 586 588 588 590 590 592 596* 598 600 605 615 before builtin function dcl 168 ref 1143 binary builtin function dcl 168 ref 891 1084 bit_count 002463 automatic fixed bin(24,0) dcl 833 in procedure "Process_A_Name" set ref 839* 845* 847 855 915 927 936 945 948* 952* bit_count 3(11) based fixed bin(24,0) level 2 in structure "entry" packed unaligned dcl 831 in procedure "Process_A_Name" ref 839 c_name 002600 automatic char(32) unaligned dcl 1048 set ref 1055* 1058* c_ptr 000110 automatic pointer dcl 59 set ref 1053* 1055* 1057 c_starname parameter char(32) unaligned dcl 1048 set ref 1046 1058* char_168 000112 automatic char(168) unaligned dcl 60 set ref 871* chars_left 000164 automatic fixed bin(17,0) dcl 61 set ref 634* 809 811* 811 815* chase 000165 automatic bit(1) unaligned dcl 62 set ref 572* 582* 584* 626 841 875 check_star_name_$entry 000022 constant entry external dcl 123 ref 717 991 cleanup 002310 stack reference condition dcl 164 ref 508 1113 code 000166 automatic fixed bin(35,0) dcl 63 in procedure "entries" set ref 514* 516 537* 538 575* 576 577* 596* 597 636* 638 639* 645* 647 648* 693* 694 697* 702* 717* 718 718 718 721 721 722 722 722 742* 842* 843 845* 871* 879* 885* 987* 991* 992 992 994* 995 996 996 1006* 1015* 1017 1055* 1056 1058* 1059 1154* 1155 code 002512 automatic fixed bin(35,0) dcl 1026 in procedure "Msf_Nonzero" set ref 1035* 1037 com_err_ 000020 constant entry external dcl 122 ref 521 command_name 000167 automatic varying char(32) dcl 64 set ref 511* 534* 534* 551* 577* 592* 600* 605* 611* 620* 620* 636 639* 645 648* 674* 742* 766* 775* 781* 794* 1069 1071 comp 002513 automatic fixed bin(17,0) dcl 1027 set ref 1034* 1035 1035* comp_bit_count 002514 automatic fixed bin(24,0) dcl 1028 set ref 1035* 1037 component 000200 automatic char(32) unaligned dcl 65 set ref 693* 696 701 991* 992* 994* copy_flags based structure level 1 dcl 2-8 count based fixed bin(17,0) level 2 dcl 112 set ref 868 1076 1131* 1135 1166* 1167 1186 cu_$af_arg_ptr 000024 constant entry external dcl 124 ref 526 cu_$af_return_arg 000026 constant entry external dcl 125 ref 514 cu_$arg_count 000030 constant entry external dcl 126 ref 519 cu_$arg_ptr 000032 constant entry external dcl 127 ref 520 dir parameter char unaligned dcl 1012 in procedure "Check_Object_Segment" set ref 1010 1015* dir parameter char unaligned dcl 1024 in procedure "Msf_Nonzero" set ref 1022 1032* dir 000210 automatic char(168) unaligned dcl 66 in procedure "entries" set ref 693* 706 755* 788* 799 800 842* 845* 879* 885* 948* 952* 957* 962* 967* 972* 977* 982* 987* 1006* dir_dname 000262 automatic char(168) unaligned dcl 67 set ref 755* 756* dir_ename 000334 automatic char(32) unaligned dcl 68 set ref 755* 756* divide builtin function dcl 168 ref 891 1084 ename parameter char unaligned dcl 1024 in procedure "Msf_Nonzero" set ref 1022 1032* ename parameter char unaligned dcl 749 in procedure "Return_Entry" set ref 747 762 769 784 788* 803 ename parameter char unaligned dcl 1012 in procedure "Check_Object_Segment" set ref 1010 1015* ename 000344 automatic char(32) unaligned dcl 69 in procedure "entries" set ref 693* 706 708* 711* 713* 717* 869 871* 894* 1006* entry based structure level 1 dcl 831 entry_index 000354 automatic fixed bin(17,0) dcl 70 set ref 312* 318* 325* 332* 338* 344* 351* 358* 364* 371* 378* 385* 391* 397* 404* 411* 418* 425* 432* 439* 446* 453* 460* 467* 474* 480* 486* 492* 511 530 562 entry_ptr parameter pointer dcl 830 ref 827 838 839 842 845 918 939 948 952 957 962 967 972 977 982 987 entry_type based structure level 1 dcl 112 set ref 1076 1131 entry_type_count 000355 automatic fixed bin(17,0) dcl 71 set ref 1123* 1127* 1131 1131 entry_type_list parameter char unaligned dcl 1099 ref 1097 1117 1119 1139 entry_type_no 000104 automatic fixed bin(17,0) dcl 1106 in procedure "process_entry_type_list" set ref 1141* 1150 1151* 1151 1155* 1155 1166 entry_type_no 002616 automatic fixed bin(17,0) dcl 1184 in procedure "entry_type_selected" set ref 1186* 1187* entry_type_no 000356 automatic fixed bin(17,0) dcl 72 in procedure "entries" set ref 868* 870 871 880 886* entry_type_ptr 000360 automatic pointer dcl 73 set ref 506* 598* 708* 868 870 871 875* 880 886 1076 1076 entry_type_struct_ptr parameter pointer dcl 1182 in procedure "entry_type_selected" ref 1179 1186 1187 entry_type_struct_ptr parameter pointer dcl 1100 in procedure "process_entry_type_list" set ref 1097 1131* 1135 1150 1166 1167 error 000362 automatic entry variable dcl 74 set ref 521* 527* 534 551 577 592 600 605 611 620 639 648 674 742 766 775 781 794 error_table_$archive_fmt_err 000034 external static fixed bin(35,0) dcl 128 ref 996 error_table_$archive_pathname 000036 external static fixed bin(35,0) dcl 129 ref 702 error_table_$bad_arg 000040 external static fixed bin(35,0) dcl 130 set ref 600* error_table_$badopt 000042 external static fixed bin(35,0) dcl 131 set ref 605* error_table_$no_dir 000050 external static fixed bin(35,0) dcl 134 ref 722 error_table_$no_s_permission 000044 external static fixed bin(35,0) dcl 132 ref 721 error_table_$noarg 000046 external static fixed bin(35,0) dcl 133 set ref 534* 592* 620* error_table_$noentry 000052 external static fixed bin(35,0) dcl 135 ref 722 error_table_$nomatch 000054 external static fixed bin(35,0) dcl 136 ref 722 error_table_$not_act_fnc 000056 external static fixed bin(35,0) dcl 137 ref 516 error_table_$not_archive 000060 external static fixed bin(35,0) dcl 138 ref 697 996 error_table_$too_many_args 000062 external static fixed bin(35,0) dcl 139 set ref 611* expand_pathname_ 000064 constant entry external dcl 140 ref 755 expand_pathname_$add_suffix 000066 constant entry external dcl 141 ref 871 expand_pathname_$component 000070 constant entry external dcl 142 ref 693 first_arg 000366 automatic fixed bin(17,0) dcl 75 set ref 532* 561* 574 found_something 000367 automatic bit(1) dcl 76 set ref 512* 541* 657* 657 658 662 672 found_uid 000370 automatic bit(1) dcl 77 set ref 757* 758 760* 772 fs_type parameter char(32) unaligned dcl 1183 in procedure "entry_type_selected" ref 1179 1187 fs_type 000371 automatic char(32) unaligned dcl 78 in procedure "entries" set ref 879* 880 885* 886 fs_util_$get_type 000072 constant entry external dcl 143 ref 879 885 fs_util_$suffix_info_for_type 000074 constant entry external dcl 144 ref 1154 get_argument 000402 automatic entry variable dcl 79 set ref 520* 526* 537 575 596 get_line_length_$switch 000076 constant entry external dcl 145 ref 634 get_system_free_area_ 000100 constant entry external dcl 146 ref 498 get_temp_segment_ 000102 constant entry external dcl 147 ref 636 645 got_key 000406 automatic bit(1) dcl 80 set ref 546* 547 548* 550 hbound builtin function dcl 168 ref 547 765 774 780 793 hcs_$get_uid_file 000104 constant entry external dcl 148 ref 756 788 hcs_$star_dir_list_ 000106 constant entry external dcl 149 ref 1006 hcs_$status_minf 000110 constant entry external dcl 150 ref 842 845 1035 idx 002465 automatic fixed bin(17,0) dcl 835 in procedure "Process_A_Name" set ref 873* 874 875 879 880 885 886* 902* 903 903* idx 000407 automatic fixed bin(17,0) dcl 81 in procedure "entries" set ref 574* 575* 591 595* 595 596* 655* 657* idx 002341 automatic fixed bin(17,0) dcl 689 in procedure "Process_Pathname" set ref 725* 726 726 726 726* index builtin function dcl 168 ref 1123 inhibit_error 000410 automatic bit(1) dcl 82 set ref 572* 586* 588* 741 initiate_file_ 000112 constant entry external dcl 151 ref 987 ioa_ 000114 constant entry external dcl 152 ref 664 668 676 739 ioa_$nnl 000116 constant entry external dcl 153 ref 810 814 iox_$user_output 000010 external static pointer dcl 118 set ref 634* is_link parameter bit(1) unaligned dcl 750 ref 747 754 jdx 000411 automatic fixed bin(17,0) dcl 83 set ref 758* 759* 789* 790* kdx 000412 automatic fixed bin(17,0) dcl 84 set ref 761* 762* kname_index 000413 automatic fixed bin(17,0) dcl 85 set ref 547* 548* 555* 555 556 559* 696 701 length builtin function dcl 168 ref 739 809 809 811 811 815 1117 limit_entry_selections parameter bit(1) dcl 1101 set ref 1097 1167* 1168* line_length 000414 automatic fixed bin(17,0) dcl 86 set ref 634* 815 link_array based char(32) array dcl 110 set ref 762 765 769* 780 784* link_array_ptr 000416 automatic pointer dcl 87 set ref 506* 636* 762 765 769 780 784 1069 1069* master_dir 3(10) based bit(1) level 2 packed unaligned dcl 831 ref 918 939 match_star_name_ 000120 constant entry external dcl 154 ref 1058 max builtin function dcl 168 ref 815 msf_bit_count 002515 automatic fixed bin(35,0) dcl 1029 set ref 1033* 1037* 1037 1040 msf_dir 002516 automatic char(168) unaligned dcl 1030 set ref 1032* 1035* msf_indicator parameter fixed bin(24,0) dcl 1025 ref 1022 1034 n_link_names 000420 automatic fixed bin(21,0) dcl 88 set ref 643* 761 764* 764 765 769 779* 779 780 784 n_uids 000421 automatic fixed bin(21,0) dcl 89 set ref 652* 758 773* 773 774 778 789 792* 792 793 797 nindex 0(18) based fixed bin(18,0) array level 2 in structure "star_links" packed unsigned unaligned dcl 5-76 in procedure "entries" ref 891 1084 nindex 0(18) based fixed bin(18,0) array level 2 in structure "star_dir_list_branch" packed unsigned unaligned dcl 5-59 in procedure "entries" set ref 726 875 879 880 885 886 903 nindex 0(18) based fixed bin(18,0) level 2 in structure "entry" packed unsigned unaligned dcl 831 in procedure "Process_A_Name" ref 842 845 948 952 957 962 967 972 977 982 987 nnames 0(02) based fixed bin(16,0) array level 2 packed unsigned unaligned dcl 5-76 ref 891 1084 null builtin function dcl 168 ref 501 506 731 731 890 989 994 1014 1053 1057 1069 1071 1074 1075 1076 1084 1087 1090 1112 1114 null_link 002464 automatic bit(1) unaligned dcl 834 set ref 843* 921 942 object_lib_$initiate 000122 constant entry external dcl 155 ref 1015 old_ename 000422 automatic char(32) unaligned dcl 90 set ref 869* 871* 894 pathname parameter char unaligned dcl 687 set ref 684 693* 742* pathname_ 000124 constant entry external dcl 156 ref 1032 pathname_len 3 based fixed bin(18,0) array level 2 packed unsigned unaligned dcl 5-76 ref 891 1084 release_temp_segment_ 000126 constant entry external dcl 157 ref 1069 1071 requote_string_ 000130 constant entry external dcl 158 ref 807 result 002340 automatic bit(1) dcl 688 set ref 691* 725 731* 737 823* 906 return_absolute_pathnames 000432 automatic bit(1) dcl 91 set ref 572* 581* 799 return_names 000433 automatic bit(1) dcl 92 set ref 531* 560* 581 633 658 661 725 753 899 return_value based varying char dcl 93 set ref 663* 667* 673* 806* 806 807* 807 return_value_lth 000434 automatic fixed bin(21,0) dcl 94 set ref 514* 663 667 673 806 807 return_value_ptr 000436 automatic pointer dcl 95 set ref 514* 663 667 673 806 806 807 807 rtrim builtin function dcl 168 ref 800 803 seg_ptr 000440 automatic pointer dcl 96 set ref 506* 1014* 1015* 1016* 1074 1074* 1075* select_entry_type 000442 automatic bit(1) dcl 97 set ref 572* 598* 599 708 867 space 000444 automatic varying char(2) dcl 98 set ref 504* 739 806 809 810 811 818* 819* star_ALL_ENTRIES constant fixed bin(2,0) initial dcl 5-111 ref 626 865 star_BRANCHES_ONLY constant fixed bin(2,0) initial dcl 5-110 ref 626 star_LINK constant fixed bin(2,0) initial unsigned dcl 5-119 ref 891 1084 star_LINKS_ONLY_WITH_LINK_PATHS constant fixed bin(3,0) initial dcl 5-112 ref 891 1084 star_branch_count 002316 automatic fixed bin(17,0) dcl 5-13 set ref 725 873 891 891 891 891 892 899 902 1005* 1006* 1084 1084 1084 1084 1087 star_dir_list_branch based structure array level 1 dcl 5-59 set ref 726 726 892 1087 star_link_count 002322 automatic fixed bin(17,0) dcl 5-17 set ref 725 873 891 891 891 891 892 899 902 1005* 1006* 1084 1084 1084 1084 1087 star_links based structure array level 1 dcl 5-76 star_list_branch_ptr 002320 automatic pointer dcl 5-16 set ref 501* 726 726 726 726 874 875 879 880 885 886 891 891 891 891 892 903 903 1006* 1084 1084 1084 1084 1087 1087 1090* star_list_names based char(32) array unaligned dcl 5-92 set ref 726* 842* 845* 875* 879* 880* 885* 886* 891 903* 948* 952* 957* 962* 967* 972* 977* 982* 987* 1084 star_list_names_ptr 002324 automatic pointer dcl 5-20 set ref 501* 726 842 845 875 879 880 885 886 890 891 903 948 952 957 962 967 972 977 982 987 1006* 1084 1084 1090* star_select_sw 002326 automatic fixed bin(3,0) dcl 5-21 set ref 565* 626 626* 865* 891 1006* 1084 starname_count 000446 automatic fixed bin(17,0) dcl 99 set ref 571* 610 614* 614 615 619 655 starnames 000447 automatic char(168) array unaligned dcl 100 set ref 615* 657* substr builtin function dcl 168 ref 580 870 1144 suffix 1 based char(32) array level 2 packed unaligned dcl 112 set ref 870 871* 880 886 1135* 1150* 1187 suffix_info based structure level 1 dcl 7-12 sys_info$max_seg_size 000132 external static fixed bin(35,0) dcl 159 ref 765 774 780 793 system_area based area(1024) dcl 101 ref 1076 1114 1118 1131 1163 system_area_ptr 002160 automatic pointer dcl 102 set ref 498* 1006* 1076 1114 1118 1131 1163 table_index parameter fixed bin(17,0) dcl 829 in procedure "Process_A_Name" ref 827 837 850 table_index 002162 automatic fixed bin(17,0) dcl 103 in procedure "entries" set ref 556* 562* 565 582 584 590 590 590 620 707 713 719 726* 731* temp_string 002350 automatic varying char(256) dcl 751 set ref 799* 800* 801* 803* 803 807 809 810* 811 814* 815 terminate_file_ 000134 constant entry external dcl 160 ref 1016 1074 1075 this_type 000105 automatic char(32) unaligned dcl 1107 set ref 1143* 1144 1145 1145* 1146 1146* 1147 1147* 1148 1148* 1149 1149* 1150 1151 1154* type 002462 automatic fixed bin(2,0) dcl 832 in procedure "Process_A_Name" set ref 838* 840 845* 847 847* 852 855 858 861 908 912 912 915 921 924 927 930 933 933 936 939 942 945 948 952 957 957 962 962 967 972 977 982 type based fixed bin(2,0) level 2 in structure "entry" packed unsigned unaligned dcl 831 in procedure "Process_A_Name" ref 838 type based fixed bin(2,0) array level 2 in structure "star_links" packed unsigned unaligned dcl 5-76 in procedure "entries" ref 891 1084 type based fixed bin(2,0) array level 2 in structure "star_dir_list_branch" packed unsigned unaligned dcl 5-59 in procedure "entries" set ref 726 874 903 type_info 002163 automatic structure level 1 dcl 104 set ref 1154 1154 types based char unaligned dcl 1105 set ref 1114 1118 1119* 1123 1126* 1126 1139* 1142 1143 1158* 1158 1163 types_len 000100 automatic fixed bin(24,0) dcl 1103 set ref 1114 1114 1117* 1118 1118 1119 1123 1126 1126 1139 1142 1143 1158 1158 1163 1163 types_ptr 000102 automatic pointer dcl 1104 set ref 1112* 1114 1114 1118* 1119 1123 1126 1126 1139 1142 1143 1158 1158 1163 uid_array based bit(36) array dcl 111 set ref 759 774 778* 790 793 797* uid_array_ptr 002304 automatic pointer dcl 105 set ref 506* 645* 759 774 778 790 793 797 1071 1071* unique_id 002306 automatic bit(36) dcl 106 set ref 756* 759 778 788* 790 797 version 002163 automatic char(8) level 2 dcl 104 set ref 1140* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-33 E_ACCESS internal static bit(3) initial unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 FS_ADD_ACL_ENTRIES internal static char(64) initial unaligned dcl 3-6 FS_ADD_EXTENDED_ACL_ENTRIES internal static char(64) initial unaligned dcl 3-6 FS_CHNAME_FILE internal static char(64) initial unaligned dcl 3-6 FS_COPY internal static char(64) initial unaligned dcl 3-6 FS_DELENTRY_FILE internal static char(64) initial unaligned dcl 3-6 FS_DELETE_ACL_ENTRIES internal static char(64) initial unaligned dcl 3-6 FS_GET_BIT_COUNT internal static char(64) initial unaligned dcl 3-6 FS_GET_MAX_LENGTH internal static char(64) initial unaligned dcl 3-6 FS_GET_RING_BRACKETS internal static char(64) initial unaligned dcl 3-6 FS_GET_SWITCH internal static char(64) initial unaligned dcl 3-6 FS_GET_USER_ACCESS_MODES internal static char(64) initial unaligned dcl 3-6 FS_LIST_ACL internal static char(64) initial unaligned dcl 3-6 FS_LIST_EXTENDED_ACL internal static char(64) initial unaligned dcl 3-6 FS_LIST_SWITCHES internal static char(64) initial unaligned dcl 3-6 FS_REPLACE_ACL internal static char(64) initial unaligned dcl 3-6 FS_REPLACE_EXTENDED_ACL internal static char(64) initial unaligned dcl 3-6 FS_SET_BIT_COUNT internal static char(64) initial unaligned dcl 3-6 FS_SET_MAX_LENGTH internal static char(64) initial unaligned dcl 3-6 FS_SET_RING_BRACKETS internal static char(64) initial unaligned dcl 3-6 FS_SET_SWITCH internal static char(64) initial unaligned dcl 3-6 FS_SUFFIX_INFO internal static char(64) initial unaligned dcl 3-6 FS_VALIDATE internal static char(64) initial unaligned dcl 3-6 M_ACCESS internal static bit(3) initial unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 N_ACCESS internal static bit(3) initial unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 REW_ACCESS internal static bit(3) initial unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS internal static bit(3) initial unaligned dcl 1-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SWITCH_LIST_VERSION_1 internal static char(8) initial unaligned dcl 7-48 S_ACCESS internal static bit(3) initial unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 TERM_FILE_BC internal static bit(2) initial unaligned dcl 8-12 TERM_FILE_DELETE internal static bit(5) initial unaligned dcl 8-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial unaligned dcl 8-16 TERM_FILE_TRUNC internal static bit(1) initial unaligned dcl 8-11 TERM_FILE_TRUNC_BC internal static bit(2) initial unaligned dcl 8-13 TERM_FILE_TRUNC_BC_TERM internal static bit(3) initial unaligned dcl 8-15 W_ACCESS internal static bit(3) initial unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 alloc_switch_count automatic fixed bin(17,0) dcl 7-33 alloc_switch_name_count automatic fixed bin(17,0) dcl 7-33 object_info based structure level 1 dcl 4-6 object_info_version_2 internal static fixed bin(17,0) initial dcl 4-60 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 5-114 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 5-121 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 5-109 star_SEGMENT internal static fixed bin(2,0) initial unsigned dcl 5-120 star_entries based structure array level 1 dcl 5-27 star_entry_count automatic fixed bin(17,0) dcl 5-14 star_entry_ptr automatic pointer dcl 5-15 star_link_pathname based char unaligned dcl 5-102 star_linkx automatic fixed bin(17,0) dcl 5-18 star_list_branch based structure array level 1 dcl 5-41 star_names based char(32) array unaligned dcl 5-37 star_names_ptr automatic pointer dcl 5-19 status_area_ptr automatic pointer dcl 6-47 status_branch based structure level 1 dcl 6-8 status_entry_names based char(32) array dcl 6-47 status_link based structure level 1 dcl 6-38 status_pathname based char dcl 6-47 status_ptr automatic pointer dcl 6-47 suffix_info_ptr automatic pointer dcl 7-10 switch_list based structure level 1 dcl 7-37 switch_list_ptr automatic pointer dcl 7-33 terminate_file_switches based structure level 1 packed unaligned dcl 8-4 NAMES DECLARED BY EXPLICIT CONTEXT. ABORT 003653 constant label dcl 679 ref 612 623 640 649 743 767 776 782 795 ARGERR 002617 constant label dcl 577 ref 538 597 COMMON 002224 constant label dcl 498 set ref 313 319 326 333 339 345 352 359 365 372 379 386 392 398 405 412 419 426 433 440 447 454 461 468 475 481 487 493 Check_Object_Segment 007352 constant entry internal dcl 1010 ref 957 962 967 972 977 982 Cleanup 010014 constant entry internal dcl 1067 ref 508 679 DONE 003515 constant label dcl 661 ref 542 658 Get_Star_Names 007300 constant entry internal dcl 1003 ref 720 872 898 Msf_Nonzero 007505 constant entry internal dcl 1022 ref 948 952 PATH_ERR 004221 constant label dcl 739 ref 694 698 703 718 722 989 996 PROCESS 000000 constant label array(28) dcl 852 ref 850 Process_A_Name 005226 constant entry internal dcl 827 ref 726 731 Process_Pathname 003660 constant entry internal dcl 684 ref 657 Return_Entry 004300 constant entry internal dcl 747 ref 708 711 713 726 875 880 886 903 USAGE 002364 constant label dcl 534 ref 544 branches 001526 constant entry external dcl 341 directories 001504 constant entry external dcl 328 dirs 001475 constant entry external dcl 328 entries 001433 constant entry external dcl 43 entry_type_selected 010742 constant entry internal dcl 1179 ref 708 875 exists 002214 constant entry external dcl 489 files 001444 constant entry external dcl 315 free_star_structures 010231 constant entry internal dcl 1081 ref 735 1073 links 001515 constant entry external dcl 335 master_directories 001637 constant entry external dcl 374 mdirs 001630 constant entry external dcl 374 msfs 001577 constant entry external dcl 361 nlinks 001650 constant entry external dcl 381 nmdirs 001732 constant entry external dcl 407 nnlinks 001752 constant entry external dcl 414 nobfiles 002052 constant entry external dcl 442 nobmsfs 002112 constant entry external dcl 456 nobsegs 002152 constant entry external dcl 470 nonbranches 002172 constant entry external dcl 477 nondirectories 001566 constant entry external dcl 354 nondirs 001557 constant entry external dcl 354 nonfiles 001701 constant entry external dcl 394 nonlinks 002203 constant entry external dcl 483 nonmaster_directories 001741 constant entry external dcl 407 nonmsfs 001670 constant entry external dcl 388 nonnull_links 001761 constant entry external dcl 414 nonobject_files 002061 constant entry external dcl 442 nonobject_msfs 002121 constant entry external dcl 456 nonobject_segments 002161 constant entry external dcl 470 nonsegments 001546 constant entry external dcl 347 nonsegs 001537 constant entry external dcl 347 nonzero_files 002001 constant entry external dcl 421 nonzero_msfs 002021 constant entry external dcl 428 nonzero_segments 001721 constant entry external dcl 400 null_links 001657 constant entry external dcl 381 nzfiles 001772 constant entry external dcl 421 nzmsfs 002012 constant entry external dcl 428 nzsegs 001712 constant entry external dcl 400 obfiles 002032 constant entry external dcl 435 object_files 002041 constant entry external dcl 435 object_msfs 002101 constant entry external dcl 449 object_segments 002141 constant entry external dcl 463 obmsfs 002072 constant entry external dcl 449 obsegs 002132 constant entry external dcl 463 process_component_starname 007671 constant entry internal dcl 1046 ref 992 process_entry_type_list 010323 constant entry internal dcl 1097 ref 598 segments 001464 constant entry external dcl 321 segs 001455 constant entry external dcl 321 zero_segments 001617 constant entry external dcl 367 zsegs 001610 constant entry external dcl 367 NAMES DECLARED BY CONTEXT OR IMPLICATION. char builtin function ref 1035 1035 ltrim builtin function ref 1035 1035 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 12250 12406 11064 12260 Length 13154 11064 136 531 1163 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME entries 1774 external procedure is an external procedure. on unit on line 508 64 on unit Process_Pathname internal procedure shares stack frame of external procedure entries. Return_Entry internal procedure shares stack frame of external procedure entries. Process_A_Name internal procedure shares stack frame of external procedure entries. Get_Star_Names internal procedure shares stack frame of external procedure entries. Check_Object_Segment internal procedure shares stack frame of external procedure entries. Msf_Nonzero internal procedure shares stack frame of external procedure entries. process_component_starname internal procedure shares stack frame of external procedure entries. Cleanup 100 internal procedure is called by several nonquick procedures. free_star_structures 70 internal procedure is called by several nonquick procedures. process_entry_type_list 104 internal procedure enables or reverts conditions. on unit on line 1113 64 on unit entry_type_selected internal procedure shares stack frame of external procedure entries. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME entries 000100 active_function entries 000101 archive_bc entries 000102 archive_ptr entries 000104 arg_count entries 000105 argument_lth entries 000106 argument_ptr entries 000110 c_ptr entries 000112 char_168 entries 000164 chars_left entries 000165 chase entries 000166 code entries 000167 command_name entries 000200 component entries 000210 dir entries 000262 dir_dname entries 000334 dir_ename entries 000344 ename entries 000354 entry_index entries 000355 entry_type_count entries 000356 entry_type_no entries 000360 entry_type_ptr entries 000362 error entries 000366 first_arg entries 000367 found_something entries 000370 found_uid entries 000371 fs_type entries 000402 get_argument entries 000406 got_key entries 000407 idx entries 000410 inhibit_error entries 000411 jdx entries 000412 kdx entries 000413 kname_index entries 000414 line_length entries 000416 link_array_ptr entries 000420 n_link_names entries 000421 n_uids entries 000422 old_ename entries 000432 return_absolute_pathnames entries 000433 return_names entries 000434 return_value_lth entries 000436 return_value_ptr entries 000440 seg_ptr entries 000442 select_entry_type entries 000444 space entries 000446 starname_count entries 000447 starnames entries 002160 system_area_ptr entries 002162 table_index entries 002163 type_info entries 002304 uid_array_ptr entries 002306 unique_id entries 002316 star_branch_count entries 002320 star_list_branch_ptr entries 002322 star_link_count entries 002324 star_list_names_ptr entries 002326 star_select_sw entries 002340 result Process_Pathname 002341 idx Process_Pathname 002350 temp_string Return_Entry 002462 type Process_A_Name 002463 bit_count Process_A_Name 002464 null_link Process_A_Name 002465 idx Process_A_Name 002512 code Msf_Nonzero 002513 comp Msf_Nonzero 002514 comp_bit_count Msf_Nonzero 002515 msf_bit_count Msf_Nonzero 002516 msf_dir Msf_Nonzero 002600 c_name process_component_starname 002616 entry_type_no entry_type_selected process_entry_type_list 000100 types_len process_entry_type_list 000102 types_ptr process_entry_type_list 000104 entry_type_no process_entry_type_list 000105 this_type process_entry_type_list THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_e_as r_ne_as r_ge_a alloc_char_temp call_ent_var_desc call_ent_var call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other return_mac signal_op enable_op shorten_stack ext_entry int_entry int_entry_desc trunc_fx2 divide_fx1 op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. active_fnc_err_ archive_$get_component archive_$next_component check_star_name_$entry com_err_ cu_$af_arg_ptr cu_$af_return_arg cu_$arg_count cu_$arg_ptr expand_pathname_ expand_pathname_$add_suffix expand_pathname_$component fs_util_$get_type fs_util_$suffix_info_for_type get_line_length_$switch get_system_free_area_ get_temp_segment_ hcs_$get_uid_file hcs_$star_dir_list_ hcs_$status_minf initiate_file_ ioa_ ioa_$nnl match_star_name_ object_lib_$initiate pathname_ release_temp_segment_ requote_string_ terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$archive_fmt_err error_table_$archive_pathname error_table_$bad_arg error_table_$badopt error_table_$no_dir error_table_$no_s_permission error_table_$noarg error_table_$noentry error_table_$nomatch error_table_$not_act_fnc error_table_$not_archive error_table_$too_many_args iox_$user_output sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 43 001432 312 001440 313 001442 315 001443 318 001451 319 001453 321 001454 325 001471 326 001473 328 001474 332 001511 333 001513 335 001514 338 001522 339 001524 341 001525 344 001533 345 001535 347 001536 351 001553 352 001555 354 001556 358 001573 359 001575 361 001576 364 001604 365 001606 367 001607 371 001624 372 001626 374 001627 378 001644 379 001646 381 001647 385 001664 386 001666 388 001667 391 001675 392 001677 394 001700 397 001706 398 001710 400 001711 404 001726 405 001730 407 001731 411 001746 412 001750 414 001751 418 001766 419 001770 421 001771 425 002006 426 002010 428 002011 432 002026 433 002030 435 002031 439 002046 440 002050 442 002051 446 002066 447 002070 449 002071 453 002106 454 002110 456 002111 460 002126 461 002130 463 002131 467 002146 468 002150 470 002151 474 002166 475 002170 477 002171 480 002177 481 002201 483 002202 486 002210 487 002212 489 002213 492 002221 493 002223 498 002224 501 002233 504 002236 506 002237 508 002245 511 002267 512 002300 514 002301 516 002316 518 002322 519 002323 520 002331 521 002336 522 002341 525 002342 526 002344 527 002350 530 002353 531 002356 532 002357 533 002361 534 002364 535 002422 537 002423 538 002441 540 002443 541 002451 542 002455 544 002456 546 002461 547 002462 548 002471 549 002502 550 002504 551 002506 552 002544 555 002545 556 002547 557 002552 559 002553 560 002555 561 002557 562 002560 565 002562 571 002564 572 002565 574 002572 575 002601 576 002615 577 002617 578 002633 580 002634 581 002641 582 002657 584 002675 586 002706 588 002722 590 002734 591 002753 592 002756 593 003011 595 003012 596 003013 597 003027 598 003031 599 003054 600 003057 601 003112 603 003113 605 003114 606 003146 608 003147 610 003150 611 003153 612 003177 614 003200 615 003201 617 003210 619 003212 620 003214 623 003262 626 003263 633 003272 634 003274 636 003316 638 003347 639 003352 640 003375 643 003376 645 003377 647 003430 648 003433 649 003456 652 003457 655 003460 657 003467 658 003507 659 003513 661 003515 662 003517 663 003521 664 003536 665 003551 667 003552 668 003567 670 003602 672 003603 673 003605 674 003612 675 003636 676 003637 679 003653 681 003657 684 003660 691 003671 693 003672 694 003724 696 003726 697 003742 698 003745 701 003746 702 003757 703 003762 706 003763 707 003773 708 003776 710 004012 711 004021 712 004024 713 004025 714 004035 715 004043 717 004044 718 004061 719 004067 720 004072 721 004073 722 004100 725 004114 726 004127 728 004174 729 004177 731 004200 735 004207 737 004213 739 004221 741 004237 742 004241 743 004271 745 004272 747 004300 753 004311 754 004313 755 004321 756 004346 757 004374 758 004375 759 004407 760 004413 761 004415 762 004425 763 004440 764 004442 765 004443 766 004454 767 004500 769 004501 771 004513 772 004515 773 004517 774 004520 775 004524 776 004550 778 004551 779 004555 780 004556 781 004565 782 004611 784 004612 786 004624 788 004625 789 004654 790 004663 791 004670 792 004672 793 004673 794 004677 795 004723 797 004724 799 004730 800 004743 801 004776 803 005000 805 005027 806 005032 807 005045 808 005113 809 005115 810 005121 811 005154 812 005161 814 005162 815 005201 818 005207 819 005217 823 005223 825 005225 827 005226 837 005230 838 005233 839 005237 840 005244 841 005246 842 005250 843 005320 844 005324 845 005325 847 005373 850 005402 852 005405 855 005416 858 005433 861 005444 865 005454 867 005456 868 005461 869 005471 870 005474 871 005504 872 005537 873 005540 874 005547 875 005555 877 005611 879 005612 880 005646 883 005702 885 005703 886 005737 889 005773 890 005776 891 006002 892 006042 894 006047 895 006052 896 006054 898 006055 899 006056 901 006071 902 006072 903 006101 904 006135 906 006140 908 006146 912 006156 915 006173 918 006210 921 006217 924 006230 927 006241 930 006257 933 006271 936 006307 939 006324 942 006345 945 006361 948 006374 950 006442 952 006447 955 006516 957 006523 960 006570 962 006575 965 006643 967 006650 970 006713 972 006720 975 006764 977 006771 980 007034 982 007041 985 007105 987 007112 989 007156 991 007162 992 007177 994 007217 995 007255 996 007265 997 007272 1003 007300 1005 007301 1006 007303 1008 007351 1010 007352 1014 007370 1015 007372 1016 007445 1017 007474 1022 007505 1032 007523 1033 007546 1034 007547 1035 007557 1037 007647 1039 007656 1040 007660 1046 007671 1053 007673 1054 007675 1055 007676 1056 007733 1057 007743 1058 007755 1059 007776 1060 010006 1062 010007 1067 010013 1069 010021 1071 010057 1073 010117 1074 010125 1075 010161 1076 010215 1078 010227 1081 010230 1084 010236 1087 010303 1090 010315 1093 010321 1097 010322 1112 010336 1113 010340 1114 010354 1115 010366 1117 010367 1118 010375 1119 010405 1123 010414 1126 010433 1127 010456 1131 010461 1135 010475 1139 010516 1140 010525 1141 010531 1142 010533 1143 010542 1144 010552 1145 010556 1146 010566 1147 010576 1148 010606 1149 010616 1150 010625 1151 010636 1154 010644 1155 010670 1158 010674 1159 010721 1163 010722 1166 010727 1167 010734 1168 010740 1170 010741 1179 010742 1186 010744 1187 010755 1188 010772 1189 010774 ----------------------------------------------------------- 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