COMPILATION LISTING OF SEGMENT status Compiled by: Multics PL/I Compiler, Release 31b, of April 24, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 05/10/89 0947.5 mst Wed Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 6* * * 7* *********************************************************** */ 8 9 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(87-02-17,TLNguyen), approve(87-02-17,MCR7622), 14* audit(87-02-25,Gilcrease), install(87-03-23,MR12.1-1008): 15* - Make "status" active function returns the current length when the 16* "-length" control argument is specified. 17* - Add the "-nonstandard_names" (-nsn) control argument to the status 18* command or active function. 19* 2) change(87-02-24,TLNguyen), approve(87-02-24,MCR7620), 20* audit(87-02-25,Gilcrease), install(87-03-23,MR12.1-1008): 21* - Change "status" command to always display an appropriate error message 22* if "-chase" control argument is specified and the entry is a null link. 23* - Change "status" command to always skip printing an error message if the 24* code received from "file_manager_$status" is "A transaction is currently 25* in progress." 26* - Change "status" to always display an error message if specified paths 27* are directories, MSFs, DM files, and links and the "-synchronized_ 28* switch" is specified. 29* - Change "status" to always call "msf_manager_$close" when it finishes for 30* an MSF and to always call "cleanup" internal procedure when it finishes. 31* - Change "status" to always not display a specified MSF's contents which 32* appeared at the end of the error message. 33* 3) change(87-03-25,TLNguyen), approve(87-03-25,MCR7620), 34* audit(87-03-25,Gilcrease), install(87-03-25,MR12.1-1015): 35* PBF to last installation, status with no arguments ok now. 36* 4) change(87-09-04,TLNguyen), approve(87-09-04,PBF7620), 37* audit(87-09-04,Farley), install(87-09-09,MR12.1-1099): 38* status with MSFs and -all control argument work ok now. 39* 5) change(88-01-29,TLNguyen), approve(88-01-29,MCR7833), 40* audit(88-02-02,Lippard), install(88-02-02,MR12.2-1020): 41* Make status with -length work as documented when it is used as a command. 42* 6) change(88-05-12,Lippard), approve(88-05-02,MCR7881), 43* audit(88-06-09,Fawcett), install(88-08-02,MR12.2-1074): 44* Add -audit_switch, -asw. 45* 7) change(89-04-06,Vu), approve(89-04-06,MCR8096), audit(89-04-26,Lee), 46* install(89-05-10,MR12.3-1040): 47* status -switch SW_NAME yields bogus error for link and the date returned 48* by status for the root does not use the user's default date/time format. 49* Reformatted status.pl1 50* END HISTORY COMMENTS */ 51 52 53 54 /* format: style4,ifthenstmt,^indproc */ 55 56 status: st: procedure options (variable); 57 58 /* WARNING: Some hcs_ entries are mis-declared with char (*) aligned */ 59 60 /* This command and active function returns selected 61* attributes of storage system entries. */ 62 63 /* Written 5/20/76 by Steve Herbst */ 64 /* Control args -dr, -lk, -sm added and [st -nm] names quoted 09/28/79 S. Herbst */ 65 /* Changed to print damaged switch (if on) by default 03/19/80 S. Herbst */ 66 /* Fix dates reported for MSF's (most recent date of all components) 01/06/81 S. Herbst */ 67 /* Chasing fixed, -chase_if_possible added, -records_used -> -records 01/12/81 S. Herbst */ 68 /* Fixed bug in MSF processing 10/01/81 S. Herbst */ 69 /* fixed not to assume 168 char link pathname BIM 3/82 */ 70 /* Added printing of synchronized switch, J. Bongiovanni, September 1982 */ 71 /* Fixed to handle et_$vtoce_connection_fail like et_$logical_volume_not_connected 11/23/82 S. Herbst */ 72 /* Changed back again to treat VTOCE errors as errors, since no info can be trusted. 12/07/82 S. Herbst */ 73 /* Simple support for object_type_ 2/24/83 Jay Pattin */ 74 /* Added entry_bound, -switch, changed behavior of -all w/switches 6/2/83 Jay Pattin */ 75 /* 830924 object_type_ --> fs_util_, BIM */ 76 /* Modified 11/21/83 by C Spitzer. fix lots of bugs */ 77 /* Fixed to not free switch_list when switch_list_ptr is null, 1984.02.16, MAP */ 78 /* Modified 07/18/84 by Jim Lippard to only allocate names when they're 79* asked for and to free them properly */ 80 /* Modified 84-09-17 by JAFalksen. Utilize date_time_$format("date_time",... */ 81 /* Modified 01/11/84 by C Spitzer. work on root (changes adapted by Steve Herbst) */ 82 /* Changed to work on DM files 10/23/84 Steve Herbst */ 83 /* Added extended entry type control args -select_entry_type, changed -force_no_type to -inase 11/20/84 M. Pandolf */ 84 /* Changed -no_(concurrency rollback)_sw to -(concurrency rollback)_sw 12/04/84 Steve Herbst */ 85 /* Fixed mode value for DM files 01/11/85 Steve Herbst */ 86 /* Modified 02/05/85 by M. Sharpe to implement -slet correctly and to complain 87* about unsupported operation when type does not have ring brackets, extended 88* mode, max length, etc. */ 89 /* Fixed to print DM file switches without a transaction in effect 02/26/85 Steve Herbst */ 90 91 92 /* DECLARATIONS */ 93 94 /* Options structure. Various settings for it are at the back of the listing. */ 95 96 dcl 1 opt, /* attributes to be requested */ 97 (2 primary_name, /* -primary, -pri */ 98 2 names, /* -name, -names, -nm */ 99 2 type, /* -type, -tp */ 100 2 link_path, /* -link_path, -lp */ 101 2 unique_id, /* -unique_id, -uid */ 102 2 dtu, /* -date_time_used, -dtu */ 103 2 dtcm, /* -date_time_contents_modified, -dtcm */ 104 2 dtem, /* -date_time_entry_modified, -dtem */ 105 2 dtd, /* -date_time_dumped, -dtd */ 106 2 dtvd, /* -date_time_volume_dumped, -dtvd */ 107 2 author, /* -author, -at */ 108 2 bc_author, /* -bc_author, -bca */ 109 2 logical_volume, /* -logical_volume, -lv, -device, -dv */ 110 2 bit_count, /* -bit_count, -bc */ 111 2 records_used, /* -records, -rec */ 112 2 current_length, /* -current_length, -cl */ 113 2 max_length, /* -max_length, -ml */ 114 2 mode, /* -mode, -md */ 115 2 access_class, /* -access_class, -acc */ 116 2 ring_brackets, /* -ring_brackets, -rb */ 117 2 safety_switch, /* -safety_switch, -ssw */ 118 2 copy_switch, /* -copy_switch, -csw */ 119 2 audit_switch, /* -audit_switch, -asw */ 120 2 ivds, /* -incr_volume_dump_switch, -ivds */ 121 2 cvds, /* -comp_volume_dump_switch , -cvds */ 122 2 usage_count, /* -usage_count, -use */ 123 2 damaged_switch, /* -damaged_switch, -dsw */ 124 2 synchronized_switch, /* -synchronized_switch, -synch */ 125 2 entry_bound /* -entry_bound, -eb */ 126 ) bit (1) unaligned, 127 2 dm_files_only, 128 (3 highest_ci, /* -highest_control_interval, -hci */ 129 3 concurrency_switch, /* -concurrency_sw, -concsw */ 130 3 rollback_switch, /* -rollback_sw, -rlbsw */ 131 3 protected_switch /* -protected_sw, -psw */ 132 ) bit (1) unaligned; 133 134 135 dcl 1 explicit_opt like opt; /* attributes explicitly requested */ 136 137 dcl 1 saved_options like opt; /* saved copy of opt */ 138 139 dcl ALL_OPTIONS bit (33) aligned int static options (constant) init ((33)"1"b); /* for -all */ 140 141 dcl LONG_OPTION (33) char (64) int static options (constant) init 142 ("-primary", "-name", "-type", "-link_path", "-unique_id", 143 "-date_time_used", "-date_time_contents_modified", "-date_time_entry_modified", 144 "-date_time_dumped", "-date_time_volume_dumped", "-author", "-bc_author", 145 "-logical_volume", "-bit_count", "-records", "-current_length", "-max_length", 146 "-mode", "-access_class", "-ring_brackets", "-safety_switch", "-copy_switch", 147 "-audit_switch", "-incr_volume_dump_switch", "-comp_volume_dump_switch", "-usage_count", 148 "-damaged_switch", "-synchronized_switch", "-entry_bound", 149 /* (DM file options:) */ 150 "-highest_control_interval", "-concurrency_sw", "-rollback_sw", "-protected_sw"); 151 152 dcl SHORT_OPTION (33) char (8) int static options (constant) init 153 ("-pri", "-nm", "-tp", "-lp", "-uid", 154 "-dtu", "-dtcm", "-dtem", "-dtd", "-dtvd", "-at", "-bca", 155 "-lv", "-bc", "-rec", "-cl", "-ml", 156 "-md", "-acc", "-rb", "-ssw", "-csw", "-asw", 157 "-ivds", "-cvds", "-use", 158 "-dsw", "-synch", "-eb", 159 "-hci", "-concsw", "-rlbsw", "-psw"); 160 161 162 dcl 1 bks aligned like status_for_backup; 163 164 dcl 1 link_status aligned based (addr (branch_status)), /* status for link entries */ 165 2 type bit (2) unaligned, 166 2 nnames bit (16) unaligned, 167 2 nrp bit (18) unaligned, 168 2 dtlm bit (36) unaligned, 169 2 dtd bit (36) unaligned, 170 2 pnl fixed bin (18) uns unaligned, 171 2 pnrp bit (18) unaligned; 172 173 dcl 1 msf_info aligned, /* status for MSF components */ 174 2 type bit (2) unaligned, 175 2 nnames bit (16) unaligned, 176 2 names_offset bit (18) unaligned, 177 2 dtcm bit (36) unaligned, 178 2 dtu bit (36) unaligned, 179 2 mode bit (5) unaligned, 180 2 pad bit (13) unaligned, 181 2 records fixed bin (17) unaligned, 182 2 dtd bit (36) unaligned, 183 2 dtem bit (36) unaligned, 184 2 pad3 bit (36) unaligned, 185 2 current_length fixed bin (11) unaligned, 186 2 bit_count bit (24) unaligned, 187 2 pad2 bit (18) unaligned, 188 2 rbs (0:2) fixed bin (5) unaligned, 189 2 pad4 bit (36) unaligned; 190 191 dcl branch_names (0:99) char (32) based (branch_names_ptr);/* names from hcs_$status_long */ 192 193 dcl ROOT_NAMES (1) char (32) int static options (constant) init (">"); 194 195 dcl 1 si aligned like suffix_info; 196 197 dcl 1 auto_dm_file_status aligned like dm_file_status; 198 199 dcl 1 path_array (path_array_size) aligned based (path_array_ptr), 200 2 path_ptr ptr, 201 2 path_len fixed bin, 202 2 nonstandard_names_flag bit (1) aligned; 203 dcl 1 slet_path_array (slet_path_array_size) aligned based (slet_path_array_ptr) like path_array; 204 dcl 1 path_array_space (25) like path_array; 205 206 dcl dates_array (5) bit (36); 207 208 dcl 1 combined_options, 209 (2 access, /* -access */ 210 2 all, /* -all */ 211 2 dates, /* -date */ 212 2 lengths /* -length */ 213 ) bit (1) unaligned; 214 215 dcl 1 fs_entry_type aligned based (fs_entry_type_ptr), 216 2 count fixed bin, 217 2 suffix char (32) unaligned dim (fs_entry_type_count refer (fs_entry_type.count)); 218 219 dcl 1 fs_time_value aligned based, 220 2 pad1 bit (20) unal, 221 2 time bit (36) unal, 222 2 pad2 bit (16) unal; 223 224 dcl temp_clock fixed bin (71); 225 dcl stime bit (36); 226 dcl switch_names (10) char (32); /* for -switch */ 227 dcl mode_bits (5) bit (1) unaligned; 228 dcl ring_brackets (8) fixed bin (3); 229 230 /* Constants */ 231 232 dcl ME char (32) int static options (constant) init ("status"); 233 dcl INITIALIZER_ID char (32) int static options (constant) init ("Initializer.SysDaemon.z"); 234 dcl EXTENDED_type fixed bin int static options (constant) init (5); 235 dcl (CHASE init (1), NO_CHASE init (0)) fixed bin int static options (constant); 236 237 /* Based */ 238 239 dcl area area based (area_ptr); 240 dcl arg char (arg_len) based (arg_ptr); 241 dcl return_string char (return_len) varying based (return_ptr); 242 dcl slet_path char (slet_path_len) based (slet_path_ptr); 243 dcl target_path char (target_len) based (target_ptr); 244 245 /* Automatic */ 246 247 dcl slet_area area; 248 249 dcl date_string char (64) varying; 250 dcl mode_string char (36) varying; 251 252 dcl (class, temp_string) char (336); /* ASCII access class */ 253 dcl (dn, msf_path, saved_dn, target_dn) char (168); 254 dcl (author_string, bc_author_string, comp_name, en, fs_type, fs_util_type) char (32); 255 dcl (lv_string, saved_en, star_en, target_en) char (32); 256 dcl type_string char (32); /* avoid string size condition while compiling. */ 257 258 dcl access_class bit (72) aligned; 259 dcl (exmodes, local_unique_id, modes) bit (36) aligned; 260 dcl (bc36, msf_dtcm, msf_dtd, msf_dtem, msf_dtu) bit (36); 261 dcl switch_mask bit (10) aligned; 262 dcl (active_function, chase, chase_if_possible, chased, dir_sw, dm_file_sw, interpret_as_standard_entry) bit (1) aligned; 263 dcl (link_sw, matched, msf, msf_error, one_item, printed_pathname, printed_something) bit (1) aligned; 264 dcl (root_sw, safety_switch, seg_sw, selecting_by_entry_type, star_sw) bit (1) aligned; 265 266 dcl (area_ptr, arg_ptr, branch_names_ptr, comp_ptr, fs_entry_type_ptr, msf_ptr) ptr; 267 dcl (path_array_ptr, return_ptr, slet_path_array_ptr, slet_path_ptr, target_ptr) ptr; 268 269 dcl status_chase fixed bin (1); 270 dcl entry_type fixed bin (3); 271 dcl (arg_count, arg_len, class_len, cvds, entry_type_index, extended_type_count, fs_entry_type_count, i, ivds) fixed bin; 272 dcl (j, k, kk, path_array_size, path_count, return_len, slet_path_array_size, slet_path_len) fixed bin; 273 dcl (switch_count, switch_length, target_len, total_length, total_records) fixed bin; 274 dcl max_length fixed bin (19); 275 dcl total_bit_count fixed bin (24); 276 dcl (bc35, code, usage_count) fixed bin (35); 277 278 /* External */ 279 280 dcl dm_error_$transaction_in_progress fixed bin (35) ext; 281 dcl error_table_$badopt fixed bin (35) ext; 282 dcl error_table_$inconsistent fixed bin (35) ext; 283 dcl error_table_$incorrect_access fixed bin (35) ext; 284 dcl error_table_$logical_volume_not_connected fixed bin (35) ext; 285 dcl error_table_$logical_volume_not_defined fixed bin (35) ext; 286 dcl error_table_$moderr fixed bin (35) ext; 287 dcl error_table_$no_s_permission fixed bin (35) ext; 288 dcl error_table_$noarg fixed bin (35) ext; 289 dcl error_table_$noentry fixed bin (35) ext; 290 dcl error_table_$nomatch fixed bin (35) ext; 291 dcl error_table_$not_act_fnc fixed bin (35) ext; 292 dcl error_table_$root fixed bin (35) ext; 293 dcl error_table_$segknown fixed bin (35) ext; 294 dcl error_table_$unsupported_operation fixed bin (35) ext; 295 296 /* Entries */ 297 298 dcl complain entry variable options (variable); 299 300 dcl active_fnc_err_ entry options (variable); 301 dcl check_star_name_$entry entry (char (*), fixed bin (35)); 302 dcl com_err_ entry options (variable); 303 dcl convert_authorization_$to_string_short entry (bit (72) aligned, char (*), fixed bin (35)); 304 dcl cu_$af_return_arg entry (fixed bin, ptr, fixed bin, fixed bin (35)); 305 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 306 dcl expand_path_ entry (ptr, fixed bin, ptr, ptr, fixed bin (35)); 307 dcl expand_pathname_$add_suffix entry (char (*), char (*), char (*), char (*), fixed bin (35)); 308 dcl get_group_id_ entry () returns (char (32)); 309 dcl get_system_free_area_ entry returns (ptr); 310 dcl get_wdir_ entry returns (char (168)); 311 dcl file_manager_$status entry (char (*), char (*), ptr, fixed bin (35)); 312 dcl fs_util_$get_type entry (char (*), char (*), char (*), fixed bin (35)); 313 dcl fs_util_$get_max_length entry (char (*), char (*), fixed bin (19), fixed bin (35)); 314 dcl fs_util_$get_ring_brackets entry (char (*), char (*), (*) fixed bin (3), fixed bin (35)); 315 dcl fs_util_$get_switch entry (char (*), char (*), char (*), bit (1) aligned, fixed bin (35)); 316 dcl fs_util_$get_user_access_modes entry (char (*), char (*), char (*), fixed bin, bit (36) aligned, 317 bit (36) aligned, fixed bin (35)); 318 dcl fs_util_$list_switches_for_type entry (char (*), char (*), ptr, ptr, fixed bin (35)); 319 dcl fs_util_$suffix_info_for_type entry (char (*), ptr, fixed bin (35)); 320 dcl hcs_$get_access_class entry (char (*), char (*), bit (72) aligned, fixed bin (35)); 321 dcl hcs_$get_dates entry (char (*), char (*), (5) bit (36), fixed bin (35)); 322 dcl hcs_$get_author entry (char (*), char (*), fixed bin, char (*), fixed bin (35)); 323 dcl hcs_$get_bc_author entry (char (*), char (*), char (*), fixed bin (35)); 324 dcl hcs_$get_link_target entry (char (*), char (*), char (*), char (*), fixed bin (35)); 325 dcl hcs_$get_max_length entry (char (*), char (*), fixed bin (19), fixed bin (35)); 326 dcl hcs_$get_safety_sw entry (char (*), char (*), bit (1) aligned, fixed bin (35)); 327 dcl hcs_$get_volume_dump_switches entry (char (*), char (*), fixed bin, fixed bin, fixed bin (35)); 328 dcl hcs_$star_dir_list_ entry (char (*), char (*), fixed bin (3), ptr, fixed bin, fixed bin, ptr, ptr, fixed bin (35)); 329 dcl hcs_$status_for_backup entry (char (*), char (*), ptr, fixed bin (35)); 330 dcl hcs_$status_long entry (char (*), char (*), fixed bin (1), ptr, ptr, fixed bin (35)); 331 dcl ioa_ entry options (variable); 332 dcl ioa_$nnl entry options (variable); 333 dcl ioa_$rsnnl entry options (variable); 334 dcl mdc_$find_lvname entry (bit (36), char (*), fixed bin (35)); 335 dcl mhcs_$get_seg_usage entry (char (*), char (*), fixed bin (35), fixed bin (35)); 336 dcl msf_manager_$close entry (ptr); 337 dcl msf_manager_$get_ptr entry (ptr, fixed bin, bit (1), ptr, fixed bin (24), fixed bin (35)); 338 dcl msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); 339 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 340 dcl requote_string_ entry (char (*)) returns (char (*)); 341 342 /* Builtins */ 343 344 dcl (addr, after, before, bin, binary, clock, convert, divide, fixed, hbound, index, null) builtin; 345 dcl (length, max, ptr, reverse, rtrim, string, substr, unspec, verify, empty) builtin; 346 347 /* Conditions */ 348 349 dcl (cleanup, linkage_error) condition; 350 351 /* END OF DECLARATIONS */ 352 353 call cu_$af_return_arg (arg_count, return_ptr, return_len, code); 354 if code = error_table_$not_act_fnc then do; 355 active_function = "0"b; 356 complain = com_err_; 357 end; 358 else do; 359 active_function = "1"b; 360 complain = active_fnc_err_; 361 end; 362 363 code = 0; /* must reset code to 0 */ 364 string (opt) = "0"b; 365 string (combined_options) = "0"b; 366 chase, chase_if_possible, dir_sw, dm_file_sw, interpret_as_standard_entry, link_sw, root_sw, seg_sw = "0"b; 367 area_ptr = get_system_free_area_ (); 368 369 path_array_ptr = addr (path_array_space); 370 fs_entry_type_ptr, star_list_branch_ptr, star_list_names_ptr = null; 371 selecting_by_entry_type = ""b; 372 373 on cleanup call CLEAN_UP (); 374 375 path_array_size = arg_count; 376 if path_array_size > hbound (path_array_space, 1) then 377 allocate path_array in (area) set (path_array_ptr); 378 379 path_count, switch_count = 0; 380 switch_length = 13; 381 382 do i = 1 to arg_count; 383 384 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 385 386 if substr (arg, 1, 1) ^= "-" then do; 387 path_count = path_count + 1; 388 path_array.path_ptr (path_count) = arg_ptr; 389 path_array.path_len (path_count) = arg_len; 390 path_array.nonstandard_names_flag (path_count) = "0"b; 391 end; 392 393 else if arg = "-working_dir" | arg = "-wd" then do; 394 path_count = path_count + 1; 395 path_array.path_len (path_count) = 0; /* use expand_path_'s working dir feature */ 396 path_array.nonstandard_names_flag (path_count) = "0"b; 397 end; 398 399 else if arg = "-chase" then chase = "1"b; 400 else if arg = "-no_chase" then chase = "0"b; 401 else if arg = "-chase_if_possible" | arg = "-cip" then chase_if_possible = "1"b; 402 else if arg = "-no_chase_if_possible" | arg = "-ncip" then chase_if_possible = "0"b; 403 else if arg = "-directory" | arg = "-dr" then dir_sw = "1"b; 404 else if arg = "-link" | arg = "-lk" then link_sw = "1"b; 405 else if arg = "-segment" | arg = "-sm" then seg_sw = "1"b; 406 else if arg = "-switch" then do; 407 i = i + 1; 408 if i > arg_count then do; 409 call complain (error_table_$noarg, ME, "Following -switch."); 410 return; 411 end; 412 if switch_count = 10 then do; 413 call complain (0, ME, "Only 10 switch names allowed."); 414 return; 415 end; 416 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 417 switch_count = switch_count + 1; 418 switch_names (switch_count) = arg; 419 switch_length = max (switch_length, arg_len); 420 end; 421 422 else do; 423 do j = hbound (LONG_OPTION, 1) by -1 to 1 424 while (arg ^= LONG_OPTION (j) & arg ^= SHORT_OPTION (j)); 425 end; 426 if j ^= 0 then substr (string (opt), j, 1) = "1"b; 427 else if arg = "-device" | arg = "-dv" then opt.logical_volume = "1"b; 428 else if arg = "-entry_type" | arg = "-ettp" then opt.type = "1"b; 429 else if arg = "-interpret_as_extended_entry" | arg = "-inaee" then interpret_as_standard_entry = "0"b; 430 else if arg = "-interpret_as_standard_entry" | arg = "-inase" then interpret_as_standard_entry = "1"b; 431 else if arg = "-names" then opt.names = "1"b; /* synonym for -name and -nm */ 432 else if arg = "-nonstandard_names" | arg = "-nsn" then do; 433 i = i + 1; 434 if i > arg_count then do; 435 call complain (error_table_$noarg, ME, "Need an argument for ^a.", arg); 436 return; 437 end; 438 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 439 path_count = path_count + 1; 440 path_array.path_ptr (path_count) = arg_ptr; 441 path_array.path_len (path_count) = arg_len; 442 path_array.nonstandard_names_flag (path_count) = "1"b; 443 end; 444 else if arg = "-records_used" | arg = "-ru" then opt.records_used = "1"b; /* syn for -records */ 445 else if arg = "-select_entry_type" | arg = "-slet" then do; 446 i = i + 1; 447 if i > arg_count then do; 448 call complain (error_table_$noarg, ME, "Following ^a", arg); 449 return; 450 end; 451 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 452 call BUILD_ENTRY_TYPE_LIST (arg, fs_entry_type_ptr, selecting_by_entry_type); 453 end; 454 else if arg = "-length" | arg = "-lengths" | arg = "-ln" then lengths = "1"b; 455 else if active_function then do; /* not any control arg acceptable to status af */ 456 call complain (0, ME, 457 "Specified control argument is not implemented by this active function. ^a", arg); 458 return; 459 end; 460 else if arg = "-access" | arg = "-ac" then access = "1"b; 461 /* -all, -a are undocumented synonyms of -long to be retained for compatibility. */ 462 else if arg = "-all" | arg = "-a" | arg = "-long" | arg = "-lg" then all = "1"b; 463 else if arg = "-date" | arg = "-dt" then dates = "1"b; 464 else do; 465 call complain (error_table_$badopt, ME, "^a", arg); 466 return; 467 end; 468 end; 469 end; 470 471 /* Adjust the environment for slet processing, if any requested */ 472 473 if selecting_by_entry_type then do; 474 475 if link_sw | seg_sw | dir_sw then do; 476 call complain (error_table_$inconsistent, ME, 477 "-select_entry_type is an alternative to -directory, -segment, or -link."); 478 return; 479 end; 480 dir_sw, link_sw, seg_sw = "1"b; 481 482 extended_type_count = 0; 483 do entry_type_index = 1 to fs_entry_type.count; 484 if substr (fs_entry_type.suffix (entry_type_index), 1, 1) ^= "-" then 485 extended_type_count = extended_type_count + 1; 486 end; 487 488 if extended_type_count = fs_entry_type.count then slet_path_array_size = path_count * extended_type_count; 489 else slet_path_array_size = path_count * (extended_type_count + 1); 490 491 if slet_path_array_size > hbound (path_array_space, 1) then 492 allocate slet_path_array in (area) set (slet_path_array_ptr); 493 else slet_path_array_ptr = addr (path_array_space); 494 495 i = slet_path_array_size; 496 do j = path_count by -1 to 1; 497 498 do entry_type_index = 1 to fs_entry_type.count; 499 if substr (fs_entry_type.suffix (entry_type_index), 1, 1) ^= "-" then do; 500 slet_path_len = path_array.path_len (j) + 1 + 501 length (rtrim (fs_entry_type.suffix (entry_type_index))); 502 allocate slet_path in (slet_area) set (slet_path_ptr); 503 target_len = path_array.path_len (j); 504 if ^path_array.nonstandard_names_flag (j) then 505 call expand_pathname_$add_suffix (path_array.path_ptr (j) -> target_path, 506 fs_entry_type.suffix (entry_type_index), target_dn, 507 slet_path_ptr -> slet_path, code); 508 else do; 509 target_dn = get_wdir_ (); 510 arg_len = path_array.path_len (j); 511 arg_ptr = path_array.path_ptr (j); 512 slet_path_ptr -> slet_path = arg; 513 end; 514 slet_path_array.path_ptr (i) = slet_path_ptr; 515 slet_path_array.path_len (i) = slet_path_len; 516 i = i - 1; 517 end; 518 end; 519 if fs_entry_type.count > extended_type_count then do; 520 slet_path_array.path_ptr (i) = path_array.path_ptr (j); 521 slet_path_array.path_len (i) = path_array.path_len (j); 522 i = i - 1; 523 end; 524 end; 525 526 if path_array_ptr ^= addr (path_array_space) then do; 527 free path_array in (area); 528 path_array_ptr = slet_path_array_ptr; 529 end; 530 531 path_count = slet_path_array_size; 532 end; 533 534 /* Set star selection variables */ 535 536 if ^dir_sw & ^link_sw & ^seg_sw then dir_sw, link_sw, seg_sw = "1"b; /* default */ 537 538 if ^link_sw then star_select_sw = star_BRANCHES_ONLY; 539 else if ^dir_sw & ^seg_sw then star_select_sw = star_LINKS_ONLY; 540 else star_select_sw = star_ALL_ENTRIES; 541 542 k = 0; 543 switch_mask = ""b; 544 do i = 1 to switch_count; /* check for standards */ 545 if switch_names (i) = "damaged" then opt.damaged_switch = "1"b; 546 else if switch_names (i) = "safety" then opt.safety_switch = "1"b; 547 else if switch_names (i) = "copy" then opt.copy_switch = "1"b; 548 else if switch_names (i) = "audit" then opt.audit_switch = "1"b; 549 else if switch_names (i) = "synchronized" then opt.synchronized_switch = "1"b; 550 else if switch_names (i) = "complete_volume_dump" then opt.cvds = "1"b; 551 else if switch_names (i) = "incremental_volume_dump" then opt.ivds = "1"b; 552 else substr (switch_mask, i, 1) = "1"b; 553 554 if ^(substr (switch_mask, i, 1)) then k = k + 1; /* was a standard switch */ 555 end; 556 557 explicit_opt = opt; 558 559 if all then string (opt) = ALL_OPTIONS; 560 561 if access then string (opt) = string (opt) | string (access_options); 562 if dates then string (opt) = string (opt) | string (date_options); 563 if lengths then do; 564 if active_function then 565 string (opt) = string (opt) | string (active_function_length_options); 566 else string (opt) = string (opt) | string (length_options); 567 end; 568 if switch_count = 0 & string (opt) = "0"b then 569 if active_function then do; /* control arg must be supplied to active function */ 570 AF_USAGE: 571 call active_fnc_err_ (0, ME, "Usage: [status path control_arg {-chase}]"); 572 return; 573 end; 574 else unspec (opt) = unspec (default_options); 575 576 /* Shorter output format if only one item of information is requested. */ 577 578 j = switch_count - k; 579 do i = 1 to hbound (LONG_OPTION, 1); 580 if substr (string (opt), i, 1) then j = j + 1; 581 end; 582 if j = 1 then one_item = "1"b; 583 else if active_function & ^lengths then go to AF_USAGE; 584 else one_item = "0"b; 585 586 if path_count = 0 then do; /* assume working directory */ 587 if active_function & arg_count = 2 then go to AF_USAGE; 588 path_count = 1; 589 path_array.path_len (1) = 0; /* use expand_path_'s working dir feature */ 590 path_array.path_ptr (1) = null (); 591 end; 592 else if active_function & path_count > 1 then go to AF_USAGE; 593 594 saved_options = opt; 595 596 printed_something = "0"b; /* haven't output anything yet */ 597 598 do i = 1 to path_count; 599 if path_array.nonstandard_names_flag (i) then do; 600 dn = get_wdir_ (); 601 arg_len = path_array.path_len (i); 602 arg_ptr = path_array.path_ptr (i); 603 en = arg; 604 end; 605 else do; 606 call expand_path_ (path_array.path_ptr (i), path_array.path_len (i), addr (dn), addr (en), code); 607 if code ^= 0 then do; 608 arg_ptr = path_array.path_ptr (i); 609 arg_len = path_array.path_len (i); 610 call complain (code, ME, "^a", arg); 611 go to NEXT_PATH; 612 end; 613 if en ^= "" then call check_star_name_$entry (en, code); /* star convention? */ 614 end; 615 if code = 0 then do; 616 star_sw = "0"b; 617 j, star_entry_count = 1; 618 printed_pathname = "0"b; 619 msf = "0"b; 620 msf_ptr = null (); 621 622 call ENTRY_STATUS (); /* do the work */ 623 624 if msf then 625 if msf_ptr ^= null then call msf_manager_$close (msf_ptr); 626 if branch_names_ptr ^= null & ^root_sw then free branch_names in (area); 627 end; 628 else if code > 2 then do; /* invalid entry name */ 629 arg_ptr = path_array.path_ptr (i); 630 arg_len = path_array.path_len (i); 631 call complain (code, ME, "^a", arg); 632 go to NEXT_PATH; 633 end; 634 else if active_function then do; 635 call active_fnc_err_ (0, ME, "Star convention is not allowed."); 636 RETURN: 637 return; 638 end; 639 else 640 star_loop: 641 begin; 642 star_sw = "1"b; 643 star_list_branch_ptr, star_list_names_ptr = null; 644 645 on condition (cleanup) call CLEAN_UP (); 646 647 call hcs_$star_dir_list_ (dn, en, star_select_sw, area_ptr, star_branch_count, star_link_count, 648 star_list_branch_ptr, star_list_names_ptr, code); 649 if code ^= 0 then do; 650 call complain (code, ME, "^a", pathname_ (dn, en)); 651 go to NEXT_PATH; 652 end; 653 star_en = en; 654 matched = "0"b; 655 star_entry_count = star_branch_count + star_link_count; 656 do j = 1 to star_entry_count; 657 entry_type = star_dir_list_branch (j).type; 658 if entry_type = star_SEGMENT then do; 659 if ^seg_sw then go to NEXT_MATCH; 660 end; 661 else if entry_type = star_LINK then do; 662 if ^link_sw then go to NEXT_MATCH; 663 end; 664 else do; /* directory type: dir or MSF */ 665 if star_dir_list_branch (j).bit_count = 0 then do; 666 if ^dir_sw then go to NEXT_MATCH; 667 end; 668 else if ^seg_sw then go to NEXT_MATCH; 669 end; 670 matched = "1"b; 671 en = star_list_names (star_dir_list_branch (j).nindex); 672 printed_pathname = "0"b; 673 msf = "0"b; 674 msf_ptr = null (); 675 676 call ENTRY_STATUS (); /* do the work */ 677 678 if ^printed_something then /* if we haven't output anything yet, */ 679 printed_something = printed_pathname; /* then if we printed the pathname, */ 680 /* well that's something */ 681 682 if chased | msf_error then dn = saved_dn; 683 if msf then 684 if msf_ptr ^= null then call msf_manager_$close (msf_ptr); 685 if branch_names_ptr ^= null & ^root_sw then free branch_names in (area); 686 NEXT_MATCH: 687 end; 688 if ^matched | (matched & ^printed_something) then 689 call complain (error_table_$nomatch, ME, "^a", pathname_ (dn, star_en)); 690 call CLEAN_UP (); 691 end star_loop; 692 693 NEXT_PATH: 694 end; 695 STATUS_EXIT: 696 call CLEAN_UP (); 697 return; 698 699 ENTRY_STATUS: proc; 700 701 /* This internal procedure returns the requested attributes of dn>en */ 702 /* It uses a number of global values declared in the external procedure. */ 703 /* It allocates branch names and sets branch_names_ptr. */ 704 /* For multisegment files, it turns on the flag msf. */ 705 706 dcl max_switch_length fixed bin; 707 dcl not_mounted fixed bin (35); 708 dcl msf_mode bit (5) aligned; 709 dcl msf_rbs (0:2) fixed bin (5) unaligned; 710 711 max_switch_length = switch_length; 712 branch_status.number_names = "0"b; 713 opt = saved_options; 714 chased, dm_file_sw, msf_error, root_sw = "0"b; 715 not_mounted = 0; 716 717 status_chase = NO_CHASE; /* get info on entry */ 718 719 /* If it's a link, we'll be coming back here with status_chase = CHASE */ 720 721 STATUS: 722 branch_status.names_rel_pointer = "0"b; 723 724 if opt.names | opt.primary_name | opt.link_path then 725 call hcs_$status_long (dn, en, status_chase, addr (branch_status), area_ptr, code); 726 else call hcs_$status_long (dn, en, status_chase, addr (branch_status), null, code); 727 branch_names_ptr = null; 728 729 if branch_status.names_rel_pointer ^= "0"b then 730 branch_names_ptr = ptr (area_ptr, branch_status.names_rel_pointer); 731 732 on condition (cleanup) begin; 733 if branch_names_ptr ^= null & ^root_sw then free branch_names in (area); 734 end; 735 736 if code ^= 0 then 737 if code = error_table_$no_s_permission then do; 738 NO_S: 739 string (opt) = string (opt) & string (no_s_options); 740 if string (opt) = "0"b then call ENTRY_ERROR (code, dn, en); 741 end; 742 else if code = error_table_$logical_volume_not_connected | 743 code = error_table_$logical_volume_not_defined then do; 744 not_mounted = code; 745 string (opt) = string (opt) & string (off_line_options); 746 if branch_status.number_names = "0"b then string (opt) = string (opt) & string (no_s_options); 747 if string (opt) = "0"b then call ENTRY_ERROR (code, dn, en); 748 end; 749 else if code = error_table_$root then do; /* now it works on the root */ 750 root_sw = "1"b; 751 string (opt) = string (opt) & string (root_options); 752 if string (opt) = "0"b then call ENTRY_WRONG_TYPE ("the root"); 753 dn = ">"; 754 en = ""; 755 branch_names_ptr = addr (ROOT_NAMES); /* fake hcs_$status info */ 756 unspec (branch_status) = "0"b; 757 branch_status.type = directory_type; 758 branch_status.unique_id = (36)"1"b; 759 branch_status.number_names = "0001"b4; 760 if get_group_id_ () = INITIALIZER_ID then branch_status.mode = "01011"b; /* sma */ 761 else branch_status.mode = "01"b; /* s for everybody else */ 762 branch_status.ring_brackets (*) = "000111"b; /* 7,7,7 */ 763 end; 764 else call ENTRY_ERROR (code, dn, en); 765 766 /* Check the fs type when we are -inase with -slet, and fake out status if wrong type */ 767 768 if selecting_by_entry_type then do; 769 call fs_util_$get_type (dn, en, fs_type, code); 770 if code ^= 0 then do; 771 call complain (code, ME, "Getting type of ^a", pathname_ (dn, en)); 772 return; 773 end; 774 if ^ENTRY_TYPE_SELECTED (fs_type, fs_entry_type_ptr) then do; 775 matched = "1"b; 776 return; 777 end; 778 else if substr (fs_type, 1, 1) = "-" then ; /* standard type, no faking necessary */ 779 else if star_sw then 780 if before (reverse (rtrim (en)), ".") ^= before (reverse (rtrim (star_en)), ".") then do; 781 matched = "1"b; 782 return; 783 end; 784 end; 785 786 /* See if the entry is a special type */ 787 788 entry_type = fixed (branch_status.type); 789 msf = (entry_type = star_DIRECTORY & branch_status.bit_count ^= "0"b); 790 791 if ^interpret_as_standard_entry & entry_type ^= star_LINK & ^root_sw then 792 if msf | switch_count > 0 | (string (opt) & string (typed_options)) then do; 793 call fs_util_$get_type (dn, en, fs_util_type, code); 794 dm_file_sw = (code = 0 & fs_util_type = FS_OBJECT_TYPE_DM_FILE); 795 if code = 0 & substr (fs_util_type, 1, 1) ^= "-" then do; 796 /* for now, handle segs, dirs, DM files, and MSF's by hand */ 797 entry_type = EXTENDED_type; 798 msf = "0"b; 799 si.version = SUFFIX_INFO_VERSION_1; 800 call fs_util_$suffix_info_for_type (fs_util_type, addr (si), (0)); 801 end; 802 end; 803 804 if branch_status.type = link_type then do; /* process link for -chase or -chase_if_possible */ 805 if chase & chased then do; /* null link */ 806 call complain (0, ME, "Null link with -chase. ^a", pathname_ (dn, en)); 807 return; 808 end; 809 else if (chase_if_possible | chase) then 810 if ^chased then do; 811 call hcs_$get_link_target (dn, en, target_dn, target_en, code); 812 if code = 0 & dn ^= "" then do; 813 chased = "1"b; 814 saved_dn = dn; 815 saved_en = en; 816 dn = target_dn; 817 en = target_en; 818 status_chase = CHASE; /* chase the link this time */ 819 go to STATUS; /* go back to get link info */ 820 end; 821 else if code = error_table_$noentry then 822 if chase then do; /* null link */ 823 call complain (code, ME, 824 "Target: ^a. Link to a null link with -chase. Source: ^a", 825 pathname_ (target_dn, target_en), pathname_ (dn, en)); 826 return; 827 end; 828 end; /* if ^chase */ 829 830 string (opt) = string (opt) & string (link_options); 831 if string (opt) = "0"b & switch_count = 0 then /* no applicable control args */ 832 call ENTRY_WRONG_TYPE ("a link"); 833 end; /* if branch_status.type = link_type */ 834 835 else do; /* non-link */ 836 if ^star_sw then 837 if branch_status.type = directory_type & ^dm_file_sw then do; 838 if (seg_sw | link_sw) & ^dir_sw then call ENTRY_WRONG_TYPE ("a directory"); 839 end; 840 else if (link_sw | dir_sw) & ^seg_sw then 841 if dm_file_sw then call ENTRY_WRONG_TYPE ("a Data Management file"); 842 else call ENTRY_WRONG_TYPE ("a segment"); 843 844 string (opt) = string (opt) & string (nonlink_options); 845 if string (opt) = "0"b & switch_count = 0 then do; /* no applicable control args */ 846 if ^star_sw then call ENTRY_WRONG_TYPE ("not a link"); 847 return; 848 end; 849 end; 850 851 if lengths & active_function then /* set up the return value for -length only when status acts as an active function */ 852 if branch_status.type = directory_type & branch_status.bit_count = "0"b then opt.current_length = "0"b; /* for directory type -- status active function returns bit count for -length */ 853 else opt.bit_count = "0"b; /* for other types -- status active function returns current length for -length */ 854 else ; 855 856 if dm_file_sw | root_sw then msf = "0"b; /* root's not, can't look inside a DM file */ 857 858 if dm_file_sw then do; 859 string (opt) = string (opt) & string (dm_file_options); 860 if string (opt) = "0"b & switch_count = 0 then call ENTRY_WRONG_TYPE ("a Data Management file"); 861 end; 862 else do; /* not DM file; make sure some control args apply */ 863 unspec (opt.dm_files_only) = "0"b; 864 865 /**** vp: phx20203 ; case when string (opt) = "0"b and switch_count > 0 for a link ****/ 866 if string (opt) = "0"b then do; 867 if branch_status.type = link_type then call ENTRY_WRONG_TYPE ("a link"); 868 else call ENTRY_WRONG_TYPE ("not a Data Management file"); 869 end; 870 end; 871 872 /* Now we know we can proceed to print or return some info */ 873 874 if ^active_function & ^one_item then do; /* multiple entries; print pathname */ 875 call PRINT_PATHNAME (); 876 call ioa_ (""); 877 end; 878 879 if dm_file_sw then do; 880 if (string (opt) & string (fm_status_options)) ^= "0"b then do; 881 unspec (auto_dm_file_status) = "0"b; 882 auto_dm_file_status.version = DM_FILE_STATUS_VERSION_1; 883 call file_manager_$status (dn, en, addr (auto_dm_file_status), code); 884 if code ^= 0 & code ^= dm_error_$transaction_in_progress then do; 885 call complain (code, ME, "^a", pathname_ (dn, en)); 886 return; 887 end; 888 end; 889 end; 890 891 /* Format each item of status info */ 892 893 if opt.names | opt.primary_name then do; /* -name or -primary */ 894 if active_function then do; 895 return_string = requote_string_ (rtrim (branch_names (0))); 896 if opt.names then 897 do k = 1 to bin (branch_status.number_names) - 1; 898 return_string = return_string || " " || requote_string_ (rtrim (branch_names (k))); 899 end; 900 return; 901 end; 902 call PRINT_PATHNAME (); 903 if opt.names then do; 904 if one_item then call ioa_ ("^a", branch_names (0)); 905 else call ioa_ ("names:^4x^a", branch_names (0)); 906 do k = 1 to bin (branch_status.number_names) - 1; 907 if one_item then call ioa_ ("^a", branch_names (k)); 908 else call ioa_ ("^10x^a", branch_names (k)); 909 end; 910 end; 911 else if one_item then call ioa_ ("^a", branch_names (0)); 912 else call ioa_ ("primary name:^7x^a", branch_names (0)); 913 end; 914 915 if opt.type then do; /* -type */ 916 if root_sw then type_string = "directory"; 917 else if dm_file_sw then type_string = "Data Management file"; 918 else if entry_type = EXTENDED_type then type_string = si.type_name; 919 else if entry_type = star_LINK then type_string = "link"; 920 else if entry_type = star_SEGMENT then type_string = "segment"; 921 else if entry_type = star_DIRECTORY then 922 if branch_status.bit_count ^= "0"b then type_string = "multisegment file"; 923 else if branch_status.mdir then type_string = "master directory"; 924 else type_string = "directory"; 925 926 if active_function then do; 927 return_string = """" || rtrim (type_string) || """"; 928 return; 929 end; 930 call PRINT_PATHNAME (); 931 if one_item then call ioa_ ("^a", type_string); 932 else call ioa_ ("type:^15x^a", type_string); 933 end; 934 935 if opt.link_path then do; /* -link_path */ 936 target_ptr = ptr (area_ptr, link_status.pnrp); 937 target_len = link_status.pnl; 938 if active_function then do; 939 return_string = rtrim (target_path); 940 return; 941 end; 942 call PRINT_PATHNAME (); 943 if one_item then call ioa_ ("^a", target_ptr -> target_path); 944 else call ioa_ ("links to:^11x^a", target_ptr -> target_path); 945 end; 946 947 if opt.unique_id then do; /* -unique_id */ 948 if dm_file_sw then local_unique_id = auto_dm_file_status.fm_unique_id; 949 else local_unique_id = branch_status.unique_id; 950 if active_function then do; 951 call ioa_$rsnnl ("^w", return_string, k, local_unique_id); 952 return; 953 end; 954 else do; 955 call PRINT_PATHNAME (); 956 if one_item then call ioa_ ("^w", local_unique_id); 957 else call ioa_ ("^[fm unique id:^7x^;unique id:^10x^]^w", dm_file_sw, local_unique_id); 958 end; 959 end; 960 961 /* Get MSF information */ 962 963 if opt.dtu | opt.dtcm | opt.dtem | opt.dtd | opt.bit_count | opt.records_used | opt.current_length | 964 opt.mode | opt.ring_brackets then do; 965 966 call PRINT_PATHNAME (); 967 968 if msf then 969 get_msf_info: 970 begin; 971 on cleanup begin; 972 if msf_ptr ^= null then call msf_manager_$close (msf_ptr); 973 end; 974 975 call msf_manager_$open (dn, en, msf_ptr, code); 976 if msf_ptr = null then do; 977 call complain (code, ME, "Unable to open multisegment file ^a>^a", dn, en); 978 msf = "0"b; 979 return; 980 end; 981 982 msf_dtu, msf_dtcm, msf_dtem, msf_dtd = "0"b; 983 total_records = bin (branch_status.records, 17); 984 total_length = bin (branch_status.current_length, 11); 985 total_bit_count = 0; 986 msf_path = rtrim (dn) || ">" || en; 987 /* initialize in case no components */ 988 msf_mode = branch_status.mode & "01010"b; 989 unspec (msf_rbs) = unspec (branch_status.ring_brackets); 990 991 do k = 0 by 1 while (code = 0); /* look at all components */ 992 call msf_manager_$get_ptr (msf_ptr, k, "0"b, comp_ptr, 0, code); 993 if code = 0 | code = error_table_$segknown then do; 994 comp_name = convert (comp_name, k); 995 comp_name = substr (comp_name, verify (comp_name, " ")); 996 call hcs_$status_long (msf_path, comp_name, 1, addr (msf_info), null, code); 997 if code ^= 0 then 998 if code = error_table_$no_s_permission then do; 999 opt.ring_brackets = "0"b; 1000 if string (opt) = "0"b then do; 1001 saved_dn = dn; 1002 msf_error = "1"b; 1003 call ENTRY_ERROR (code, msf_path, comp_name); 1004 end; 1005 end; 1006 else do; 1007 call complain (code, ME, "^a>^a", msf_path, comp_name); 1008 return; 1009 end; 1010 code = 0; 1011 if fixed (msf_info.dtu) > fixed (msf_dtu) then msf_dtu = msf_info.dtu; 1012 if fixed (msf_info.dtcm) > fixed (msf_dtcm) then msf_dtcm = msf_info.dtcm; 1013 if fixed (msf_info.dtem) > fixed (msf_dtem) then msf_dtem = msf_info.dtem; 1014 if fixed (msf_info.dtd) > fixed (msf_dtd) then msf_dtd = msf_info.dtd; 1015 if k = 0 then do; /* first component */ 1016 msf_mode = msf_info.mode; 1017 unspec (msf_rbs) = unspec (msf_info.rbs); 1018 end; 1019 total_records = total_records + msf_info.records; 1020 total_bit_count = total_bit_count + bin (msf_info.bit_count); 1021 total_length = total_length + msf_info.current_length; 1022 end; 1023 else if code ^= error_table_$noentry then do; 1024 opt.bit_count, opt.records_used, opt.current_length, opt.dtu, opt.dtcm, 1025 opt.dtem, opt.dtd, opt.mode, opt.ring_brackets = "0"b; 1026 if string (opt) = "0"b then do; 1027 saved_dn = dn; 1028 msf_error = "1"b; 1029 comp_name = convert (comp_name, k); 1030 call ENTRY_ERROR (error_table_$moderr, 1031 dn, en); 1032 end; 1033 end; 1034 end; 1035 end get_msf_info; 1036 end; 1037 1038 if opt.dtu then do; /* -date_time_used */ 1039 1040 /**** vp: phx20897; convert the system clock to 36 bits then make use of 1041* the internal procedure CONVERT_DATE to convert a 36 bits clock time 1042* into an ASCII date string. This will effectively check for active 1043* function as well. ****/ 1044 1045 if root_sw then do; 1046 temp_clock = clock (); /* This conversion method was taken from date_time_.pl1 routine */ 1047 stime = addr (temp_clock) -> fs_time_value.time; 1048 call CONVERT_DATE (stime); 1049 end; 1050 else if msf & msf_dtu ^= "0"b then call CONVERT_DATE (msf_dtu); 1051 else call CONVERT_DATE (branch_status.date_time_used); 1052 call PRINT_PATHNAME (); 1053 if one_item then call ioa_ ("^a", date_string); 1054 else if date_string ^= "ZERO" | explicit_opt.dtu then call ioa_ ("date used:^10x^a", date_string); 1055 end; 1056 1057 if opt.dtcm then do; /* -date_time_contents_modified */ 1058 if msf & msf_dtcm ^= "0"b then call CONVERT_DATE (msf_dtcm); 1059 else call CONVERT_DATE (branch_status.date_time_modified); 1060 call PRINT_PATHNAME (); 1061 if one_item then call ioa_ ("^a", date_string); 1062 else if date_string ^= "ZERO" | explicit_opt.dtcm then call ioa_ ("date modified:^6x^a", date_string); 1063 end; 1064 1065 if opt.dtem then do; /* -date_time_entry_modified */ 1066 call PRINT_PATHNAME (); 1067 if entry_type = star_LINK then do; 1068 call CONVERT_DATE (link_status.dtlm); 1069 if one_item then call ioa_ ("^a", date_string); 1070 else if date_string ^= "ZERO" | explicit_opt.dtem then 1071 call ioa_ ("date link modified: ^a", date_string); 1072 end; 1073 else do; 1074 if msf & msf_dtem ^= "0"b then call CONVERT_DATE (msf_dtem); 1075 else call CONVERT_DATE (branch_status.date_time_entry_modified); 1076 if one_item then call ioa_ ("^a", date_string); 1077 else if date_string ^= "ZERO" | explicit_opt.dtem then 1078 call ioa_ ("branch modified:^4x^a", date_string); 1079 end; 1080 end; 1081 1082 if opt.dtvd then do; /* -date_time_volume_dumped */ 1083 call PRINT_PATHNAME (); 1084 if entry_type = star_LINK then do; 1085 call hcs_$get_dates (dn, "", dates_array, code); 1086 call CONVERT_DATE (dates_array (5)); 1087 if one_item then call ioa_ ("link dtvd: ^a", date_string); 1088 else if date_string ^= "ZERO" | explicit_opt.dtd then 1089 call ioa_ ("link volume dumped:^1x^a", date_string); 1090 end; 1091 else do; 1092 call hcs_$get_dates (dn, en, dates_array, code); 1093 call CONVERT_DATE (dates_array (5)); 1094 if one_item then call ioa_ ("dtvd: ^a", date_string); 1095 else if date_string ^= "ZERO" | explicit_opt.dtd then 1096 call ioa_ ("date volume dumped:^1x^a", date_string); 1097 end; 1098 end; 1099 1100 if opt.dtd then do; /* -date_time_dumped */ 1101 call PRINT_PATHNAME (); 1102 if entry_type = star_LINK then do; 1103 call CONVERT_DATE (link_status.dtd); 1104 if one_item then call ioa_ ("dtd: ^a", date_string); 1105 else if date_string ^= "ZERO" | explicit_opt.dtd then 1106 call ioa_ ("link dumped:^8x^a", date_string); 1107 end; 1108 else do; 1109 if msf & msf_dtd ^= "0"b then call CONVERT_DATE (msf_dtd); 1110 else call CONVERT_DATE (branch_status.date_time_dumped); 1111 if one_item then call ioa_ ("br dtd: ^a", date_string); 1112 else if date_string ^= "ZERO" | explicit_opt.dtd then 1113 call ioa_ ("date branch dumped:^1x^a", date_string); 1114 end; 1115 end; 1116 1117 if opt.author then do; /* -author */ 1118 call PRINT_PATHNAME (); 1119 if root_sw then do; 1120 author_string = INITIALIZER_ID; 1121 code = 0; 1122 end; 1123 else call hcs_$get_author (dn, en, 0, author_string, code); 1124 if active_function then do; 1125 if code = 0 then return_string = rtrim (author_string); 1126 else call active_fnc_err_ (code, ME); 1127 return; 1128 end; 1129 if code = 0 then do; 1130 if one_item then call ioa_ ("^a", author_string); 1131 else call ioa_ ("author:^13x^a", author_string); 1132 end; 1133 else if one_item then call complain (code, ME); 1134 else if explicit_opt.author then call complain (code, ME, "Unable to get author."); 1135 end; 1136 1137 if opt.bc_author then do; /* -bc_author */ 1138 call PRINT_PATHNAME (); 1139 if root_sw then do; 1140 bc_author_string = INITIALIZER_ID; 1141 code = 0; 1142 end; 1143 else call hcs_$get_bc_author (dn, en, bc_author_string, code); 1144 if active_function then do; 1145 if code = 0 then return_string = rtrim (bc_author_string); 1146 else call active_fnc_err_ (code, ME); 1147 return; 1148 end; 1149 if code = 0 then do; 1150 if one_item then call ioa_ ("^a", bc_author_string); 1151 else if explicit_opt.bc_author | bc_author_string ^= author_string then 1152 call ioa_ ("bit count author:^3x^a", bc_author_string); 1153 end; 1154 else if one_item then call complain (code, ME); 1155 else if explicit_opt.bc_author then call complain (code, ME, "Unable to get bit count author."); 1156 end; 1157 1158 if opt.logical_volume then do; /* -logical_volume */ 1159 call PRINT_PATHNAME (); 1160 if root_sw then do; 1161 lv_string = "root"; 1162 code = 0; 1163 end; 1164 else call mdc_$find_lvname (branch_status.lvid, lv_string, code); 1165 if active_function then do; 1166 if code = 0 then return_string = rtrim (lv_string); 1167 else call active_fnc_err_ (code, ME); 1168 return; 1169 end; 1170 else if code = 0 then do; 1171 if one_item then call ioa_ ("^a", lv_string); 1172 else if entry_type = star_SEGMENT then call ioa_ ("volume name:^8x^a", lv_string); 1173 else call ioa_ ("sons volume:^8x^a", lv_string); 1174 end; 1175 else if one_item then call complain (code, ME); 1176 else if explicit_opt.logical_volume then call complain (code, ME, "Unable to get logical volume."); 1177 end; 1178 1179 if opt.bit_count then do; /* -bit_count */ 1180 call PRINT_PATHNAME (); 1181 if root_sw then bc35 = 0; 1182 else do; 1183 bc36 = "0000"b3 || branch_status.bit_count; 1184 unspec (bc35) = bc36; /* convert to fixed bin (35) */ 1185 end; 1186 if msf then 1187 if active_function then do; 1188 call ioa_$rsnnl ("^d", return_string, k, total_bit_count); 1189 return; 1190 end; 1191 else do; 1192 call ioa_ ("number of components:^9x^d", k - 1); 1193 if k - 1 ^= bin (branch_status.bit_count) then 1194 call ioa_ ("msf indicator:^6x^d (inconsistent with number of components)", bc35); 1195 call ioa_ ("total bit count:^4x^d", total_bit_count); 1196 end; 1197 else if active_function then do; 1198 call ioa_$rsnnl ("^d", return_string, k, bc35); 1199 return; 1200 end; 1201 else if one_item then call ioa_ ("^d", bc35); 1202 else call ioa_ ("bit count:^10x^d", bc35); 1203 end; 1204 1205 if opt.records_used then do; /* -records_used */ 1206 call PRINT_PATHNAME (); 1207 if msf then 1208 if active_function then do; 1209 call ioa_$rsnnl ("^d", return_string, k, total_records); 1210 return; 1211 end; 1212 else do; 1213 if one_item then call ioa_ ("^d", total_records); 1214 else call ioa_ ("total records used:^x^d", total_records); 1215 end; 1216 else if active_function then do; 1217 call ioa_$rsnnl ("^d", return_string, k, fixed (branch_status.records, 18)); 1218 return; 1219 end; 1220 else do; 1221 if one_item then call ioa_ ("^d", fixed (branch_status.records, 18)); 1222 else call ioa_ ("records used:^7x^d", fixed (branch_status.records, 18)); 1223 end; 1224 end; 1225 1226 if opt.current_length then do; /* -current_length */ 1227 call PRINT_PATHNAME (); 1228 if msf then 1229 if active_function then do; 1230 call ioa_$rsnnl ("^d", return_string, k, total_length); 1231 return; 1232 end; 1233 else do; 1234 if one_item then call ioa_ ("^d", total_length); 1235 else if explicit_opt.current_length | total_length ^= total_records then 1236 call ioa_ ("total length:^7x^d", total_length); 1237 end; 1238 else if active_function then do; 1239 call ioa_$rsnnl ("^d", return_string, k, fixed (branch_status.current_length, 12)); 1240 return; 1241 end; 1242 else do; 1243 if one_item then call ioa_ ("^d", fixed (branch_status.current_length, 12)); 1244 else if explicit_opt.current_length | 1245 branch_status.current_length ^= substr (branch_status.records, 7, 12) then 1246 call ioa_ ("current length:^5x^d", fixed (branch_status.current_length, 12)); 1247 end; 1248 end; 1249 1250 if opt.max_length then do; /* -max_length */ 1251 call PRINT_PATHNAME (); 1252 if entry_type ^= star_DIRECTORY then do; 1253 if msf then call hcs_$get_max_length (msf_path, "0", max_length, code); 1254 else if entry_type = EXTENDED_type then call fs_util_$get_max_length (dn, en, max_length, code); 1255 else call hcs_$get_max_length (dn, en, max_length, code); 1256 if active_function then do; 1257 if code = 0 then call ioa_$rsnnl ("^d", return_string, k, max_length); 1258 else call active_fnc_err_ (code, ME); 1259 return; 1260 end; 1261 if code = 0 then 1262 if one_item then call ioa_ ("^d", max_length); 1263 else call ioa_ ("max length:^9x^d", max_length); 1264 else if code = error_table_$unsupported_operation & ^explicit_opt.max_length then ; 1265 /* ignore if this type has no max length */ 1266 else if one_item then call complain (code, ME); 1267 else if explicit_opt.max_length then call complain (code, ME, "Unable to get max length."); 1268 end; 1269 else if active_function then do; 1270 call active_fnc_err_ (0, ME, "Unable to get the max length of a directory. ^a>^a", dn, en); 1271 return; 1272 end; 1273 else if explicit_opt.max_length then 1274 call complain (0, ME, "Unable to get the max length of a directory. ^a>^a", dn, en); 1275 end; 1276 1277 if opt.mode then do; /* -mode */ 1278 call PRINT_PATHNAME (); 1279 if dm_file_sw then string (mode_bits) = "0"b || substr (auto_dm_file_status.mode, 1, 4); /* prevent string size condition while compiling. */ 1280 else if msf then string (mode_bits) = msf_mode; 1281 else string (mode_bits) = branch_status.mode; 1282 mode_string = ""; 1283 if entry_type = EXTENDED_type then do; 1284 call fs_util_$get_user_access_modes (dn, en, "", -1, modes, exmodes, code); 1285 if code ^= 0 then 1286 if code = error_table_$unsupported_operation & ^explicit_opt.mode then ; 1287 /* ignore if this type has no extended mode */ 1288 else call complain (code, ME, "Unable to get extended mode."); 1289 else do; 1290 do k = 1 to length (rtrim (si.modes)); 1291 if substr (modes, k, 1) then mode_string = mode_string || substr (si.modes, k, 1); 1292 end; 1293 end; 1294 end; 1295 else if dm_file_sw | msf | entry_type = star_SEGMENT then do; 1296 if mode_bits (2) then mode_string = "r"; 1297 if mode_bits (3) then mode_string = mode_string || "e"; 1298 if mode_bits (4) then mode_string = mode_string || "w"; 1299 end; 1300 else do; /* directory */ 1301 if mode_bits (2) then mode_string = "s"; 1302 if mode_bits (4) then mode_string = mode_string || "m"; 1303 if mode_bits (5) then mode_string = mode_string || "a"; 1304 end; 1305 if code = 0 then do; 1306 if mode_string = "" then mode_string = "null"; 1307 if active_function then do; 1308 return_string = mode_string; 1309 return; 1310 end; 1311 if one_item then call ioa_ ("^a", mode_string); 1312 else call ioa_ ("mode:^15x^a", mode_string); 1313 end; 1314 end; 1315 1316 if opt.access_class then do; /* -access_class */ 1317 call PRINT_PATHNAME (); 1318 call hcs_$get_access_class (dn, en, access_class, code); 1319 if code = 0 then do; 1320 call convert_authorization_$to_string_short (access_class, class, code); 1321 if code ^= 0 then call complain (code, ME, "Unable to convert access class."); 1322 else if active_function then do; 1323 if class = "" then class = "system_low"; 1324 return_string = rtrim (class); 1325 return; 1326 end; 1327 else if class ^= "" then do; /* format access class in lines of 50 chars */ 1328 class_len = index (class, " ") - 1; 1329 if class_len = -1 then class_len = 336; 1330 k = 1; 1331 if ^one_item then call ioa_$nnl ("access class:^7x"); 1332 do while ((class_len - k + 1) > 50); 1333 temp_string = substr (class, k, 50); 1334 kk = length (temp_string) + 1 - index (reverse (temp_string), ","); 1335 call ioa_$nnl ("^a", substr (class, k, kk)); 1336 if ^one_item then call ioa_$nnl ("^/^20x"); 1337 k = k + kk; 1338 end; 1339 call ioa_ ("^a", substr (class, k)); 1340 end; 1341 else if explicit_opt.access_class then 1342 if one_item then call ioa_ ("system_low"); 1343 else call ioa_ ("access class:^7xsystem_low"); 1344 end; 1345 else if active_function | explicit_opt.access_class then do; 1346 call complain (code, ME, "Unable to get access class."); 1347 return; 1348 end; 1349 end; 1350 1351 if opt.ring_brackets then do; /* -ring_brackets */ 1352 call PRINT_PATHNAME (); 1353 if entry_type = EXTENDED_type then do; 1354 if si.num_ring_brackets = 0 then 1355 if explicit_opt.ring_brackets then 1356 call complain (0, ME, "The ^a object type does not support ring brackets.", 1357 si.type_name); 1358 else ; 1359 else do; 1360 call fs_util_$get_ring_brackets (dn, en, ring_brackets, code); 1361 if code ^= 0 then 1362 if code = error_table_$unsupported_operation & ^explicit_opt.ring_brackets then ; 1363 /* ignore if this type has no ring brackets */ 1364 else call complain (code, ME, "Unable to get ring brackets."); 1365 else if active_function then call ioa_$rsnnl ("^v(^d ^)", return_string, k, 1366 si.num_ring_brackets, ring_brackets); 1367 else call ioa_ ("^[ring brackets:^6x^]^v(^d, ^)^d", ^one_item, 1368 si.num_ring_brackets - 1, ring_brackets); 1369 end; 1370 end; 1371 else if active_function then do; 1372 if dm_file_sw then 1373 call ioa_$rsnnl ("^d ^d", return_string, k, auto_dm_file_status.ring_brackets); 1374 else if msf then call ioa_$rsnnl ("^d ^d ^d", return_string, k, msf_rbs); 1375 else if entry_type ^= star_DIRECTORY then 1376 call ioa_$rsnnl ("^d ^d ^d", return_string, k, fixed (branch_status.ring_brackets, 5)); 1377 else call ioa_$rsnnl ("^d ^d", return_string, k, fixed (branch_status.ring_brackets (0), 5), 1378 fixed (branch_status.ring_brackets (1), 5)); 1379 return; 1380 end; 1381 else if dm_file_sw then 1382 if one_item then call ioa_ ("^d, ^d", auto_dm_file_status.ring_brackets); 1383 else call ioa_ ("extended ring brackets:^2x^d, ^d", auto_dm_file_status.ring_brackets); 1384 else if msf then 1385 if one_item then call ioa_ ("^d, ^d, ^d", msf_rbs); 1386 else call ioa_ ("ring brackets:^6x^d, ^d, ^d", msf_rbs); 1387 else if entry_type ^= star_DIRECTORY then 1388 if one_item then call ioa_ ("^d, ^d, ^d", fixed (branch_status.ring_brackets, 5)); 1389 else call ioa_ ("ring brackets:^6x^d, ^d, ^d", fixed (branch_status.ring_brackets, 5)); 1390 else if one_item then call ioa_ ("^d, ^d", fixed (branch_status.ring_brackets (0), 5), 1391 fixed (branch_status.ring_brackets (1), 5)); 1392 else call ioa_ ("ring brackets:^6x^d, ^d", fixed (branch_status.ring_brackets (0), 5), 1393 fixed (branch_status.ring_brackets (1), 5)); 1394 end; 1395 1396 if opt.usage_count then do; /* -usage_count */ 1397 call PRINT_PATHNAME (); 1398 if entry_type = star_DIRECTORY then 1399 if explicit_opt.usage_count & ^star_sw then 1400 call complain (0, ME, "Cannot determine the usage count of a directory."); 1401 else ; 1402 else do; 1403 usage_count = 0; 1404 on linkage_error begin; 1405 usage_count = -1; 1406 go to flurp; 1407 end; 1408 call mhcs_$get_seg_usage (dn, en, usage_count, code); 1409 flurp: 1410 revert linkage_error; 1411 if usage_count < 0 then code = error_table_$incorrect_access; 1412 if active_function then do; 1413 if code = 0 then call ioa_$rsnnl ("^d", return_string, k, usage_count); 1414 else call active_fnc_err_ (code, ME); 1415 return; 1416 end; 1417 if code = 0 then 1418 if one_item then call ioa_ ("^d", usage_count); 1419 else call ioa_ ("usage count:^8x^d", usage_count); 1420 else if explicit_opt.usage_count then 1421 call complain (code, ME, "Unable to get usage count."); 1422 end; 1423 end; 1424 1425 if entry_type = EXTENDED_type | dm_file_sw then do; 1426 call PRINT_PATHNAME (); 1427 switch_list_ptr = null (); 1428 on cleanup begin; 1429 if switch_list_ptr ^= null () 1430 then free switch_list; 1431 end; 1432 1433 call fs_util_$list_switches_for_type (fs_util_type, SWITCH_LIST_VERSION_1, area_ptr, 1434 switch_list_ptr, code); 1435 if code = error_table_$unsupported_operation & 1436 ^(explicit_opt.safety_switch | explicit_opt.ivds | explicit_opt.copy_switch | explicit_opt.audit_switch | explicit_opt.cvds | 1437 explicit_opt.synchronized_switch | explicit_opt.damaged_switch | explicit_opt.concurrency_switch | 1438 explicit_opt.rollback_switch | explicit_opt.protected_switch) then 1439 goto SKIP_SWITCHES; /* WARNING, this ain't too modular */ 1440 if code ^= 0 then do; 1441 call complain (code, ME, "Listing switches."); 1442 return; 1443 end; 1444 if all then do k = 1 to switch_list.switch_count; 1445 max_switch_length = max (max_switch_length, 1446 length (rtrim (switch_list.names (switch_list.name_index (k))))); 1447 end; 1448 end; 1449 max_switch_length = max_switch_length + 8; /* " switch: " */ 1450 1451 if opt.safety_switch then do; /* -safety_switch */ 1452 call PRINT_PATHNAME (); 1453 if entry_type = EXTENDED_type | dm_file_sw then call STATUS_SWITCH ("safety", explicit_opt.safety_switch); 1454 else do; 1455 if root_sw then safety_switch = "0"b; 1456 else call hcs_$get_safety_sw (dn, en, safety_switch, code); 1457 call PRINT_SWITCH ("safety", explicit_opt.safety_switch, safety_switch, "0"b); 1458 end; 1459 end; 1460 1461 if opt.ivds then do; /* -ivds */ 1462 call PRINT_PATHNAME (); 1463 if entry_type = star_DIRECTORY & ^root_sw then 1464 if explicit_opt.ivds then call ENTRY_WRONG_TYPE ("a directory"); 1465 else ; /* not valid for dirs */ 1466 else do; 1467 if entry_type = EXTENDED_type | dm_file_sw then 1468 call STATUS_SWITCH ("ivds", explicit_opt.ivds); 1469 else do; 1470 if root_sw then ivds = 1; 1471 else call hcs_$get_volume_dump_switches (dn, en, ivds, cvds, code); 1472 call PRINT_SWITCH ("ivds", explicit_opt.ivds, (ivds = -1), "1"b); 1473 end; 1474 end; 1475 end; 1476 1477 if opt.cvds then do; /* -cvds */ 1478 call PRINT_PATHNAME (); 1479 if entry_type = star_DIRECTORY & ^root_sw then 1480 if explicit_opt.cvds then call ENTRY_WRONG_TYPE ("a directory"); 1481 else ; /* not valid for dirs */ 1482 else do; 1483 if entry_type = EXTENDED_type | dm_file_sw then call STATUS_SWITCH ("cvds", explicit_opt.cvds); 1484 else do; 1485 if root_sw then cvds = 1; 1486 else call hcs_$get_volume_dump_switches (dn, en, ivds, cvds, code); 1487 call PRINT_SWITCH ("cvds", explicit_opt.cvds, (cvds = -1), "1"b); 1488 end; 1489 end; 1490 end; 1491 1492 if opt.audit_switch then do; /* -audit_switch */ 1493 call PRINT_PATHNAME (); 1494 if entry_type = EXTENDED_type | dm_file_sw then call STATUS_SWITCH ("audit", explicit_opt.audit_switch); 1495 else do; 1496 bks.version = status_for_backup_version_2; 1497 call hcs_$status_for_backup (dn, en, addr (bks), code); 1498 call PRINT_SWITCH ("audit", explicit_opt.audit_switch, (bks.audit_flag), "0"b); 1499 end; 1500 end; 1501 1502 if opt.copy_switch then do; /* -copy_switch */ 1503 call PRINT_PATHNAME (); 1504 if entry_type = EXTENDED_type | dm_file_sw then call STATUS_SWITCH ("copy", explicit_opt.copy_switch); 1505 else do; 1506 code = 0; 1507 call PRINT_SWITCH ("copy", explicit_opt.copy_switch, (branch_status.copy_switch), "0"b); 1508 end; 1509 end; 1510 1511 if opt.damaged_switch then do; /* -damaged_switch */ 1512 call PRINT_PATHNAME (); 1513 if entry_type = EXTENDED_type | dm_file_sw then 1514 call STATUS_SWITCH ("damaged", explicit_opt.damaged_switch); 1515 else do; 1516 code = 0; 1517 call PRINT_SWITCH ("damaged", explicit_opt.damaged_switch, (branch_status.damaged_switch), "0"b); 1518 end; 1519 end; 1520 1521 if opt.synchronized_switch then do; /* -synchronized_switch */ 1522 call PRINT_PATHNAME (); 1523 if entry_type = EXTENDED_type | dm_file_sw then 1524 call STATUS_SWITCH ("synchronized", explicit_opt.synchronized_switch); 1525 else do; 1526 code = 0; 1527 if fixed (branch_status.bit_count) = 0 & branch_status.type = directory_type then do; 1528 if ^all then 1529 call complain (0, ME, "Directories do not support the synch switch. ^a.", pathname_ (dn, en)); 1530 end; 1531 else call PRINT_SWITCH ("synchronized", explicit_opt.synchronized_switch, 1532 (branch_status.synchronized_switch), "0"b); 1533 end; 1534 end; 1535 1536 call PRINT_PATHNAME (); 1537 if entry_type = EXTENDED_type then do; 1538 if all then do; 1539 do k = 1 to switch_list.switch_count; 1540 if switch_list.name_index (k) > 0 then 1541 call STATUS_SWITCH_QUICK ((switch_list.names (switch_list.name_index (k))), "0"b); 1542 end; 1543 do k = 1 to switch_count; 1544 do kk = 1 to switch_list.switch_name_count; 1545 if switch_names (k) = switch_list.names (kk) then go to FOUND; 1546 end; 1547 call complain (0, ME, "The ^a switch is not supported by ^a.", switch_names (k), 1548 si.plural_name); 1549 FOUND: 1550 end; 1551 end; 1552 1553 else if switch_mask ^= "0"b then do kk = 1 to switch_count; 1554 call STATUS_SWITCH (switch_names (kk), "1"b); 1555 end; 1556 end; 1557 else if switch_mask ^= "0"b then do k = 1 to switch_count; 1558 if substr (switch_mask, k, 1) then 1559 call complain (0, ME, "Standard objects do not support the ^a switch.", switch_names (k)); 1560 end; 1561 1562 SKIP_SWITCHES: 1563 if opt.entry_bound then do; 1564 call PRINT_PATHNAME (); 1565 if entry_type ^= star_SEGMENT then 1566 if explicit_opt.entry_bound then 1567 call complain (0, ME, "The entry is not a gate. ^a", pathname_ (dn, en)); 1568 else ; 1569 else do; 1570 bks.version = status_for_backup_version_2; 1571 call hcs_$status_for_backup (dn, en, addr (bks), code); 1572 if code ^= 0 then call complain (code, ME, "Unable to obtain entrybound."); 1573 else if ^bks.entrypt then 1574 NOT_GATE: 1575 if explicit_opt.entry_bound then call complain (0, ME, "The entry is not a gate."); 1576 else ; 1577 else if active_function then call ioa_$rsnnl ("^d", return_string, k, fixed (bks.entrypt_bound)); 1578 else if one_item then call ioa_ ("^d", fixed (bks.entrypt_bound)); 1579 else call ioa_ ("entry bound:^8x^d", fixed (bks.entrypt_bound)); 1580 end; 1581 end; 1582 1583 if opt.highest_ci then do; 1584 call PRINT_PATHNAME (); 1585 if active_function then call ioa_$rsnnl ("^d", return_string, k, auto_dm_file_status.highest_ci); 1586 else if one_item then call ioa_ ("^d", auto_dm_file_status.highest_ci); 1587 else call ioa_ ("highest control interval: ^d", auto_dm_file_status.highest_ci); 1588 end; 1589 1590 if opt.concurrency_switch then do; 1591 call PRINT_PATHNAME (); 1592 call PRINT_SWITCH ("concurrency", explicit_opt.concurrency_switch, 1593 ^auto_dm_file_status.no_concurrency_sw, "1"b); 1594 end; 1595 1596 if opt.rollback_switch then do; 1597 call PRINT_PATHNAME (); 1598 call PRINT_SWITCH ("rollback", explicit_opt.rollback_switch, 1599 ^auto_dm_file_status.no_rollback_sw, "1"b); 1600 end; 1601 1602 if opt.protected_switch then do; 1603 call PRINT_PATHNAME (); 1604 call PRINT_SWITCH ("protected", explicit_opt.protected_switch, 1605 (auto_dm_file_status.protected_sw), "1"b); 1606 end; 1607 1608 if not_mounted ^= 0 & all & ^active_function then 1609 call complain (not_mounted, ME, 1610 "Unable to determine: date used, date modified, date volume dumped, records used, max length or usage count."); 1611 1612 if j = star_entry_count & ^active_function & ^one_item then call ioa_ (""); 1613 if (entry_type = EXTENDED_type) & (switch_list_ptr ^= null ()) then free switch_list; 1614 1615 ENTRY_RETURN: 1616 return; 1617 1618 CONVERT_DATE: proc (date_time); 1619 1620 /* This internal procedure converts a bit(36) clock time into an ASCII date string. 1621* If status was called as an active function, the string is returned. */ 1622 1623 dcl date_time bit (36); 1624 dcl date_time_$format entry (char (*), fixed bin (71), char (*), char (*)) returns (char (250) var); 1625 dcl cv_fstime_ entry (bit (36) aligned) returns (fixed bin (71)); 1626 1627 if date_time = "0"b then date_string = "ZERO"; 1628 else date_string = date_time_$format ("date_time", cv_fstime_ ((date_time)), "", ""); 1629 if active_function then do; 1630 return_string = """" || rtrim (date_string) || """"; 1631 go to ENTRY_RETURN; /* "status" active function must call normal cleanup handler before it finishes. */ 1632 end; 1633 1634 end CONVERT_DATE; 1635 1636 ENTRY_ERROR: proc (P_code, P_dn, P_en); 1637 1638 dcl P_code fixed bin (35); 1639 dcl (P_dn, P_en) char (*); 1640 1641 if active_function then do; 1642 if msf_ptr ^= null then 1643 call msf_manager_$close (msf_ptr); 1644 call CLEAN_UP; 1645 end; 1646 call complain (P_code, ME, "^a", pathname_ (P_dn, P_en)); 1647 go to ENTRY_RETURN; 1648 1649 end ENTRY_ERROR; 1650 1651 ENTRY_WRONG_TYPE: proc (P_string); 1652 1653 dcl P_string char (*); 1654 1655 if ^star_sw then 1656 call complain (0, ME, "^a is ^[the root^;^a^]. Control arguments given do not apply.", 1657 pathname_ (dn, en), root_sw, P_string); 1658 go to ENTRY_RETURN; 1659 1660 end ENTRY_WRONG_TYPE; 1661 1662 PRINT_PATHNAME: proc; 1663 1664 /* This internal procedure merely prints out the pathname if it hasn't been 1665* printed yet. */ 1666 1667 if printed_pathname | active_function then return; 1668 1669 if star_sw | (path_count > 1) then 1670 if one_item then call ioa_ ("^5x^a", pathname_ (dn, en)); 1671 else call ioa_ ("^/^10x^a", pathname_ (dn, en)); 1672 else ; /* don't print header for only 1 path on command line */ 1673 1674 printed_pathname = "1"b; 1675 return; 1676 1677 end PRINT_PATHNAME; 1678 1679 STATUS_SWITCH: proc (switch, explicit); 1680 1681 dcl switch char (*); 1682 dcl temp_switch char (32); 1683 dcl explicit bit (1) unaligned; 1684 dcl default bit (1) aligned; 1685 dcl value bit (1) aligned; 1686 dcl x fixed bin; 1687 1688 if switch = "cvds" then temp_switch = "complete_volume_dump"; 1689 else if switch = "ivds" then temp_switch = "incremental_volume_dump"; 1690 else temp_switch = switch; 1691 1692 do k = 1 to switch_list.switch_count; 1693 do x = 0 to switch_list.name_count (k) - 1; 1694 if switch_list.name_index (k) > 0 then 1695 if switch = switch_list.names (switch_list.name_index (k) + x) then go to JOIN; 1696 end; 1697 end; 1698 1699 if explicit then 1700 call complain (0, ME, "The ^a switch is not supported by ^a.", switch, si.plural_name); 1701 1702 return; 1703 1704 STATUS_SWITCH_QUICK: entry (switch, explicit); 1705 1706 temp_switch = switch; 1707 JOIN: 1708 if switch_list.name_index (k) = 0 then return; /* already printed */ 1709 switch_list.name_index (k) = 0; /* so we don't come back */ 1710 default = switch_list.default_value (k); 1711 1712 call fs_util_$get_switch (dn, en, temp_switch, value, code); 1713 goto PRINT; 1714 1715 PRINT_SWITCH: entry (switch, explicit, switch_value, default_value); 1716 1717 dcl switch_value bit (1) aligned; 1718 dcl default_value bit (1) aligned; 1719 1720 value = switch_value; 1721 default = default_value; 1722 code = 0; 1723 PRINT: 1724 if code ^= 0 then call complain (code, ME, "Unable to get ^a switch.", switch); 1725 1726 if active_function then do; 1727 if value then return_string = "true"; 1728 else return_string = "false"; 1729 return; 1730 end; 1731 else if all | (value ^= default) then 1732 if one_item then call ioa_ ("^[on^;off^]", value); 1733 else call ioa_ ("^a switch:^vt^[on^;off^] (default^[ = ^[off^;on^]^])", switch, max_switch_length, value, 1734 value ^= default, value); 1735 else if explicit then 1736 if one_item then call ioa_ ("^[on^;off^]", value); 1737 else call ioa_ ("^a switch:^vt^[on^;off^]", switch, max_switch_length, value); 1738 1739 return; 1740 1741 end STATUS_SWITCH; 1742 1743 end ENTRY_STATUS; 1744 1745 BUILD_ENTRY_TYPE_LIST: proc (P_entry_type_list, P_fs_entry_type_ptr, P_slet_enabled_sw); 1746 1747 dcl P_entry_type_list char (*); 1748 dcl P_fs_entry_type_ptr ptr; 1749 dcl P_slet_enabled_sw bit (1) aligned; 1750 dcl 1 entry_type_info aligned like suffix_info; 1751 dcl types char (types_len) based (types_ptr); 1752 dcl types_len fixed bin (24); 1753 dcl types_ptr ptr; 1754 dcl this_type char (32); 1755 1756 /* Copy the entry type list parameter into locally managed storage */ 1757 1758 types_ptr = null; 1759 on cleanup begin; 1760 if types_ptr ^= null then free types in (area); 1761 end; 1762 1763 types_len = length (P_entry_type_list); 1764 allocate types set (types_ptr) in (area); 1765 types = P_entry_type_list; 1766 1767 /* Count the number of entry types and allocate the entry type array */ 1768 1769 do fs_entry_type_count = 1 1770 repeat (fs_entry_type_count + 1) 1771 while (index (types, ",") ^= 0); 1772 types = after (types, ","); 1773 end; 1774 1775 allocate fs_entry_type in (area) set (P_fs_entry_type_ptr); 1776 1777 entry_type_info.version = SUFFIX_INFO_VERSION_1; 1778 P_fs_entry_type_ptr -> fs_entry_type.suffix (*) = ""; 1779 1780 /* For each potential entry type, validate it and add it to the structure */ 1781 1782 types = P_entry_type_list; 1783 entry_type_index = 1; 1784 1785 do while (types ^= ""); 1786 1787 this_type = before (types, ","); 1788 if substr (this_type, 1, 1) ^= "-" then do; 1789 if this_type = "link" then this_type = FS_OBJECT_TYPE_LINK; 1790 else if this_type = "segment" then this_type = FS_OBJECT_TYPE_SEGMENT; 1791 else if this_type = "directory" then this_type = FS_OBJECT_TYPE_DIRECTORY; 1792 else if this_type = "multisegment_file" then this_type = FS_OBJECT_TYPE_MSF; 1793 else if this_type = "data_management_file" then this_type = FS_OBJECT_TYPE_DM_FILE; 1794 1795 P_fs_entry_type_ptr -> fs_entry_type.suffix (entry_type_index) = this_type; 1796 1797 if this_type = FS_OBJECT_TYPE_LINK then entry_type_index = entry_type_index + 1; 1798 /* fs_util_ does not handle links */ 1799 else do; 1800 call fs_util_$suffix_info_for_type (this_type, addr (entry_type_info), code); 1801 if code = 0 then entry_type_index = entry_type_index + 1; 1802 end; 1803 end; 1804 1805 types = after (types, ","); 1806 end; 1807 1808 /* Free the types variable and set P_slet_enabled_sw */ 1809 1810 free types_ptr -> types in (area); 1811 1812 P_fs_entry_type_ptr -> fs_entry_type.count = entry_type_index - 1; 1813 if P_fs_entry_type_ptr -> fs_entry_type.count > 0 then P_slet_enabled_sw = "1"b; 1814 else do; 1815 call complain (0, ME, 1816 "^[None of the specified entry types is valid^;The specified entry type is not valid^]: ^a", 1817 P_fs_entry_type_ptr -> fs_entry_type.count > 1, P_entry_type_list); 1818 go to STATUS_EXIT; 1819 end; 1820 1821 return; 1822 1823 end BUILD_ENTRY_TYPE_LIST; 1824 1825 ENTRY_TYPE_SELECTED: proc (P_fs_type, P_fs_entry_type_ptr) returns (bit (1) aligned); 1826 1827 dcl P_fs_type char (*); 1828 dcl P_fs_entry_type_ptr ptr; 1829 dcl entry_type_index fixed bin; 1830 1831 do entry_type_index = 1 to P_fs_entry_type_ptr -> fs_entry_type.count; 1832 if P_fs_type = P_fs_entry_type_ptr -> fs_entry_type.suffix (entry_type_index) then return ("1"b); 1833 end; 1834 1835 return ("0"b); 1836 1837 end ENTRY_TYPE_SELECTED; 1838 1839 CLEAN_UP: proc; 1840 1841 if star_list_names_ptr ^= null then free star_list_names in (area); 1842 if star_list_branch_ptr ^= null then free star_dir_list_branch in (area); 1843 if fs_entry_type_ptr ^= null then free fs_entry_type in (area); 1844 if path_array_ptr ^= null & path_array_ptr ^= addr (path_array_space) then free path_array in (area); 1845 1846 end CLEAN_UP; 1847 1848 dcl 1 access_options int static, /* for -access */ 1849 1850 (2 primary_name init ("0"b), 1851 2 names init ("0"b), 1852 2 type init ("0"b), 1853 2 link_path init ("0"b), 1854 2 unique_id init ("0"b), 1855 2 dtu init ("0"b), 1856 2 dtcm init ("0"b), 1857 2 dtem init ("0"b), 1858 2 dtd init ("0"b), 1859 2 dtvd init ("0"b), 1860 2 author init ("0"b), 1861 2 bc_author init ("0"b), 1862 2 logical_volume init ("0"b), 1863 2 bit_count init ("0"b), 1864 2 records_used init ("0"b), 1865 2 current_length init ("0"b), 1866 2 max_length init ("0"b), 1867 2 mode init ("1"b), 1868 2 access_class init ("1"b), 1869 2 ring_brackets init ("1"b), 1870 2 safety_switch init ("1"b), 1871 2 copy_switch init ("0"b), 1872 2 audit_switch init ("0"b), 1873 2 ivds init ("0"b), 1874 2 cvds init ("0"b), 1875 2 usage_count init ("0"b), 1876 2 damaged_switch init ("0"b), 1877 2 synchronized_switch init ("0"b), 1878 2 entry_bound init ("0"b), 1879 2 highest_ci init ("0"b), 1880 2 concurrency_switch init ("0"b), 1881 2 rollback_switch init ("0"b), 1882 2 protected_switch init ("0"b) 1883 ) bit (1) unaligned; 1884 1885 dcl 1 date_options int static, /* for -date */ 1886 (2 primary_name init ("0"b), 1887 2 names init ("0"b), 1888 2 type init ("0"b), 1889 2 link_path init ("0"b), 1890 2 unique_id init ("0"b), 1891 2 dtu init ("1"b), 1892 2 dtcm init ("1"b), 1893 2 dtem init ("1"b), 1894 2 dtd init ("1"b), 1895 2 dtvd init ("1"b), 1896 2 author init ("0"b), 1897 2 bc_author init ("0"b), 1898 2 logical_volume init ("0"b), 1899 2 bit_count init ("0"b), 1900 2 records_used init ("0"b), 1901 2 current_length init ("0"b), 1902 2 max_length init ("0"b), 1903 2 mode init ("0"b), 1904 2 access_class init ("0"b), 1905 2 ring_brackets init ("0"b), 1906 2 safety_switch init ("0"b), 1907 2 copy_switch init ("0"b), 1908 2 audit_switch init ("0"b), 1909 2 ivds init ("0"b), 1910 2 cvds init ("0"b), 1911 2 usage_count init ("0"b), 1912 2 damaged_switch init ("0"b), 1913 2 synchronized_switch init ("0"b), 1914 2 entry_bound init ("0"b), 1915 2 highest_ci init ("0"b), 1916 2 concurrency_switch init ("0"b), 1917 2 rollback_switch init ("0"b), 1918 2 protected_switch init ("0"b) 1919 ) bit (1) unaligned; 1920 1921 dcl 1 length_options int static, /* for -length */ 1922 (2 primary_name init ("0"b), 1923 2 names init ("0"b), 1924 2 type init ("0"b), 1925 2 link_path init ("0"b), 1926 2 unique_id init ("0"b), 1927 2 dtu init ("0"b), 1928 2 dtcm init ("0"b), 1929 2 dtem init ("0"b), 1930 2 dtd init ("0"b), 1931 2 dtvd init ("0"b), 1932 2 author init ("0"b), 1933 2 bc_author init ("0"b), 1934 2 logical_volume init ("0"b), 1935 2 bit_count init ("1"b), 1936 2 records_used init ("1"b), 1937 2 current_length init ("1"b), 1938 2 max_length init ("1"b), 1939 2 mode init ("0"b), 1940 2 access_class init ("0"b), 1941 2 ring_brackets init ("0"b), 1942 2 safety_switch init ("0"b), 1943 2 copy_switch init ("0"b), 1944 2 audit_switch init ("0"b), 1945 2 ivds init ("0"b), 1946 2 cvds init ("0"b), 1947 2 usage_count init ("0"b), 1948 2 damaged_switch init ("0"b), 1949 2 synchronized_switch init ("0"b), 1950 2 entry_bound init ("0"b), 1951 2 highest_ci init ("0"b), 1952 2 concurrency_switch init ("0"b), 1953 2 rollback_switch init ("0"b), 1954 2 protected_sw init ("0"b) 1955 ) bit (1) unaligned; 1956 1957 dcl 1 active_function_length_options int static, /* for -length */ 1958 (2 primary_name init ("0"b), 1959 2 names init ("0"b), 1960 2 type init ("0"b), 1961 2 link_path init ("0"b), 1962 2 unique_id init ("0"b), 1963 2 dtu init ("0"b), 1964 2 dtcm init ("0"b), 1965 2 dtem init ("0"b), 1966 2 dtd init ("0"b), 1967 2 dtvd init ("0"b), 1968 2 author init ("0"b), 1969 2 bc_author init ("0"b), 1970 2 logical_volume init ("0"b), 1971 2 bit_count init ("1"b), /* for directory type only */ 1972 2 records_used init ("0"b), 1973 2 current_length init ("1"b), /* for other types such as segment or MSF or DM file */ 1974 2 max_length init ("0"b), 1975 2 mode init ("0"b), 1976 2 access_class init ("0"b), 1977 2 ring_brackets init ("0"b), 1978 2 safety_switch init ("0"b), 1979 2 copy_switch init ("0"b), 1980 2 audit_switch init ("0"b), 1981 2 ivds init ("0"b), 1982 2 cvds init ("0"b), 1983 2 usage_count init ("0"b), 1984 2 damaged_switch init ("0"b), 1985 2 synchronized_switch init ("0"b), 1986 2 entry_bound init ("0"b), 1987 2 highest_ci init ("0"b), 1988 2 concurrency_switch init ("0"b), 1989 2 rollback_switch init ("0"b), 1990 2 protected_sw init ("0"b) 1991 ) bit (1) unaligned; 1992 1993 dcl 1 default_options int static, /* no control arguments specified */ 1994 (2 primary_name init ("0"b), 1995 2 names init ("1"b), 1996 2 type init ("1"b), 1997 2 link_path init ("1"b), 1998 2 unique_id init ("0"b), 1999 2 dtu init ("1"b), 2000 2 dtcm init ("1"b), 2001 2 dtem init ("1"b), 2002 2 dtd init ("0"b), 2003 2 dtvd init ("0"b), 2004 2 author init ("0"b), 2005 2 bc_author init ("0"b), 2006 2 logical_volume init ("0"b), 2007 2 bit_count init ("1"b), 2008 2 records_used init ("1"b), 2009 2 current_length init ("0"b), 2010 2 max_length init ("0"b), 2011 2 mode init ("1"b), 2012 2 access_class init ("0"b), 2013 2 ring_brackets init ("0"b), 2014 2 safety_switch init ("0"b), 2015 2 copy_switch init ("0"b), 2016 2 audit_switch init ("0"b), 2017 2 ivds init ("0"b), 2018 2 cvds init ("0"b), 2019 2 usage_count init ("0"b), 2020 2 damaged_switch init ("1"b), 2021 2 synchronized_switch init ("0"b), 2022 2 entry_bound init ("0"b), 2023 2 highest_ci init ("1"b), 2024 2 concurrency_switch init ("1"b), 2025 2 rollback_switch init ("1"b), 2026 2 protected_switch init ("1"b) 2027 ) bit (1) unaligned; 2028 2029 dcl 1 no_s_options int static, /* attributes available without s access */ 2030 (2 primary_name init ("0"b), 2031 2 names init ("0"b), 2032 2 type init ("1"b), 2033 2 link_path init ("1"b), 2034 2 unique_id init ("1"b), 2035 2 dtu init ("1"b), 2036 2 dtcm init ("1"b), 2037 2 dtem init ("1"b), 2038 2 dtd init ("1"b), 2039 2 dtvd init ("1"b), 2040 2 author init ("1"b), 2041 2 bc_author init ("1"b), 2042 2 logical_volume init ("1"b), 2043 2 bit_count init ("1"b), 2044 2 records_used init ("1"b), 2045 2 current_length init ("1"b), 2046 2 max_length init ("1"b), 2047 2 mode init ("1"b), 2048 2 access_class init ("1"b), 2049 2 ring_brackets init ("1"b), 2050 2 safety_switch init ("1"b), 2051 2 copy_switch init ("1"b), 2052 2 audit_switch init ("1"b), 2053 2 ivds init ("1"b), 2054 2 cvds init ("1"b), 2055 2 usage_count init ("1"b), 2056 2 damaged_switch init ("1"b), 2057 2 synchronized_switch init ("1"b), 2058 2 entry_bound init ("1"b), 2059 2 highest_ci init ("1"b), 2060 2 concurrency_switch init ("1"b), 2061 2 rollback_switch init ("1"b), 2062 2 protected_switch init ("1"b) 2063 ) bit (1) unaligned; 2064 2065 dcl 1 off_line_options int static, /* attributes available without VTOC */ 2066 (2 primary_name init ("1"b), 2067 2 names init ("1"b), 2068 2 type init ("1"b), 2069 2 link_path init ("1"b), 2070 2 unique_id init ("1"b), 2071 2 dtu init ("0"b), 2072 2 dtcm init ("0"b), 2073 2 dtem init ("1"b), 2074 2 dtd init ("1"b), 2075 2 dtvd init ("0"b), 2076 2 author init ("1"b), 2077 2 bc_author init ("1"b), 2078 2 logical_volume init ("1"b), 2079 2 bit_count init ("1"b), 2080 2 records_used init ("0"b), 2081 2 current_length init ("0"b), 2082 2 max_length init ("1"b), 2083 2 mode init ("1"b), 2084 2 access_class init ("1"b), 2085 2 ring_brackets init ("1"b), 2086 2 safety_switch init ("1"b), 2087 2 copy_switch init ("1"b), 2088 2 audit_switch init ("1"b), 2089 2 ivds init ("0"b), 2090 2 cvds init ("0"b), 2091 2 usage_count init ("0"b), 2092 2 damaged_switch init ("0"b), 2093 2 synchronized_switch init ("0"b), 2094 2 entry_bound init ("1"b), 2095 2 highest_ci init ("0"b), 2096 2 concurrency_switch init ("0"b), 2097 2 rollback_switch init ("0"b), 2098 2 protected_switch init ("0"b) 2099 ) bit (1) unaligned; 2100 2101 dcl 1 link_options int static, /* attributes valid for links */ 2102 (2 primary_name init ("1"b), 2103 2 names init ("1"b), 2104 2 type init ("1"b), 2105 2 link_path init ("1"b), 2106 2 unique_id init ("0"b), 2107 2 dtu init ("0"b), 2108 2 dtcm init ("0"b), 2109 2 dtem init ("1"b), 2110 2 dtd init ("1"b), 2111 2 dtvd init ("1"b), 2112 2 author init ("1"b), 2113 2 bc_author init ("0"b), 2114 2 logical_volume init ("0"b), 2115 2 bit_count init ("0"b), 2116 2 records_used init ("0"b), 2117 2 current_length init ("0"b), 2118 2 max_length init ("0"b), 2119 2 mode init ("0"b), 2120 2 access_class init ("0"b), 2121 2 ring_brackets init ("0"b), 2122 2 safety_switch init ("0"b), 2123 2 copy_switch init ("0"b), 2124 2 audit_switch init ("0"b), 2125 2 ivds init ("0"b), 2126 2 cvds init ("0"b), 2127 2 usage_count init ("0"b), 2128 2 damaged_switch init ("0"b), 2129 2 synchronized_switch init ("0"b), 2130 2 entry_bound init ("0"b), 2131 2 highest_ci init ("0"b), 2132 2 concurrency_switch init ("0"b), 2133 2 rollback_switch init ("0"b), 2134 2 protected_switch init ("0"b) 2135 ) bit (1) unaligned; 2136 2137 dcl 1 nonlink_options int static, /* attributes valid for non-links */ 2138 (2 primary_name init ("1"b), 2139 2 names init ("1"b), 2140 2 type init ("1"b), 2141 2 link_path init ("0"b), 2142 2 unique_id init ("1"b), 2143 2 dtu init ("1"b), 2144 2 dtcm init ("1"b), 2145 2 dtem init ("1"b), 2146 2 dtd init ("1"b), 2147 2 dtvd init ("1"b), 2148 2 author init ("1"b), 2149 2 bc_author init ("1"b), 2150 2 logical_volume init ("1"b), 2151 2 bit_count init ("1"b), 2152 2 records_used init ("1"b), 2153 2 current_length init ("1"b), 2154 2 max_length init ("1"b), 2155 2 mode init ("1"b), 2156 2 access_class init ("1"b), 2157 2 ring_brackets init ("1"b), 2158 2 safety_switch init ("1"b), 2159 2 copy_switch init ("1"b), 2160 2 audit_switch init ("1"b), 2161 2 ivds init ("1"b), 2162 2 cvds init ("1"b), 2163 2 usage_count init ("1"b), 2164 2 damaged_switch init ("1"b), 2165 2 synchronized_switch init ("1"b), 2166 2 entry_bound init ("1"b), 2167 2 highest_ci init ("1"b), 2168 2 concurrency_switch init ("1"b), 2169 2 rollback_switch init ("1"b), 2170 2 protected_switch init ("1"b) 2171 ) bit (1) unaligned; 2172 2173 dcl 1 dm_file_options int static, /* attributes valid for DM files */ 2174 (2 primary_name init ("1"b), 2175 2 names init ("1"b), 2176 2 type init ("1"b), 2177 2 link_path init ("0"b), 2178 2 unique_id init ("1"b), 2179 2 dtu init ("1"b), 2180 2 dtcm init ("1"b), 2181 2 dtem init ("1"b), 2182 2 dtd init ("1"b), 2183 2 dtvd init ("1"b), 2184 2 author init ("1"b), 2185 2 bc_author init ("0"b), 2186 2 logical_volume init ("1"b), 2187 2 bit_count init ("0"b), 2188 2 records_used init ("1"b), 2189 2 current_length init ("1"b), 2190 2 max_length init ("1"b), 2191 2 mode init ("1"b), 2192 2 access_class init ("1"b), 2193 2 ring_brackets init ("1"b), 2194 2 safety_switch init ("0"b), 2195 2 copy_switch init ("0"b), 2196 2 audit_switch init ("0"b), 2197 2 ivds init ("0"b), 2198 2 cvds init ("0"b), 2199 2 usage_count init ("0"b), 2200 2 damaged_switch init ("0"b), 2201 2 synchronized_switch init ("0"b), 2202 2 entry_bound init ("0"b), 2203 2 highest_ci init ("1"b), 2204 2 concurrency_switch init ("1"b), 2205 2 rollback_switch init ("1"b), 2206 2 protected_switch init ("1"b) 2207 ) bit (1) unaligned; 2208 2209 dcl 1 fm_status_options int static, /* DM file attr's requiring file_manager_$status */ 2210 (2 primary_name init ("0"b), 2211 2 names init ("0"b), 2212 2 type init ("0"b), 2213 2 link_path init ("0"b), 2214 2 unique_id init ("1"b), 2215 2 dtu init ("0"b), 2216 2 dtcm init ("0"b), 2217 2 dtem init ("0"b), 2218 2 dtd init ("0"b), 2219 2 dtvd init ("0"b), 2220 2 author init ("0"b), 2221 2 bc_author init ("0"b), 2222 2 logical_volume init ("0"b), 2223 2 bit_count init ("0"b), 2224 2 records_used init ("0"b), 2225 2 current_length init ("0"b), 2226 2 max_length init ("0"b), 2227 2 mode init ("1"b), 2228 2 access_class init ("0"b), 2229 2 ring_brackets init ("1"b), 2230 2 safety_switch init ("0"b), 2231 2 copy_switch init ("0"b), 2232 2 audit_switch init ("0"b), 2233 2 ivds init ("0"b), 2234 2 cvds init ("0"b), 2235 2 usage_count init ("0"b), 2236 2 damaged_switch init ("0"b), 2237 2 synchronized_switch init ("0"b), 2238 2 entry_bound init ("0"b), 2239 2 highest_ci init ("1"b), 2240 2 concurrency_switch init ("1"b), 2241 2 rollback_switch init ("1"b), 2242 2 protected_switch init ("1"b) 2243 ) bit (1) unaligned; 2244 2245 dcl 1 root_options int static, /* attributes available for the root */ 2246 (2 primary_name init ("1"b), 2247 2 names init ("1"b), 2248 2 type init ("1"b), 2249 2 link_path init ("0"b), 2250 2 unique_id init ("1"b), 2251 2 dtu init ("1"b), 2252 2 dtcm init ("0"b), 2253 2 dtem init ("0"b), 2254 2 dtd init ("0"b), 2255 2 dtvd init ("0"b), 2256 2 author init ("1"b), 2257 2 bc_author init ("1"b), 2258 2 logical_volume init ("1"b), 2259 2 bit_count init ("1"b), 2260 2 records_used init ("0"b), 2261 2 current_length init ("0"b), 2262 2 max_length init ("0"b), 2263 2 mode init ("1"b), 2264 2 access_class init ("0"b), 2265 2 ring_brackets init ("1"b), 2266 2 safety_switch init ("1"b), 2267 2 copy_switch init ("0"b), 2268 2 audit_switch init ("0"b), 2269 2 ivds init ("0"b), 2270 2 cvds init ("0"b), 2271 2 usage_count init ("0"b), 2272 2 damaged_switch init ("1"b), 2273 2 synchronized_switch init ("0"b), 2274 2 entry_bound init ("0"b), 2275 2 highest_ci init ("0"b), 2276 2 concurrency_switch init ("0"b), 2277 2 rollback_switch init ("0"b), 2278 2 protected_switch init ("0"b) 2279 ) bit (1) unaligned; 2280 2281 dcl 1 typed_options int static, /* attributes that must come from fs_util_ */ 2282 (2 primary_name init ("0"b), 2283 2 names init ("0"b), 2284 2 type init ("1"b), 2285 2 link_path init ("0"b), 2286 2 unique_id init ("0"b), 2287 2 dtu init ("0"b), 2288 2 dtcm init ("0"b), 2289 2 dtem init ("0"b), 2290 2 dtd init ("0"b), 2291 2 dtvd init ("0"b), 2292 2 author init ("0"b), 2293 2 bc_author init ("0"b), 2294 2 logical_volume init ("0"b), 2295 2 bit_count init ("0"b), 2296 2 records_used init ("0"b), 2297 2 current_length init ("0"b), 2298 2 max_length init ("1"b), 2299 2 mode init ("1"b), 2300 2 access_class init ("0"b), 2301 2 ring_brackets init ("1"b), 2302 2 safety_switch init ("1"b), 2303 2 copy_switch init ("1"b), 2304 2 audit_switch init ("1"b), 2305 2 ivds init ("1"b), 2306 2 cvds init ("1"b), 2307 2 usage_count init ("0"b), 2308 2 damaged_switch init ("1"b), 2309 2 synchronized_switch init ("1"b), 2310 2 entry_bound init ("0"b), 2311 2 highest_ci init ("1"b), 2312 2 concurrency_switch init ("1"b), 2313 2 no_rollback_sw init ("1"b), 2314 2 protected_switch init ("1"b) 2315 ) bit (1) unaligned; 2316 1 1 declare /* Structure returned by hcs_$status_long */ 1 2 1 3 1 branch_status aligned, /* automatic: hcs_$status uses a pointer */ 1 4 1 5 2 type bit(2) unaligned, /* type of entry: link, segment, dir */ 1 6 2 number_names bit(16) unaligned, /* unused by directory_status_ */ 1 7 2 names_rel_pointer bit(18) unaligned, /* unused by directory_status_ */ 1 8 2 date_time_modified bit(36) unaligned, /* date time modified */ 1 9 2 date_time_used bit(36) unaligned, /* date time entry used */ 1 10 2 mode bit(5) unaligned, /* effective access of caller */ 1 11 2 raw_mode bit(5) unaligned, 1 12 2 pad1 bit(8) unaligned, 1 13 2 records bit(18) unaligned, /* number of records in use */ 1 14 2 date_time_dumped bit(36) unaligned, /* date time last dumped */ 1 15 2 date_time_entry_modified bit(36) unaligned, /* date time entry modified */ 1 16 2 lvid bit(36) unaligned, /* logical volume id */ 1 17 2 current_length bit(12) unaligned, /* number of blocks currently allocated */ 1 18 2 bit_count bit(24) unaligned, /* bit count of entry */ 1 19 2 pad3 bit(8) unaligned, 1 20 2 copy_switch bit(1) unaligned, /* the copy switch */ 1 21 2 tpd bit(1) unaligned, /* transparent to paging device */ 1 22 2 mdir bit(1) unaligned, /* master directory switch */ 1 23 2 damaged_switch bit (1) unaligned, /* true if contents damaged */ 1 24 2 synchronized_switch bit (1) unaligned, /* true if a DM synchronized file */ 1 25 2 pad4 bit(5) unaligned, 1 26 2 ring_brackets (0:2) bit(6) unaligned, /* branch ring brackets */ 1 27 2 unique_id bit(36) unaligned, /* entry unique id */ 1 28 1 29 1 30 /* The types of each class of branch */ 1 31 segment_type bit(2) aligned internal static initial ("01"b), 1 32 directory_type bit(2) aligned internal static initial ("10"b), 1 33 msf_type bit(2) aligned internal static initial ("10"b), /* will eventually be different */ 1 34 link_type bit(2) aligned internal static initial ("00"b); 1 35 1 36 2317 2318 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 */ 2319 2320 3 1 /* BEGIN INCLUDE FILE: dm_file_status.incl.pl1 */ 3 2 3 3 /* format: style4,ifthenstmt,^indproc,^indcomtxt */ 3 4 3 5 /* DESCRIPTION: 3 6* 3 7* This include file contains dm_file_status, the structure of information 3 8* returned by file_manager_$status. The caller should pass the addr of an 3 9* automatic copy as follows: 3 10* 3 11* dcl auto_dm_file_status aligned like dm_file_status; 3 12* unspec (auto_dm_file_status) = "0"b; 3 13* auto_dm_file_status.version = DM_FILE_STATUS_VERSION_1; 3 14* call file_manager_$status (dirname, entryname, 3 15* addr (auto_dm_file_status, code); 3 16**/ 3 17 /* HISTORY: 3 18* 3 19*Written by Steve Herbst, 07/06/84. 3 20*Modified: 3 21*11/07/84 by Steve Herbst: Changed in response to audit comments: 3 22* Reformatted history section, made version aligned. 3 23*12/12/84 by Steve Herbst: Changed further in response to audit comments: 3 24* Changed highest_ci from fixed(18) to fixed(27). 3 25*12/17/84 by Steve Herbst: Changed again in response to audit comments: 3 26* Improved journalization comments. 3 27**/ 3 28 3 29 3 30 dcl 1 dm_file_status aligned based (dm_file_status_ptr), 3 31 2 version char (8), 3 32 2 fm_unique_id bit (36) aligned, /* file manager unique id */ 3 33 2 mode bit (36) aligned, /* extended user's effective access to file */ 3 34 2 date_time_created fixed bin (71), 3 35 2 ring_brackets (2) fixed bin (3), /* extended ring brackets */ 3 36 2 switches, 3 37 3 (protected_sw, 3 38 no_concurrency_sw, 3 39 no_rollback_sw) bit (1) unaligned, 3 40 3 mbz bit (33) unaligned, 3 41 2 highest_ci fixed bin (27), /* number of highest control interval */ 3 42 2 ci_size fixed bin (18); /* size in bytes (4/wd) of a control interval */ 3 43 3 44 dcl dm_file_status_ptr ptr; 3 45 3 46 dcl DM_FILE_STATUS_VERSION_1 char (8) int static options (constant) init ("DMFLST01"); 3 47 3 48 /* END INCLUDE FILE: dm_file_status.incl.pl1 */ 2321 2322 4 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 4 2 4 3 /* This include file contains structures for the hcs_$star_, 4 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 4 5* 4 6* Written 23 October 1978 by Monte Davidoff. 4 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 4 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 4 9**/ 4 10 4 11 /* automatic */ 4 12 4 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 4 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 4 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 4 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 4 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 4 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 4 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 4 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 4 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 4 22 4 23 /* based */ 4 24 4 25 /* hcs_$star_ entry structure */ 4 26 4 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 4 28 2 type fixed binary (2) unsigned unaligned, 4 29 /* storage system type */ 4 30 2 nnames fixed binary (16) unsigned unaligned, 4 31 /* number of names of entry that match star_name */ 4 32 2 nindex fixed binary (18) unsigned unaligned; 4 33 /* index of first name in star_names */ 4 34 4 35 /* hcs_$star_ name structure */ 4 36 4 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 4 38 4 39 /* hcs_$star_list_ branch structure */ 4 40 4 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 4 42 2 type fixed binary (2) unsigned unaligned, 4 43 /* storage system type */ 4 44 2 nnames fixed binary (16) unsigned unaligned, 4 45 /* number of names of entry that match star_name */ 4 46 2 nindex fixed binary (18) unsigned unaligned, 4 47 /* index of first name in star_list_names */ 4 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 4 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 4 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 4 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 4 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 4 53 2 pad bit (7) unaligned, 4 54 2 records fixed binary (18) unsigned unaligned; 4 55 /* records used by branch */ 4 56 4 57 /* hcs_$star_dir_list_ branch structure */ 4 58 4 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 4 60 2 type fixed binary (2) unsigned unaligned, 4 61 /* storage system type */ 4 62 2 nnames fixed binary (16) unsigned unaligned, 4 63 /* number of names of entry that match star_name */ 4 64 2 nindex fixed binary (18) unsigned unaligned, 4 65 /* index of first name in star_list_names */ 4 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 4 67 2 pad bit (36) unaligned, 4 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 4 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 4 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 4 71 2 bit_count fixed binary (24) unaligned; 4 72 /* bit count of the branch */ 4 73 4 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 4 75 4 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 4 77 2 type fixed binary (2) unsigned unaligned, 4 78 /* storage system type */ 4 79 2 nnames fixed binary (16) unsigned unaligned, 4 80 /* number of names of entry that match star_name */ 4 81 2 nindex fixed binary (18) unsigned unaligned, 4 82 /* index of first name in star_list_names */ 4 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 4 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 4 85 2 pathname_len fixed binary (18) unsigned unaligned, 4 86 /* length of the pathname of the link */ 4 87 2 pathname_index fixed binary (18) unsigned unaligned; 4 88 /* index of start of pathname in star_list_names */ 4 89 4 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 4 91 4 92 declare star_list_names char (32) based (star_list_names_ptr) 4 93 dimension (star_links (star_branch_count + star_link_count).nindex 4 94 + star_links (star_branch_count + star_link_count).nnames 4 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 4 96 * binary ( 4 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 4 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 4 99 4 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 4 101 4 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 4 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 4 104 4 105 /* internal static */ 4 106 4 107 /* star_select_sw values */ 4 108 4 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 4 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 4 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 4 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 4 113 fixed binary (3) internal static options (constant) initial (5); 4 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 4 115 fixed binary (3) internal static options (constant) initial (7); 4 116 4 117 /* storage system types */ 4 118 4 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 4 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 4 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 4 122 4 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 2323 2324 5 1 /* --------------- BEGIN include file status_for_backup.incl.pl1 --------------- */ 5 2 5 3 5 4 /****^ HISTORY COMMENTS: 5 5* 1) change(86-05-20,Lippard), approve(86-06-02,MCR7427), 5 6* audit(86-06-17,Farley), install(86-06-17,MR12.0-1077): 5 7* Change non-returned information into pad fields. 5 8* END HISTORY COMMENTS */ 5 9 5 10 5 11 dcl 1 status_for_backup aligned based, 5 12 2 version fixed bin, 5 13 2 pad1 bit (108), 5 14 2 switches unaligned, 5 15 3 safety bit (1) unaligned, 5 16 3 entrypt bit (1) unaligned, 5 17 3 security_oosw bit (1) unaligned, 5 18 3 audit_flag bit (1) unaligned, 5 19 3 multiple_class bit (1) unaligned, 5 20 3 pad2 bit (2) unaligned, 5 21 3 master_dir bit (1) unaligned, 5 22 3 tpd bit (1) unaligned, 5 23 3 pad13 bit (13) unaligned, 5 24 2 entrypt_bound bit (14) unaligned, 5 25 2 access_class bit (72), 5 26 2 spad bit (36), 5 27 2 author char (32), 5 28 2 bc_author char (32), 5 29 2 lvid bit (36), 5 30 2 pvid bit (36), 5 31 2 pad3 bit (216); 5 32 5 33 dcl status_for_backup_version_2 fixed bin initial (2) static options (constant); 5 34 5 35 /* ---------------- END include file status_for_backup.incl.pl1 ---------------- */ 2325 2326 6 1 /* BEGIN INCLUDE FILE: suffix_info.incl.pl1 */ 6 2 /* format: style3,indcomtxt,idind30 */ 6 3 /**** Jay Pattin 2/13/83 6 4* M. Pandolf 1984.11.30 to set FS_OBJECT_TYPE_MSF to -multisegment_file 6 5* 6 6* The include file copy_flags.incl.pl1 must be included in any program using this include file. 6 7* 6 8* This structure is returned by the suffix_XXX_$suffix_info subroutines */ 6 9 6 10 declare suffix_info_ptr ptr; 6 11 6 12 declare 1 suffix_info aligned based (suffix_info_ptr), 6 13 2 version char (8), 6 14 2 type char (32) unaligned, 6 15 2 type_name char (32) unaligned, /* Singular name of the object type, e.g. "mailbox" */ 6 16 2 plural_name char (32) unaligned, /* Plural of above, e.g. "mailboxes" */ 6 17 2 flags unaligned, 6 18 3 standard_object bit (1) unaligned, /* ON if not an extended object (no suffix_XXX_) */ 6 19 3 extended_acl bit (1) unaligned, /* ON if uses extended ACLs, off if regular ACLs */ 6 20 3 has_switches bit (1) unaligned, /* ON if supports switches for objects */ 6 21 3 mbz1 bit (33) unaligned, 6 22 2 modes char (36), /* correspondence between bits and chars for extended modes */ 6 23 2 max_mode_len fixed bin, /* maximum number of modes on an object */ 6 24 2 num_ring_brackets fixed bin, /* number of ring brackets on object */ 6 25 2 copy_flags like copy_flags, /* See copy_flags.incl.pl1 */ 6 26 2 info_pathname char (168) unaligned; 6 27 /* pathname of info segment containing more info */ 6 28 6 29 declare SUFFIX_INFO_VERSION_1 char (8) static options (constant) init ("SUFFIX01"); 6 30 6 31 /* This information is returned by the suffix_XXX_$list_switches subroutines */ 6 32 6 33 declare switch_list_ptr ptr, 6 34 alloc_switch_count fixed bin, 6 35 alloc_switch_name_count fixed bin; 6 36 6 37 declare 1 switch_list aligned based (switch_list_ptr), 6 38 2 version char (8), /* SWITCH_LIST_VERSION_1 */ 6 39 2 switch_count fixed bin, /* total number of switches */ 6 40 2 switch_name_count fixed bin, /* total number of names */ 6 41 2 switches (alloc_switch_count refer (switch_list.switch_count)), 6 42 3 name_index fixed bin, /* index of first name for this switch */ 6 43 3 name_count fixed bin, /* number of names for this switch */ 6 44 3 default_value bit (1) aligned, /* default setting for this switch */ 6 45 3 mbz1 bit (36) aligned, /* reserved for future use */ 6 46 2 names (alloc_switch_name_count refer (switch_list.switch_name_count)) char (32); 6 47 6 48 declare SWITCH_LIST_VERSION_1 char (8) static options (constant) init ("SWLIST01"); 6 49 6 50 declare ( 6 51 FS_OBJECT_TYPE_SEGMENT init ("-segment"), 6 52 FS_OBJECT_TYPE_DIRECTORY init ("-directory"), 6 53 FS_OBJECT_TYPE_MSF init ("-multisegment_file"), 6 54 FS_OBJECT_TYPE_DM_FILE init ("-dm_file"), 6 55 FS_OBJECT_TYPE_LINK init ("-link") 6 56 ) char (32) unaligned int static options (constant); 6 57 6 58 /* END INCLUDE FILE: suffix_info.incl.pl1 */ 2327 2328 2329 2330 end status; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/10/89 0947.5 status.pl1 >spec>install>1040>status.pl1 2317 1 11/22/82 0955.6 branch_status.incl.pl1 >ldd>include>branch_status.incl.pl1 2319 2 10/14/83 1606.7 copy_flags.incl.pl1 >ldd>include>copy_flags.incl.pl1 2321 3 03/06/85 1031.1 dm_file_status.incl.pl1 >ldd>include>dm_file_status.incl.pl1 2323 4 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 2325 5 06/17/86 1513.1 status_for_backup.incl.pl1 >ldd>include>status_for_backup.incl.pl1 2327 6 03/05/85 1807.3 suffix_info.incl.pl1 >ldd>include>suffix_info.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. ALL_OPTIONS constant bit(33) initial dcl 139 ref 559 CHASE constant fixed bin(17,0) initial dcl 235 ref 818 DM_FILE_STATUS_VERSION_1 000072 constant char(8) initial packed unaligned dcl 3-46 ref 882 EXTENDED_type constant fixed bin(17,0) initial dcl 234 ref 797 918 1254 1283 1353 1425 1453 1467 1483 1494 1504 1513 1523 1537 1613 FS_OBJECT_TYPE_DIRECTORY 000045 constant char(32) initial packed unaligned dcl 6-50 ref 1791 FS_OBJECT_TYPE_DM_FILE 000025 constant char(32) initial packed unaligned dcl 6-50 ref 794 1793 FS_OBJECT_TYPE_LINK 000015 constant char(32) initial packed unaligned dcl 6-50 ref 1789 1797 FS_OBJECT_TYPE_MSF 000035 constant char(32) initial packed unaligned dcl 6-50 ref 1792 FS_OBJECT_TYPE_SEGMENT 000055 constant char(32) initial packed unaligned dcl 6-50 ref 1790 INITIALIZER_ID 000074 constant char(32) initial packed unaligned dcl 233 ref 760 1120 1140 LONG_OPTION 000226 constant char(64) initial array packed unaligned dcl 141 ref 423 423 579 ME 000104 constant char(32) initial packed unaligned dcl 232 set ref 409* 413* 435* 448* 456* 465* 476* 570* 610* 631* 635* 650* 688* 771* 806* 823* 885* 977* 1007* 1126* 1133* 1134* 1146* 1154* 1155* 1167* 1175* 1176* 1258* 1266* 1267* 1270* 1273* 1288* 1321* 1346* 1354* 1364* 1398* 1414* 1420* 1441* 1528* 1547* 1558* 1565* 1572* 1573* 1608* 1646* 1655* 1699* 1723* 1815* NO_CHASE constant fixed bin(17,0) initial dcl 235 ref 717 P_code parameter fixed bin(35,0) dcl 1638 set ref 1636 1646* P_dn parameter char packed unaligned dcl 1639 set ref 1636 1646* 1646* P_en parameter char packed unaligned dcl 1639 set ref 1636 1646* 1646* P_entry_type_list parameter char packed unaligned dcl 1747 set ref 1745 1763 1765 1782 1815* P_fs_entry_type_ptr parameter pointer dcl 1828 in procedure "ENTRY_TYPE_SELECTED" ref 1825 1831 1832 P_fs_entry_type_ptr parameter pointer dcl 1748 in procedure "BUILD_ENTRY_TYPE_LIST" set ref 1745 1775* 1778 1795 1812 1813 1815 P_fs_type parameter char packed unaligned dcl 1827 ref 1825 1832 P_slet_enabled_sw parameter bit(1) dcl 1749 set ref 1745 1813* P_string parameter char packed unaligned dcl 1653 set ref 1651 1655* ROOT_NAMES 000114 constant char(32) initial array packed unaligned dcl 193 set ref 755 SHORT_OPTION 000124 constant char(8) initial array packed unaligned dcl 152 ref 423 SUFFIX_INFO_VERSION_1 000070 constant char(8) initial packed unaligned dcl 6-29 ref 799 1777 SWITCH_LIST_VERSION_1 000066 constant char(8) initial packed unaligned dcl 6-48 set ref 1433* access 000463 automatic bit(1) level 2 packed packed unaligned dcl 208 set ref 460* 561 access_class 003524 automatic bit(72) dcl 258 in procedure "st" set ref 1318* 1320* access_class 0(18) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1316 access_class 0(18) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1341 1345 access_options 000000 constant structure level 1 packed packed unaligned dcl 1848 ref 561 active_fnc_err_ 000046 constant entry external dcl 300 ref 360 570 635 1126 1146 1167 1258 1270 1414 active_function 003537 automatic bit(1) dcl 262 set ref 355* 359* 455 564 568 583 587 592 634 851 874 894 926 938 950 1124 1144 1165 1186 1197 1207 1216 1228 1238 1256 1269 1307 1322 1345 1365 1371 1412 1577 1585 1608 1612 1629 1641 1667 1726 active_function_length_options 000003 constant structure level 1 packed packed unaligned dcl 1957 ref 564 addr builtin function dcl 344 ref 369 493 526 606 606 606 606 724 724 726 726 755 800 800 883 883 936 937 996 996 1047 1068 1103 1497 1497 1571 1571 1800 1800 1844 after builtin function dcl 344 ref 1772 1805 all 0(01) 000463 automatic bit(1) level 2 packed packed unaligned dcl 208 set ref 462* 559 1444 1528 1538 1608 1731 area based area(1024) dcl 239 ref 376 491 527 626 685 733 1760 1764 1775 1810 1841 1842 1843 1844 area_ptr 003562 automatic pointer dcl 266 set ref 367* 376 491 527 626 647* 685 724* 729 733 936 1433* 1760 1764 1775 1810 1841 1842 1843 1844 arg based char packed unaligned dcl 240 set ref 386 393 393 399 400 401 401 402 402 403 403 404 404 405 405 406 418 423 423 427 427 428 428 429 429 430 430 431 432 432 435* 444 444 445 445 448* 452* 454 454 454 456* 460 460 462 462 462 462 463 463 465* 512 603 610* 631* arg_count 003612 automatic fixed bin(17,0) dcl 271 set ref 353* 375 382 408 434 447 587 arg_len 003613 automatic fixed bin(17,0) dcl 271 set ref 384* 386 389 393 393 399 400 401 401 402 402 403 403 404 404 405 405 406 416* 418 419 423 423 427 427 428 428 429 429 430 430 431 432 432 435 435 438* 441 444 444 445 445 448 448 451* 452 452 454 454 454 456 456 460 460 462 462 462 462 463 463 465 465 510* 512 601* 603 609* 610 610 630* 631 631 arg_ptr 003564 automatic pointer dcl 266 set ref 384* 386 388 393 393 399 400 401 401 402 402 403 403 404 404 405 405 406 416* 418 423 423 427 427 428 428 429 429 430 430 431 432 432 435 438* 440 444 444 445 445 448 451* 452 454 454 454 456 460 460 462 462 462 462 463 463 465 511* 512 602* 603 608* 610 629* 631 audit_flag 4(03) 000103 automatic bit(1) level 3 packed packed unaligned dcl 162 set ref 1498 audit_switch 0(22) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 548* 1492 audit_switch 0(22) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1494* 1498* author 0(10) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1134 author 0(10) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1117 author_string 003373 automatic char(32) packed unaligned dcl 254 set ref 1120* 1123* 1125 1130* 1131* 1151 auto_dm_file_status 000276 automatic structure level 1 dcl 197 set ref 881* 883 883 bc35 003642 automatic fixed bin(35,0) dcl 276 set ref 1181* 1184* 1193* 1198* 1201* 1202* bc36 003531 automatic bit(36) packed unaligned dcl 260 set ref 1183* 1184 bc_author 0(11) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1151 1155 bc_author 0(11) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1137 bc_author_string 003403 automatic char(32) packed unaligned dcl 254 set ref 1140* 1143* 1145 1150* 1151 1151* before builtin function dcl 344 ref 779 779 1787 bin builtin function dcl 344 ref 896 906 983 984 1020 1193 binary builtin function dcl 344 ref 1841 bit_count 0(13) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 853* 963 1024* 1179 bit_count 7(12) 003660 automatic bit(24) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 789 851 921 1183 1193 1527 bit_count 3(11) based fixed bin(24,0) array level 2 in structure "star_dir_list_branch" packed packed unaligned dcl 4-59 in procedure "st" ref 665 bit_count 7(12) 000143 automatic bit(24) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1020 bks 000103 automatic structure level 1 dcl 162 set ref 1497 1497 1571 1571 branch_names based char(32) array packed unaligned dcl 191 set ref 626 685 733 895 895 898 898 904* 905* 907* 908* 911* 912* branch_names_ptr 003566 automatic pointer dcl 266 set ref 626 626 685 685 727* 729* 733 733 755* 895 895 898 898 904 905 907 908 911 912 branch_status 003660 automatic structure level 1 dcl 1-1 set ref 724 724 726 726 756* 936 937 1068 1103 chase 003540 automatic bit(1) dcl 262 set ref 366* 399* 400* 805 809 821 chase_if_possible 003541 automatic bit(1) dcl 262 set ref 366* 401* 402* 809 chased 003542 automatic bit(1) dcl 262 set ref 682 714* 805 809 813* check_star_name_$entry 000050 constant entry external dcl 301 ref 613 class 002653 automatic char(336) packed unaligned dcl 252 set ref 1320* 1323 1323* 1324 1327 1328 1333 1335 1335 1339 1339 class_len 003614 automatic fixed bin(17,0) dcl 271 set ref 1328* 1329 1329* 1332 cleanup 003652 stack reference condition dcl 349 ref 373 645 732 971 1428 1759 clock builtin function dcl 344 ref 1046 code 003643 automatic fixed bin(35,0) dcl 276 set ref 353* 354 363* 384* 416* 438* 451* 504* 606* 607 610* 613* 615 628 631* 647* 649 650* 724* 726* 736 736 740* 742 742 744 747* 749 764* 769* 770 771* 793* 794 795 811* 812 821 823* 883* 884 884 885* 975* 977* 991 992* 993 993 996* 997 997 1003* 1007* 1010* 1023 1085* 1092* 1121* 1123* 1125 1126* 1129 1133* 1134* 1141* 1143* 1145 1146* 1149 1154* 1155* 1162* 1164* 1166 1167* 1170 1175* 1176* 1253* 1254* 1255* 1257 1258* 1261 1264 1266* 1267* 1284* 1285 1285 1288* 1305 1318* 1319 1320* 1321 1321* 1346* 1360* 1361 1361 1364* 1408* 1411* 1413 1414* 1417 1420* 1433* 1435 1440 1441* 1456* 1471* 1486* 1497* 1506* 1516* 1526* 1571* 1572 1572* 1712* 1722* 1723 1723* 1800* 1801 com_err_ 000052 constant entry external dcl 302 ref 356 combined_options 000463 automatic structure level 1 packed packed unaligned dcl 208 set ref 365* comp_name 003413 automatic char(32) packed unaligned dcl 254 set ref 994* 994 995* 995 995 996* 1003* 1007* 1029* 1029 comp_ptr 003570 automatic pointer dcl 266 set ref 992* complain 003646 automatic entry variable dcl 298 set ref 356* 360* 409 413 435 448 456 465 476 610 631 650 688 771 806 823 885 977 1007 1133 1134 1154 1155 1175 1176 1266 1267 1273 1288 1321 1346 1354 1364 1398 1420 1441 1528 1547 1558 1565 1572 1573 1608 1646 1655 1699 1723 1815 concurrency_switch 0(30) 000100 automatic bit(1) level 3 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1590 concurrency_switch 0(30) 000101 automatic bit(1) level 3 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1592* convert builtin function dcl 344 ref 994 1029 convert_authorization_$to_string_short 000054 constant entry external dcl 303 ref 1320 copy_flags based structure level 1 dcl 2-8 copy_switch 10(08) 003660 automatic bit(1) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 1507 copy_switch 0(21) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1504* 1507* copy_switch 0(21) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 547* 1502 count based fixed bin(17,0) level 2 dcl 215 set ref 483 488 498 519 1775* 1778 1812* 1813 1815 1831 1843 cu_$af_return_arg 000056 constant entry external dcl 304 ref 353 cu_$arg_ptr 000060 constant entry external dcl 305 ref 384 416 438 451 current_length 0(15) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1235 1244 current_length 7 003660 automatic bit(12) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 984 1239 1239 1243 1243 1244 1244 1244 current_length 7 000143 automatic fixed bin(11,0) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1021 current_length 0(15) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 851* 963 1024* 1226 cv_fstime_ 000170 constant entry external dcl 1625 ref 1628 1628 cvds 003615 automatic fixed bin(17,0) dcl 271 in procedure "st" set ref 1471* 1485* 1486* 1487 cvds 0(24) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 550* 1477 cvds 0(24) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1479 1483* 1487* damaged_switch 0(26) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1513* 1517* damaged_switch 10(11) 003660 automatic bit(1) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 1517 damaged_switch 0(26) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 545* 1511 date_options 000001 constant structure level 1 packed packed unaligned dcl 1885 ref 562 date_string 002620 automatic varying char(64) dcl 249 set ref 1053* 1054 1054* 1061* 1062 1062* 1069* 1070 1070* 1076* 1077 1077* 1087* 1088 1088* 1094* 1095 1095* 1104* 1105 1105* 1111* 1112 1112* 1627* 1628* 1630 date_time parameter bit(36) packed unaligned dcl 1623 ref 1618 1627 1628 1628 date_time_$format 000166 constant entry external dcl 1624 ref 1628 date_time_dumped 4 003660 automatic bit(36) level 2 packed packed unaligned dcl 1-1 set ref 1110* date_time_entry_modified 5 003660 automatic bit(36) level 2 packed packed unaligned dcl 1-1 set ref 1075* date_time_modified 1 003660 automatic bit(36) level 2 packed packed unaligned dcl 1-1 set ref 1059* date_time_used 2 003660 automatic bit(36) level 2 packed packed unaligned dcl 1-1 set ref 1051* dates 0(02) 000463 automatic bit(1) level 2 packed packed unaligned dcl 208 set ref 463* 562 dates_array 000456 automatic bit(36) array packed unaligned dcl 206 set ref 1085* 1086* 1092* 1093* default 000176 automatic bit(1) dcl 1684 set ref 1710* 1721* 1731 1733 default_options 000004 constant structure level 1 packed packed unaligned dcl 1993 ref 574 default_value parameter bit(1) dcl 1718 in procedure "STATUS_SWITCH" ref 1715 1721 default_value 6 based bit(1) array level 3 in structure "switch_list" dcl 6-37 in procedure "st" ref 1710 dir_sw 003543 automatic bit(1) dcl 262 set ref 366* 403* 475 480* 536 536* 539 666 838 840 directory_type constant bit(2) initial dcl 1-1 ref 757 836 851 1527 divide builtin function dcl 344 ref 1841 dm_error_$transaction_in_progress 000010 external static fixed bin(35,0) dcl 280 ref 884 dm_file_options 000011 constant structure level 1 packed packed unaligned dcl 2173 ref 859 dm_file_status based structure level 1 dcl 3-30 dm_file_sw 003544 automatic bit(1) dcl 262 set ref 366* 714* 794* 836 840 856 858 879 917 948 957* 1279 1295 1372 1381 1425 1453 1467 1483 1494 1504 1513 1523 dm_files_only 0(29) 000101 automatic structure level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" dm_files_only 0(29) 000100 automatic structure level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 863* dn 003123 automatic char(168) packed unaligned dcl 253 set ref 600* 606 606 647* 650* 650* 682* 688* 688* 724* 726* 740* 747* 753* 764* 769* 771* 771* 793* 806* 806* 811* 812 814 816* 823* 823* 883* 885* 885* 975* 977* 986 1001 1027 1030* 1085* 1092* 1123* 1143* 1254* 1255* 1270* 1273* 1284* 1318* 1360* 1408* 1456* 1471* 1486* 1497* 1528* 1528* 1565* 1565* 1571* 1655* 1655* 1669* 1669* 1671* 1671* 1712* dtcm 0(06) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1062 dtcm 1 000143 automatic bit(36) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1012 1012 dtcm 0(06) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 963 1024* 1057 dtd 0(08) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 963 1024* 1100 dtd 2 based bit(36) level 2 in structure "link_status" packed packed unaligned dcl 164 in procedure "st" set ref 1103* dtd 0(08) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1088 1095 1105 1112 dtd 4 000143 automatic bit(36) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1014 1014 dtem 0(07) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1070 1077 dtem 0(07) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 963 1024* 1065 dtem 5 000143 automatic bit(36) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1013 1013 dtlm 1 based bit(36) level 2 packed packed unaligned dcl 164 set ref 1068* dtu 2 000143 automatic bit(36) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1011 1011 dtu 0(05) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1054 dtu 0(05) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 963 1024* 1038 dtvd 0(09) 000100 automatic bit(1) level 2 packed packed unaligned dcl 96 set ref 1082 empty builtin function dcl 345 ref 247 en 003423 automatic char(32) packed unaligned dcl 254 set ref 603* 606 606 613 613* 647* 650* 650* 653 671* 724* 726* 740* 747* 754* 764* 769* 771* 771* 779 793* 806* 806* 811* 815 817* 823* 823* 883* 885* 885* 975* 977* 986 1030* 1092* 1123* 1143* 1254* 1255* 1270* 1273* 1284* 1318* 1360* 1408* 1456* 1471* 1486* 1497* 1528* 1528* 1565* 1565* 1571* 1655* 1655* 1669* 1669* 1671* 1671* 1712* entry_bound 0(28) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1562 entry_bound 0(28) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1565 1573 entry_type 003611 automatic fixed bin(3,0) dcl 270 set ref 657* 658 661 788* 789 791 797* 918 919 920 921 1067 1084 1102 1172 1252 1254 1283 1295 1353 1375 1387 1398 1425 1453 1463 1467 1479 1483 1494 1504 1513 1523 1537 1565 1613 entry_type_index 000212 automatic fixed bin(17,0) dcl 1829 in procedure "ENTRY_TYPE_SELECTED" set ref 1831* 1832* entry_type_index 003616 automatic fixed bin(17,0) dcl 271 in procedure "st" set ref 483* 484* 498* 499 500 504* 1783* 1795 1797* 1797 1801* 1801 1812 entry_type_info 000100 automatic structure level 1 dcl 1750 set ref 1800 1800 entrypt 4(01) 000103 automatic bit(1) level 3 packed packed unaligned dcl 162 set ref 1573 entrypt_bound 4(22) 000103 automatic bit(14) level 2 packed packed unaligned dcl 162 set ref 1577 1577 1578 1578 1579 1579 error_table_$badopt 000012 external static fixed bin(35,0) dcl 281 set ref 465* error_table_$inconsistent 000014 external static fixed bin(35,0) dcl 282 set ref 476* error_table_$incorrect_access 000016 external static fixed bin(35,0) dcl 283 ref 1411 error_table_$logical_volume_not_connected 000020 external static fixed bin(35,0) dcl 284 ref 742 error_table_$logical_volume_not_defined 000022 external static fixed bin(35,0) dcl 285 ref 742 error_table_$moderr 000024 external static fixed bin(35,0) dcl 286 set ref 1030* error_table_$no_s_permission 000026 external static fixed bin(35,0) dcl 287 ref 736 997 error_table_$noarg 000030 external static fixed bin(35,0) dcl 288 set ref 409* 435* 448* error_table_$noentry 000032 external static fixed bin(35,0) dcl 289 ref 821 1023 error_table_$nomatch 000034 external static fixed bin(35,0) dcl 290 set ref 688* error_table_$not_act_fnc 000036 external static fixed bin(35,0) dcl 291 ref 354 error_table_$root 000040 external static fixed bin(35,0) dcl 292 ref 749 error_table_$segknown 000042 external static fixed bin(35,0) dcl 293 ref 993 error_table_$unsupported_operation 000044 external static fixed bin(35,0) dcl 294 ref 1264 1285 1361 1435 exmodes 003526 automatic bit(36) dcl 259 set ref 1284* expand_path_ 000062 constant entry external dcl 306 ref 606 expand_pathname_$add_suffix 000064 constant entry external dcl 307 ref 504 explicit parameter bit(1) packed unaligned dcl 1683 ref 1679 1699 1704 1715 1735 explicit_opt 000101 automatic structure level 1 packed packed unaligned dcl 135 set ref 557* extended_type_count 003617 automatic fixed bin(17,0) dcl 271 set ref 482* 484* 484 488 488 489 519 file_manager_$status 000074 constant entry external dcl 311 ref 883 fixed builtin function dcl 344 ref 788 1011 1011 1012 1012 1013 1013 1014 1014 1217 1217 1221 1221 1222 1222 1239 1239 1243 1243 1244 1244 1375 1375 1377 1377 1377 1377 1387 1387 1389 1389 1390 1390 1390 1390 1392 1392 1392 1392 1527 1577 1577 1578 1578 1579 1579 fm_status_options 000012 constant structure level 1 packed packed unaligned dcl 2209 ref 880 fm_unique_id 2 000276 automatic bit(36) level 2 dcl 197 set ref 948 fs_entry_type based structure level 1 dcl 215 set ref 1775 1843 fs_entry_type_count 003620 automatic fixed bin(17,0) dcl 271 set ref 1769* 1773* 1775 1775 fs_entry_type_ptr 003572 automatic pointer dcl 266 set ref 370* 452* 483 484 488 498 499 500 504 519 774* 1843 1843 fs_time_value based structure level 1 dcl 219 fs_type 003433 automatic char(32) packed unaligned dcl 254 set ref 769* 774* 778 fs_util_$get_max_length 000100 constant entry external dcl 313 ref 1254 fs_util_$get_ring_brackets 000102 constant entry external dcl 314 ref 1360 fs_util_$get_switch 000104 constant entry external dcl 315 ref 1712 fs_util_$get_type 000076 constant entry external dcl 312 ref 769 793 fs_util_$get_user_access_modes 000106 constant entry external dcl 316 ref 1284 fs_util_$list_switches_for_type 000110 constant entry external dcl 318 ref 1433 fs_util_$suffix_info_for_type 000112 constant entry external dcl 319 ref 800 1800 fs_util_type 003443 automatic char(32) packed unaligned dcl 254 set ref 793* 794 795 800* 1433* get_group_id_ 000066 constant entry external dcl 308 ref 760 get_system_free_area_ 000070 constant entry external dcl 309 ref 367 get_wdir_ 000072 constant entry external dcl 310 ref 509 600 hbound builtin function dcl 344 ref 376 423 491 579 hcs_$get_access_class 000114 constant entry external dcl 320 ref 1318 hcs_$get_author 000120 constant entry external dcl 322 ref 1123 hcs_$get_bc_author 000122 constant entry external dcl 323 ref 1143 hcs_$get_dates 000116 constant entry external dcl 321 ref 1085 1092 hcs_$get_link_target 000124 constant entry external dcl 324 ref 811 hcs_$get_max_length 000126 constant entry external dcl 325 ref 1253 1255 hcs_$get_safety_sw 000130 constant entry external dcl 326 ref 1456 hcs_$get_volume_dump_switches 000132 constant entry external dcl 327 ref 1471 1486 hcs_$star_dir_list_ 000134 constant entry external dcl 328 ref 647 hcs_$status_for_backup 000136 constant entry external dcl 329 ref 1497 1571 hcs_$status_long 000140 constant entry external dcl 330 ref 724 726 996 highest_ci 11 000276 automatic fixed bin(27,0) level 2 in structure "auto_dm_file_status" dcl 197 in procedure "st" set ref 1585* 1586* 1587* highest_ci 0(29) 000100 automatic bit(1) level 3 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1583 i 003621 automatic fixed bin(17,0) dcl 271 set ref 382* 384* 407* 407 408 416* 433* 433 434 438* 446* 446 447 451* 495* 514 515 516* 516 520 521 522* 522 544* 545 546 547 548 549 550 551 552 554* 579* 580* 598* 599 601 602 606 606 608 609 629 630* index builtin function dcl 344 ref 1328 1334 1769 interpret_as_standard_entry 003545 automatic bit(1) dcl 262 set ref 366* 429* 430* 791 ioa_ 000142 constant entry external dcl 331 ref 876 904 905 907 908 911 912 931 932 943 944 956 957 1053 1054 1061 1062 1069 1070 1076 1077 1087 1088 1094 1095 1104 1105 1111 1112 1130 1131 1150 1151 1171 1172 1173 1192 1193 1195 1201 1202 1213 1214 1221 1222 1234 1235 1243 1244 1261 1263 1311 1312 1339 1341 1343 1367 1381 1383 1384 1386 1387 1389 1390 1392 1417 1419 1578 1579 1586 1587 1612 1669 1671 1731 1733 1735 1737 ioa_$nnl 000144 constant entry external dcl 332 ref 1331 1335 1336 ioa_$rsnnl 000146 constant entry external dcl 333 ref 951 1188 1198 1209 1217 1230 1239 1257 1365 1372 1374 1375 1377 1413 1577 1585 ivds 003622 automatic fixed bin(17,0) dcl 271 in procedure "st" set ref 1470* 1471* 1472 1486* ivds 0(23) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 551* 1461 ivds 0(23) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1463 1467* 1472* j 003623 automatic fixed bin(17,0) dcl 272 set ref 423* 423 423* 426 426 496* 500 503 504 504 510 511 520 521* 578* 580* 580 582 617* 656* 657 665 671* 1612 k 003624 automatic fixed bin(17,0) dcl 272 set ref 542* 554* 554 578 896* 898 898* 906* 907 908* 951* 991* 992* 994 1015 1029* 1188* 1192 1193 1198* 1209* 1217* 1230* 1239* 1257* 1290* 1291 1291* 1330* 1332 1333 1335 1335 1337* 1337 1339 1339 1365* 1372* 1374* 1375* 1377* 1413* 1444* 1445* 1539* 1540 1540* 1543* 1545 1547* 1557* 1558 1558* 1577* 1585* 1692* 1693 1694 1694* 1707 1709 1710 kk 003625 automatic fixed bin(17,0) dcl 272 set ref 1334* 1335 1335 1337 1544* 1545* 1553* 1554* length builtin function dcl 345 ref 500 1290 1334 1445 1763 length_options 000002 constant structure level 1 packed packed unaligned dcl 1921 ref 566 lengths 0(03) 000463 automatic bit(1) level 2 packed packed unaligned dcl 208 set ref 454* 563 583 851 link_options 000007 constant structure level 1 packed packed unaligned dcl 2101 ref 830 link_path 0(03) 000100 automatic bit(1) level 2 packed packed unaligned dcl 96 set ref 724 935 link_status based structure level 1 dcl 164 link_sw 003546 automatic bit(1) dcl 263 set ref 366* 404* 475 480* 536 536* 538 662 838 840 link_type constant bit(2) initial dcl 1-1 ref 804 867 linkage_error 000000 stack reference condition dcl 349 ref 1404 1409 local_unique_id 003527 automatic bit(36) dcl 259 set ref 948* 949* 951* 956* 957* logical_volume 0(12) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 427* 1158 logical_volume 0(12) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1176 lv_string 003453 automatic char(32) packed unaligned dcl 255 set ref 1161* 1164* 1166 1171* 1172* 1173* lvid 6 003660 automatic bit(36) level 2 packed packed unaligned dcl 1-1 set ref 1164* matched 003547 automatic bit(1) dcl 263 set ref 654* 670* 688 688 775* 781* max builtin function dcl 345 ref 419 1445 max_length 0(16) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1264 1267 1273 max_length 003640 automatic fixed bin(19,0) dcl 274 in procedure "st" set ref 1253* 1254* 1255* 1257* 1261* 1263* max_length 0(16) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1250 max_switch_length 000100 automatic fixed bin(17,0) dcl 706 set ref 711* 1445* 1445 1449* 1449 1733* 1737* mdc_$find_lvname 000150 constant entry external dcl 334 ref 1164 mdir 10(10) 003660 automatic bit(1) level 2 packed packed unaligned dcl 1-1 set ref 923 mhcs_$get_seg_usage 000152 constant entry external dcl 335 ref 1408 mode 3 000143 automatic bit(5) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1016 mode 3 000276 automatic bit(36) level 2 in structure "auto_dm_file_status" dcl 197 in procedure "st" set ref 1279 mode 0(17) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1285 mode 3 003660 automatic bit(5) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 760* 761* 988 1281 mode 0(17) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 963 1024* 1277 mode_bits 000607 automatic bit(1) array packed unaligned dcl 227 set ref 1279* 1280* 1281* 1296 1297 1298 1301 1302 1303 mode_string 002641 automatic varying char(36) dcl 250 set ref 1282* 1291* 1291 1296* 1297* 1297 1298* 1298 1301* 1302* 1302 1303* 1303 1306 1306* 1308 1311* 1312* modes 003530 automatic bit(36) dcl 259 in procedure "st" set ref 1284* 1291 modes 33 000155 automatic char(36) level 2 in structure "si" dcl 195 in procedure "st" set ref 1290 1291 msf 003550 automatic bit(1) dcl 263 set ref 619* 624 673* 683 789* 791 798* 856* 968 978* 1050 1058 1074 1109 1186 1207 1228 1253 1280 1295 1374 1384 msf_dtcm 003532 automatic bit(36) packed unaligned dcl 260 set ref 982* 1012 1012* 1058 1058* msf_dtd 003533 automatic bit(36) packed unaligned dcl 260 set ref 982* 1014 1014* 1109 1109* msf_dtem 003534 automatic bit(36) packed unaligned dcl 260 set ref 982* 1013 1013* 1074 1074* msf_dtu 003535 automatic bit(36) packed unaligned dcl 260 set ref 982* 1011 1011* 1050 1050* msf_error 003551 automatic bit(1) dcl 263 set ref 682 714* 1002* 1028* msf_info 000143 automatic structure level 1 dcl 173 set ref 996 996 msf_manager_$close 000154 constant entry external dcl 336 ref 624 683 972 1642 msf_manager_$get_ptr 000156 constant entry external dcl 337 ref 992 msf_manager_$open 000160 constant entry external dcl 338 ref 975 msf_mode 000102 automatic bit(5) dcl 708 set ref 988* 1016* 1280 msf_path 003175 automatic char(168) packed unaligned dcl 253 set ref 986* 996* 1003* 1007* 1253* msf_ptr 003574 automatic pointer dcl 266 set ref 620* 624 624* 674* 683 683* 972 972* 975* 976 992* 1642 1642* msf_rbs 000103 automatic fixed bin(5,0) array packed unaligned dcl 709 set ref 989* 1017* 1374* 1384* 1386* name_count 5 based fixed bin(17,0) array level 3 dcl 6-37 ref 1693 name_index 4 based fixed bin(17,0) array level 3 dcl 6-37 set ref 1445 1540 1540 1694 1694 1707 1709* names 0(01) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 431* 724 893 896 903 names based char(32) array level 2 in structure "switch_list" dcl 6-37 in procedure "st" ref 1445 1540 1545 1694 names_rel_pointer 0(18) 003660 automatic bit(18) level 2 packed packed unaligned dcl 1-1 set ref 721* 729 729 nindex 0(18) based fixed bin(18,0) array level 2 in structure "star_links" packed packed unsigned unaligned dcl 4-76 in procedure "st" ref 1841 nindex 0(18) based fixed bin(18,0) array level 2 in structure "star_dir_list_branch" packed packed unsigned unaligned dcl 4-59 in procedure "st" ref 671 nnames 0(02) based fixed bin(16,0) array level 2 packed packed unsigned unaligned dcl 4-76 ref 1841 no_concurrency_sw 10(01) 000276 automatic bit(1) level 3 packed packed unaligned dcl 197 set ref 1592 no_rollback_sw 10(02) 000276 automatic bit(1) level 3 packed packed unaligned dcl 197 set ref 1598 no_s_options 000005 constant structure level 1 packed packed unaligned dcl 2029 ref 738 746 nonlink_options 000010 constant structure level 1 packed packed unaligned dcl 2137 ref 844 nonstandard_names_flag 3 based bit(1) array level 2 dcl 199 set ref 390* 396* 442* 504 599 not_mounted 000101 automatic fixed bin(35,0) dcl 707 set ref 715* 744* 1608 1608* null builtin function dcl 344 ref 370 590 620 624 626 643 674 683 685 726 726 727 733 972 976 996 996 1427 1429 1613 1642 1758 1760 1841 1842 1843 1844 num_ring_brackets 45 000155 automatic fixed bin(17,0) level 2 dcl 195 set ref 1354 1365* 1367 number_names 0(02) 003660 automatic bit(16) level 2 packed packed unaligned dcl 1-1 set ref 712* 746 759* 896 906 off_line_options 000006 constant structure level 1 packed packed unaligned dcl 2065 ref 745 one_item 003552 automatic bit(1) dcl 263 set ref 582* 584* 874 904 907 911 931 943 956 1053 1061 1069 1076 1087 1094 1104 1111 1130 1133 1150 1154 1171 1175 1201 1213 1221 1234 1243 1261 1266 1311 1331 1336 1341 1367 1381 1384 1387 1390 1417 1578 1586 1612 1669 1731 1735 opt 000100 automatic structure level 1 packed packed unaligned dcl 96 set ref 364* 426 557 559* 561* 561 562* 562 564* 564 566* 566 568 574* 580 594 713* 738* 738 740 745* 745 746* 746 747 751* 751 752 791 830* 830 831 844* 844 845 859* 859 860 866 880 1000 1026 path_array based structure array level 1 dcl 199 set ref 376 527 1844 path_array_ptr 003576 automatic pointer dcl 267 set ref 369* 376* 388 389 390 395 396 440 441 442 500 503 504 504 510 511 520 521 526 527 528* 589 590 599 601 602 606 606 608 609 629 630 1844 1844 1844 path_array_size 003626 automatic fixed bin(17,0) dcl 272 set ref 375* 376 376 527 1844 path_array_space 000312 automatic structure array level 1 unaligned dcl 204 set ref 369 376 491 493 526 1844 path_count 003627 automatic fixed bin(17,0) dcl 272 set ref 379* 387* 387 388 389 390 394* 394 395 396 439* 439 440 441 442 488 489 496 531* 586 588* 592 598 1669 path_len 2 based fixed bin(17,0) array level 2 in structure "slet_path_array" dcl 203 in procedure "st" set ref 515* 521* path_len 2 based fixed bin(17,0) array level 2 in structure "path_array" dcl 199 in procedure "st" set ref 389* 395* 441* 500 503 510 521 589* 601 606* 609 630 path_ptr based pointer array level 2 in structure "path_array" dcl 199 in procedure "st" set ref 388* 440* 504 511 520 590* 602 606* 608 629 path_ptr based pointer array level 2 in structure "slet_path_array" dcl 203 in procedure "st" set ref 514* 520* pathname_ 000162 constant entry external dcl 339 ref 650 650 688 688 771 771 806 806 823 823 823 823 885 885 1528 1528 1565 1565 1646 1646 1655 1655 1669 1669 1671 1671 pathname_len 3 based fixed bin(18,0) array level 2 packed packed unsigned unaligned dcl 4-76 ref 1841 plural_name 22 000155 automatic char(32) level 2 packed packed unaligned dcl 195 set ref 1547* 1699* pnl 3 based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 164 ref 937 pnrp 3(18) based bit(18) level 2 packed packed unaligned dcl 164 ref 936 primary_name 000100 automatic bit(1) level 2 packed packed unaligned dcl 96 set ref 724 893 printed_pathname 003553 automatic bit(1) dcl 263 set ref 618* 672* 678 1667 1674* printed_something 003554 automatic bit(1) dcl 263 set ref 596* 678 678* 688 protected_sw 10 000276 automatic bit(1) level 3 packed packed unaligned dcl 197 set ref 1604 protected_switch 0(32) 000101 automatic bit(1) level 3 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1604* protected_switch 0(32) 000100 automatic bit(1) level 3 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1602 ptr builtin function dcl 345 ref 729 936 rbs 10(18) 000143 automatic fixed bin(5,0) array level 2 packed packed unaligned dcl 173 set ref 1017 records 3(18) 000143 automatic fixed bin(17,0) level 2 in structure "msf_info" packed packed unaligned dcl 173 in procedure "st" set ref 1019 records 3(18) 003660 automatic bit(18) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 983 1217 1217 1221 1221 1222 1222 1244 records_used 0(14) 000100 automatic bit(1) level 2 packed packed unaligned dcl 96 set ref 444* 963 1024* 1205 requote_string_ 000164 constant entry external dcl 340 ref 895 898 return_len 003630 automatic fixed bin(17,0) dcl 272 set ref 353* 895 898 927 939 951 1125 1145 1166 1188 1198 1209 1217 1230 1239 1257 1308 1324 1365 1372 1374 1375 1377 1413 1577 1585 1630 1727 1728 return_ptr 003600 automatic pointer dcl 267 set ref 353* 895 898 898 927 939 951 1125 1145 1166 1188 1198 1209 1217 1230 1239 1257 1308 1324 1365 1372 1374 1375 1377 1413 1577 1585 1630 1727 1728 return_string based varying char dcl 241 set ref 895* 898* 898 927* 939* 951* 1125* 1145* 1166* 1188* 1198* 1209* 1217* 1230* 1239* 1257* 1308* 1324* 1365* 1372* 1374* 1375* 1377* 1413* 1577* 1585* 1630* 1727* 1728* reverse builtin function dcl 345 ref 779 779 1334 ring_brackets 0(19) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 963 999* 1024* 1351 ring_brackets 000610 automatic fixed bin(3,0) array dcl 228 in procedure "st" set ref 1360* 1365* 1367* ring_brackets 0(19) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1354 1361 ring_brackets 6 000276 automatic fixed bin(3,0) array level 2 in structure "auto_dm_file_status" dcl 197 in procedure "st" set ref 1372* 1381* 1383* ring_brackets 10(18) 003660 automatic bit(6) array level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 762* 989 1375 1375 1377 1377 1377 1377 1387 1387 1389 1389 1390 1390 1390 1390 1392 1392 1392 1392 rollback_switch 0(31) 000100 automatic bit(1) level 3 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1596 rollback_switch 0(31) 000101 automatic bit(1) level 3 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1598* root_options 000013 constant structure level 1 packed packed unaligned dcl 2245 ref 751 root_sw 003555 automatic bit(1) dcl 264 set ref 366* 626 685 714* 733 750* 791 856 916 1045 1119 1139 1160 1181 1455 1463 1470 1479 1485 1655* rtrim builtin function dcl 345 ref 500 779 779 895 895 898 898 927 939 986 1125 1145 1166 1290 1324 1445 1630 safety_switch 0(20) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1453* 1457* safety_switch 0(20) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 546* 1451 safety_switch 003556 automatic bit(1) dcl 264 in procedure "st" set ref 1455* 1456* 1457* saved_dn 003247 automatic char(168) packed unaligned dcl 253 set ref 682 814* 1001* 1027* saved_en 003463 automatic char(32) packed unaligned dcl 255 set ref 815* saved_options 000102 automatic structure level 1 packed packed unaligned dcl 137 set ref 594* 713 seg_sw 003557 automatic bit(1) dcl 264 set ref 366* 405* 475 480* 536 536* 539 659 668 838 840 selecting_by_entry_type 003560 automatic bit(1) dcl 264 set ref 371* 452* 473 768 si 000155 automatic structure level 1 dcl 195 set ref 800 800 slet_area 000620 automatic area(1024) dcl 247 set ref 247* 502 slet_path based char packed unaligned dcl 242 set ref 502 504* 512* slet_path_array based structure array level 1 dcl 203 set ref 491 slet_path_array_ptr 003602 automatic pointer dcl 267 set ref 491* 493* 514 515 520 521 528 slet_path_array_size 003631 automatic fixed bin(17,0) dcl 272 set ref 488* 489* 491 491 495 531 slet_path_len 003632 automatic fixed bin(17,0) dcl 272 set ref 500* 502 502 504 504 512 515 slet_path_ptr 003604 automatic pointer dcl 267 set ref 502* 504 512 514 star_ALL_ENTRIES constant fixed bin(2,0) initial dcl 4-111 ref 540 star_BRANCHES_ONLY constant fixed bin(2,0) initial dcl 4-110 ref 538 star_DIRECTORY constant fixed bin(2,0) initial unsigned dcl 4-121 ref 789 921 1252 1375 1387 1398 1463 1479 star_LINK constant fixed bin(2,0) initial unsigned dcl 4-119 ref 661 791 919 1067 1084 1102 1841 star_LINKS_ONLY constant fixed bin(2,0) initial dcl 4-109 ref 539 star_LINKS_ONLY_WITH_LINK_PATHS constant fixed bin(3,0) initial dcl 4-112 ref 1841 star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 4-120 ref 658 920 1172 1295 1565 star_branch_count 003672 automatic fixed bin(17,0) dcl 4-13 set ref 647* 655 1841 1841 1841 1841 1842 star_dir_list_branch based structure array level 1 dcl 4-59 ref 1842 star_en 003473 automatic char(32) packed unaligned dcl 255 set ref 653* 688* 688* 779 star_entry_count 003673 automatic fixed bin(17,0) dcl 4-14 set ref 617* 655* 656 1612 star_link_count 003676 automatic fixed bin(17,0) dcl 4-17 set ref 647* 655 1841 1841 1841 1841 1842 star_links based structure array level 1 dcl 4-76 star_list_branch_ptr 003674 automatic pointer dcl 4-16 set ref 370* 643* 647* 657 665 671 1841 1841 1841 1841 1842 1842 star_list_names based char(32) array packed unaligned dcl 4-92 ref 671 1841 star_list_names_ptr 003700 automatic pointer dcl 4-20 set ref 370* 643* 647* 671 1841 1841 star_select_sw 003702 automatic fixed bin(3,0) dcl 4-21 set ref 538* 539* 540* 647* 1841 star_sw 003561 automatic bit(1) dcl 264 set ref 616* 642* 779 836 846 1398 1655 1669 status_chase 003610 automatic fixed bin(1,0) dcl 269 set ref 717* 724* 726* 818* status_for_backup based structure level 1 dcl 5-11 status_for_backup_version_2 constant fixed bin(17,0) initial dcl 5-33 ref 1496 1570 stime 000466 automatic bit(36) packed unaligned dcl 225 set ref 1047* 1048* string builtin function dcl 345 set ref 364* 365* 426 559* 561* 561 561 562* 562 562 564* 564 564 566* 566 566 568 580 738* 738 738 740 745* 745 745 746* 746 746 747 751* 751 751 752 791 791 830* 830 830 831 844* 844 844 845 859* 859 859 860 866 880 880 1000 1026 1279* 1280* 1281* substr builtin function dcl 345 set ref 386 426* 484 499 552* 554 580 778 795 995 1244 1279 1291 1291 1333 1335 1335 1339 1339 1558 1788 suffix 1 based char(32) array level 2 packed packed unaligned dcl 215 set ref 484 499 500 504* 1778* 1795* 1832 suffix_info based structure level 1 dcl 6-12 switch parameter char packed unaligned dcl 1681 set ref 1679 1688 1689 1690 1694 1699* 1704 1706 1715 1723* 1733* 1737* switch_count 003633 automatic fixed bin(17,0) dcl 273 in procedure "st" set ref 379* 412 417* 417 418 544 568 578 791 831 845 860 1543 1553 1557 switch_count 2 based fixed bin(17,0) level 2 in structure "switch_list" dcl 6-37 in procedure "st" ref 1429 1444 1445 1539 1540 1545 1613 1692 1694 switch_length 003634 automatic fixed bin(17,0) dcl 273 set ref 380* 419* 419 711 switch_list based structure level 1 dcl 6-37 set ref 1429 1613 switch_list_ptr 003704 automatic pointer dcl 6-33 set ref 1427* 1429 1429 1433* 1444 1445 1445 1539 1540 1540 1540 1544 1545 1613 1613 1692 1693 1694 1694 1694 1707 1709 1710 switch_mask 003536 automatic bit(10) dcl 261 set ref 543* 552* 554 1553 1557 1558 switch_name_count 3 based fixed bin(17,0) level 2 dcl 6-37 ref 1429 1544 1613 switch_names 000467 automatic char(32) array packed unaligned dcl 226 set ref 418* 545 546 547 548 549 550 551 1545 1547* 1554* 1558* switch_value parameter bit(1) dcl 1717 ref 1715 1720 switches 10 000276 automatic structure level 2 in structure "auto_dm_file_status" dcl 197 in procedure "st" switches 4 000103 automatic structure level 2 in structure "bks" packed packed unaligned dcl 162 in procedure "st" switches 4 based structure array level 2 in structure "switch_list" dcl 6-37 in procedure "st" synchronized_switch 0(27) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 549* 1521 synchronized_switch 0(27) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1435 1523* 1531* synchronized_switch 10(12) 003660 automatic bit(1) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 1531 target_dn 003321 automatic char(168) packed unaligned dcl 253 set ref 504* 509* 811* 816 823* 823* target_en 003503 automatic char(32) packed unaligned dcl 255 set ref 811* 817 823* 823* target_len 003635 automatic fixed bin(17,0) dcl 273 set ref 503* 504 504 937* 939 943 943 944 944 target_path based char packed unaligned dcl 243 set ref 504* 939 943* 944* target_ptr 003606 automatic pointer dcl 267 set ref 936* 939 943 944 temp_clock 000464 automatic fixed bin(71,0) dcl 224 set ref 1046* 1047 temp_string 002777 automatic char(336) packed unaligned dcl 252 set ref 1333* 1334 1334 temp_switch 000166 automatic char(32) packed unaligned dcl 1682 set ref 1688* 1689* 1690* 1706* 1712* this_type 000224 automatic char(32) packed unaligned dcl 1754 set ref 1787* 1788 1789 1789* 1790 1790* 1791 1791* 1792 1792* 1793 1793* 1795 1797 1800* time 0(20) based bit(36) level 2 packed packed unaligned dcl 219 ref 1047 total_bit_count 003641 automatic fixed bin(24,0) dcl 275 set ref 985* 1020* 1020 1188* 1195* total_length 003636 automatic fixed bin(17,0) dcl 273 set ref 984* 1021* 1021 1230* 1234* 1235 1235* total_records 003637 automatic fixed bin(17,0) dcl 273 set ref 983* 1019* 1019 1209* 1213* 1214* 1235 type 003660 automatic bit(2) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 757* 788 804 836 851 867 1527 type based fixed bin(2,0) array level 2 in structure "star_links" packed packed unsigned unaligned dcl 4-76 in procedure "st" ref 1841 type 0(02) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 428* 915 type based fixed bin(2,0) array level 2 in structure "star_dir_list_branch" packed packed unsigned unaligned dcl 4-59 in procedure "st" ref 657 type_name 12 000155 automatic char(32) level 2 packed packed unaligned dcl 195 set ref 918 1354* type_string 003513 automatic char(32) packed unaligned dcl 256 set ref 916* 917* 918* 919* 920* 921* 923* 924* 927 931* 932* typed_options 000014 constant structure level 1 packed packed unaligned dcl 2281 ref 791 types based char packed unaligned dcl 1751 set ref 1760 1764 1765* 1769 1772* 1772 1782* 1785 1787 1805* 1805 1810 types_len 000221 automatic fixed bin(24,0) dcl 1752 set ref 1760 1760 1763* 1764 1764 1765 1769 1772 1772 1782 1785 1787 1805 1805 1810 1810 types_ptr 000222 automatic pointer dcl 1753 set ref 1758* 1760 1760 1764* 1765 1769 1772 1772 1782 1785 1787 1805 1805 1810 unique_id 0(04) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 947 unique_id 11 003660 automatic bit(36) level 2 in structure "branch_status" packed packed unaligned dcl 1-1 in procedure "st" set ref 758* 949 unspec builtin function dcl 345 set ref 574* 574 756* 863* 881* 989* 989 1017* 1017 1184* usage_count 003644 automatic fixed bin(35,0) dcl 276 in procedure "st" set ref 1403* 1405* 1408* 1411 1413* 1417* 1419* usage_count 0(25) 000101 automatic bit(1) level 2 in structure "explicit_opt" packed packed unaligned dcl 135 in procedure "st" set ref 1398 1420 usage_count 0(25) 000100 automatic bit(1) level 2 in structure "opt" packed packed unaligned dcl 96 in procedure "st" set ref 1396 value 000177 automatic bit(1) dcl 1685 set ref 1712* 1720* 1727 1731 1731* 1733* 1733 1733* 1735* 1737* verify builtin function dcl 345 ref 995 version 000100 automatic char(8) level 2 in structure "entry_type_info" dcl 1750 in procedure "BUILD_ENTRY_TYPE_LIST" set ref 1777* version 000103 automatic fixed bin(17,0) level 2 in structure "bks" dcl 162 in procedure "st" set ref 1496* 1570* version 000155 automatic char(8) level 2 in structure "si" dcl 195 in procedure "st" set ref 799* version 000276 automatic char(8) level 2 in structure "auto_dm_file_status" dcl 197 in procedure "st" set ref 882* x 000200 automatic fixed bin(17,0) dcl 1686 set ref 1693* 1694* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. alloc_switch_count automatic fixed bin(17,0) dcl 6-33 alloc_switch_name_count automatic fixed bin(17,0) dcl 6-33 dm_file_status_ptr automatic pointer dcl 3-44 msf_type internal static bit(2) initial dcl 1-1 segment_type internal static bit(2) initial dcl 1-1 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 4-114 star_entries based structure array level 1 dcl 4-27 star_entry_ptr automatic pointer dcl 4-15 star_link_pathname based char packed unaligned dcl 4-102 star_linkx automatic fixed bin(17,0) dcl 4-18 star_list_branch based structure array level 1 dcl 4-41 star_names based char(32) array packed unaligned dcl 4-37 star_names_ptr automatic pointer dcl 4-19 suffix_info_ptr automatic pointer dcl 6-10 NAMES DECLARED BY EXPLICIT CONTEXT. AF_USAGE 005045 constant label dcl 570 ref 583 587 592 BUILD_ENTRY_TYPE_LIST 023672 constant entry internal dcl 1745 ref 452 CLEAN_UP 024417 constant entry internal dcl 1839 ref 373 645 690 695 1644 CONVERT_DATE 022406 constant entry internal dcl 1618 ref 1048 1050 1051 1058 1059 1068 1074 1075 1086 1093 1103 1109 1110 ENTRY_ERROR 022561 constant entry internal dcl 1636 ref 740 747 764 1003 1030 ENTRY_RETURN 022405 constant label dcl 1615 ref 1631 1647 1658 ENTRY_STATUS 006105 constant entry internal dcl 699 ref 622 676 ENTRY_TYPE_SELECTED 024351 constant entry internal dcl 1825 ref 774 ENTRY_WRONG_TYPE 022703 constant entry internal dcl 1651 ref 752 831 838 840 842 846 860 867 868 1463 1479 FOUND 021365 constant label dcl 1549 ref 1545 JOIN 023322 constant label dcl 1707 ref 1694 NEXT_MATCH 006007 constant label dcl 686 ref 659 662 666 668 NEXT_PATH 006075 constant label dcl 693 ref 611 632 651 NOT_GATE 021653 constant label dcl 1573 NO_S 006307 constant label dcl 738 PRINT 023413 constant label dcl 1723 ref 1713 PRINT_PATHNAME 023003 constant entry internal dcl 1662 ref 875 902 930 942 955 966 1052 1060 1066 1083 1101 1118 1138 1159 1180 1206 1227 1251 1278 1317 1352 1397 1426 1452 1462 1478 1493 1503 1512 1522 1536 1564 1584 1591 1597 1603 PRINT_SWITCH 023371 constant entry internal dcl 1715 ref 1457 1472 1487 1498 1507 1517 1531 1592 1598 1604 RETURN 005467 constant label dcl 636 SKIP_SWITCHES 021502 constant label dcl 1562 ref 1435 STATUS 006132 constant label dcl 721 ref 819 STATUS_EXIT 006077 constant label dcl 695 ref 1818 STATUS_SWITCH 023124 constant entry internal dcl 1679 ref 1453 1467 1483 1494 1504 1513 1523 1554 STATUS_SWITCH_QUICK 023303 constant entry internal dcl 1704 ref 1540 flurp 017455 constant label dcl 1409 ref 1406 get_msf_info 011117 constant label dcl 968 st 003055 constant entry external dcl 56 star_loop 005470 constant label dcl 639 status 003065 constant entry external dcl 56 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 25664 26056 24665 25674 Length 26630 24665 172 536 777 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME st 2096 external procedure is an external procedure. on unit on line 373 64 on unit begin block on line 639 154 begin block enables or reverts conditions. on unit on line 645 64 on unit ENTRY_STATUS 623 internal procedure enables or reverts conditions. on unit on line 732 64 on unit begin block on line 968 144 begin block enables or reverts conditions. on unit on line 971 68 on unit on unit on line 1404 64 on unit on unit on line 1428 65 on unit CONVERT_DATE internal procedure shares stack frame of internal procedure ENTRY_STATUS. ENTRY_ERROR 148 internal procedure is called by several nonquick procedures. ENTRY_WRONG_TYPE internal procedure shares stack frame of internal procedure ENTRY_STATUS. PRINT_PATHNAME internal procedure shares stack frame of internal procedure ENTRY_STATUS. STATUS_SWITCH internal procedure shares stack frame of internal procedure ENTRY_STATUS. BUILD_ENTRY_TYPE_LIST 230 internal procedure enables or reverts conditions. on unit on line 1759 64 on unit ENTRY_TYPE_SELECTED internal procedure shares stack frame of internal procedure ENTRY_STATUS. CLEAN_UP 70 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME BUILD_ENTRY_TYPE_LIST 000100 entry_type_info BUILD_ENTRY_TYPE_LIST 000221 types_len BUILD_ENTRY_TYPE_LIST 000222 types_ptr BUILD_ENTRY_TYPE_LIST 000224 this_type BUILD_ENTRY_TYPE_LIST ENTRY_STATUS 000100 max_switch_length ENTRY_STATUS 000101 not_mounted ENTRY_STATUS 000102 msf_mode ENTRY_STATUS 000103 msf_rbs ENTRY_STATUS 000166 temp_switch STATUS_SWITCH 000176 default STATUS_SWITCH 000177 value STATUS_SWITCH 000200 x STATUS_SWITCH 000212 entry_type_index ENTRY_TYPE_SELECTED st 000100 opt st 000101 explicit_opt st 000102 saved_options st 000103 bks st 000143 msf_info st 000155 si st 000276 auto_dm_file_status st 000312 path_array_space st 000456 dates_array st 000463 combined_options st 000464 temp_clock st 000466 stime st 000467 switch_names st 000607 mode_bits st 000610 ring_brackets st 000620 slet_area st 002620 date_string st 002641 mode_string st 002653 class st 002777 temp_string st 003123 dn st 003175 msf_path st 003247 saved_dn st 003321 target_dn st 003373 author_string st 003403 bc_author_string st 003413 comp_name st 003423 en st 003433 fs_type st 003443 fs_util_type st 003453 lv_string st 003463 saved_en st 003473 star_en st 003503 target_en st 003513 type_string st 003524 access_class st 003526 exmodes st 003527 local_unique_id st 003530 modes st 003531 bc36 st 003532 msf_dtcm st 003533 msf_dtd st 003534 msf_dtem st 003535 msf_dtu st 003536 switch_mask st 003537 active_function st 003540 chase st 003541 chase_if_possible st 003542 chased st 003543 dir_sw st 003544 dm_file_sw st 003545 interpret_as_standard_entry st 003546 link_sw st 003547 matched st 003550 msf st 003551 msf_error st 003552 one_item st 003553 printed_pathname st 003554 printed_something st 003555 root_sw st 003556 safety_switch st 003557 seg_sw st 003560 selecting_by_entry_type st 003561 star_sw st 003562 area_ptr st 003564 arg_ptr st 003566 branch_names_ptr st 003570 comp_ptr st 003572 fs_entry_type_ptr st 003574 msf_ptr st 003576 path_array_ptr st 003600 return_ptr st 003602 slet_path_array_ptr st 003604 slet_path_ptr st 003606 target_ptr st 003610 status_chase st 003611 entry_type st 003612 arg_count st 003613 arg_len st 003614 class_len st 003615 cvds st 003616 entry_type_index st 003617 extended_type_count st 003620 fs_entry_type_count st 003621 i st 003622 ivds st 003623 j st 003624 k st 003625 kk st 003626 path_array_size st 003627 path_count st 003630 return_len st 003631 slet_path_array_size st 003632 slet_path_len st 003633 switch_count st 003634 switch_length st 003635 target_len st 003636 total_length st 003637 total_records st 003640 max_length st 003641 total_bit_count st 003642 bc35 st 003643 code st 003644 usage_count st 003646 complain st 003660 branch_status st 003672 star_branch_count st 003673 star_entry_count st 003674 star_list_branch_ptr st 003676 star_link_count st 003700 star_list_names_ptr st 003702 star_select_sw st 003704 switch_list_ptr st THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_e_as r_ne_as r_ge_a alloc_char_temp cat_realloc_chars enter_begin_block leave_begin_block call_ent_var_desc call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other begin_return_mac return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry int_entry_desc reverse_cs set_chars_eis op_alloc_ op_freen_ op_empty_ clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. active_fnc_err_ check_star_name_$entry com_err_ convert_authorization_$to_string_short cu_$af_return_arg cu_$arg_ptr cv_fstime_ date_time_$format expand_path_ expand_pathname_$add_suffix file_manager_$status fs_util_$get_max_length fs_util_$get_ring_brackets fs_util_$get_switch fs_util_$get_type fs_util_$get_user_access_modes fs_util_$list_switches_for_type fs_util_$suffix_info_for_type get_group_id_ get_system_free_area_ get_wdir_ hcs_$get_access_class hcs_$get_author hcs_$get_bc_author hcs_$get_dates hcs_$get_link_target hcs_$get_max_length hcs_$get_safety_sw hcs_$get_volume_dump_switches hcs_$star_dir_list_ hcs_$status_for_backup hcs_$status_long ioa_ ioa_$nnl ioa_$rsnnl mdc_$find_lvname mhcs_$get_seg_usage msf_manager_$close msf_manager_$get_ptr msf_manager_$open pathname_ requote_string_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. dm_error_$transaction_in_progress error_table_$badopt error_table_$inconsistent error_table_$incorrect_access error_table_$logical_volume_not_connected error_table_$logical_volume_not_defined error_table_$moderr error_table_$no_s_permission error_table_$noarg error_table_$noentry error_table_$nomatch error_table_$not_act_fnc error_table_$root error_table_$segknown error_table_$unsupported_operation LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 247 003047 56 003054 353 003073 354 003110 355 003114 356 003115 357 003121 359 003122 360 003124 363 003130 364 003131 365 003133 366 003135 367 003145 369 003153 370 003155 371 003161 373 003162 375 003204 376 003206 379 003216 380 003220 382 003222 384 003231 386 003246 387 003253 388 003254 389 003260 390 003263 391 003264 393 003265 394 003276 395 003277 396 003303 397 003304 399 003305 400 003314 401 003322 402 003335 403 003347 404 003362 405 003375 406 003410 407 003414 408 003415 409 003420 410 003444 412 003445 413 003450 414 003474 416 003475 417 003512 418 003513 419 003523 420 003530 423 003531 425 003556 426 003561 427 003567 428 003604 429 003617 430 003631 431 003644 432 003653 433 003663 434 003664 435 003667 436 003722 438 003723 439 003740 440 003741 441 003746 442 003751 443 003753 444 003754 445 003767 446 003777 447 004000 448 004003 449 004040 451 004041 452 004056 453 004101 454 004102 455 004121 456 004123 458 004156 460 004157 462 004172 463 004215 465 004230 466 004262 469 004263 473 004265 475 004270 476 004276 478 004322 480 004323 482 004327 483 004330 484 004337 486 004346 488 004350 489 004356 491 004361 493 004372 495 004374 496 004376 498 004403 499 004413 500 004421 502 004446 503 004455 504 004463 509 004532 510 004541 511 004547 512 004551 514 004556 515 004563 516 004566 518 004570 519 004572 520 004575 521 004606 522 004611 524 004613 526 004616 527 004624 528 004630 531 004632 536 004634 538 004646 539 004653 540 004662 542 004664 543 004665 544 004666 545 004675 546 004707 547 004716 548 004725 549 004734 550 004743 551 004752 552 004761 554 004765 555 004773 557 004775 559 005001 561 005006 562 005014 563 005022 564 005025 566 005033 568 005036 570 005045 572 005072 574 005073 578 005077 579 005101 580 005107 581 005114 582 005116 583 005124 584 005131 586 005132 587 005134 588 005141 589 005143 590 005145 591 005147 592 005150 594 005154 596 005160 598 005161 599 005171 600 005176 601 005205 602 005213 603 005215 604 005220 606 005221 607 005244 608 005246 609 005253 610 005256 611 005306 613 005307 615 005330 616 005332 617 005333 618 005336 619 005337 620 005340 622 005342 624 005346 626 005363 627 005374 628 005375 629 005377 630 005404 631 005407 632 005437 634 005440 635 005442 636 005467 639 005470 642 005473 643 005476 645 005501 647 005523 649 005572 650 005575 651 005644 653 005647 654 005652 655 005653 656 005656 657 005666 658 005674 659 005676 660 005700 661 005701 662 005703 663 005705 665 005706 666 005713 667 005715 668 005716 670 005720 671 005722 672 005733 673 005734 674 005735 676 005737 678 005744 682 005751 683 005760 685 005775 686 006007 688 006012 690 006067 691 006074 693 006075 695 006077 697 006103 699 006104 711 006112 712 006115 713 006117 714 006123 715 006127 717 006130 721 006132 724 006135 726 006177 727 006237 729 006242 732 006251 733 006265 734 006300 736 006301 738 006307 740 006320 741 006343 742 006344 744 006350 745 006351 746 006362 747 006376 748 006421 749 006422 750 006424 751 006426 752 006437 753 006447 754 006453 755 006456 756 006460 757 006463 758 006467 759 006471 760 006475 761 006516 762 006523 763 006540 764 006541 768 006561 769 006565 770 006611 771 006614 772 006664 774 006665 775 006710 776 006713 778 006714 779 006722 781 007002 782 007005 788 007006 789 007011 791 007021 793 007044 794 007070 795 007103 797 007111 798 007113 799 007114 800 007117 804 007143 805 007150 806 007154 807 007225 809 007226 811 007234 812 007263 813 007272 814 007274 815 007277 816 007302 817 007305 818 007310 819 007312 821 007313 823 007320 826 007413 830 007414 831 007425 833 007437 836 007440 838 007450 839 007466 840 007467 842 007507 844 007516 845 007530 846 007535 847 007547 851 007550 853 007570 856 007572 858 007601 859 007604 860 007615 861 007630 863 007631 866 007633 867 007636 868 007647 874 007655 875 007662 876 007663 879 007674 880 007700 881 007707 882 007712 883 007714 884 007743 885 007751 886 010017 893 010020 894 010023 895 010025 896 010101 898 010123 899 010234 900 010237 902 010240 903 010241 904 010245 905 010267 906 010310 907 010327 908 010353 909 010374 910 010377 911 010400 912 010422 915 010445 916 010451 917 010460 918 010467 919 010476 920 010504 921 010512 923 010523 924 010532 926 010535 927 010537 928 010603 930 010605 931 010606 932 010631 935 010652 936 010656 937 010663 938 010666 939 010670 940 010711 942 010712 943 010713 944 010741 947 010765 948 010771 949 010777 950 011001 951 011003 952 011036 955 011037 956 011040 957 011063 963 011107 966 011113 968 011114 971 011122 972 011136 973 011153 975 011154 976 011203 977 011211 978 011243 979 011246 982 011250 983 011254 984 011257 985 011262 986 011263 988 011322 989 011330 991 011333 992 011340 993 011364 994 011373 995 011405 996 011427 997 011471 999 011500 1000 011502 1001 011505 1002 011510 1003 011512 1005 011533 1007 011534 1008 011565 1010 011567 1011 011572 1012 011603 1013 011614 1014 011625 1015 011636 1016 011640 1017 011644 1019 011647 1020 011653 1021 011657 1022 011662 1023 011663 1024 011665 1026 011707 1027 011712 1028 011715 1029 011717 1030 011731 1034 011752 1035 011756 1038 011757 1045 011763 1046 011766 1047 011771 1048 011774 1049 012002 1050 012003 1051 012016 1052 012024 1053 012025 1054 012050 1057 012101 1058 012105 1059 012120 1060 012126 1061 012127 1062 012152 1065 012202 1066 012206 1067 012207 1068 012212 1069 012220 1070 012243 1072 012273 1074 012274 1075 012307 1076 012315 1077 012340 1082 012370 1083 012374 1084 012375 1085 012400 1086 012425 1087 012434 1088 012461 1090 012511 1092 012512 1093 012537 1094 012546 1095 012571 1100 012621 1101 012625 1102 012626 1103 012631 1104 012637 1105 012662 1107 012715 1109 012716 1110 012731 1111 012737 1112 012765 1117 013015 1118 013021 1119 013022 1120 013026 1121 013031 1122 013032 1123 013033 1124 013064 1125 013067 1126 013113 1127 013130 1129 013131 1130 013133 1131 013155 1132 013176 1133 013177 1134 013216 1137 013244 1138 013250 1139 013251 1140 013255 1141 013260 1142 013261 1143 013262 1144 013306 1145 013311 1146 013335 1147 013352 1149 013353 1150 013355 1151 013377 1153 013426 1154 013427 1155 013446 1158 013474 1159 013500 1160 013501 1161 013505 1162 013510 1163 013511 1164 013512 1165 013533 1166 013536 1167 013562 1168 013577 1170 013600 1171 013602 1172 013624 1173 013650 1174 013673 1175 013674 1176 013713 1179 013741 1180 013745 1181 013746 1183 013754 1184 013757 1186 013760 1188 013764 1189 014017 1192 014020 1193 014043 1195 014075 1196 014116 1197 014117 1198 014121 1199 014154 1201 014155 1202 014177 1205 014220 1206 014224 1207 014225 1209 014232 1210 014264 1213 014265 1214 014307 1215 014327 1216 014330 1217 014332 1218 014370 1221 014371 1222 014416 1226 014441 1227 014445 1228 014446 1230 014453 1231 014505 1234 014506 1235 014530 1237 014561 1238 014562 1239 014564 1240 014622 1243 014623 1244 014650 1250 014705 1251 014711 1252 014712 1253 014716 1254 014750 1255 015000 1256 015025 1257 015030 1258 015066 1259 015103 1261 015104 1263 015130 1264 015152 1266 015165 1267 015204 1268 015231 1269 015232 1270 015234 1271 015270 1273 015271 1277 015327 1278 015333 1279 015334 1280 015347 1281 015356 1282 015362 1283 015363 1284 015366 1285 015430 1288 015442 1290 015466 1291 015506 1292 015522 1294 015524 1295 015525 1296 015534 1297 015543 1298 015555 1299 015567 1301 015570 1302 015577 1303 015611 1305 015623 1306 015626 1307 015637 1308 015641 1309 015652 1311 015653 1312 015675 1316 015716 1317 015722 1318 015723 1319 015751 1320 015754 1321 015775 1322 016024 1323 016026 1324 016035 1325 016056 1327 016057 1328 016063 1329 016073 1330 016077 1331 016101 1332 016120 1333 016126 1334 016132 1335 016146 1336 016173 1337 016212 1338 016215 1339 016216 1340 016252 1341 016254 1343 016300 1344 016314 1345 016315 1346 016322 1347 016345 1351 016346 1352 016352 1353 016353 1354 016357 1358 016413 1360 016414 1361 016441 1364 016453 1365 016477 1367 016540 1370 016576 1371 016577 1372 016601 1374 016640 1375 016676 1377 016755 1379 017023 1381 017024 1383 017051 1384 017072 1386 017120 1387 017141 1389 017210 1390 017251 1392 017306 1396 017341 1397 017345 1398 017346 1401 017403 1403 017404 1404 017405 1405 017421 1406 017425 1408 017430 1409 017455 1411 017456 1412 017464 1413 017466 1414 017524 1415 017541 1417 017542 1419 017566 1420 017612 1425 017640 1426 017647 1427 017650 1428 017653 1429 017667 1431 017707 1433 017710 1435 017741 1440 017754 1441 017756 1442 020001 1444 020002 1445 020016 1447 020046 1449 020050 1451 020052 1452 020055 1453 020056 1455 020106 1456 020113 1457 020140 1461 020172 1462 020176 1463 020177 1465 020221 1467 020222 1470 020250 1471 020256 1472 020306 1477 020344 1478 020350 1479 020351 1481 020373 1483 020374 1485 020422 1486 020430 1487 020460 1492 020516 1493 020522 1494 020523 1496 020553 1497 020555 1498 020604 1502 020642 1503 020646 1504 020647 1506 020677 1507 020700 1511 020735 1512 020741 1513 020742 1516 020772 1517 020773 1521 021030 1522 021034 1523 021035 1526 021067 1527 021070 1528 021077 1530 021153 1531 021154 1536 021213 1537 021214 1538 021220 1539 021223 1540 021234 1542 021260 1543 021263 1544 021274 1545 021306 1546 021327 1547 021331 1549 021365 1551 021370 1553 021371 1554 021404 1555 021423 1556 021426 1557 021427 1558 021442 1560 021477 1562 021502 1564 021506 1565 021507 1568 021567 1570 021570 1571 021572 1572 021621 1573 021650 1576 021705 1577 021706 1578 021747 1579 021774 1583 022022 1584 022026 1585 022027 1586 022066 1587 022110 1590 022130 1591 022134 1592 022135 1596 022177 1597 022203 1598 022204 1602 022243 1603 022247 1604 022250 1608 022307 1612 022342 1613 022363 1615 022405 1618 022406 1627 022410 1628 022424 1629 022505 1630 022510 1631 022555 1634 022557 1636 022560 1641 022601 1642 022605 1644 022617 1646 022624 1647 022700 1651 022703 1655 022714 1658 023002 1662 023003 1667 023004 1669 023012 1671 023061 1674 023120 1675 023123 1679 023124 1688 023135 1689 023147 1690 023157 1692 023162 1693 023174 1694 023205 1696 023233 1697 023235 1699 023240 1702 023302 1704 023303 1706 023314 1707 023322 1709 023331 1710 023333 1712 023340 1713 023370 1715 023371 1720 023402 1721 023406 1722 023411 1723 023413 1726 023447 1727 023452 1728 023467 1729 023500 1731 023501 1733 023534 1735 023602 1737 023634 1739 023670 1745 023671 1758 023705 1759 023707 1760 023723 1761 023735 1763 023736 1764 023744 1765 023754 1769 023763 1772 024001 1773 024024 1775 024027 1777 024043 1778 024045 1782 024066 1783 024075 1785 024100 1787 024106 1788 024116 1789 024122 1790 024132 1791 024142 1792 024152 1793 024162 1795 024171 1797 024203 1800 024211 1801 024234 1805 024240 1806 024265 1810 024266 1812 024273 1813 024301 1815 024305 1818 024345 1821 024350 1825 024351 1831 024362 1832 024373 1833 024411 1835 024413 1839 024416 1841 024424 1842 024471 1843 024503 1844 024515 1846 024534 ----------------------------------------------------------- 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