COMPILATION LISTING OF SEGMENT amu_find_system_dump_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 02/16/88 1411.6 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 4* * * 5* *********************************************************** */ 6 amu_find_system_dump_: 7 procedure (); 8 9 /* amu_find_system_dump_ -- wrapper for search_paths_ for FDUMPS and PDIRS 10* BIM 0783 11* Modified for pdir use by B. Braun 08/10/84 12* Modified by BLB 11/08/84 to handle starnames better and absolute path + full component name (eg. >dumps>110184.2400.0.20) 13**/ 14 15 16 dcl Dump_name char (*); 17 dcl Dump_info_ptr pointer; 18 dcl Code fixed bin (35); 19 20 21 /* Dump_name (input) 22* For FDUMPS: This can be an ERF number, or a pathname ending with an erf number, 23* or a pathname of the first segment of a dump (rel or abs) 24* For PDIRS: This can be the pdir name (with or without the suffix "pdir", or an absolute or relative 25* pathname ending with the pdir name. 26* Dump_info_ptr (input) 27* pointer to system_dump_info structure that will be filled in. 28* Code (output) 29* error_table_$noentry or 0. For ambiguous requests, this program signals sub_err_. 30* Catch the condition if you disapprove. 31**/ 32 33 34 /* External Entires */ 35 36 dcl check_star_name_$entry entry (character (*), fixed binary (35)); 37 dcl expand_pathname_ entry (character (*), character (*), character (*), fixed binary (35)); 38 dcl expand_pathname_$add_suffix entry (char(*), char(*), char(*), char(*), fixed bin(35)); 39 dcl get_system_free_area_ entry () returns (ptr); 40 dcl hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, fixed bin (35)); 41 dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), 42 fixed bin (35)); 43 dcl ioa_$rsnnl entry () options (variable); 44 dcl search_paths_$get entry (char(*), bit(36), char(*), ptr, ptr, fixed bin, ptr, 45 fixed bin(35)); 46 dcl sub_err_ entry () options (variable); 47 48 /* External Static */ 49 50 dcl error_table_$nomatch fixed bin (35) ext static; 51 dcl error_table_$unimplemented_version fixed bin (35) ext static; 52 dcl error_table_$noentry fixed bin (35) ext static; 53 54 /* Internal Static */ 55 56 dcl DUMP_LIST char (5) init ("dumps") internal static options (constant); 57 dcl PDIR_SUFFIX char (4) init ("pdir") internal static options (constant); 58 59 /* Automatic */ 60 61 dcl 1 match_star(3), 62 2 name char(32), 63 2 pdir_sw bit(1); 64 dcl search_dir_name char (168); 65 dcl search_entryname char (32); 66 dcl system_area_ptr ptr; 67 dcl want_a_pdir bit(1); 68 dcl what_to_list fixed bin; 69 70 /* Conditions */ 71 72 dcl cleanup condition; 73 74 /* Based */ 75 76 dcl system_area area based (system_area_ptr); 77 78 /* Builtins */ 79 80 dcl (after, before, 81 hbound, null, 82 reverse, rtrim, 83 search, sum) builtin; 84 85 /* 86* 87* The strategy here is somewhat complicated. Analysis of the name 88* given proceeds as follows: 89* 90* if there no <> in the pathname, then get a complete list of conventionally 91* named dumps. apply the search technique described below to each 92* directory's worth of dumps at a time. 93* 94* if there is <> in the pathname, then use expand_pathname_ to strip out 95* directory, and use the search technique below to look for the entryname. 96* 97*SEARCH TECHNIQUE: 98* 99*For FDUMPS: 100* if there are "."'s in the entryname, then demand that it is the complete 101* entryname of segment zero of the dump. The name must match the entryname 102* in the directory completely. 103* 104* If there are no "."'s, then the entryname is assumed to be a dump number. 105* If there is only one segment with a name of the form ??????.????.*.NAME 106* (the conventional form), then the search finds it. If there are more than 107* one, sub_err_ is signalled. Caller can catch. 108* 109*For PDIRS: 110* if there are "."'s in the entryname, then demand that it is the complete 111* entryname of the pdir directory. The name must match the entryname 112* in the directory completely. The suffix "pdir" is assumed if not given. 113* 114* If there are no "."'s, then the entryname is assumed to be a NAME 115* If there is only one segment with a name of the form NAME.pdir 116* (the conventional form), then the search finds it. If there are more than 117* one, sub_err_ is signalled. Caller can catch. 118**/ 119 120 /*****************************************************************************/ 121 122 amu_find_system_dump_$pdir: 123 entry (Dump_name, Dump_info_ptr, Code); 124 125 want_a_pdir = "1"b; 126 what_to_list = LIST_PDIRS; 127 goto COMMON_FIND; 128 129 /*****************************************************************************/ 130 131 amu_find_system_dump_$fdump: 132 entry (Dump_name, Dump_info_ptr, Code); 133 134 want_a_pdir = "0"b; 135 what_to_list = LIST_FDUMPS; 136 137 COMMON_FIND: 138 139 system_dump_info_ptr = Dump_info_ptr; 140 if system_dump_info.version ^= SYSTEM_DUMP_INFO_VERSION_1 then 141 call sub_err_ (error_table_$unimplemented_version, "amu_find_system_dump_", ACTION_CANT_RESTART, null (), (0), 142 "Invalid version ^a in system_dump_info structure.", system_dump_info.version); 143 144 call setup(); 145 system_dump_info.dump_dir_name, system_dump_info.dump_seg_prefix, system_dump_info.dump_name, 146 system_dump_info.dump_entry_format = ""; 147 148 Code = 0; 149 if search (Dump_name, "<>") > 0 then call FIND_GIVEN_PATHNAME (); 150 else call FIND_GIVEN_SEARCHNAME(); 151 152 return; 153 154 /*****************************************************************************/ 155 156 amu_find_system_dump_$list: 157 entry (Dump_list_select_name, Dump_list_version, List_what, Dump_list_area_ptr, Dump_list_ptr, Code); 158 159 dcl Dump_list_select_name char (*); /* Input - see below */ 160 dcl Dump_list_version char (8) aligned; /* Input - Caller expected list version */ 161 dcl List_what fixed bin; /* Inout - list fdumps, pdirs or both */ 162 dcl Dump_list_area_ptr pointer; /* Input - area to allocate list */ 163 dcl Dump_list_ptr pointer; /* Output - the usual */ 164 165 /***** Code is non-zero when there is a problem with the search name */ 166 167 /* If there are <> in the select name, then there is a particular dir */ 168 /* to list. if not, then we list all dumps. The entryname part of */ 169 /* the select name is tacked onto the usual ??????.????.*. */ 170 171 if Dump_list_version ^= SYSTEM_DUMP_LIST_VERSION_1 then 172 call sub_err_ (error_table_$unimplemented_version, "amu_find_system_dump_$search", ACTION_CANT_RESTART, 173 null (), (0), "Unsupported version ^a supplied in call to amu_find_system_dump_$list.", Dump_list_version); 174 175 call setup(); 176 want_a_pdir = "0"b; 177 if search (Dump_list_select_name, "<>") > 0 then do; 178 if List_what = LIST_PDIRS then call expand_pathname_$add_suffix (Dump_list_select_name, PDIR_SUFFIX, 179 search_dir_name, search_entryname, Code); 180 else call expand_pathname_ (Dump_list_select_name, search_dir_name, search_entryname, Code); 181 if Code ^= 0 then return; 182 call determine_search_name (search_entryname, List_what, match_star); 183 call get_one_dir (search_dir_name, match_star, Dump_list_area_ptr, Dump_list_ptr, Code); 184 end; 185 186 else do; 187 call determine_search_name(Dump_list_select_name, List_what, match_star); 188 call LIST_ALL_DIRS (match_star, Dump_list_area_ptr, Dump_list_ptr, Code); 189 end; 190 191 if Code = error_table_$nomatch then Code = error_table_$noentry; 192 return; 193 194 /*****************************************************************************/ 195 196 FIND_GIVEN_PATHNAME: 197 procedure; 198 199 /* The difficulty here is that it is hard to know how many pathnames */ 200 /* there are going to be for the whole search list. The expensive, */ 201 /* but simple approach is to allocate a structure for each dir in the */ 202 /* search list, then merge them all together. */ 203 204 dcl dump_dir_name char (168); 205 dcl dump_entryname char (32); 206 dcl code fixed bin (35); 207 208 /**** Called when Dump_name needs expanding */ 209 210 code = 0; 211 if want_a_pdir then call expand_pathname_$add_suffix (Dump_name, PDIR_SUFFIX, dump_dir_name, dump_entryname, code); 212 else call expand_pathname_ (Dump_name, dump_dir_name, dump_entryname, code); 213 214 if code ^= 0 then 215 BAD_NAME: 216 call sub_err_ (code, "amu_find_system_dump_", ACTION_CANT_RESTART, null (), (0), "Invalid search name ^a.", Dump_name); 217 218 call check_star_name_$entry (dump_entryname, code); 219 if code > 2 then go to BAD_NAME; 220 if code = 0 then do; /* perhaps no list needed? */ 221 if search (dump_entryname, ".") ^= 0 then do; /* Really simple, absolute */ 222 call hcs_$status_minf (dump_dir_name, dump_entryname, 1, (0), (0), code); 223 Code = code; 224 /* fill in structure */ 225 system_dump_info.dump_dir_name = dump_dir_name; 226 if ^want_a_pdir then do; 227 system_dump_info.dump_name = reverse(before(reverse(dump_entryname), ".")); 228 system_dump_info.dump_seg_prefix = reverse (after (after (reverse (dump_entryname), "."), ".")); 229 call ioa_$rsnnl ("^a.^^d.^a", system_dump_info.dump_entry_format, (0), 230 system_dump_info.dump_seg_prefix, system_dump_info.dump_name); 231 end; 232 else system_dump_info.dump_name = dump_entryname; 233 234 return; 235 end; 236 end; 237 238 call determine_search_name (dump_entryname, what_to_list, match_star); 239 call get_one_dir (dump_dir_name, match_star, system_area_ptr, system_dump_list_ptr, code); 240 if code ^= 0 then do; 241 Code = code; 242 return; 243 end; 244 245 RETURN_INFO: 246 /**** At this point, there better be just one. However, for now, */ 247 /**** we will return the first one, unless there is ambiguity. */ 248 249 if system_dump_list.n_dumps > 1 & system_dump_list.duplicate (1) 250 then begin; 251 dcl bad_dump_name char (32); 252 dcl bad_dump_dir char (168); 253 254 bad_dump_name = system_dump_list.minimal_entryname (1); 255 bad_dump_dir = system_dump_list.dir_name (1); 256 free system_dump_list in (system_area); 257 call sub_err_ ((0), "amu_find_system_dump_", ACTION_CANT_RESTART, null (), (0), 258 "Multiple dumps numbered ^a in ^a.", bad_dump_name, bad_dump_dir); 259 end; 260 261 system_dump_info.dump_dir_name = system_dump_list.dir_name (1); 262 if ^want_a_pdir then system_dump_info.dump_seg_prefix = 263 reverse (after (after (reverse (system_dump_list.full_entryname (1)), "."), ".")); 264 system_dump_info.dump_name = system_dump_list.minimal_entryname (1); 265 if ^want_a_pdir then call ioa_$rsnnl ("^a.^^d.^a", system_dump_info.dump_entry_format, (0), 266 system_dump_info.dump_seg_prefix, system_dump_info.dump_name); 267 free system_dump_list in (system_area); 268 return; 269 270 271 FIND_GIVEN_SEARCHNAME: 272 entry (); 273 274 dump_entryname = Dump_name; 275 call determine_search_name (dump_entryname, what_to_list, match_star); 276 call LIST_ALL_DIRS (match_star, system_area_ptr, system_dump_list_ptr, code); 277 if code ^= 0 278 then do; 279 Code = code; 280 return; 281 end; 282 283 go to RETURN_INFO; 284 285 end FIND_GIVEN_PATHNAME; 286 287 /*****************************************************************************/ 288 289 LIST_ONE_DIR: 290 procedure (dir_name, star_name, area_ptr, pdirs_wanted, a_info_ptr, code); 291 292 declare code fixed bin (35); 293 declare a_info_ptr pointer; 294 declare area_ptr pointer; 295 declare star_name char (*); /* starname for dump name part of the problem */ 296 declare dir_name char (*); /* pathname of dir to list */ 297 dcl pdirs_wanted bit(1); 298 declare dumpx fixed bin; 299 declare an_area area based (area_ptr); 300 declare name_index fixed bin; 301 declare n_dead_links fixed bin; 302 declare n_remove_dirs fixed bin; 303 declare n_remove_segs fixed bin; 304 declare type fixed bin (2); 305 declare starx fixed bin; 306 declare checkx fixed bin; 307 308 /* To save LIST_ALL_DIRS the trouble of accumulating results of */ 309 /* status_minf calls when it is given a precise entryname, this */ 310 /* code calls star on a non-star name. Sure, its expensive, */ 311 /* but this program does not have to be cheap. */ 312 313 star_names_ptr, star_entry_ptr, system_dump_list_ptr = null(); 314 a_info_ptr = null(); 315 on cleanup begin; 316 if star_names_ptr ^= null() then free star_names in (an_area); 317 if star_entry_ptr ^= null() then free star_entries in (an_area); 318 if system_dump_list_ptr ^= null() then free system_dump_list in (an_area); 319 end; 320 321 call hcs_$star_ (dir_name, star_name, star_ALL_ENTRIES, area_ptr, star_entry_count, star_entry_ptr, 322 star_names_ptr, code); 323 if code ^= 0 then return; 324 325 /***** Remove null links from the list */ 326 327 n_dead_links = 0; 328 n_remove_dirs = 0; 329 n_remove_segs = 0; 330 do dumpx = 1 to star_entry_count; 331 name_index = star_entries (dumpx).nindex; 332 if star_entries (dumpx).type = star_LINK then do; 333 call hcs_$status_minf (dir_name, star_names (name_index), 1, type, (0), code); 334 if code = error_table_$noentry then do; 335 star_names (name_index) = "-"; 336 n_dead_links = n_dead_links + 1; 337 end; 338 end; 339 340 if pdirs_wanted then do; /* not a directory, remove any segment entries */ 341 if star_entries(dumpx).type = star_SEGMENT then do; 342 star_names (name_index) = "-"; 343 n_remove_segs = n_remove_segs + 1; 344 end; 345 end; 346 else do; /* just fdumps */ 347 if star_entries(dumpx).type = star_DIRECTORY then do; 348 star_names (name_index) = "-"; 349 n_remove_dirs = n_remove_dirs + 1; 350 end; 351 end; 352 end; 353 354 code = 0; /* residue from link checking */ 355 356 system_dump_list_n_dumps = star_entry_count - n_dead_links - n_remove_dirs - n_remove_segs; 357 if system_dump_list_n_dumps = 0 then do; 358 code = error_table_$nomatch; 359 return; 360 end; 361 362 allocate system_dump_list in (an_area); 363 system_dump_list.version = SYSTEM_DUMP_LIST_VERSION_1; 364 365 name_index = 1; 366 dumpx = 1; 367 368 do starx = 1 to star_entry_count; 369 name_index = star_entries (starx).nindex; 370 if star_names (name_index) = "-" /* null link, or no dirs or segs */ 371 then go to SKIP; 372 373 system_dump_list.dir_name (dumpx) = dir_name; 374 system_dump_list.new_directory (dumpx) = "0"b; 375 system_dump_list.full_entryname (dumpx) = star_names (name_index); 376 if pdirs_wanted then system_dump_list.minimal_entryname (dumpx) = system_dump_list.full_entryname (dumpx); 377 else system_dump_list.minimal_entryname (dumpx) = reverse (before (reverse (star_names (name_index)), ".")); 378 379 system_dump_list.duplicate (dumpx) = "0"b; 380 381 do checkx = 1 to dumpx - 1; 382 if system_dump_list.minimal_entryname (checkx) = system_dump_list.minimal_entryname (dumpx) then 383 system_dump_list.duplicate (checkx), system_dump_list.duplicate (dumpx) = "1"b; 384 end; 385 386 dumpx = dumpx + 1; 387 SKIP: 388 end; 389 390 free star_names in (an_area); 391 free star_entries in (an_area); 392 revert cleanup; 393 394 a_info_ptr = system_dump_list_ptr; 395 return; 396 397 end LIST_ONE_DIR; 398 399 /*****************************************************************************/ 400 401 LIST_ALL_DIRS: 402 procedure (match_star, area_ptr, a_info_ptr, code); 403 404 /* parameters */ 405 406 dcl area_ptr pointer; 407 dcl a_info_ptr pointer; 408 dcl code fixed bin (35); 409 dcl 1 match_star(3), 410 2 name char(32), 411 2 pdir_sw bit(1); 412 413 /* local */ 414 415 dcl an_area area based (area_ptr); 416 dcl listing_dirname char(168); 417 dcl (match_count, idx) fixed bin; 418 dcl (sx, path_count) fixed bin; 419 dcl temp_n_dumps fixed bin; 420 1 1 /* BEGIN INCLUDE FILE . . . sl_control_s.incl.pl1 */ 1 2 1 3 declare 1 sl_control_s unaligned based (addr (sl_control)), 1 4 2 af_pathname bit (1), /* "1"b => expand active functions */ 1 5 2 pad1 bit (1), /* Must be zero */ 1 6 2 key_ref_dir bit (1), /* "1"b => expand -referencing_dir keyword */ 1 7 2 key_work_dir bit (1), /* "1"b => expand -working_dir keyword */ 1 8 2 key_proc_dir bit (1), /* "1"b => expand -process_dir keyword */ 1 9 2 key_home_dir bit (1), /* "1"b => expand -home_dir keyword */ 1 10 2 pad2 bit (30); /* Must be zero */ 1 11 1 12 declare sl_control bit (36); 1 13 declare sl_control_default bit (36) internal static options (constant) initial ("101111"b); 1 14 1 15 /* END INCLUDE FILE . . . sl_control_s.incl.pl1 */ 421 422 2 1 /* BEGIN INCLUDE FILE . . . sl_info.incl.pl1 */ 2 2 2 3 2 4 2 5 /****^ HISTORY COMMENTS: 2 6* 1) change(87-11-16,Lippard), approve(87-12-21,MCR7822), 2 7* audit(88-02-09,Blair), install(88-02-16,MR12.2-1023): 2 8* Modified to add INITIATED_SEGS type. 2 9* 2) change(87-11-19,Lippard), approve(87-12-21,MCR7822), 2 10* audit(88-02-09,Blair), install(88-02-16,MR12.2-1023): 2 11* Added uid to sl_info structure. 2 12* END HISTORY COMMENTS */ 2 13 2 14 2 15 declare 1 sl_info aligned based (sl_info_p), 2 16 2 version fixed binary, /* Must be 1 */ 2 17 2 num_paths fixed binary, /* Number of search paths */ 2 18 2 change_index_p pointer, /* Pointer to search list's update count */ 2 19 2 change_index fixed binary (71), /* This search list's update count */ 2 20 2 pad1 (6) bit (36), /* Must be zero */ 2 21 2 paths (sl_info_num_paths refer (sl_info.num_paths)), 2 22 3 type fixed binary, /* Type of search path */ 2 23 3 code fixed binary (35), /* Standard status code of search path */ 2 24 3 uid bit (36), /* Unique ID */ 2 25 3 pathname char (168) unaligned; /* Search pathname */ 2 26 2 27 declare sl_info_num_paths fixed binary; 2 28 declare sl_info_p pointer; 2 29 declare sl_info_version_1 fixed binary internal static options (constant) initial (1); 2 30 2 31 /* Keyword Types */ 2 32 2 33 declare ABSOLUTE_PATH fixed binary internal static options (constant) initial (0); 2 34 declare UNEXPANDED_PATH fixed binary internal static options (constant) initial (1); 2 35 declare REFERENCING_DIR fixed binary internal static options (constant) initial (3); 2 36 declare WORKING_DIR fixed binary internal static options (constant) initial (4); 2 37 declare PROCESS_DIR fixed binary internal static options (constant) initial (5); 2 38 declare HOME_DIR fixed binary internal static options (constant) initial (6); 2 39 declare INITIATED_SEGS fixed binary internal static options (constant) initial (7); 2 40 2 41 /* END INCLUDE FILE . . . sl_info.incl.pl1 */ 423 424 425 426 427 sl_info_p = null(); 428 match_count = 0; 429 do idx = 1 to hbound(match_star,1); 430 if match_star(idx).name ^= "" then match_count = match_count+1; 431 end; 432 433 call search_paths_$get (DUMP_LIST, sl_control_default, "" /* no ref path */, null () /* default search seg */, 434 area_ptr, sl_info_version_1, sl_info_p, code); 435 436 if code ^= 0 then call sub_err_ (code, "amu_find_system_dump_", ACTION_CAN_RESTART, null (), (0), 437 "No ""dumps"" search list defined."); 438 439 path_count = 0; 440 do sx = 1 to sl_info.num_paths; 441 if sl_info.paths (sx).type = ABSOLUTE_PATH then 442 path_count = path_count + 1; 443 end; 444 path_count = match_count * path_count; 445 begin; 446 declare one_dir_list_ptrs (path_count) pointer; 447 declare (pathx, final_dumpx, dirx, dumpx, i) 448 fixed bin; 449 declare sx fixed bin; 450 451 one_dir_list_ptrs(*) = null(); 452 system_dump_list_ptr = null(); 453 on cleanup begin; 454 if sl_info_p ^= null() then free sl_info in (an_area); 455 if system_dump_list_ptr ^= null() then free system_dump_list in (an_area); 456 do i = 1 to path_count; 457 if one_dir_list_ptrs(i) ^= null() then 458 free one_dir_list_ptrs(i) -> system_dump_list in (an_area); 459 end; 460 end; 461 462 pathx = 1; 463 temp_n_dumps = 0; 464 do sx = 1 to sl_info.num_paths; 465 if sl_info.code (sx) ^= 0 then go to SKIP; 466 do idx = 1 to match_count; 467 call LIST_ONE_DIR (sl_info.pathname (sx), match_star.name(idx), system_area_ptr, match_star.pdir_sw(idx), 468 one_dir_list_ptrs (pathx), code); 469 470 if code ^= 0 then do; 471 code = 0; 472 go to SKIP; 473 end; 474 temp_n_dumps = temp_n_dumps + one_dir_list_ptrs (pathx) -> system_dump_list.n_dumps; 475 pathx = pathx + 1; 476 SKIP: 477 end; /* end search_name loop */ 478 end; 479 480 if temp_n_dumps = 0 then do; 481 code = error_table_$noentry; 482 return; 483 end; 484 485 system_dump_list_n_dumps = temp_n_dumps; /* avoid interference with LIST_ONE */ 486 487 /* Okay, now we have N lists. turn them into one BIG list. */ 488 489 allocate system_dump_list in (an_area); 490 system_dump_list.version = SYSTEM_DUMP_LIST_VERSION_1; 491 492 final_dumpx = 1; 493 listing_dirname = ""; 494 do dirx = 1 to pathx - 1; /* that many are useful */ 495 do dumpx = 1 to one_dir_list_ptrs (dirx) -> system_dump_list.n_dumps; 496 system_dump_list.per_dump (final_dumpx) = one_dir_list_ptrs (dirx) -> system_dump_list.per_dump (dumpx); 497 if listing_dirname ^= system_dump_list.per_dump (final_dumpx).dir_name then 498 system_dump_list.per_dump (final_dumpx).new_directory = "1"b; 499 500 listing_dirname = system_dump_list.per_dump (final_dumpx).dir_name; 501 final_dumpx = final_dumpx + 1; 502 end; 503 free one_dir_list_ptrs (dirx) -> system_dump_list in (an_area); 504 end; 505 506 end; /* The Begin Block */ 507 508 free sl_info in (an_area); 509 revert cleanup; 510 a_info_ptr = system_dump_list_ptr; 511 512 return; 513 514 end LIST_ALL_DIRS; 515 516 /*****************************************************************************/ 517 518 determine_search_name: proc(entryname, list_what, match_star); 519 520 /* parameters */ 521 522 dcl entryname char(*); 523 dcl list_what fixed bin; 524 dcl 1 match_star(3), 525 2 name char(32), 526 2 pdir_sw bit(1); 527 528 /* local */ 529 530 dcl code fixed bin(35); 531 dcl idx fixed bin; 532 dcl match_all bit(1); 533 dcl no_dot bit(1); 534 dcl s_name char(32); 535 dcl suffixed_name_$make entry (char(*), char(*), char(32), fixed bin(35)); 536 537 match_star(*).name = ""; 538 match_star(*).pdir_sw = "0"b; 539 idx, code = 0; 540 call check_star_name_$entry (entryname, code); 541 match_all = (code=2); /* This is a starname that matches all */ 542 no_dot = (search(entryname, ".") = 0); 543 544 if list_what = LIST_PDIRS | list_what = LIST_ALL then do; 545 idx = idx + 1; 546 if match_all then do; 547 match_star(idx).name = "**" || ".pdir"; /* This will match all pdirs */ 548 match_star(idx).pdir_sw = "1"b; 549 end; 550 else do; 551 if no_dot then do; 552 match_star(idx).name = rtrim(entryname) || ".pdir"; 553 match_star(idx).pdir_sw = "1"b; 554 idx = idx + 1; 555 match_star(idx).name = rtrim(entryname) || ".*.pdir"; 556 match_star(idx).pdir_sw = "1"b; 557 end; 558 else do; 559 call suffixed_name_$make (entryname, PDIR_SUFFIX, s_name, code); 560 if code = 0 then match_star(idx).name = s_name; 561 else match_star(idx).name = entryname; 562 match_star(idx).pdir_sw = "1"b; 563 end; 564 end; 565 end; 566 567 if list_what = LIST_FDUMPS | list_what = LIST_ALL then do; 568 idx = idx + 1; 569 if match_all then match_star(idx).name = "??????.????.0." || "*"; 570 else do; 571 if no_dot then /* fdump component, assume it's the erf number */ 572 match_star(idx).name = "??????.????.0." || rtrim(entryname); 573 else match_star(idx).name = rtrim(entryname); 574 end; 575 end; 576 577 end determine_search_name; 578 579 /*****************************************************************************/ 580 581 get_one_dir: proc (dir_name, match_star, area_ptr, a_info_ptr, code); 582 583 /* parameters */ 584 585 dcl area_ptr pointer; 586 dcl a_info_ptr pointer; 587 dcl code fixed bin (35); 588 dcl dir_name char(*); 589 dcl 1 match_star(3), 590 2 name char(32), 591 2 pdir_sw bit(1); 592 593 /* local */ 594 595 dcl an_area area based (area_ptr); 596 dcl (idx, match_count) fixed bin; 597 dcl temp_n_dumps fixed bin; 598 599 a_info_ptr = null(); 600 match_count = 0; 601 do idx = 1 to hbound(match_star,1); 602 if match_star(idx).name ^= "" then match_count = match_count+1; 603 end; 604 605 begin; 606 declare one_dir_list_ptrs (match_count) pointer; 607 declare (pathx, final_dumpx, dirx, dumpx, i) 608 fixed bin; 609 declare set_new_dir bit (1) aligned; 610 611 one_dir_list_ptrs(*) = null(); 612 system_dump_list_ptr = null(); 613 on cleanup begin; 614 if system_dump_list_ptr ^= null() then free system_dump_list in (an_area); 615 do i = 1 to match_count; 616 if one_dir_list_ptrs(i) ^= null() then 617 free one_dir_list_ptrs(i) -> system_dump_list in (an_area); 618 end; 619 end; 620 621 pathx = 1; 622 temp_n_dumps = 0; 623 do idx = 1 to match_count; 624 call LIST_ONE_DIR (dir_name, match_star.name(idx), area_ptr, match_star.pdir_sw(idx), 625 one_dir_list_ptrs (pathx), code); 626 if code ^= 0 then do; 627 code = 0; 628 go to SKIP; 629 end; 630 temp_n_dumps = temp_n_dumps + one_dir_list_ptrs (pathx) -> system_dump_list.n_dumps; 631 pathx = pathx + 1; 632 SKIP: 633 end; 634 635 if temp_n_dumps = 0 then do; 636 code = error_table_$noentry; 637 return; 638 end; 639 640 system_dump_list_n_dumps = temp_n_dumps; /* avoid interference with LIST_ONE */ 641 642 /* Okay, now we have N lists. turn them into one BIG list. */ 643 644 allocate system_dump_list in (an_area); 645 system_dump_list.version = SYSTEM_DUMP_LIST_VERSION_1; 646 647 final_dumpx = 1; 648 do dirx = 1 to pathx - 1; /* that many are useful */ 649 set_new_dir = "1"b; 650 do dumpx = 1 to one_dir_list_ptrs (dirx) -> system_dump_list.n_dumps; 651 system_dump_list.per_dump (final_dumpx) = one_dir_list_ptrs (dirx) -> system_dump_list.per_dump (dumpx); 652 if set_new_dir then do; 653 system_dump_list.per_dump (final_dumpx).new_directory = "1"b; 654 set_new_dir = "0"b; 655 end; 656 final_dumpx = final_dumpx + 1; 657 end; 658 free one_dir_list_ptrs (dirx) -> system_dump_list in (an_area); 659 end; 660 661 end; /* The Begin Block */ 662 663 revert cleanup; 664 a_info_ptr = system_dump_list_ptr; 665 666 return; 667 668 end get_one_dir; 669 670 /*****************************************************************************/ 671 672 setup: proc(); 673 674 star_names_ptr, star_entry_ptr = null(); 675 system_area_ptr = get_system_free_area_(); 676 677 end setup; 678 3 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 3 2 3 3 /* This include file contains structures for the hcs_$star_, 3 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 3 5* 3 6* Written 23 October 1978 by Monte Davidoff. 3 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 3 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 3 9**/ 3 10 3 11 /* automatic */ 3 12 3 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 3 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 3 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 3 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 3 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 3 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 3 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 3 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 3 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 3 22 3 23 /* based */ 3 24 3 25 /* hcs_$star_ entry structure */ 3 26 3 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 3 28 2 type fixed binary (2) unsigned unaligned, 3 29 /* storage system type */ 3 30 2 nnames fixed binary (16) unsigned unaligned, 3 31 /* number of names of entry that match star_name */ 3 32 2 nindex fixed binary (18) unsigned unaligned; 3 33 /* index of first name in star_names */ 3 34 3 35 /* hcs_$star_ name structure */ 3 36 3 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 3 38 3 39 /* hcs_$star_list_ branch structure */ 3 40 3 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 3 42 2 type fixed binary (2) unsigned unaligned, 3 43 /* storage system type */ 3 44 2 nnames fixed binary (16) unsigned unaligned, 3 45 /* number of names of entry that match star_name */ 3 46 2 nindex fixed binary (18) unsigned unaligned, 3 47 /* index of first name in star_list_names */ 3 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 3 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 3 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 3 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 3 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 3 53 2 pad bit (7) unaligned, 3 54 2 records fixed binary (18) unsigned unaligned; 3 55 /* records used by branch */ 3 56 3 57 /* hcs_$star_dir_list_ branch structure */ 3 58 3 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 3 60 2 type fixed binary (2) unsigned unaligned, 3 61 /* storage system type */ 3 62 2 nnames fixed binary (16) unsigned unaligned, 3 63 /* number of names of entry that match star_name */ 3 64 2 nindex fixed binary (18) unsigned unaligned, 3 65 /* index of first name in star_list_names */ 3 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 3 67 2 pad bit (36) unaligned, 3 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 3 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 3 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 3 71 2 bit_count fixed binary (24) unaligned; 3 72 /* bit count of the branch */ 3 73 3 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 3 75 3 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 3 77 2 type fixed binary (2) unsigned unaligned, 3 78 /* storage system type */ 3 79 2 nnames fixed binary (16) unsigned unaligned, 3 80 /* number of names of entry that match star_name */ 3 81 2 nindex fixed binary (18) unsigned unaligned, 3 82 /* index of first name in star_list_names */ 3 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 3 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 3 85 2 pathname_len fixed binary (18) unsigned unaligned, 3 86 /* length of the pathname of the link */ 3 87 2 pathname_index fixed binary (18) unsigned unaligned; 3 88 /* index of start of pathname in star_list_names */ 3 89 3 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 3 91 3 92 declare star_list_names char (32) based (star_list_names_ptr) 3 93 dimension (star_links (star_branch_count + star_link_count).nindex 3 94 + star_links (star_branch_count + star_link_count).nnames 3 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 3 96 * binary ( 3 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 3 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 3 99 3 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 3 101 3 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 3 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 3 104 3 105 /* internal static */ 3 106 3 107 /* star_select_sw values */ 3 108 3 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 3 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 3 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 3 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 3 113 fixed binary (3) internal static options (constant) initial (5); 3 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 3 115 fixed binary (3) internal static options (constant) initial (7); 3 116 3 117 /* storage system types */ 3 118 3 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 3 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 3 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 3 122 3 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 679 680 4 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 4 2 /* format: style3 */ 4 3 4 4 /* These constants are to be used for the flags argument of sub_err_ */ 4 5 /* They are just "string (condition_info_header.action_flags)" */ 4 6 4 7 declare ( 4 8 ACTION_CAN_RESTART init (""b), 4 9 ACTION_CANT_RESTART init ("1"b), 4 10 ACTION_DEFAULT_RESTART 4 11 init ("01"b), 4 12 ACTION_QUIET_RESTART 4 13 init ("001"b), 4 14 ACTION_SUPPORT_SIGNAL 4 15 init ("0001"b) 4 16 ) bit (36) aligned internal static options (constant); 4 17 4 18 /* End include file */ 681 682 5 1 /* Begin include file system_dump_info.incl.pl1 */ 5 2 /* format: style3,idind30 */ 5 3 5 4 /* Information needed to get set up on an fdump */ 5 5 5 6 declare system_dump_info_ptr pointer; 5 7 declare 1 system_dump_info aligned based (system_dump_info_ptr), 5 8 2 version char (8) aligned, 5 9 2 dump_dir_name char (168) unaligned, 5 10 2 dump_seg_prefix char (32) varying, /* includes last ., not component number */ 5 11 2 dump_name char (32) varying, /* Usually ERF number */ 5 12 2 dump_entry_format char (40) unaligned;/* ioa_ string that you feed the component number into */ 5 13 5 14 declare SYSTEM_DUMP_INFO_VERSION_1 char (8) init ("sysd0001") int static options (constant); 5 15 5 16 declare system_dump_list_ptr pointer; 5 17 declare 1 system_dump_list aligned based (system_dump_list_ptr), 5 18 2 version char (8) aligned, 5 19 2 n_dumps fixed bin, 5 20 2 per_dump (system_dump_list_n_dumps refer (system_dump_list.n_dumps)) aligned, 5 21 3 dir_name char (168) unaligned, 5 22 3 minimal_entryname char (32) unaligned,/* for non-dup's, just number */ 5 23 3 full_entryname char (32) unaligned,/* component 0 entryname */ 5 24 3 new_directory bit (1) aligned, /* first of its dir */ 5 25 3 duplicate bit (1) aligned; /* on if more than one ERF N in same directory */ 5 26 5 27 declare system_dump_list_n_dumps fixed bin; 5 28 declare SYSTEM_DUMP_LIST_VERSION_1 char (8) aligned init ("sysdl001") int static options (constant); 5 29 5 30 declare (LIST_ALL fixed bin init (1), 5 31 LIST_FDUMPS fixed bin init (2), 5 32 LIST_PDIRS fixed bin init (3)) 5 33 int static options (constant); 5 34 5 35 /* End include file system_dump_info.incl.pl1 */ 683 684 685 686 end amu_find_system_dump_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/16/88 1409.6 amu_find_system_dump_.pl1 >spec>install>MR12.2-1023>amu_find_system_dump_.pl1 421 1 01/09/79 1617.9 sl_control_s.incl.pl1 >ldd>include>sl_control_s.incl.pl1 423 2 02/16/88 1407.4 sl_info.incl.pl1 >spec>install>MR12.2-1023>sl_info.incl.pl1 679 3 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 681 4 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.incl.pl1 683 5 11/20/84 0854.8 system_dump_info.incl.pl1 >ldd>include>system_dump_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. ABSOLUTE_PATH constant fixed bin(17,0) initial dcl 2-33 ref 441 ACTION_CANT_RESTART 000041 constant bit(36) initial dcl 4-7 set ref 140* 171* 214* 257* ACTION_CAN_RESTART 000040 constant bit(36) initial dcl 4-7 set ref 436* Code parameter fixed bin(35,0) dcl 18 set ref 122 131 148* 156 178* 180* 181 183* 188* 191 191* 223* 241* 279* DUMP_LIST 000010 constant char(5) initial unaligned dcl 56 set ref 433* Dump_info_ptr parameter pointer dcl 17 ref 122 131 137 Dump_list_area_ptr parameter pointer dcl 162 set ref 156 183* 188* Dump_list_ptr parameter pointer dcl 163 set ref 156 183* 188* Dump_list_select_name parameter char unaligned dcl 159 set ref 156 177 178* 180* 187* Dump_list_version parameter char(8) dcl 160 set ref 156 171 171* Dump_name parameter char unaligned dcl 16 set ref 122 131 149 211* 212* 214* 274 LIST_ALL constant fixed bin(17,0) initial dcl 5-30 ref 544 567 LIST_FDUMPS constant fixed bin(17,0) initial dcl 5-30 ref 135 567 LIST_PDIRS constant fixed bin(17,0) initial dcl 5-30 ref 126 178 544 List_what parameter fixed bin(17,0) dcl 161 set ref 156 178 182* 187* PDIR_SUFFIX 000006 constant char(4) initial unaligned dcl 57 set ref 178* 211* 559* SYSTEM_DUMP_INFO_VERSION_1 000004 constant char(8) initial unaligned dcl 5-14 ref 140 SYSTEM_DUMP_LIST_VERSION_1 000002 constant char(8) initial dcl 5-28 ref 171 363 490 645 a_info_ptr parameter pointer dcl 407 in procedure "LIST_ALL_DIRS" set ref 401 510* a_info_ptr parameter pointer dcl 293 in procedure "LIST_ONE_DIR" set ref 289 314* 394* a_info_ptr parameter pointer dcl 586 in procedure "get_one_dir" set ref 581 599* 664* after builtin function dcl 80 ref 228 228 262 262 an_area based area(1024) dcl 299 in procedure "LIST_ONE_DIR" ref 316 317 318 362 390 391 an_area based area(1024) dcl 595 in procedure "get_one_dir" ref 614 616 644 658 an_area based area(1024) dcl 415 in procedure "LIST_ALL_DIRS" ref 454 455 457 489 503 508 area_ptr parameter pointer dcl 585 in procedure "get_one_dir" set ref 581 614 616 624* 644 658 area_ptr parameter pointer dcl 406 in procedure "LIST_ALL_DIRS" set ref 401 433* 454 455 457 489 503 508 area_ptr parameter pointer dcl 294 in procedure "LIST_ONE_DIR" set ref 289 316 317 318 321* 362 390 391 bad_dump_dir 000345 automatic char(168) unaligned dcl 252 set ref 255* 257* bad_dump_name 000335 automatic char(32) unaligned dcl 251 set ref 254* 257* before builtin function dcl 80 ref 227 377 check_star_name_$entry 000010 constant entry external dcl 36 ref 218 540 checkx 000107 automatic fixed bin(17,0) dcl 306 set ref 381* 382 382* cleanup 000000 stack reference condition dcl 72 ref 315 392 453 509 613 663 code parameter fixed bin(35,0) dcl 408 in procedure "LIST_ALL_DIRS" set ref 401 433* 436 436* 467* 470 471* 481* code 000426 automatic fixed bin(35,0) dcl 530 in procedure "determine_search_name" set ref 539* 540* 541 559* 560 code 15 based fixed bin(35,0) array level 3 in structure "sl_info" dcl 2-15 in procedure "LIST_ALL_DIRS" ref 465 code parameter fixed bin(35,0) dcl 587 in procedure "get_one_dir" set ref 581 624* 626 627* 636* code parameter fixed bin(35,0) dcl 292 in procedure "LIST_ONE_DIR" set ref 289 321* 323 333* 334 354* 358* code 000334 automatic fixed bin(35,0) dcl 206 in procedure "FIND_GIVEN_PATHNAME" set ref 210* 211* 212* 214 214* 218* 219 220 222* 223 239* 240 241 276* 277 279 dir_name 3 based char(168) array level 3 in structure "system_dump_list" packed unaligned dcl 5-17 in procedure "amu_find_system_dump_" set ref 255 261 373* 497 500 dir_name parameter char unaligned dcl 296 in procedure "LIST_ONE_DIR" set ref 289 321* 333* 373 dir_name parameter char unaligned dcl 588 in procedure "get_one_dir" set ref 581 624* dirx 000102 automatic fixed bin(17,0) dcl 607 in begin block on line 605 set ref 648* 650 651 658* dirx 000102 automatic fixed bin(17,0) dcl 447 in begin block on line 445 set ref 494* 495 496 503* dump_dir_name 2 based char(168) level 2 in structure "system_dump_info" packed unaligned dcl 5-7 in procedure "amu_find_system_dump_" set ref 145* 225* 261* dump_dir_name 000252 automatic char(168) unaligned dcl 204 in procedure "FIND_GIVEN_PATHNAME" set ref 211* 212* 222* 225 239* dump_entry_format 76 based char(40) level 2 packed unaligned dcl 5-7 set ref 145* 229* 265* dump_entryname 000324 automatic char(32) unaligned dcl 205 set ref 211* 212* 218* 221 222* 227 228 232 238* 274* 275* dump_name 65 based varying char(32) level 2 dcl 5-7 set ref 145* 227* 229* 232* 264* 265* dump_seg_prefix 54 based varying char(32) level 2 dcl 5-7 set ref 145* 228* 229* 262* 265* dumpx 000103 automatic fixed bin(17,0) dcl 607 in begin block on line 605 set ref 650* 651* dumpx 000100 automatic fixed bin(17,0) dcl 298 in procedure "LIST_ONE_DIR" set ref 330* 331 332 341 347* 366* 373 374 375 376 376 377 379 381 382 382 386* 386 dumpx 000103 automatic fixed bin(17,0) dcl 447 in begin block on line 445 set ref 495* 496* duplicate 76 based bit(1) array level 3 dcl 5-17 set ref 245 379* 382* 382* entryname parameter char unaligned dcl 522 set ref 518 540* 542 552 555 559* 561 571 573 error_table_$noentry 000036 external static fixed bin(35,0) dcl 52 ref 191 334 481 636 error_table_$nomatch 000032 external static fixed bin(35,0) dcl 50 ref 191 358 error_table_$unimplemented_version 000034 external static fixed bin(35,0) dcl 51 set ref 140* 171* expand_pathname_ 000012 constant entry external dcl 37 ref 180 212 expand_pathname_$add_suffix 000014 constant entry external dcl 38 ref 178 211 final_dumpx 000101 automatic fixed bin(17,0) dcl 447 in begin block on line 445 set ref 492* 496 497 497 500 501* 501 final_dumpx 000101 automatic fixed bin(17,0) dcl 607 in begin block on line 605 set ref 647* 651 653 656* 656 full_entryname 65 based char(32) array level 3 packed unaligned dcl 5-17 set ref 262 375* 376 get_system_free_area_ 000016 constant entry external dcl 39 ref 675 hbound builtin function dcl 80 ref 429 601 hcs_$star_ 000020 constant entry external dcl 40 ref 321 hcs_$status_minf 000022 constant entry external dcl 41 ref 222 333 i 000104 automatic fixed bin(17,0) dcl 447 in begin block on line 445 set ref 456* 457 457* i 000104 automatic fixed bin(17,0) dcl 607 in begin block on line 605 set ref 615* 616 616* idx 000427 automatic fixed bin(17,0) dcl 531 in procedure "determine_search_name" set ref 539* 545* 545 547 548 552 553 554* 554 555 556 560 561 562 568* 568 569 571 573 idx 000100 automatic fixed bin(17,0) dcl 596 in procedure "get_one_dir" set ref 601* 602* 623* 624 624* idx 000153 automatic fixed bin(17,0) dcl 417 in procedure "LIST_ALL_DIRS" set ref 429* 430* 466* 467 467* ioa_$rsnnl 000024 constant entry external dcl 43 ref 229 265 list_what parameter fixed bin(17,0) dcl 523 ref 518 544 544 567 567 listing_dirname 000100 automatic char(168) unaligned dcl 416 set ref 493* 497 500* match_all 000430 automatic bit(1) unaligned dcl 532 set ref 541* 546 569 match_count 000101 automatic fixed bin(17,0) dcl 596 in procedure "get_one_dir" set ref 600* 602* 602 606 615 623 match_count 000152 automatic fixed bin(17,0) dcl 417 in procedure "LIST_ALL_DIRS" set ref 428* 430* 430 444 466 match_star parameter structure array level 1 packed unaligned dcl 409 in procedure "LIST_ALL_DIRS" set ref 401 429 match_star parameter structure array level 1 packed unaligned dcl 589 in procedure "get_one_dir" set ref 581 601 match_star parameter structure array level 1 packed unaligned dcl 524 in procedure "determine_search_name" set ref 518 match_star 000100 automatic structure array level 1 packed unaligned dcl 61 in procedure "amu_find_system_dump_" set ref 182* 183* 187* 188* 238* 239* 275* 276* minimal_entryname 55 based char(32) array level 3 packed unaligned dcl 5-17 set ref 254 264 376* 377* 382 382 n_dead_links 000102 automatic fixed bin(17,0) dcl 301 set ref 327* 336* 336 356 n_dumps 2 based fixed bin(17,0) level 2 dcl 5-17 set ref 245 256 267 318 362* 455 457 474 489* 495 503 614 616 630 644* 650 658 n_remove_dirs 000103 automatic fixed bin(17,0) dcl 302 set ref 328* 349* 349 356 n_remove_segs 000104 automatic fixed bin(17,0) dcl 303 set ref 329* 343* 343 356 name parameter char(32) array level 2 in structure "match_star" packed unaligned dcl 409 in procedure "LIST_ALL_DIRS" set ref 430 467* name parameter char(32) array level 2 in structure "match_star" packed unaligned dcl 589 in procedure "get_one_dir" set ref 602 624* name parameter char(32) array level 2 in structure "match_star" packed unaligned dcl 524 in procedure "determine_search_name" set ref 537* 547* 552* 555* 560* 561* 569* 571* 573* name_index 000101 automatic fixed bin(17,0) dcl 300 set ref 331* 333 335 342 348 365* 369* 370 375 377 new_directory 75 based bit(1) array level 3 dcl 5-17 set ref 374* 497* 653* nindex 0(18) based fixed bin(18,0) array level 2 packed unsigned unaligned dcl 3-27 ref 331 369 nnames 0(02) based fixed bin(16,0) array level 2 packed unsigned unaligned dcl 3-27 ref 316 390 no_dot 000431 automatic bit(1) unaligned dcl 533 set ref 542* 551 571 null builtin function dcl 80 ref 140 140 171 171 214 214 257 257 313 314 316 317 318 427 433 433 436 436 451 452 454 455 457 599 611 612 614 616 674 num_paths 1 based fixed bin(17,0) level 2 dcl 2-15 ref 440 454 464 508 one_dir_list_ptrs 000100 automatic pointer array dcl 606 in begin block on line 605 set ref 611* 616 616 624* 630 650 651 658 one_dir_list_ptrs 000100 automatic pointer array dcl 446 in begin block on line 445 set ref 451* 457 457 467* 474 495 496 503 path_count 000155 automatic fixed bin(17,0) dcl 418 set ref 439* 441* 441 444* 444 446 456 pathname 17 based char(168) array level 3 packed unaligned dcl 2-15 set ref 467* paths 14 based structure array level 2 dcl 2-15 pathx 000100 automatic fixed bin(17,0) dcl 607 in begin block on line 605 set ref 621* 624 630 631* 631 648 pathx 000100 automatic fixed bin(17,0) dcl 447 in begin block on line 445 set ref 462* 467 474 475* 475 494 pdir_sw 10 parameter bit(1) array level 2 in structure "match_star" packed unaligned dcl 409 in procedure "LIST_ALL_DIRS" set ref 467* pdir_sw 10 parameter bit(1) array level 2 in structure "match_star" packed unaligned dcl 524 in procedure "determine_search_name" set ref 538* 548* 553* 556* 562* pdir_sw 10 parameter bit(1) array level 2 in structure "match_star" packed unaligned dcl 589 in procedure "get_one_dir" set ref 624* pdirs_wanted parameter bit(1) unaligned dcl 297 ref 289 340 376 per_dump 3 based structure array level 2 dcl 5-17 set ref 496* 496 651* 651 reverse builtin function dcl 80 ref 227 227 228 228 262 262 377 377 rtrim builtin function dcl 80 ref 552 555 571 573 s_name 000432 automatic char(32) unaligned dcl 534 set ref 559* 560 search builtin function dcl 80 ref 149 177 221 542 search_dir_name 000131 automatic char(168) unaligned dcl 64 set ref 178* 180* 183* search_entryname 000203 automatic char(32) unaligned dcl 65 set ref 178* 180* 182* search_paths_$get 000026 constant entry external dcl 44 ref 433 set_new_dir 000105 automatic bit(1) dcl 609 set ref 649* 652 654* sl_control_default 000000 constant bit(36) initial unaligned dcl 1-13 set ref 433* sl_info based structure level 1 dcl 2-15 set ref 454 508 sl_info_p 000160 automatic pointer dcl 2-28 set ref 427* 433* 440 441 454 454 464 465 467 508 sl_info_version_1 000050 constant fixed bin(17,0) initial dcl 2-29 set ref 433* star_ALL_ENTRIES 000042 constant fixed bin(2,0) initial dcl 3-111 set ref 321* star_DIRECTORY constant fixed bin(2,0) initial unsigned dcl 3-121 ref 347 star_LINK constant fixed bin(2,0) initial unsigned dcl 3-119 ref 332 star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 3-120 ref 341 star_entries based structure array level 1 dcl 3-27 ref 317 391 star_entry_count 000220 automatic fixed bin(17,0) dcl 3-14 set ref 316 317 321* 330 356 368 390 391 star_entry_ptr 000222 automatic pointer dcl 3-15 set ref 313* 316 317 317 321* 331 332 341 347 369 390 391 674* star_name parameter char unaligned dcl 295 set ref 289 321* star_names based char(32) array unaligned dcl 3-37 set ref 316 333* 335* 342* 348* 370 375 377 390 star_names_ptr 000224 automatic pointer dcl 3-19 set ref 313* 316 316 321* 333 335 342 348 370 375 377 390 674* starx 000106 automatic fixed bin(17,0) dcl 305 set ref 368* 369* sub_err_ 000030 constant entry external dcl 46 ref 140 171 214 257 436 suffixed_name_$make 000040 constant entry external dcl 535 ref 559 sum builtin function dcl 80 ref 316 390 sx 000154 automatic fixed bin(17,0) dcl 418 in procedure "LIST_ALL_DIRS" set ref 440* 441* sx 000105 automatic fixed bin(17,0) dcl 449 in begin block on line 445 set ref 464* 465 467* system_area based area(1024) dcl 76 ref 256 267 system_area_ptr 000214 automatic pointer dcl 66 set ref 239* 256 267 276* 467* 675* system_dump_info based structure level 1 dcl 5-7 system_dump_info_ptr 000226 automatic pointer dcl 5-6 set ref 137* 140 140 145 145 145 145 225 227 228 229 229 229 232 261 262 264 265 265 265 system_dump_list based structure level 1 dcl 5-17 set ref 256 267 318 362 455 457 489 503 614 616 644 658 system_dump_list_n_dumps 000232 automatic fixed bin(17,0) dcl 5-27 set ref 356* 357 362 362 485* 489 489 640* 644 644 system_dump_list_ptr 000230 automatic pointer dcl 5-16 set ref 239* 245 245 254 255 256 261 262 264 267 276* 313* 318 318 362* 363 373 374 375 376 376 377 379 382 382 382 382 394 452* 455 455 489* 490 496 497 497 500 510 612* 614 614 644* 645 651 653 664 temp_n_dumps 000102 automatic fixed bin(17,0) dcl 597 in procedure "get_one_dir" set ref 622* 630* 630 635 640 temp_n_dumps 000156 automatic fixed bin(17,0) dcl 419 in procedure "LIST_ALL_DIRS" set ref 463* 474* 474 480 485 type 000105 automatic fixed bin(2,0) dcl 304 in procedure "LIST_ONE_DIR" set ref 333* type 14 based fixed bin(17,0) array level 3 in structure "sl_info" dcl 2-15 in procedure "LIST_ALL_DIRS" ref 441 type based fixed bin(2,0) array level 2 in structure "star_entries" packed unsigned unaligned dcl 3-27 in procedure "amu_find_system_dump_" ref 332 341 347 version based char(8) level 2 in structure "system_dump_list" dcl 5-17 in procedure "amu_find_system_dump_" set ref 363* 490* 645* version based char(8) level 2 in structure "system_dump_info" dcl 5-7 in procedure "amu_find_system_dump_" set ref 140 140* want_a_pdir 000216 automatic bit(1) unaligned dcl 67 set ref 125* 134* 176* 211 226 262 265 what_to_list 000217 automatic fixed bin(17,0) dcl 68 set ref 126* 135* 238* 275* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 4-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 4-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 4-7 HOME_DIR internal static fixed bin(17,0) initial dcl 2-38 INITIATED_SEGS internal static fixed bin(17,0) initial dcl 2-39 PROCESS_DIR internal static fixed bin(17,0) initial dcl 2-37 REFERENCING_DIR internal static fixed bin(17,0) initial dcl 2-35 UNEXPANDED_PATH internal static fixed bin(17,0) initial dcl 2-34 WORKING_DIR internal static fixed bin(17,0) initial dcl 2-36 sl_control automatic bit(36) unaligned dcl 1-12 sl_control_s based structure level 1 packed unaligned dcl 1-3 sl_info_num_paths automatic fixed bin(17,0) dcl 2-27 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 3-114 star_BRANCHES_ONLY internal static fixed bin(2,0) initial dcl 3-110 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 3-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 3-112 star_branch_count automatic fixed bin(17,0) dcl 3-13 star_dir_list_branch based structure array level 1 dcl 3-59 star_link_count automatic fixed bin(17,0) dcl 3-17 star_link_pathname based char unaligned dcl 3-102 star_links based structure array level 1 dcl 3-76 star_linkx automatic fixed bin(17,0) dcl 3-18 star_list_branch based structure array level 1 dcl 3-41 star_list_branch_ptr automatic pointer dcl 3-16 star_list_names based char(32) array unaligned dcl 3-92 star_list_names_ptr automatic pointer dcl 3-20 star_select_sw automatic fixed bin(3,0) dcl 3-21 NAMES DECLARED BY EXPLICIT CONTEXT. BAD_NAME 001040 constant label dcl 214 set ref 219 COMMON_FIND 000301 constant label dcl 137 ref 127 FIND_GIVEN_PATHNAME 000747 constant entry internal dcl 196 ref 149 FIND_GIVEN_SEARCHNAME 001673 constant entry internal dcl 271 ref 150 LIST_ALL_DIRS 002575 constant entry internal dcl 401 ref 188 276 LIST_ONE_DIR 001727 constant entry internal dcl 289 ref 467 624 RETURN_INFO 001426 constant label dcl 245 ref 283 SKIP 004362 constant label dcl 632 in begin block on line 605 ref 628 SKIP 003261 constant label dcl 476 in begin block on line 445 ref 465 472 SKIP 002531 constant label dcl 387 in procedure "LIST_ONE_DIR" ref 370 amu_find_system_dump_ 000221 constant entry external dcl 6 amu_find_system_dump_$fdump 000260 constant entry external dcl 131 amu_find_system_dump_$list 000425 constant entry external dcl 156 amu_find_system_dump_$pdir 000233 constant entry external dcl 122 determine_search_name 003446 constant entry internal dcl 518 ref 182 187 238 275 get_one_dir 004072 constant entry internal dcl 581 ref 183 239 setup 004526 constant entry internal dcl 672 ref 144 175 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 5476 5540 5161 5506 Length 6074 5161 42 317 315 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_find_system_dump_ 538 external procedure is an external procedure. FIND_GIVEN_PATHNAME internal procedure shares stack frame of external procedure amu_find_system_dump_. begin block on line 245 begin block shares stack frame of external procedure amu_find_system_dump_. LIST_ONE_DIR 123 internal procedure enables or reverts conditions. on unit on line 315 64 on unit LIST_ALL_DIRS 192 internal procedure enables or reverts conditions. begin block on line 445 118 begin block uses auto adjustable storage, and enables or reverts conditions. on unit on line 453 66 on unit determine_search_name internal procedure shares stack frame of external procedure amu_find_system_dump_. get_one_dir 75 internal procedure enables or reverts conditions. begin block on line 605 116 begin block uses auto adjustable storage, and enables or reverts conditions. on unit on line 613 66 on unit setup internal procedure shares stack frame of external procedure amu_find_system_dump_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME LIST_ALL_DIRS 000100 listing_dirname LIST_ALL_DIRS 000152 match_count LIST_ALL_DIRS 000153 idx LIST_ALL_DIRS 000154 sx LIST_ALL_DIRS 000155 path_count LIST_ALL_DIRS 000156 temp_n_dumps LIST_ALL_DIRS 000160 sl_info_p LIST_ALL_DIRS LIST_ONE_DIR 000100 dumpx LIST_ONE_DIR 000101 name_index LIST_ONE_DIR 000102 n_dead_links LIST_ONE_DIR 000103 n_remove_dirs LIST_ONE_DIR 000104 n_remove_segs LIST_ONE_DIR 000105 type LIST_ONE_DIR 000106 starx LIST_ONE_DIR 000107 checkx LIST_ONE_DIR amu_find_system_dump_ 000100 match_star amu_find_system_dump_ 000131 search_dir_name amu_find_system_dump_ 000203 search_entryname amu_find_system_dump_ 000214 system_area_ptr amu_find_system_dump_ 000216 want_a_pdir amu_find_system_dump_ 000217 what_to_list amu_find_system_dump_ 000220 star_entry_count amu_find_system_dump_ 000222 star_entry_ptr amu_find_system_dump_ 000224 star_names_ptr amu_find_system_dump_ 000226 system_dump_info_ptr amu_find_system_dump_ 000230 system_dump_list_ptr amu_find_system_dump_ 000232 system_dump_list_n_dumps amu_find_system_dump_ 000252 dump_dir_name FIND_GIVEN_PATHNAME 000324 dump_entryname FIND_GIVEN_PATHNAME 000334 code FIND_GIVEN_PATHNAME 000335 bad_dump_name begin block on line 245 000345 bad_dump_dir begin block on line 245 000426 code determine_search_name 000427 idx determine_search_name 000430 match_all determine_search_name 000431 no_dot determine_search_name 000432 s_name determine_search_name begin block on line 445 000100 pathx begin block on line 445 000100 one_dir_list_ptrs begin block on line 445 000101 final_dumpx begin block on line 445 000102 dirx begin block on line 445 000103 dumpx begin block on line 445 000104 i begin block on line 445 000105 sx begin block on line 445 begin block on line 605 000100 one_dir_list_ptrs begin block on line 605 000100 pathx begin block on line 605 000101 final_dumpx begin block on line 605 000102 dirx begin block on line 605 000103 dumpx begin block on line 605 000104 i begin block on line 605 000105 set_new_dir begin block on line 605 get_one_dir 000100 idx get_one_dir 000101 match_count get_one_dir 000102 temp_n_dumps get_one_dir THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp enter_begin_block leave_begin_block call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc begin_return_mac return_mac alloc_auto_adj mpfx2 enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc reverse_cs set_chars_eis op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. check_star_name_$entry expand_pathname_ expand_pathname_$add_suffix get_system_free_area_ hcs_$star_ hcs_$status_minf ioa_$rsnnl search_paths_$get sub_err_ suffixed_name_$make THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$noentry error_table_$nomatch error_table_$unimplemented_version LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000220 122 000226 125 000251 126 000253 127 000255 131 000256 134 000276 135 000277 137 000301 140 000305 144 000363 145 000364 148 000375 149 000376 150 000415 152 000416 156 000417 171 000443 175 000523 176 000524 177 000525 178 000542 180 000600 181 000626 182 000630 183 000651 184 000701 187 000702 188 000723 191 000740 192 000746 196 000747 210 000750 211 000751 212 001007 214 001036 218 001114 219 001131 220 001134 221 001136 222 001150 223 001211 225 001213 226 001217 227 001221 228 001252 229 001323 231 001361 232 001362 234 001367 238 001370 239 001373 240 001422 241 001424 242 001425 245 001426 254 001434 255 001440 256 001443 257 001450 261 001526 262 001533 264 001617 265 001625 267 001664 268 001672 271 001673 274 001674 275 001702 276 001705 277 001721 279 001723 280 001724 283 001725 289 001726 313 001747 314 001754 315 001757 316 001773 317 002032 318 002042 319 002056 321 002057 323 002125 327 002130 328 002131 329 002132 330 002133 331 002143 332 002150 333 002154 334 002224 335 002231 336 002241 340 002242 341 002250 342 002257 343 002266 345 002267 347 002270 348 002277 349 002306 352 002307 354 002311 356 002313 357 002321 358 002322 359 002325 362 002326 363 002343 365 002346 366 002350 368 002351 369 002361 370 002366 373 002375 374 002410 375 002412 376 002420 377 002434 379 002471 381 002475 382 002505 384 002526 386 002530 387 002531 390 002533 391 002563 392 002566 394 002567 395 002573 401 002574 427 002602 428 002604 429 002605 430 002613 431 002623 433 002625 436 002673 439 002744 440 002745 441 002755 443 002762 444 002764 445 002767 446 002772 467 003001 451 003003 452 003020 453 003024 454 003040 455 003054 456 003071 457 003104 459 003122 460 003125 462 003126 463 003130 464 003132 465 003143 466 003150 467 003160 470 003244 471 003250 472 003251 474 003252 475 003260 476 003261 478 003263 480 003265 481 003270 482 003274 485 003276 489 003300 490 003320 492 003323 493 003325 494 003331 495 003341 496 003353 497 003375 500 003406 501 003411 502 003412 503 003414 504 003427 506 003431 508 003432 509 003440 510 003441 512 003445 518 003446 537 003457 538 003475 539 003514 540 003516 541 003534 542 003540 544 003556 545 003563 546 003564 547 003566 548 003574 549 003600 551 003601 552 003603 553 003636 554 003645 555 003646 556 003700 557 003707 559 003710 560 003736 561 003750 562 003761 567 003767 568 003774 569 003775 571 004006 573 004045 577 004070 581 004071 599 004105 600 004110 601 004111 602 004117 603 004127 605 004131 606 004134 624 004143 611 004145 612 004162 613 004166 614 004202 615 004217 616 004232 618 004250 619 004253 621 004254 622 004256 623 004260 624 004270 626 004345 627 004351 628 004352 630 004353 631 004361 632 004362 635 004364 636 004366 637 004372 640 004374 644 004376 645 004416 647 004421 648 004423 649 004433 650 004435 651 004447 652 004471 653 004474 654 004476 656 004477 657 004500 658 004502 659 004515 661 004517 663 004520 664 004521 666 004525 672 004526 674 004527 675 004532 677 004541 ----------------------------------------------------------- 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