COMPILATION LISTING OF SEGMENT list_sub_tree Compiled by: Multics PL/I Compiler, Release 30, of February 16, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/10/88 1526.1 mst Mon Options: optimize map 1 /****^ ******************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* ******************************************** */ 6 7 8 /****^ HISTORY COMMENTS: 9* 1) change(88-09-20,GDixon), approve(88-09-20,MCR8008), 10* audit(88-10-07,Beattie), install(88-10-10,MR12.2-1159): 11* A) Rewritten to use fs_star_ for searching/selecting of entries to be 12* listed. 13* B) Added many new control arguments. 14* END HISTORY COMMENTS */ 15 16 17 list_sub_tree: 18 lst: 19 procedure; 20 21 dcl 1 auto_hd aligned auto, /* AUTOMATIC */ 22 2 args, 23 3 archive bit(1) aligned, 24 3 debug bit(1) aligned, 25 3 depth fixed bin, 26 3 inaee bit(1) aligned, 27 3 length bit(1) aligned, 28 3 names bit(1) aligned, 29 3 selection bit(1) aligned, 30 3 total bit(1) aligned, 31 3 total_only bit(1) aligned, 32 3 type bit(1) aligned, 33 2 subtree, 34 3 error bit(1) aligned, 35 3 lengths fixed bin(35), 36 2 last_ent, 37 3 depth fixed bin, 38 3 path char(168), 39 3 type char(32), 40 3 uids (15) bit(36) aligned, 41 2 ext_ent, 42 3 type (19) char(32) unal, 43 3 count (19) fixed bin, 44 3 lengths (19) fixed bin(35); 45 46 dcl code fixed bin(35) auto; 47 dcl hdP ptr auto; 48 dcl max_lineL fixed bin auto; 49 dcl pathX fixed bin auto; 50 dcl typeX fixed bin auto; 51 52 /* BASED */ 53 dcl 1 hd aligned like auto_hd based (hdP); 54 55 /* BUILTINS */ 56 dcl (addr, after, before, bin, char, copy, divide, hbound, index, lbound, length, ltrim, max, min, 57 null, rtrim, search, substr, sum) 58 builtin; 59 60 dcl cleanup condition; /* CONDITIONS */ 61 62 /* CONSTANTS */ 63 dcl ALT_ENTRY_TYPES (9) char(12) int static options(constant) init( 64 "lk", "seg", "dir", "ms_file", "ms_comp", "dm_file", 65 "arch", "arch_comp", "unkn"); 66 dcl (TYPE_LINK init(1), 67 TYPE_SEGMENT init(2), 68 TYPE_DIRECTORY init(3), 69 TYPE_MSF init(4), 70 TYPE_MSF_COMP init(5), 71 TYPE_DM_FILE init(6), 72 TYPE_ARCHIVE init(7), 73 TYPE_ARCHIVE_COMP init(8)) fixed bin int static options(constant); 74 dcl (FALSE init("0"b), 75 TRUE init("1"b)) bit(1) int static options(constant); 76 dcl LST_ENTRY_TYPES (9) char(8) int static options(constant) init( 77 "lk", "sm", "dr", "msf", "msf_comp", "dmf", 78 "ac", "ac_comp", "unkn"); 79 dcl ME init("list_sub_tree") char(13) int static options(constant); 80 dcl PRINT_ENTRY_TYPES (9) char(9) int static options(constant) init( 81 " lk", " sm", " dr", " msf", "msf_comp", 82 " dmf", " ac", " ac_comp", " unkn"); 83 dcl SPACES char(100) int static options(constant) init(""); 84 85 /* ENTRIES */ 86 dcl convert_status_code_ entry (fixed bin(35), char(8) aligned, char(100) aligned); 87 dcl fs_star_$adjust_structure_size entry (ptr, char(*), char(8), fixed bin, fixed bin(35)); 88 dcl fs_star_$init entry (ptr, char(*), char(*), char(8), ptr, fixed bin(35)); 89 dcl fs_star_$select entry (ptr, ptr, fixed bin(35)); 90 dcl fs_star_$term entry (ptr); 91 dcl expand_pathname_ entry (char(*), char(*), char(*), fixed bin(35)); 92 dcl get_line_length_$switch entry (ptr, fixed bin(35)) returns(fixed bin); 93 dcl get_wdir_ entry() returns(char(168)); 94 dcl hcs_$get_uid_file entry (char(*), char(*), bit(36) aligned, fixed bin(35)); 95 dcl hcs_$quota_read entry (char(*), fixed bin(18), fixed bin(71), bit(36) aligned, 96 bit(36), fixed bin(1), fixed bin(18), fixed bin(35)); 97 dcl hcs_$status_ entry (char(*), char(*), fixed bin(1), ptr, ptr, 98 fixed bin(35)); 99 dcl ioa_ entry() options(variable); 100 dcl pathname_ entry (char(*), char(*)) returns(char(168)); 101 dcl pathname_$component entry (char(*), char(*), char(*)) returns(char(194)); 102 103 /* EXTERNAL STATIC */ 104 dcl (error_table_$bad_opt, 105 error_table_$no_s_permission, 106 error_table_$root 107 ) fixed bin(35) ext static; 108 109 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 110 /* */ 111 /* OVERVIEW of OPERATION: */ 112 /* 1) Establish cleanup handler. */ 113 /* 2) Initialize command interface and argument processing. */ 114 /* 3) Process input arguments. Call fs_star_$init to obtain place to store input arguments. */ 115 /* */ 116 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 117 118 call CLEANUP_init(); 119 on cleanup call CLEANUP(); 120 121 call ARG_initialization (ME, "1.0", ALLOW_COMMAND, exit_proc); 122 call ARGS_init(); 123 124 call ARGS_process(); 125 star_options.path_allow = PATH_ALLOW_NONDIR_STAR_NAMES; 126 if hd.args.depth ^= 1 then 127 star_options.entry_type.dirs, star_options.entry_type.msfs = 128 ENTRY_RETURN | ENTRY_LIST_SUBENTRIES; 129 if hd.args.archive then do; 130 do pathX = lbound(star_paths.value,1) to star_paths.count 131 while (index (star_paths.value(pathX), "::") > 0); 132 end; 133 if EXTENDED_TYPE_archive_given() then /* -slet ac given; return archives. */ 134 star_options.entry_type.archives = ENTRY_RETURN | ENTRY_LIST_SUBENTRIES; 135 else if pathX > star_paths.count then do; /* all paths are archive pathnames */ 136 /* so only return the components. */ 137 star_options.entry_type.archives = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; 138 hd.args.selection = TRUE; 139 end; 140 else /* otherwise return both archives & comps*/ 141 star_options.entry_type.archives = ENTRY_RETURN | ENTRY_LIST_SUBENTRIES; 142 end; 143 if hd.args.inaee then do; 144 star_options.entry_type.dirs = star_options.entry_type.dirs | ENTRY_INAEE; 145 star_options.entry_type.segs = star_options.entry_type.segs | ENTRY_INAEE; 146 end; 147 star_options.handler = HANDLER; 148 star_options.error = ERROR_ROUTINE; 149 star_options.handler_dataP = addr(hd); 150 151 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 152 /* */ 153 /* OVERVIEW of OPERATION (continued): */ 154 /* 4) Call fs_star_$select to perform processing of subtrees. */ 155 /* 5) If processing was successful, summarize its results briefly or in detail. */ 156 /* 6) Cleanup and exit. */ 157 /* */ 158 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 159 160 call fs_star_$select (star_optionsP, star_dataP, code); 161 162 if code = 0 then do; 163 if (hd.last_ent.type = ENTRY_TYPE_DIRECTORY | /* If prior entry was a dir, and it is */ 164 /* empty, say that. Same for archives */ 165 /* if we are searching them. */ 166 ((hd.last_ent.type = ENTRY_TYPE_ARCHIVE) & hd.args.archive)) & 167 (hd.args.depth>hd.last_ent.depth) & ^hd.args.selection then 168 call ioa_ ("^[^vt^;^s^]^[^vt^;^s^]^v( ^)", hd.args.type, length(typ)+1, 169 hd.args.length, length(len)+1+bin(hd.args.type,1)*length(typ), hd.last_ent.depth); 170 171 if (star_data.matched.total > 0) & (hd.args.total | hd.args.total_only) then do; 172 call ioa_(""); 173 call TOTAL_print_init (" ", "count:", "pages:"); 174 call TOTAL_print (" ", "count:", "pages:", 175 "TOTAL", star_data.matched.total, hd.subtree.lengths); 176 call TOTAL_print (" ", "count:", "pages:", 177 "SEGMENTS", star_data.matched.segs, hd.ext_ent.lengths(TYPE_SEGMENT)); 178 call TOTAL_print (" ", "count:", "pages:", 179 "ARCHIVES", star_data.matched.archives, hd.ext_ent.lengths(TYPE_ARCHIVE)); 180 call TOTAL_print (" ", "count:", "pages:", 181 "ARCH_COMPS", star_data.matched.arch_comps, hd.ext_ent.lengths(TYPE_ARCHIVE_COMP)); 182 call TOTAL_print (" ", "count:", "pages:", 183 "LINKS", star_data.matched.links, hd.ext_ent.lengths(TYPE_LINK)); 184 call TOTAL_print (" ", "count:", "pages:", 185 "DIRS", star_data.matched.dirs, hd.ext_ent.lengths(TYPE_DIRECTORY)); 186 call TOTAL_print (" ", "count:", "pages:", 187 "MSFS", star_data.matched.msfs, hd.ext_ent.lengths(TYPE_MSF)); 188 call TOTAL_print (" ", "count:", "pages:", 189 "MSF_COMPS", star_data.matched.msf_comps, hd.ext_ent.lengths(TYPE_MSF_COMP)); 190 call TOTAL_print (" ", "count:", "pages:", 191 "DM_FILES", star_data.matched.dm_files, hd.ext_ent.lengths(TYPE_DM_FILE)); 192 if hd.ext_ent.type(hbound(STANDARD_ENTRY_TYPES,1)+1) ^= "" then do; 193 do typeX = hbound(STANDARD_ENTRY_TYPES,1)+1 to hbound(hd.ext_ent.type,1) 194 while (hd.ext_ent.type(typeX) ^= ""); 195 call TOTAL_print ("EXTENDED", "ENTRIES ", " pages: ", 196 hd.ext_ent.type(typeX), hd.ext_ent.count(typeX), hd.ext_ent.lengths(typeX)); 197 end; 198 call TOTAL_print_end ("EXTENDED", "ENTRIES ", " pages: "); 199 end; 200 else 201 call TOTAL_print_end (" ", "count:", "pages:"); 202 end; 203 else 204 call ioa_ ("^[^/^]^d ^[entries^;entry^] found^[, ^d total pages^;^s^].", 205 star_data.matched.total > 0, star_data.matched.total, star_data.matched.total ^= 1, 206 (star_data.matched.total > 0) & hd.args.length, hd.subtree.lengths); 207 end; 208 209 EXIT: 210 call CLEANUP(); 211 return; 212 213 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 214 /* */ 215 /* EXIT PROCEDURE: */ 216 /* 1) This procedure is called by ssu_$abort_subsystem when ERR_fatal is called to report a fatal */ 217 /* error. */ 218 /* 2) It does a non-local goto to the EXIT label to stop execution of the command. */ 219 /* */ 220 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 221 222 exit_proc: 223 proc; 224 go to EXIT; 225 end exit_proc; 226 227 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 228 229 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 230 /* */ 231 /* ARGUMENT PROCESSING: */ 232 /* Declare variables and subroutines needed for argument processing. This is a general argument */ 233 /* processing package that can be shared among many programs. */ 234 /* */ 235 /* SEE ARGUMENT PROCESSING PROGRAMS: */ 236 /* ARG_initialization, ARG_get, ARG_get_numeric_operand, ARG_get_extra_operand, ARG_get_operand, */ 237 /* ARG_remaining_arg_count */ 238 /* */ 239 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 240 241 dcl (afS bit(1) aligned, /* on: called as an active function */ 242 argL fixed bin(21), /* current argument length */ 243 argN fixed bin, /* arg count */ 244 argP ptr, 245 argX fixed bin, /* arg index */ 246 opL fixed bin(21), /* control argument operand */ 247 opP ptr, 248 retL fixed bin(21), /* af return value */ 249 retP ptr, 250 sciP ptr) auto; /* ssu_ info ptr */ 251 252 dcl arg char(argL) based(argP), 253 op char(opL) based(opP), 254 ret char(retL) varying based(retP); 255 256 dcl ssu_$abort_subsystem entry() options(variable), 257 ssu_$arg_ptr entry (ptr, fixed bin, ptr, 258 fixed bin(21)), 259 ssu_$destroy_invocation entry (ptr), 260 ssu_$print_message entry() options(variable), 261 ssu_$return_arg entry (ptr, fixed bin, bit(1) aligned, 262 ptr, fixed bin(21)), 263 ssu_$standalone_invocation entry (ptr, char(*), char(*), ptr, 264 entry, fixed bin(35)); 265 266 dcl (ALLOW_COMMAND init(1), 267 ALLOW_AF init(2), 268 ALLOW_COMMAND_AF init(3)) fixed bin int static 269 options(constant); 270 271 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 272 /* */ 273 /* ARG_initialization: */ 274 /* 1) Initialize error handling subroutines. */ 275 /* 2) Determine whether invoked as command or af. */ 276 /* 3) Is this type of invocation allowed? */ 277 /* 4) Initialize af return argument, and index of current argument. */ 278 /* */ 279 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 280 281 ARG_initialization: 282 proc (caller, version, allowed, exit_procedure); 283 284 dcl caller char(*) parm, 285 version char(*) parm, 286 allowed fixed bin parm, 287 exit_procedure entry parm; 288 289 dcl code fixed bin(35) auto; 290 291 dcl com_err_ entry() options(variable), 292 cu_$arg_list_ptr entry returns(ptr); 293 294 dcl (error_table_$active_function, 295 error_table_$not_act_fnc) fixed bin(35) ext static; 296 297 call ssu_$standalone_invocation (sciP, caller, version, 298 cu_$arg_list_ptr(), exit_procedure, code); 299 if code ^= 0 then do; 300 call com_err_ (code, caller, 301 "Error creating standalone ssu_ invocation."); 302 call exit_procedure(); 303 end; 304 305 call ERR_init(); 306 call ssu_$return_arg (sciP, argN, afS, retP, retL); 307 if allowed = ALLOW_COMMAND & afS then 308 call ERR_fatal (sciP, error_table_$active_function); 309 else if allowed = ALLOW_AF & ^afS then 310 call ERR_fatal (sciP, error_table_$not_act_fnc); 311 else if allowed = ALLOW_COMMAND_AF then; 312 if afS then 313 ret = ""; 314 argX = 0; 315 end ARG_initialization; 316 317 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 318 319 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 320 /* */ 321 /* ARG_get: */ 322 /* Gets the next argument from arg list. Returns TRUE if an argument is available, FALSE if the */ 323 /* argument list is exhausted. */ 324 /* */ 325 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 326 327 ARG_get: 328 proc returns (bit(1)); 329 330 dcl (FALSE init("0"b), 331 TRUE init("1"b)) 332 bit(1) int static options(constant); 333 334 if argX < argN then do; 335 argX = argX + 1; 336 call ssu_$arg_ptr (sciP, argX, argP, argL); 337 return (TRUE); 338 end; 339 else 340 return (FALSE); 341 end ARG_get; 342 343 344 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 345 /* */ 346 /* ARG_get_extra_operand: */ 347 /* 1) Get an optional control arg operand. An argument beginning with a minus (-) or contains */ 348 /* < or > chars is assumed to be a subsequent control argument or a positional pathname, rather */ 349 /* than an operand. */ 350 /* 2) Returns TRUE if an extra operand is found. */ 351 /* */ 352 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 353 354 ARG_get_extra_operand: 355 proc () returns (bit(1)); 356 357 dcl (FALSE init("0"b), 358 TRUE init("1"b)) 359 bit(1) int static options(constant); 360 361 if argX < argN then do; 362 argX = argX + 1; 363 call ssu_$arg_ptr (sciP, argX, opP, opL); 364 if (index(op, "-") = 1) | (search(op,"<>") > 0) then do; 365 argX = argX - 1; /* Exclude control args and pathnames */ 366 return (FALSE); /* from being treated as extra operands.*/ 367 end; 368 else 369 return (TRUE); 370 end; 371 else 372 return (FALSE); 373 374 end ARG_get_extra_operand; 375 376 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 377 378 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 379 /* */ 380 /* ARG_get_numeric_operand: */ 381 /* 1) Parg is name of control argument whose operand is to be obtained. */ 382 /* 2) If operand is optional, Pdescription is a null string. */ 383 /* If operand is required, Pdescription is used in an error message to describe missing operand. */ 384 /* 3) If operand is optional, default_value is the default value that will be returned. The */ 385 /* constant NO_DEFAULT_VALUE can be used to specify that there is no default value. */ 386 /* 4) allowed_values is an array of accepted values. It can be NO_ALLOWED_VALUES to specify that */ 387 /* there is no restriction on the acceptable value; POSITIVE_VALUES to specify values > 0; or */ 388 /* NONNEGATIVE_VALUES to specify values >= 0. */ 389 /* 5) Returns TRUE if a numeric operand was found, with operand value in num_op integer. */ 390 /* */ 391 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 392 393 dcl num_op fixed bin(35); 394 dcl NO_DEFAULT_VALUE fixed bin(35) int static options(constant) init(-34359738368); 395 dcl NO_ALLOWED_VALUES (1) fixed bin(35) int static options(constant) init( 396 -34359738368); /* -34359738368 is -2**35, the largest */ 397 /* negative integer. */ 398 dcl POSITIVE_VALUES (2) fixed bin(35) int static options(constant) init( 399 1, 34359738367); /* 34359738367 is 2**35-1, the largest */ 400 /* positive integer. */ 401 dcl NONNEGATIVE_VALUES (2) fixed bin(35) int static options(constant) init( 402 0, 34359738367); 403 404 ARG_get_numeric_operand: 405 proc (Parg, Pdescription, Pdefault_value, Pallowed_values) returns (bit(1)); 406 407 dcl Parg char(*) parm, 408 Pdescription char(*) parm, 409 Pdefault_value fixed bin(35) parm, 410 Pallowed_values (*) fixed bin(35) parm; 411 412 dcl valX fixed bin auto; 413 414 dcl (convert, dim, hbound, lbound) builtin; 415 416 dcl (conversion, size) condition; 417 418 dcl (FALSE init("0"b), 419 TRUE init("1"b)) bit(1) int static options(constant), 420 (error_table_$bad_arg, 421 error_table_$noarg) fixed bin(35) ext static; 422 423 if Pdefault_value ^= NO_DEFAULT_VALUE & Pdescription = "" then 424 num_op = Pdefault_value; 425 426 if argX < argN then do; 427 argX = argX + 1; 428 call ssu_$arg_ptr (sciP, argX, opP, opL); 429 on conversion, size begin; 430 if index(op,"-") = 1 & Pdescription = "" then do; /* If operand optional and it begins */ 431 argX = argX - 1; /* with -, assume it is ctl arg. Save */ 432 num_op = Pdefault_value; /* it for later, and return the default */ 433 go to USE_DEFAULT_VALUE; /* value. */ 434 end; 435 else if dim(Pallowed_values,1) = dim(POSITIVE_VALUES,1) then 436 if Pallowed_values(hbound(Pallowed_values,1)) = NONNEGATIVE_VALUES(2) then 437 go to BAD_RANGE; 438 else 439 go to BAD_OPT; 440 else 441 go to BAD_OPT; 442 end; 443 num_op = convert (num_op, op); 444 revert conversion, size; 445 446 if dim(Pallowed_values,1) = 1 & Pallowed_values(1) = NO_ALLOWED_VALUES(1) then; 447 else if dim(Pallowed_values,1) = dim(POSITIVE_VALUES,1) then do; 448 if Pallowed_values(hbound(Pallowed_values,1)) = POSITIVE_VALUES(2) then do; 449 if Pallowed_values(1) <= num_op & num_op <= Pallowed_values(2) then; 450 else do; 451 BAD_RANGE: call ERR (sciP, error_table_$bad_arg, "^a ^a 452 ^a must be followed by a ^[positive^;nonnegative^] ^a.^[ 453 Default value is:^- ^d^;^s^]", 454 Parg, op, Parg, Pallowed_values(1)=1, Pdescription, 455 Pdefault_value ^= NO_DEFAULT_VALUE, Pdefault_value); 456 return (FALSE); 457 end; 458 end; 459 else go to TEST_ARRAY; 460 end; 461 else do; /* Compare with allowed values, if any. */ 462 TEST_ARRAY: 463 do valX = lbound(Pallowed_values,1) 464 to hbound(Pallowed_values,1) 465 while (num_op ^= Pallowed_values(valX)); 466 end; 467 if valX > hbound(Pallowed_values,1) then do; 468 BAD_OPT: call ERR (sciP, error_table_$bad_arg, 469 "^a ^a 470 ^a must be followed by a^[n^] ^a.^[ 471 Default value is:^- ^d^;^s^]^[ 472 Allowed ^[value is^;values are^]:^-^( ^d^)^]", 473 Parg, op, Parg, ARG_vowel(Pdescription), Pdescription, 474 Pdefault_value ^= NO_DEFAULT_VALUE, Pdefault_value, 475 ^(dim(Pallowed_values,1)=1 & Pallowed_values(1)=NO_ALLOWED_VALUES(1)), 476 dim(Pallowed_values,1)=1, Pallowed_values); 477 return (FALSE); 478 end; 479 end; 480 end; 481 482 else if Pdescription ^= "" then do; 483 call ERR (sciP, error_table_$noarg, 484 "^/^a must be followed by a^[n^] ^a.^[ 485 Default value is:^- ^d^;^s^]^[ 486 Allowed ^[value is^;values are^]:^-^( ^d^)^]", Parg, 487 ARG_vowel(Pdescription), Pdescription, 488 Pdefault_value ^= -1, Pdefault_value, 489 ^(dim(Pallowed_values,1)=1 & Pdefault_value=Pallowed_values(1)), 490 dim(Pallowed_values,1)=1, Pallowed_values); 491 return (FALSE); 492 end; 493 494 USE_DEFAULT_VALUE: 495 return (TRUE); 496 end ARG_get_numeric_operand; 497 498 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 499 500 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 501 /* */ 502 /* ARG_get_operand: */ 503 /* 1) ctl_arg is name of control argument whose operand is to be obtained. */ 504 /* 2) If operand is optional, description is a null string. */ 505 /* If operand is required, description is used in error message to describe the missing operand. */ 506 /* 3) Returns TRUE if an operand is found, with the value in op. */ 507 /* */ 508 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 509 510 ARG_get_operand: 511 proc (ctl_arg, description) returns (bit(1)); 512 513 dcl ctl_arg char(*) parm, 514 description char(*) parm; 515 516 dcl error_table_$noarg fixed bin(35) ext static; 517 518 dcl (FALSE init("0"b), 519 TRUE init("1"b)) 520 bit(1) int static options(constant); 521 522 if argX < argN then do; 523 argX = argX + 1; 524 call ssu_$arg_ptr (sciP, argX, opP, opL); 525 return (TRUE); 526 end; 527 else do; 528 if description ^= "" then 529 call ERR (sciP, error_table_$noarg, 530 "^a requires a^[n^] ^a operand.", ctl_arg, ARG_vowel(description), 531 description); 532 return (FALSE); 533 end; 534 535 end ARG_get_operand; 536 537 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 538 539 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 540 /* */ 541 /* ARG_remaining_arg_count: */ 542 /* Returns the number of unprocessed arguments. */ 543 /* */ 544 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 545 546 ARG_remaining_arg_count: 547 procedure returns (fixed bin); 548 return (max(0, argN - argX)); 549 end ARG_remaining_arg_count; 550 551 552 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 553 /* */ 554 /* ARG_vowel: */ 555 /* 1) returns true if str begins with a vowel, false otherwise. */ 556 /* */ 557 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 558 559 ARG_vowel: 560 proc (str) returns (bit(1)); 561 562 dcl str char(*) parm; 563 564 dcl (search, substr) builtin; 565 566 dcl (FALSE init("0"b), 567 TRUE init("1"b)) 568 bit(1) int static options(constant); 569 570 if search ("aeiouAEIOU", substr(str,1,1)) > 0 then 571 return (TRUE); 572 else 573 return (FALSE); 574 575 end ARG_vowel; 576 577 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 578 579 580 581 582 583 584 585 586 587 588 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 589 /* */ 590 /* ARGUMENT PROCESSING FOR list_sub_tree: */ 591 /* Routines with the ARGS_ prefix process the particular arguments accepted by the lst command. */ 592 /* Routines involved include: */ 593 /* */ 594 /* ARGS_init, ARGS_process */ 595 /* */ 596 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 597 598 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 599 /* */ 600 /* ARGS_init: */ 601 /* 1) Call fs_star_$init to initialize fs_star_. */ 602 /* 2) Initialize argument-holding handler data structure, hd. */ 603 /* 3) Get terminal line length for use in formatting output. */ 604 /* */ 605 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 606 607 ARGS_init: 608 proc; 609 610 dcl code fixed bin(35) auto; 611 dcl typeX fixed bin auto; 612 613 call fs_star_$init (sciP, "", "", STAR_OPTIONS_VERSION_1, star_optionsP, code); 614 call ERR_fatal (sciP, code, "Calling fs_star_$init."); 615 616 hdP = addr(auto_hd); 617 hd.args.archive = FALSE; 618 hd.args.debug = FALSE; 619 hd.args.depth = 99; 620 hd.args.inaee = FALSE; 621 hd.args.length = TRUE; 622 hd.args.names = FALSE; 623 hd.args.selection = FALSE; 624 hd.args.total = TRUE; 625 hd.args.total_only = FALSE; 626 hd.args.type = TRUE; 627 628 hd.subtree.error = FALSE; 629 hd.subtree.lengths = 0; 630 631 hd.last_ent.depth = 0; 632 hd.last_ent.path = ""; 633 hd.last_ent.type = ENTRY_TYPE_UNSET; 634 hd.last_ent.uids(*) = "0"b; 635 636 hd.ext_ent.type(*) = ""; 637 hd.ext_ent.count(*) = 0; 638 hd.ext_ent.lengths(*) = 0; 639 do typeX = lbound(STANDARD_ENTRY_TYPES,1) to hbound(STANDARD_ENTRY_TYPES,1); 640 hd.ext_ent.type(typeX) = STANDARD_ENTRY_TYPES(typeX); 641 end; 642 643 max_lineL = get_line_length_$switch (null, code); 644 call EXTENDED_TYPE_init(); 645 end ARGS_init; 646 647 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 648 649 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 650 /* */ 651 /* ARGS_process: */ 652 /* 1) Loop through all input arguments, storing them in the handler data structure (hd), */ 653 /* star_options and star_paths structures, etc. */ 654 /* 2) Apply argument defaults. */ 655 /* 3) If errors occur, diagnose them and exit lst. */ 656 /* */ 657 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 658 659 ARGS_process: 660 proc; 661 662 dcl archive_set bit(1) aligned auto; 663 dcl inaee_set bit(1) aligned auto; 664 dcl pathX fixed bin auto; 665 666 archive_set = FALSE; 667 inaee_set = FALSE; 668 do while (ARG_get()); 669 if index(arg, "-") = 1 then do; 670 if arg = "-archives" | arg = "-archive" | arg = "-ac" then do; 671 hd.args.archive = TRUE; 672 archive_set = TRUE; 673 end; 674 else if arg = "-no_archives" | arg = "-no_archive" | arg = "-nac" then do; 675 hd.args.archive = FALSE; 676 archive_set = TRUE; 677 end; 678 679 else if arg = "-debug" | arg = "-db" then 680 hd.args.debug = TRUE; 681 else if arg = "-no_debug" | arg = "-ndb" then 682 hd.args.debug = FALSE; 683 684 else if arg = "-depth" | arg = "-dh" then do; 685 if ARG_get_numeric_operand (arg, "maximum subtree depth to scan", 686 NO_DEFAULT_VALUE, POSITIVE_VALUES) then 687 hd.args.depth = num_op + 1; 688 end; 689 690 else if arg = "-exclude" | arg = "-ex" then do; 691 if ARG_get_operand (arg, "star name") then do; 692 if star_options.exclude_namesP = null then do; 693 exclude_names_size = ARG_remaining_arg_count() + 1; 694 call fs_star_$adjust_structure_size (star_optionsP, "exclude_names", 695 STAR_EXCLUDE_NAMES_VERSION_1, exclude_names_size, code); 696 call ERR_fatal (sciP, code, "^/Allocating exclude_names structure with ^d elements.", 697 exclude_names_size); 698 end; 699 exclude_names.count = exclude_names.count + 1; 700 exclude_names.value (exclude_names.count) = op; 701 do while (ARG_get_extra_operand()); 702 exclude_names.count = exclude_names.count + 1; 703 exclude_names.value (exclude_names.count) = op; 704 end; 705 end; 706 end; 707 else if arg = "-no_exclude" | arg = "-nex" then do; 708 if star_options.exclude_namesP ^= null then 709 exclude_names.count = 0; 710 end; 711 712 else if arg = "-interpret_as_extended_entry" | arg = "-inaee" then do; 713 hd.args.inaee = TRUE; 714 inaee_set = TRUE; 715 end; 716 else if arg = "-interpret_as_standard_entry" | arg = "-inase" then do; 717 hd.args.inaee = FALSE; 718 inaee_set = TRUE; 719 end; 720 721 else if arg = "-length" | arg = "-ln" then 722 hd.args.length = TRUE; 723 else if arg = "-no_length" | arg = "-nln" then 724 hd.args.length = FALSE; 725 726 else if arg = "-match" then do; 727 if ARG_get_operand (arg, "star name") then do; 728 if star_options.match_namesP = null then do; 729 match_names_size = ARG_remaining_arg_count() + 1; 730 call fs_star_$adjust_structure_size (star_optionsP, "match_names", 731 STAR_MATCH_NAMES_VERSION_1, match_names_size, code); 732 call ERR_fatal (sciP, code, "^/Allocating match_names structure with ^d elements.", 733 match_names_size); 734 end; 735 match_names.count = match_names.count + 1; 736 match_names.value (match_names.count) = op; 737 do while (ARG_get_extra_operand()); 738 match_names.count = match_names.count + 1; 739 match_names.value (match_names.count) = op; 740 end; 741 end; 742 end; 743 else if arg = "-no_match" | arg = "-nmatch" then do; 744 if star_options.match_namesP ^= null then 745 match_names.count = 0; 746 end; 747 748 else if arg = "-names" | arg = "-name" | arg = "-nm" | arg = "-all" | arg = "-a" then 749 hd.args.names = TRUE; 750 else if arg = "-no_names" | arg = "-no_name" | arg = "-nnm" then 751 hd.args.names = FALSE; 752 753 else if arg = "-select_entry_type" | arg = "-slet" then do; 754 if ARG_get_operand (arg, "entry type selector") then do; 755 if star_options.extended_entry_typesP = null then do; 756 extended_entry_types_size = ARG_remaining_arg_count() + 1; 757 call fs_star_$adjust_structure_size (star_optionsP, "extended_entry_types", 758 STAR_EXTENDED_ENTRY_VERSION_1, extended_entry_types_size, code); 759 call ERR_fatal (sciP, code, 760 "^/Allocating extended_entry_types structure with ^d elements.", 761 extended_entry_types_size); 762 end; 763 call EXTENDED_TYPE(op); 764 do while (ARG_get_extra_operand()); 765 call EXTENDED_TYPE(op); 766 end; 767 end; 768 end; 769 else if arg = "-no_select_entry_type" | arg = "-nslet" then do; 770 if star_options.extended_entry_typesP ^= null then 771 extended_entry_types.count = 0; 772 call EXTENDED_TYPE_init(); 773 end; 774 775 else if arg = "-totals" | arg = "-total" | arg = "-tt" then 776 hd.args.total = TRUE; 777 else if arg = "-no_totals" | arg = "-no_total" | arg = "-ntt" then 778 hd.args.total = FALSE; 779 780 else if arg = "-totals_only" | arg = "-total_only" | arg = "-tto" then 781 hd.args.total_only = TRUE; 782 else if arg = "-no_totals_only" | arg = "-no_total_only" | arg = "-ntto" then 783 hd.args.total_only = FALSE; 784 785 else if arg = "-types" | arg = "-type" | arg = "-tp" then 786 hd.args.type = TRUE; 787 else if arg = "-no_types" | arg = "-no_type" | arg = "-ntp" then 788 hd.args.type = FALSE; 789 790 else 791 call ERR (sciP, error_table_$bad_opt, arg); 792 end; 793 794 else do; 795 if star_paths.count >= hbound(star_paths.value,1) then do; 796 call fs_star_$adjust_structure_size (star_optionsP, "star_paths", STAR_PATHS_VERSION_1, 797 hbound(star_paths.value,1) + 10, code); 798 call ERR (sciP, code, 799 "Calling fs_star_$adjust_structure_size to increase star_paths array size to ^d.", 800 hbound(star_paths.value,1) + 10); 801 end; 802 star_paths.count = star_paths.count + 1; 803 star_paths.value (star_paths.count) = arg; 804 end; 805 end; 806 807 if star_paths.count = 0 then do; 808 star_paths.count = 1; 809 star_paths.value(1) = get_wdir_(); 810 end; 811 812 if ^archive_set then do; 813 do pathX = lbound(star_paths.value,1) to star_paths.count; 814 if index (star_paths.value(pathX), "::") > 0 then 815 hd.args.archive = TRUE; 816 end; 817 if EXTENDED_TYPE_archive_comp_given() then 818 hd.args.archive = TRUE; 819 end; 820 if ^inaee_set then 821 hd.args.inaee = EXTENDED_TYPE_given(); 822 823 if star_options.exclude_namesP ^= null then 824 if exclude_names.count > 0 then 825 hd.args.selection = TRUE; 826 if star_options.match_namesP ^= null then 827 if match_names.count > 0 then 828 hd.args.selection = TRUE; 829 if star_options.extended_entry_typesP ^= null then 830 if extended_entry_types.count > 0 then 831 hd.args.selection = TRUE; 832 833 if ERR_occurred() then 834 go to EXIT; 835 end ARGS_process; 836 837 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 838 839 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 840 /* */ 841 /* CLEANUP: */ 842 /* 1) Terminate fs_star_ processing. */ 843 /* 2) Destroy ssu_ invocation created to process arguments. */ 844 /* */ 845 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 846 847 CLEANUP: 848 proc; 849 850 call fs_star_$term (star_optionsP); 851 call ssu_$destroy_invocation (sciP); 852 853 end CLEANUP; 854 855 856 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 857 /* */ 858 /* CLEANUP_init: */ 859 /* 1) Initialize variables referenced by CLEANUP handler above. */ 860 /* */ 861 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 862 863 CLEANUP_init: 864 proc; 865 866 star_optionsP = null; 867 sciP = null; 868 869 end CLEANUP_init; 870 871 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 872 873 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 874 /* */ 875 /* EXTENDED_TYPE: */ 876 /* This procedure converts traditional entry types (eg, directory or dr) to fs_star_ */ 877 /* STANDARD_ENTRY_TYPES and stores them in the extended_entry_types structure. */ 878 /* */ 879 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 880 881 EXTENDED_TYPE: 882 procedure (Ptypes); 883 884 dcl Ptypes char(*) parm; 885 886 dcl standard_type bit(1) aligned auto; 887 dcl type char(32) auto; 888 dcl types char(1000) varying auto; 889 890 types = ltrim(rtrim(Ptypes)); 891 do while (types ^= ""); 892 standard_type = FALSE; 893 type = before(types, ","); 894 types = after(types, ","); 895 896 do typeX = lbound(STANDARD_ENTRY_TYPES,1) to hbound(STANDARD_ENTRY_TYPES,1); 897 if substr(STANDARD_ENTRY_TYPES(typeX),2) = type & 898 substr(STANDARD_ENTRY_TYPES(typeX),1,length("-")) = "-" then do; 899 type = STANDARD_ENTRY_TYPES(typeX); 900 standard_type = TRUE; 901 if typeX = TYPE_ARCHIVE then 902 archive_type_found = TRUE; 903 else if typeX = TYPE_ARCHIVE_COMP then 904 archive_comp_type_found = TRUE; 905 end; 906 end; 907 908 do typeX = lbound(LST_ENTRY_TYPES,1) to hbound(LST_ENTRY_TYPES,1); 909 if LST_ENTRY_TYPES(typeX) = type then do; 910 type = STANDARD_ENTRY_TYPES(typeX); 911 standard_type = TRUE; 912 if typeX = TYPE_ARCHIVE then 913 archive_type_found = TRUE; 914 else if typeX = TYPE_ARCHIVE_COMP then 915 archive_comp_type_found = TRUE; 916 end; 917 end; 918 919 do typeX = lbound(ALT_ENTRY_TYPES,1) to hbound(ALT_ENTRY_TYPES,1); 920 if ALT_ENTRY_TYPES(typeX) = type then do; 921 type = STANDARD_ENTRY_TYPES(typeX); 922 standard_type = TRUE; 923 if typeX = TYPE_ARCHIVE then 924 archive_type_found = TRUE; 925 else if typeX = TYPE_ARCHIVE_COMP then 926 archive_comp_type_found = TRUE; 927 end; 928 end; 929 930 if ^standard_type then 931 extended_types_found = TRUE; 932 933 if extended_entry_types.count >= extended_entry_types.max_count then do; 934 extended_entry_types_size = extended_entry_types.max_count + 10; 935 call fs_star_$adjust_structure_size (star_optionsP, "extended_entry_types", 936 STAR_EXTENDED_ENTRY_VERSION_1, extended_entry_types_size, code); 937 call ERR_fatal (sciP, code, "^/Allocating extended_entry_types structure with ^d elements.", 938 extended_entry_types_size); 939 end; 940 extended_entry_types.count = extended_entry_types.count + 1; 941 extended_entry_types.value (extended_entry_types.count) = type; 942 end; 943 end EXTENDED_TYPE; 944 945 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 946 947 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 948 /* */ 949 /* EXTENDED_TYPE_init: */ 950 /* This procedure initializes the flags which record whether any of the types given to -slet are */ 951 /* not standard entry types. */ 952 /* */ 953 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 954 955 dcl archive_comp_type_found bit(1) aligned auto; 956 dcl archive_type_found bit(1) aligned auto; 957 dcl extended_types_found bit(1) aligned auto; 958 959 EXTENDED_TYPE_init: 960 procedure(); 961 962 archive_comp_type_found = FALSE; 963 archive_type_found = FALSE; 964 extended_types_found = FALSE; 965 966 return; 967 968 969 970 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 971 /* */ 972 /* EXTENDED_TYPE_archive_comp_given: */ 973 /* This functions returns TRUE is any of the types given to -slet are not standard entry types.. */ 974 /* */ 975 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 976 977 EXTENDED_TYPE_archive_comp_given: 978 entry() returns (bit(1) aligned); 979 980 return (archive_comp_type_found); 981 982 983 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 984 /* */ 985 /* EXTENDED_TYPE_archive_given: */ 986 /* This functions returns TRUE is any of the types given to -slet are not standard entry types.. */ 987 /* */ 988 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 989 990 EXTENDED_TYPE_archive_given: 991 entry() returns (bit(1) aligned); 992 993 return (archive_type_found); 994 995 996 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 997 /* */ 998 /* EXTENDED_TYPE_given: */ 999 /* This functions returns TRUE is any of the types given to -slet are not standard entry types.. */ 1000 /* */ 1001 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1002 1003 EXTENDED_TYPE_given: 1004 entry() returns (bit(1) aligned); 1005 1006 return (extended_types_found); 1007 1008 end EXTENDED_TYPE_init; 1009 1010 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1011 1012 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1013 /* */ 1014 /* ERROR REPORTING ROUTINES: */ 1015 /* 1) Nonfatal errors set a switch, which can be tested via error_occurred function. */ 1016 /* 2) Fatal errors abort the subsystem by calling ssu_$abort_subsystem, which calls the main */ 1017 /* procedure's exit procedure, which branches to the EXIT label to exit the command. */ 1018 /* */ 1019 /* Syntax: call ERR (sciP, code, ioa_ctl, args); */ 1020 /* call ERR_fatal (sciP, code, ioa_ctl, args); */ 1021 /* */ 1022 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1023 1024 dcl error_occurred_sw bit(1) auto; 1025 1026 ERR: 1027 proc options (variable); 1028 1029 dcl code fixed bin(35) based (codeP), 1030 codeP ptr auto; 1031 1032 dcl cu_$arg_list_ptr entry returns(ptr), 1033 cu_$arg_ptr entry (fixed bin, ptr, fixed bin(21), 1034 fixed bin(35)), 1035 cu_$generate_call entry (entry, ptr), 1036 ioa_ entry() options(variable); 1037 1038 dcl CODE_ARG fixed bin 1039 int static options(constant) init(2), 1040 TRUE init("1"b) bit(1) 1041 int static options(constant); 1042 1043 call cu_$arg_ptr (CODE_ARG, codeP, 0, 0); 1044 if code = 0 then return; 1045 if code = -1 then code = 0; 1046 error_occurred_sw = TRUE; 1047 call cu_$generate_call (ssu_$print_message, cu_$arg_list_ptr()); 1048 return; 1049 1050 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1051 1052 ERR_fatal: 1053 entry options(variable); 1054 1055 call cu_$arg_ptr (CODE_ARG, codeP, 0, 0); 1056 if code = 0 then return; 1057 if code = -1 then code = 0; 1058 error_occurred_sw = TRUE; 1059 call ioa_ (""); 1060 call cu_$generate_call (ssu_$abort_subsystem, cu_$arg_list_ptr()); 1061 1062 end ERR; 1063 1064 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1065 1066 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1067 /* */ 1068 /* ERR_init: */ 1069 /* Initialize nonfatal error processing routine flag, which records whether such an error has */ 1070 /* occurred. */ 1071 /* */ 1072 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1073 1074 ERR_init: 1075 proc; 1076 1077 error_occurred_sw = FALSE; 1078 return; 1079 1080 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1081 /* */ 1082 /* ERR_occurred: */ 1083 /* Returns TRUE if a nonfatal error has occurred. */ 1084 /* */ 1085 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1086 1087 ERR_occurred: 1088 entry returns (bit(1)); 1089 1090 return (error_occurred_sw); 1091 end ERR_init; 1092 1093 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1094 1095 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1096 /* */ 1097 /* ERROR_ROUTINE: */ 1098 /* This is the fs_star_ error handler, which is called whenever an error occurs while processing */ 1099 /* entries in the subtree being listed. */ 1100 /* */ 1101 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1102 1103 ERROR_ROUTINE: 1104 procedure (Pstar_dataP, Pdir, Pent, Pcomp, Pcode, Pmessage, Paction); 1105 1106 dcl Pstar_dataP ptr parm; /* ptr to star_data. (In) */ 1107 dcl Pdir char(*) parm; /* dir part of entry's pathname. (In) */ 1108 dcl Pent (*) char(32) parm; /* entry names on entry. (In) */ 1109 dcl Pcomp char(*) parm; /* archive component name. (In) */ 1110 dcl Pcode fixed bin(35) parm; /* status code. (In) */ 1111 dcl Pmessage char(*) parm; /* error message. (In) */ 1112 dcl Paction fixed bin parm; /* entry action code. (Out) */ 1113 1114 dcl action fixed bin auto; 1115 dcl code fixed bin(35) auto; 1116 dcl dir char(168) auto; 1117 dcl ent (1) char(32) auto; 1118 dcl long char(100) aligned auto; 1119 dcl short char(8) aligned auto; 1120 1121 Paction = ERROR_REJECT; /* Errant entries are rejected. */ 1122 1123 star_dataP = Pstar_dataP; /* Access data structures, including our */ 1124 star_optionsP = star_data.star_optionsP; /* handler data structure. */ 1125 sciP = star_options.ssu_sciP; 1126 hdP = star_options.handler_dataP; 1127 1128 if (hd.args.depth < star_data.entry_data.depth) then /* -depth control arg limits error msgs */ 1129 return; /* which get printed. */ 1130 1131 if star_data.entry_data.depth <= 1 then do; /* error occurred prior to calling */ 1132 if star_data.matched.current > 1 then /* hcs_$star_ to list subtree entries. */ 1133 call ioa_ (""); 1134 call ssu_$print_message (sciP, Pcode, "^[^a^s^;^s^a^]^[^/(^a)^]", 1135 Pent(1)="", Pdir, pathname_$component (Pdir, Pent(1), Pcomp), Pmessage^="", Pmessage); 1136 end; 1137 1138 else do; /* error occurred on a subtree entry. */ 1139 if hd.args.total_only then return; /* Don't report if -total_only given. */ 1140 hd.subtree.error = TRUE; /* Let HANDLER report where we are in */ 1141 if Pent(1) = "" then do; /* the subtree before reporting the */ 1142 if hd.last_ent.path ^= Pdir then do; /* error. The .error flag tells the */ 1143 call expand_pathname_ (Pdir, dir, ent(1),code);/* HANDLER not to put lengths in the */ 1144 star_data.depth = star_data.depth - 1; /* subtree location. */ 1145 call HANDLER (Pstar_dataP, dir, ent, "", action); 1146 star_data.depth = star_data.depth + 1; 1147 end; 1148 end; 1149 else if hd.last_ent.path ^= pathname_(Pdir, Pent(1)) then 1150 call HANDLER (Pstar_dataP, Pdir, Pent, Pcomp, action); 1151 hd.subtree.error = FALSE; 1152 1153 call convert_status_code_ (Pcode, short, long); /* Report error against subtree entry. */ 1154 call ioa_ ("^[^vt^;^s^]^[^vt^;^s^]^v( ^)^a^[^/^[^vt^;^s^]^[^vt^;^s^]^v( ^)(^a)^]", 1155 hd.args.type, length(typ)+1, hd.args.length, length(len)+1+bin(hd.args.type,1)*length(typ), 1156 star_data.depth-1, long, Pmessage^="", hd.args.type, length(typ)+1, 1157 hd.args.length, length(len)+1+bin(hd.args.type,1)*length(typ), star_data.depth-1, 1158 Pmessage); 1159 end; 1160 1161 hd.last_ent.depth = star_data.entry_data.depth; /* Avoid marking errant entries as */ 1162 hd.last_ent.type = ENTRY_TYPE_UNSET; /* . */ 1163 1164 end ERROR_ROUTINE; 1165 1166 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1167 1168 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1169 /* */ 1170 /* HANDLER: */ 1171 /* This is the fs_star_ handler routine. It is called to process each selected entry. */ 1172 /* 1) Access fs_star_ and handler data structures. */ 1173 /* 2) Don't print location info for entries below max hierarchy level given in -depth control arg. */ 1174 /* 3) Figure out entry pathname, type (as lst will report it), its entry length (in pages). */ 1175 /* 4) If -total_only was given, return without printing information about the entry. Only entry */ 1176 /* length has been accumulated in handler data structure. */ 1177 /* 5) If -match, -exclude or -slet was given, then HANDLER won't be called for every subtree level, */ 1178 /* but only entries which match these selection criteria. hd.args.selection will be TRUE in such */ 1179 /* cases. We must call HANDLER_depth to report missing levels before printing info about the */ 1180 /* selected entry. */ 1181 /* 6) Then call HANDLER_depth to report information about the selected entry. */ 1182 /* */ 1183 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1184 1185 dcl len char(5) auto; /* length of these vars is referenced */ 1186 dcl typ char(9) auto; /* in one place outside HANDLER> */ 1187 1188 HANDLER: 1189 procedure (Pstar_dataP, Pdir, Pent, Pcomp, Paction); 1190 1191 dcl Pstar_dataP ptr parm; /* ptr to star_data. (In) */ 1192 dcl Pdir char(*) parm; /* dir part of entry's pathname. (In) */ 1193 dcl Pent (*) char(32) parm; /* entry names on entry. (In) */ 1194 dcl Pcomp char(*) parm; /* archive component name. (In) */ 1195 dcl Paction fixed bin parm; /* entry action code. (Out) */ 1196 1197 dcl code fixed bin(35) auto; 1198 dcl (common_depthI, depthI, depthN) fixed bin auto; 1199 dcl dir char(168) auto; 1200 dcl ent (1) char(32) auto; 1201 dcl 1 last_ent aligned like auto_hd.last_ent auto; 1202 dcl typeX fixed bin auto; 1203 1204 Paction = HANDLER_OK; 1205 1206 star_optionsP = star_data.star_optionsP; 1207 hdP = star_options.handler_dataP; 1208 if (hd.args.depth < star_data.entry_data.depth) then do; 1209 Paction = HANDLER_REJECT; 1210 return; 1211 end; 1212 1213 do typeX = lbound(STANDARD_ENTRY_TYPES,1) to hbound(STANDARD_ENTRY_TYPES,1) 1214 while (star_data.entry_data.type ^= STANDARD_ENTRY_TYPES(typeX)); 1215 end; 1216 if typeX > hbound(STANDARD_ENTRY_TYPES,1) then do; 1217 if star_data.entry_data.type = ENTRY_TYPE_UNSET then 1218 typ = " ^set"; 1219 else if length(rtrim(star_data.entry_data.type)) <= length(typ)-1 then 1220 typ = copy(" ",max(length(typ)-1-length(rtrim(star_data.entry_data.type)),0)) || 1221 rtrim(star_data.entry_data.type); 1222 else 1223 typ = " ext"; 1224 end; 1225 else 1226 typ = PRINT_ENTRY_TYPES(typeX); 1227 1228 do typeX = lbound(hd.ext_ent.type,1) to hbound(hd.ext_ent.type,1) 1229 while (hd.ext_ent.type(typeX) ^= "" & hd.ext_ent.type(typeX) ^= star_data.entry_data.type); 1230 end; /* count occurrences of each type of */ 1231 if typeX <= hbound(hd.ext_ent.type,1) then do; /* extended entry. */ 1232 hd.ext_ent.type (typeX) = star_data.entry_data.type; 1233 hd.ext_ent.count(typeX) = hd.ext_ent.count(typeX) + 1; 1234 end; 1235 1236 last_ent = hd.last_ent; 1237 1238 hd.last_ent.depth = star_data.entry_data.depth; 1239 hd.last_ent.path = pathname_ (Pdir, Pent(1)); 1240 hd.last_ent.type = star_data.entry_data.type; 1241 hd.last_ent.uids(*) = ""b; 1242 1243 if hd.last_ent.type = ENTRY_TYPE_ARCHIVE_COMP then do; 1244 depthN = hd.last_ent.depth-1; 1245 dir = Pdir; 1246 ent = Pent(1); 1247 end; 1248 else if (hd.last_ent.type = ENTRY_TYPE_DIRECTORY) | 1249 (hd.last_ent.type = ENTRY_TYPE_MSF) | 1250 (hd.last_ent.type = ENTRY_TYPE_ARCHIVE) then do; 1251 depthN = hd.last_ent.depth; 1252 dir = Pdir; 1253 ent = Pent(1); 1254 end; 1255 else do; 1256 depthN = hd.last_ent.depth-1; 1257 call expand_pathname_ (Pdir, dir, ent(1), code); 1258 end; 1259 1260 common_depthI = 0; 1261 do depthI = depthN to 1 by -1; 1262 call hcs_$get_uid_file (dir, ent(1), hd.last_ent.uids(depthI), code); 1263 if code = error_table_$root then 1264 hd.last_ent.uids(depthI) = "777777777777"b3; 1265 if hd.last_ent.uids(depthI) = last_ent.uids(depthI) then do; 1266 common_depthI = depthI; 1267 do depthI = depthI-1 to 1 by -1; 1268 hd.last_ent.uids(depthI) = last_ent.uids(depthI); 1269 end; 1270 end; 1271 else 1272 call expand_pathname_ (dir, dir, ent(1), code); 1273 end; 1274 1275 if hd.args.length then /* If -length given, replace type with */ 1276 if hd.subtree.error then /* an entry length (in pages). */ 1277 len = ""; /* Don't report length if processing */ 1278 else /* subtree location for an error msg. */ 1279 len = ENTRY_length(typeX); 1280 else len = ""; 1281 if hd.args.total_only then return; /* For -total_only, don't print info */ 1282 /* about specific entries. */ 1283 1284 if ^hd.args.selection then /* We're called for EVERY subtree entry */ 1285 /* so don't have to worry about missing */ 1286 /* locations in the subtree. */ 1287 call HANDLER_depth (hd.last_ent.depth, typ, len, Pdir, Pent, Pcomp, last_ent); 1288 else if hd.last_ent.depth = 1 then /* This entry is at TOP of a subtree, */ 1289 call HANDLER_depth (1, typ, len, Pdir, Pent, Pcomp, /* so don't have to worry about missing */ 1290 last_ent); /* locations in the subtree. */ 1291 1292 else do; /* Call HANDLER_depth to report missing */ 1293 depthN = hd.last_ent.depth; /* (nonselected) subtree levels prior */ 1294 if Pcomp ^= "" then depthN = depthN - 1; /* to reporting selected entry HANDLER */ 1295 do depthI = common_depthI+1 to depthN-1; /* was called with. */ 1296 dir = pathname_ (dir, ent(1)); 1297 ent(1) = before (after (hd.last_ent.path, rtrim(dir)||">"), ">"); 1298 call HANDLER_depth (depthI, PRINT_ENTRY_TYPES(TYPE_DIRECTORY), "", dir, ent, "", last_ent); 1299 last_ent.depth = depthI; 1300 last_ent.type = ENTRY_TYPE_DIRECTORY; 1301 end; 1302 if (Pcomp ^= "") & (depthI < hd.last_ent.depth) then do; 1303 call HANDLER_depth (depthI, PRINT_ENTRY_TYPES(TYPE_ARCHIVE), "", Pdir, Pent, "", last_ent); 1304 last_ent.depth = depthI; 1305 last_ent.type = ENTRY_TYPE_ARCHIVE; 1306 end; 1307 call HANDLER_depth (star_data.entry_data.depth, typ, len, Pdir, Pent, Pcomp, last_ent); 1308 end; /* Report the selected entry. */ 1309 return; 1310 1311 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1312 1313 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1314 /* */ 1315 /* HANDLER_depth: */ 1316 /* Report information about a single entry in the subtree. Before reporting about the current */ 1317 /* entry, it figures out whether the prior (directory/archive) entry was empty and reports if it */ 1318 /* was. Most of the complexity comes from this Emptiness reporting. */ 1319 /* */ 1320 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1321 1322 HANDLER_depth: 1323 procedure (Pdepth, Ptyp, Plen, Pdir, Pent, Pcomp, Plast_ent); 1324 1325 dcl Pdepth fixed bin parm; /* depth below star_paths dir. (In) */ 1326 dcl Ptyp char(9) parm; /* printable type of entry. (In) */ 1327 dcl Plen char(5) parm; /* printable length of entry. (In) */ 1328 dcl Pdir char(*) parm; /* dir part of entry's pathname. (In) */ 1329 dcl Pent (*) char(32) parm; /* entry names on entry. (In) */ 1330 dcl Pcomp char(*) parm; /* archive component name. (In) */ 1331 dcl 1 Plast_ent aligned like last_ent; 1332 /* info about prior entry. (In) */ 1333 1334 dcl (STARTING init(1), 1335 NEW_SUBTREE init(2), 1336 DOWN_DIR init(3), 1337 ANOTHER_ENTRY init(4), 1338 UP_DIR init(5), 1339 NEW_ARCHIVE init(6), 1340 ANOTHER_COMP init(7) 1341 ) fixed bin int static options(constant); 1342 1343 if Pdepth <= 1 then 1344 if star_data.matched.current <= 1 then 1345 go to PROCESS (STARTING); /* Begin the first subtree. */ 1346 else 1347 go to PROCESS (NEW_SUBTREE); /* Begin another subtree. */ 1348 1349 else if Pdepth < Plast_ent.depth then 1350 go to PROCESS (UP_DIR); /* End reporting on a subdir. */ 1351 1352 else if (Pdepth > Plast_ent.depth) then 1353 if (Pcomp = "") then 1354 go to PROCESS (DOWN_DIR); /* Begin reporting on a subdir. */ 1355 else 1356 go to PROCESS (NEW_ARCHIVE); /* Begin reporting on archive components.*/ 1357 1358 else if Pcomp = "" then 1359 go to PROCESS (ANOTHER_ENTRY); /* Process another subdir entry. */ 1360 else 1361 go to PROCESS (ANOTHER_COMP); 1362 1363 1364 PROCESS (NEW_SUBTREE): /* If prior entry was a dir, and it is */ 1365 if (Plast_ent.type = ENTRY_TYPE_DIRECTORY | /* empty, say that. Same for archives */ 1366 ((Plast_ent.type = ENTRY_TYPE_ARCHIVE) & hd.args.archive)) & (hd.args.depth>Pdepth) & 1367 ^hd.args.selection then /* if we are searching them. */ 1368 call ioa_ ("^[^vt^;^s^]^[^vt^;^s^]^v( ^)^[ NEW_SUBTREE^]", 1369 hd.args.type, length(typ)+1, hd.args.length, length(len)+1+bin(hd.args.type,1)*length(typ), 1370 Plast_ent.depth, hd.args.debug); 1371 call ioa_ (""); 1372 1373 PROCESS (STARTING): 1374 call ioa_ ("^[^a^vt^;^2s^]^[^a^vt^;^2s^]^a", hd.args.type, Ptyp, length(typ)+1, 1375 hd.args.length, Plen, length(len)+1+bin(hd.args.type,1)*length(typ), 1376 NAMES_output (Pdepth, pathname_ (Pdir,Pent(1)))); 1377 return; 1378 1379 PROCESS (UP_DIR): 1380 PROCESS (ANOTHER_ENTRY): /* If prior entry was a dir, and it is */ 1381 if (Plast_ent.type = ENTRY_TYPE_DIRECTORY | /* empty, say that. Same for archives */ 1382 /* if we are searching them. */ 1383 ((Plast_ent.type = ENTRY_TYPE_ARCHIVE) & hd.args.archive)) & (hd.args.depth>Pdepth) & 1384 ^hd.args.selection then 1385 call ioa_ ("^[^vt^;^s^]^[^vt^;^s^]^v( ^)^[ ANOTHER_ENTRY^]", 1386 hd.args.type, length(typ)+1, hd.args.length, length(len)+1+bin(hd.args.type,1)*length(typ), 1387 Pdepth, hd.args.debug); 1388 1389 PROCESS (DOWN_DIR): 1390 call ioa_ ("^[^a^vt^;^2s^]^[^a^vt^;^2s^]^v( ^)^a", hd.args.type, Ptyp, length(typ)+1, 1391 hd.args.length, Plen, length(len)+1+bin(hd.args.type,1)*length(typ), Pdepth-1, 1392 NAMES_output(Pdepth, Pent(1))); 1393 return; 1394 1395 PROCESS (NEW_ARCHIVE): 1396 PROCESS (ANOTHER_COMP): 1397 call ioa_ ("^[^a^vt^;^2s^]^[^a^vt^;^2s^]^v( ^)^a", hd.args.type, Ptyp, length(typ)+1, 1398 hd.args.length, Plen, length(len)+1+bin(hd.args.type,1)*length(typ), Pdepth-1, Pcomp); 1399 return; 1400 1401 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1402 1403 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1404 /* */ 1405 /* NAMES_output: */ 1406 /* 1) When -names was given, return a string containing the first name on an entry (or starting path */ 1407 /* of a subtree), followed by comma-separated list of the other names. */ 1408 /* 2) When -no_names was given, just return the first name (subtree path). */ 1409 /* */ 1410 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1411 1412 NAMES_output: 1413 procedure (Pdepth, first_name) returns (char(1000) varying); 1414 1415 dcl Pdepth fixed bin parm; /* depth below star_paths dir. (In) */ 1416 dcl first_name char(*) parm; 1417 1418 dcl indentL fixed bin auto; 1419 dcl lineL fixed bin auto; 1420 dcl name char(32) varying auto; 1421 dcl names char(1000) varying auto; 1422 dcl nameX fixed bin auto; 1423 1424 dcl NL char(1) int static options(constant) init(" 1425 "); 1426 1427 names = rtrim(first_name); 1428 if ^hd.args.names then return(names); 1429 1430 indentL = min(100, (length(Ptyp) * bin(hd.args.type,1)) + (length(Plen) * bin(hd.args.length,1)) 1431 + (3 * (Pdepth-1)) + length(" ")); /* multiple names are put as many as */ 1432 lineL = indentL + length(names); /* will fit on a terminal line. */ 1433 do nameX = 2 to hbound(Pent,1); /* Subsequent lines are indented at */ 1434 name = rtrim(Pent(nameX)); /* subtree level + 1. */ 1435 if length(name) + length(", ") + lineL > max_lineL then do; 1436 names = names || ","; 1437 names = names || NL; 1438 names = names || substr(SPACES,1,indentL); 1439 lineL = indentL; 1440 end; 1441 else 1442 names = names || ", "; 1443 names = names || name; 1444 lineL = lineL + length(name) + length(", "); 1445 end; 1446 return (names); 1447 1448 end NAMES_output; 1449 1450 end HANDLER_depth; 1451 1452 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1453 1454 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1455 /* */ 1456 /* ENTRY_length: */ 1457 /* 1) Call hcs_$status_ to get length (in pages) of a particular entry. This cannot get the length */ 1458 /* of inner ring entries (eg, .mbx or .ms segments), so 0 is returned for such entries. */ 1459 /* 2) Also accumulate length of all entries in handler data structure. */ 1460 /* */ 1461 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1462 1463 ENTRY_length: 1464 procedure (PtypeX) returns(char(4)); 1465 1466 dcl PtypeX fixed bin parm; 1467 1468 dcl code fixed bin(35) auto; 1469 dcl digits pic"zzz9" auto; 1470 dcl pages fixed bin(35) auto; 1471 dcl (quota, quota_used) fixed bin(18) auto; 1472 dcl NO_CHASE fixed bin(1) int static options(constant) init(0); 1473 1474 if star_data.entry_data.type = ENTRY_TYPE_LINK | 1475 star_data.entry_data.type = ENTRY_TYPE_ARCHIVE_COMP | 1476 star_data.entry_data.type = ENTRY_TYPE_UNKNOWN | 1477 star_data.entry_data.type = ENTRY_TYPE_UNSET then 1478 return (""); 1479 call hcs_$status_ (Pdir, Pent(1), NO_CHASE, addr(status), null, code); 1480 if (code ^= 0) & (code ^= error_table_$no_s_permission) then 1481 return(""); 1482 pages = status.records_used; 1483 if star_data.entry_data.type = "forum" then do; 1484 call hcs_$quota_read (pathname_ (Pdir, Pent(1)), quota, 0, ""b, ""b, 0, quota_used, code); 1485 if code = 0 then 1486 pages = pages + quota_used; 1487 end; 1488 hd.subtree.lengths = hd.subtree.lengths + pages; 1489 hd.ext_ent.lengths(PtypeX) = hd.ext_ent.lengths(PtypeX) + pages; 1490 digits = pages; 1491 return (digits); 1492 1493 end ENTRY_length; 1494 1495 end HANDLER; 1496 1497 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1498 1499 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1500 /* */ 1501 /* TOTAL_print: */ 1502 /* Adds totals information about particular entry types to the pending output lines. If the lines */ 1503 /* overflow terminal line length, they are printed and new lines are started. */ 1504 /* */ 1505 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1506 1507 dcl (line1, line2, line3) char(160) varying auto; 1508 1509 TOTAL_print: 1510 procedure (Pprefix1, Pprefix2, Pprefix3, Ptype, Pcount, Plength); 1511 1512 dcl (Pprefix1, Pprefix2, Pprefix3) char(*) parm; 1513 dcl Ptype char(*) parm; 1514 dcl Pcount fixed bin parm; 1515 dcl Plength fixed bin(35) parm; 1516 1517 dcl 1 field aligned auto, 1518 2 (type, count, length) char(32) varying, 1519 2 L fixed bin, 1520 2 (typeI, countI, lengthI) fixed bin; 1521 1522 dcl length builtin; 1523 1524 if Pcount <= 0 then return; 1525 1526 field.type = rtrim (Ptype); /* get length of field label and value. */ 1527 field.count = ltrim (char(Pcount)); /* center label/value with entire field. */ 1528 field.length = ltrim (char(Plength), " 0"); 1529 if length(field.count) < length(field.length) then 1530 field.count = substr(SPACES, 1, length(field.length)-length(field.count)) || field.count; 1531 else if length(field.count) > length(field.length) then 1532 field.length = substr(SPACES, 1, length(field.count)-length(field.length)) || field.length; 1533 if hd.args.length then 1534 field.L = max (length(field.type), length(field.count), length(field.length)); 1535 else 1536 field.L = max (length(field.type), length(field.count)); 1537 field.typeI = divide (field.L-length(field.type)+1, 2, 17, 0); 1538 field.countI = divide (field.L-length(field.count)+1, 2, 17, 0); 1539 field.lengthI = divide (field.L-length(field.length)+1, 2, 17, 0); 1540 1541 if (index(line2, Pprefix2) = 0) & (length(Pprefix2) > 0) then do; 1542 if length(line2) + field.L + length((4)" ") + length(Pprefix2) > max_lineL then 1543 call TOTAL_print_end (Pprefix1, Pprefix2, Pprefix3); 1544 else do; /* Put EXTENDED ENTRIES id in current */ 1545 line1 = line1 || (4)" "; /* output lines, if not already there. */ 1546 line2 = line2 || (4)" "; 1547 line3 = line3 || (4)" "; 1548 line1 = line1 || Pprefix1; 1549 line2 = line2 || Pprefix2; 1550 line3 = line3 || Pprefix3; 1551 end; 1552 end; 1553 else if length(line1) + field.L + length((2)" ") > max_lineL then 1554 call TOTAL_print_end (Pprefix1, Pprefix2, Pprefix3); /* Emit output lines if they are about */ 1555 /* to overflow. */ 1556 1557 if length(line1) > 0 then do; /* Put label and value into output lines.*/ 1558 line1 = line1 || (2)" "; 1559 line2 = line2 || (2)" "; 1560 line3 = line3 || (2)" "; 1561 end; 1562 line1 = line1 || substr(SPACES,1,field.typeI); 1563 line2 = line2 || substr(SPACES,1,field.countI); 1564 line3 = line3 || substr(SPACES,1,field.lengthI); 1565 line1 = line1 || field.type; 1566 line2 = line2 || field.count; 1567 line3 = line3 || field.length; 1568 line1 = line1 || substr(SPACES,1,field.L - field.typeI - length(field.type)); 1569 line2 = line2 || substr(SPACES,1,field.L - field.countI - length(field.count)); 1570 line3 = line3 || substr(SPACES,1,field.L - field.lengthI - length(field.length)); 1571 1572 end TOTAL_print; 1573 1574 1575 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1576 /* */ 1577 /* TOTAL_print_end: */ 1578 /* Print current output lines. Put prefix on a new set of output lines. */ 1579 /* */ 1580 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1581 1582 TOTAL_print_end: 1583 procedure (Pprefix1, Pprefix2, Pprefix3); 1584 1585 dcl (Pprefix1, Pprefix2, Pprefix3) char(*) parm; 1586 1587 if length(line2) > length(Pprefix2) then 1588 call ioa_ ("^a^/^a^/^[^a^/^]", line1, line2, 1589 hd.args.length & (sum(hd.ext_ent.lengths)>0), line3); 1590 1591 1592 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1593 /* */ 1594 /* TOTAL_print_init: */ 1595 /* Put prefix on a new set of output lines. */ 1596 /* */ 1597 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1598 1599 TOTAL_print_init: 1600 entry (Pprefix1, Pprefix2, Pprefix3); 1601 1602 line1 = Pprefix1; 1603 line2 = Pprefix2; 1604 line3 = Pprefix3; 1605 return; 1606 1607 end TOTAL_print_end; 1608 1609 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1610 1 1 /* BEGIN: fs_star_.incl.pl1 * * * * * * * * * * * * */ 1 2 1 3 /****^ HISTORY COMMENTS: 1 4* 1) change(88-07-15,GDixon), approve(88-09-20,MCR7987), 1 5* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 1 6* Initial version corresponding to MTB781-00. 1 7* 2) change(88-08-25,GDixon), approve(88-09-20,MCR7987), 1 8* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 1 9* Modifications corresponding to MTB781-01 correcting minor problems 1 10* found during the review of the earlier MTB. 1 11* 3) change(88-09-19,GDixon), approve(88-09-20,MCR8007), 1 12* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 1 13* Final changes reflecting MTB781-02. This is the MR12.2 version. 1 14* END HISTORY COMMENTS */ 1 15 1 16 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 17 /* */ 1 18 /* This include file declares structures and named constants used when calling the fs_star_ */ 1 19 /* subroutine. */ 1 20 /* */ 1 21 /* star_options: */ 1 22 /* defines star matching, selection and sorting criteria. */ 1 23 /* */ 1 24 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 25 1 26 dcl 1 star_options aligned based (star_optionsP), 1 27 2 version char(8), /* = STAR_OPTIONS_VERSION_1 */ 1 28 1 29 2 caller, 1 30 3 ssu_sciP ptr, /* subsystem sci_ptr, used to get */ 1 31 /* areas & temp segs, report errors. */ 1 32 /* null => use other elements as below */ 1 33 3 fs_star_dataP ptr, /* ptr to fs_star_ internal data. */ 1 34 1 35 2 selection, 1 36 3 star_pathsP ptr, /* ptr to input pathname array. */ 1 37 /* Starred paths select starting ents. */ 1 38 3 path_allow bit(36) aligned, /* type of paths allowed in star_paths */ 1 39 /* See PATH_ALLOW_xxx constants below. */ 1 40 3 entry_type, /* selection/expansion of standard */ 1 41 4 ( /* entry types. See ENTRY_xxx */ 1 42 links, /* constants below. */ 1 43 segs, 1 44 dirs, 1 45 msfs, 1 46 msf_comps, 1 47 dm_files, 1 48 archives, 1 49 arch_comps, 1 50 extended_entries) bit(36) aligned, 1 51 3 extended_entry_typesP ptr, /* ptr to entry type selection array. */ 1 52 /* ^=null => only paths matching one */ 1 53 /* extended entry type are */ 1 54 /* selected. */ 1 55 3 match_namesP ptr, /* ptr to added starname match array. */ 1 56 /* ^=null => only paths matching one */ 1 57 /* or more matchnames are */ 1 58 /* selected. */ 1 59 3 exclude_namesP ptr, /* ptr to starname exclusion array. */ 1 60 /* ^=null => selected paths matching */ 1 61 /* one or more excludenames */ 1 62 /* are de-selected. */ 1 63 1 64 2 per_entry, /* For each selected entry: */ 1 65 3 sorting (6), /* major/minor sort keys, by locator */ 1 66 4 ( /* within selected subtree. */ 1 67 dirs, /* Sorting of dirs in selected subtree */ 1 68 dir_ents, /* Sorting of ents in selected dirs. */ 1 69 comps) fixed bin, /* Sorting of archive and msf */ 1 70 /* components in selected ents. */ 1 71 /* Lower-numbered array elements are */ 1 72 /* major keys. See SORT_xxx */ 1 73 /* constants below. */ 1 74 3 handler /* call this proc to handle entry. */ 1 75 entry (ptr, char(*), (*)char(32), char(*), fixed bin), 1 76 /* call handler (star_dataP, dir, ent_names, comp_name, action); */ 1 77 3 error /* call this proc if error occurs. */ 1 78 entry (ptr, char(*), (*)char(32), char(*), 1 79 fixed bin(35), char(*), fixed bin), 1 80 /* call error (star_dataP, dir, ent_names, comp_name, */ 1 81 /* code, message, action); */ 1 82 /* =ssu_$null_entry => */ 1 83 /* use ssu_$print_error */ 1 84 3 handler_dataP ptr, /* ptr to caller-provided data passed */ 1 85 /* on to .handler and .error. */ 1 86 3 data_desired fixed bin, /* type of info to pass to .handler */ 1 87 /* for each selected entry. See */ 1 88 /* DATA_xxx constants below. */ 1 89 3 data_version char(8) unal, /* Version of star_data structure */ 1 90 /* that .handler expects to receive. */ 1 91 /* Only STAR_DATA_VERSION_1 allowed. */ 1 92 2 mbz bit(36) aligned, /* Reserved for future use. */ 1 93 star_optionsP ptr; /* ptr to star_options structure. */ 1 94 1 95 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 96 /* */ 1 97 /* Named Constant for star_options.version: */ 1 98 /* version of star_options the caller is prepared to deal with. */ 1 99 /* */ 1 100 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 101 1 102 dcl STAR_OPTIONS_VERSION_1 init("STAROPT1") char(8) int static options(constant); 1 103 1 104 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 105 /* */ 1 106 /* star_paths: */ 1 107 /* array of directory entry pathnames (or archive component pathnames) which does initial */ 1 108 /* pathname selection, based upon starnames in dir part (dir>**>ent), final entryname (dir>**), */ 1 109 /* and/or archive component part (dir>ent.archive::**) of pathname. These starnames select the */ 1 110 /* initial set of entries to which further selection criteria are applied. */ 1 111 /* star_options.path_allow setting controls which type of pathname (dir entry or archive */ 1 112 /* component) is allowed, and which parts may contain stars. */ 1 113 /* */ 1 114 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 115 1 116 dcl 1 star_paths aligned based (star_options.star_pathsP), 1 117 2 version char(8), /* = STAR_PATHS_VERSION_1 */ 1 118 2 max_count fixed bin, /* maximum size of value array for the */ 1 119 /* current allocation of star_paths. */ 1 120 2 count fixed bin, /* current size of value array. */ 1 121 2 value (star_paths_size refer (star_paths.max_count)) char(202) unal, 1 122 /* dir>**>ent>**::** */ 1 123 star_paths_size fixed bin auto, 1 124 STAR_PATHS_VERSION_1 init("STARPTH1") char(8) int static options(constant); 1 125 1 126 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 127 /* */ 1 128 /* Named Constants for star_options.path_allow: */ 1 129 /* select the types of pathnames are allowed, and which pathname components may contain stars. */ 1 130 /* */ 1 131 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 132 1 133 dcl (PATH_ALLOW_DIR_STAR_NAMES init("1"b), /* dir>**>ent */ 1 134 PATH_ALLOW_ENTRY_STAR_NAMES init("01"b), /* dir>** */ 1 135 PATH_ALLOW_ARCHIVE_COMPONENTS init("001"b), /* dir>ent::comp */ 1 136 PATH_ALLOW_ARCHIVE_STAR_NAMES init("0001"b), /* dir>ent::** */ 1 137 PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES init("0011"b), /* dir>ent::** or dir>ent::comp */ 1 138 PATH_ALLOW_NONDIR_STAR_NAMES init("0111"b), /* dir>**::** */ 1 139 PATH_ALLOW_BRANCH_STAR_NAMES init("1100"b), /* dir>**>** */ 1 140 PATH_ALLOW_ALL_STAR_NAMES init("1111"b)) /* dir>**>**::** */ 1 141 bit(36) aligned int static options(constant); 1 142 1 143 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 144 /* */ 1 145 /* Named Constants for star_options.selection.entry_type: */ 1 146 /* for entries matching the starname, selection by entry type, control expansion, etc. */ 1 147 /* One named constant from each group may be ORed together to form a value to be assigned to */ 1 148 /* each star_options.entry_type.XXX value (eg, star_options.entry_type.segs). */ 1 149 /* */ 1 150 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 151 1 152 dcl (ENTRY_DONT_RETURN init("1"b), /* Don't return entries of this type. */ 1 153 ENTRY_RETURN init("0"b), /* Return entries of this type. */ 1 154 1 155 ENTRY_LIST_SUBENTRIES init("01"b), /* List components of matching ents. */ 1 156 ENTRY_DONT_LIST_SUBENTRIES init("00"b), /* Don't list components of match ents. */ 1 157 /* Applies to: dirs, archives, msfs */ 1 158 1 159 ENTRY_INAEE init("001"b), /* Interpret as extended ent (-inaee). */ 1 160 ENTRY_INASE init("000"b), /* Interpret as standard ent (-inase). */ 1 161 /* Applies to: segs, dirs, msfs, & */ 1 162 /* dm_files. */ 1 163 1 164 ENTRY_DONT_SELECT_NULL init("0001"b), /* Select only nonnull entries. */ 1 165 ENTRY_DONT_SELECT_NONNULL init("00001"b), /* Select only null entries. */ 1 166 ENTRY_SELECT_NULL_NONNULL init("00000"b), /* Select both null and nonnull entries.*/ 1 167 /* Applies to: links, segs, msfs, */ 1 168 /* msf_comps, archives, arch_comps */ 1 169 1 170 ENTRY_CHASE_NONSTAR_LINKS init("000001"b), /* Chase links only if link was not */ 1 171 /* selected by a starname. */ 1 172 ENTRY_CHASE_ALL_LINKS init("0000001"b), /* Chase all links. (-chase) */ 1 173 ENTRY_DONT_CHASE_LINKS init("0000000"b), /* Don't chase links. (-no_chase) */ 1 174 /* Applies to: links */ 1 175 1 176 ENTRY_DONT_SELECT_OBJECTS init("00000001"b), /* Select only nonobject files. */ 1 177 ENTRY_DONT_SELECT_NONOBJECTS init("000000001"b), /* Select only object files. */ 1 178 ENTRY_SELECT_ALL_FILES init("000000000"b), /* Select both objects and nonobjects. */ 1 179 /* Applies to: segs, msfs, arch_comps */ 1 180 1 181 ENTRY_DONT_SELECT_MDIRS init("0000000001"b), /* Select only nonmaster dirs. */ 1 182 ENTRY_DONT_SELECT_NON_MDIRS init("00000000001"b),/* Select only master dirs. */ 1 183 ENTRY_SELECT_ALL_DIRS init("00000000000"b))/* Select both masters and nonmasters. */ 1 184 /* Applies to: dirs */ 1 185 bit(36) aligned int static options(constant); 1 186 1 187 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 188 /* */ 1 189 /* extended_entry_types: */ 1 190 /* array of extended entry types applied to entries selected from the star_paths array. If an */ 1 191 /* entry matches any of the given extended types, that entry is included for further selection. */ 1 192 /* */ 1 193 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 194 1 195 dcl 1 extended_entry_types aligned based (star_options.extended_entry_typesP), 1 196 2 version char(8), /* = STAR_EXTENDED_ENTRY_VERSION_1 */ 1 197 2 max_count fixed bin, /* maximum size of value array for the */ 1 198 /* current allocation of */ 1 199 /* extended_entry_types. */ 1 200 2 count fixed bin, /* current size of value array. */ 1 201 2 value (extended_entry_types_size refer (extended_entry_types.max_count)) char(32) unal, 1 202 /* -slet EXTENDED_TYPE */ 1 203 extended_entry_types_size fixed bin auto, 1 204 STAR_EXTENDED_ENTRY_VERSION_1 init("STARETP1") char(8) int static options(constant); 1 205 1 206 1 207 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 208 /* */ 1 209 /* match_names: */ 1 210 /* array of additional starnames which are applied to entries selected from the star_paths */ 1 211 /* and extended_entry_types arrays. If any name on an entry matches any match_name, that entry */ 1 212 /* is included for further selection. */ 1 213 /* */ 1 214 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 215 1 216 dcl 1 match_names aligned based (star_options.match_namesP), 1 217 2 version char(8), /* = STAR_MATCH_NAMES_VERSION_1 */ 1 218 2 max_count fixed bin, /* maximum size of value array for the */ 1 219 /* current allocation of match_names. */ 1 220 2 count fixed bin, /* current size of value array. */ 1 221 2 value (match_names_size refer (match_names.max_count)) char(32) unal, 1 222 /* -match ** */ 1 223 match_names_size fixed bin auto, 1 224 STAR_MATCH_NAMES_VERSION_1 init("STARMNM1") char(8) int static options(constant); 1 225 1 226 1 227 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 228 /* */ 1 229 /* exclude_names: */ 1 230 /* array of starnames which are applied to entries selected from star_paths, */ 1 231 /* extended_entry_types and match_names arrays. If any name on an entry matches an exclude */ 1 232 /* name, that entry is excluded from further selection. */ 1 233 /* */ 1 234 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 235 1 236 dcl 1 exclude_names aligned based (star_options.exclude_namesP), 1 237 2 version char(8), /* = STAR_EXCLUDE_NAMES_VERSION_1 */ 1 238 2 max_count fixed bin, /* maximum size of value array for the */ 1 239 /* current allocation of exclude_names */ 1 240 2 count fixed bin, /* current size of value array. */ 1 241 2 value (exclude_names_size refer (exclude_names.max_count)) char(32) unal, 1 242 /* -exclude ** */ 1 243 exclude_names_size fixed bin auto, 1 244 STAR_EXCLUDE_NAMES_VERSION_1 init("STARENM1") char(8) int static options(constant); 1 245 1 246 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 247 /* */ 1 248 /* Named Constants for star_options.handler: */ 1 249 /* handler procedure's action parameter to control the further progress of searching. */ 1 250 /* */ 1 251 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 252 1 253 dcl (HANDLER_OK init (0), /* no error when handling entry. */ 1 254 HANDLER_REJECT init (1), /* no error, but handler does not */ 1 255 /* accept entry; it should not be */ 1 256 /* counted, expanded, etc. */ 1 257 HANDLER_DONT_EXPAND init (2), /* no error, but handler does not want */ 1 258 /* dir/archive entry expanded. */ 1 259 HANDLER_EXPAND init (3), /* no error, but expand dir/archive */ 1 260 /* even if contrary to .entry_type. */ 1 261 HANDLER_EXPAND_DONT_COUNT init (4), /* no error, but handler does not accept */ 1 262 /* entry; it should not be counted, but */ 1 263 /* should be expanded. */ 1 264 HANDLER_DONT_COUNT init (5), /* no error, but handler does not accept */ 1 265 /* entry; it should not be counted. Its */ 1 266 /* expansion depends upon .entry_type */ 1 267 /* setting for this type of entry. */ 1 268 HANDLER_STOP init (6), /* no error, but the selection process */ 1 269 /* process terminates immediately. */ 1 270 /* Entry should be counted, then */ 1 271 /* fs_star_$select returns to caller. */ 1 272 HANDLER_ABORT init (7) /* error, entry not counted, selection */ 1 273 /* process terminates immediately, */ 1 274 /* handler reports any error, then */ 1 275 /* fs_star_$select returns to caller. */ 1 276 ) fixed bin internal static options(constant); 1 277 1 278 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 279 /* */ 1 280 /* Named Constants for star_options.error: */ 1 281 /* error procedure's action parameter. */ 1 282 /* */ 1 283 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 284 1 285 dcl (ERROR_OK init (0), /* error was processed successfully. */ 1 286 /* Entry causing error should be */ 1 287 /* counted as a match, but should not */ 1 288 /* be passed to handler for processing */ 1 289 /* nor expanded. */ 1 290 ERROR_REJECT init (1), /* error was processed successfully. */ 1 291 /* Entry causing error was rejected, */ 1 292 /* should not be counted as a match, */ 1 293 /* expanded, nor passed to handler. */ 1 294 ERROR_STOP init (6), /* error was processed successfully, */ 1 295 /* but error routine wants to stop the */ 1 296 /* selection process immediately. */ 1 297 /* Entry should be counted as a match, */ 1 298 /* but not expanded nor passed to the */ 1 299 /* handler routine for processing. */ 1 300 ERROR_ABORT init (7) /* error processing was unsuccessful. */ 1 301 /* Error routine wants to stop the */ 1 302 /* selection process immediately. */ 1 303 /* Entry should not be counted as a */ 1 304 /* match, expanded, nor passed to the */ 1 305 /* handler routine. */ 1 306 ) fixed bin internal static options(constant); 1 307 1 308 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 309 /* */ 1 310 /* Named Constants for star_options.sorting: */ 1 311 /* */ 1 312 /* fs_star_ can sort the selected entries before they are passed to the caller-provided handler */ 1 313 /* routine. Sorting of selected entries can be based upon three categories of sorting: */ 1 314 /* - the attributes of selected archive or MSF components (the component's name or its position */ 1 315 /* within the archive/msf); or */ 1 316 /* - the attributes of the selected directory entry (matching entryname, entry type or position */ 1 317 /* within the directory); or */ 1 318 /* - the selected entry's location within the selected subtree, or the matching entrynames in the */ 1 319 /* directory part of the pathname of a selected entry. */ 1 320 /* */ 1 321 /* To provide flexibility, any of the sorting categories above can be used singly, or in */ 1 322 /* combination. If used in combination, component sorting occurs before entry sorting, which occurs */ 1 323 /* before directory pathname sorting. Within a given category, several sorting operations are */ 1 324 /* possible. These include: */ 1 325 /* - sorting by name; */ 1 326 /* - sorting by (standard or extended) entry type; */ 1 327 /* - sorting of children entries with respect to their parent; */ 1 328 /* - sorting in ascending or descending sequence (forward or reverse); or */ 1 329 /* - sorting can be disabled for the category. */ 1 330 /* */ 1 331 /* Within a sort category, each sorting operation can be used singly, or in combinations of one to*/ 1 332 /* four sort operations in a caller-defined order. Order sort operations are specified by filling in*/ 1 333 /* the elements of the star_options.sorting arrays. For example: */ 1 334 /* star_options.selection.entry_type = ENTRY_RETURN; */ 1 335 /* star_options.sorting(*) = SORT_OFF; */ 1 336 /* star_options.sorting(1) = SORT_FORWARD; */ 1 337 /* star_options.sorting(1).comps = SORT_BY_NAME; */ 1 338 /* passes all directories and directory entries in the selected subtree to the handler routine in the*/ 1 339 /* order they were returned by hcs_$star_. Selected components of archives and MSFs are passed to */ 1 340 /* the handler routine, sorted by component name. */ 1 341 /* star_options.selection.entry_type = ENTRY_RETURN; */ 1 342 /* star_options.sorting(*) = SORT_OFF; */ 1 343 /* star_options.sorting(1) = SORT_FORWARD; */ 1 344 /* star_options.sorting(1).comps = SORT_REVERSE; */ 1 345 /* star_options.sorting(2).comps = SORT_BY_NAME; */ 1 346 /* passes the components to the handler sorted by component name, in reverse ASCII collating */ 1 347 /* sequence. */ 1 348 /* star_options.selection.entry_type = ENTRY_DONT_RETURN; */ 1 349 /* star_options.selection.entry_type.dirs = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; */ 1 350 /* star_options.selection.entry_type.archives = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; */ 1 351 /* star_options.selection.entry_type.arch_comps = ENTRY_RETURN; */ 1 352 /* star_options.sorting(*) = SORT_OFF; */ 1 353 /* star_options.sorting(1).comps = SORT_BY_NAME; */ 1 354 /* passes the archive components to the handler sorted by component name, irrespective of the archive*/ 1 355 /* the component resides in. That is, components in all archives selected from the subtree are found*/ 1 356 /* and sorted by name, and then passed to the handler in that order. */ 1 357 /* */ 1 358 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 359 1 360 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 361 /* */ 1 362 /* star_options.selection.entry_type = ENTRY_RETURN; */ 1 363 /* star_options.selection.entry_type.dirs = ENTRY_LIST_SUBENTRIES; */ 1 364 /* star_options.selection.entry_type.arch_comps = ENTRY_DONT_RETURN; */ 1 365 /* star_options.selection.entry_type.msf_comps = ENTRY_DONT_RETURN; */ 1 366 /* star_options.sorting(*) = SORT_OFF; */ 1 367 /* star_options.sorting(1).dirs = SORT_BY_NAME; */ 1 368 /* star_options.sorting(1).dir_ents = SORT_BY_STANDARD_TYPE */ 1 369 /* star_options.sorting(2).dir_ents = SORT_BY_NAME; */ 1 370 /* star_options.sorting(3).dir_ents = SORT_ENTRIES_BEFORE_SUBENTRIES; */ 1 371 /* passes selected entries to the handler routine sorted by directory, and within a directory sorted */ 1 372 /* by matching entryname within entry type groupings. For entries in a single directory, this is the*/ 1 373 /* type of grouping and sorting performed by the command: */ 1 374 /* list -sort name -all */ 1 375 /* */ 1 376 /* Sorting is based upon the location of the item within the selected subtree. If sorting by */ 1 377 /* dirs(*) is SORT_OFF, then the entire subtree must be selected and sorted before any data can be */ 1 378 /* passed to the handler. If sorting by dirs(*) is not SORT_OFF, then the contents of each dir is */ 1 379 /* sorted and passed to handler before processing subdirs. This provides more immediate response. */ 1 380 /* */ 1 381 /* Elements of the star_data.matched minor structure below are counts of the total entries found, */ 1 382 /* divided by entry type. If sorting.dirs(*) is SORT_OFF, then these counts represent the total of */ 1 383 /* all entries selected within the entire subtree. Otherwise, they represent only the entries */ 1 384 /* selected and sorted within the current node of the subtree and all previously handled nodes. */ 1 385 /* */ 1 386 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 387 1 388 dcl (SORT_OFF init(0), /* Don't sort by this subtree locator. */ 1 389 SORT_FORWARD init(1), /* Sort entries in order returned by */ 1 390 /* hcs_$star_ or archive_ subrs. */ 1 391 SORT_REVERSE init(2), /* Reverse ordering specified by */ 1 392 /* sort_sel elements with higher */ 1 393 /* index values. */ 1 394 SORT_BY_NAME init(3), /* Sort by primary matching ent name. */ 1 395 SORT_BY_STANDARD_ENTRY_TYPE init(4), /* Sort by standard entry type. */ 1 396 SORT_BY_EXTENDED_ENTRY_TYPE init(5), /* Sort by extended entry type. */ 1 397 SORT_ENTRIES_BEFORE_SUBENTRIES init(6)) /* Sort all entries in a directory before*/ 1 398 /* looking for any subentries. By */ 1 399 /* default, subentries below an entry */ 1 400 /* are expanded immediately after the */ 1 401 /* entry is encountered in the sorted */ 1 402 /* sequence of directory entries. */ 1 403 fixed bin int static options(constant); 1 404 1 405 1 406 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 407 /* */ 1 408 /* Named Constants for star_options.data_desired: */ 1 409 /* values control the amount of data returned to caller's entry handler routine in */ 1 410 /* star_data.entry_data. */ 1 411 /* */ 1 412 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 413 1 414 dcl (DATA_TYPE init (1), /* Entry type, only. */ 1 415 DATA_INITIATE init (2)) /* Entry type, length and count */ 1 416 fixed bin int static options(constant); 1 417 1 418 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 419 /* */ 1 420 /* Named constant for star_options.data_version: */ 1 421 /* caller-specified version of star_data he is willing to accept. */ 1 422 /* */ 1 423 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 424 1 425 dcl STAR_DATA_VERSION_1 init ("STARDAT1") char(8) int static options(constant); 1 426 /* star_data version 1 structure. */ 1 427 1 428 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 429 /* */ 1 430 /* star_data: */ 1 431 /* information provided to caller-supplied entry handler routine for each selected entry. */ 1 432 /* */ 1 433 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 434 1 435 dcl 1 star_data aligned based (star_dataP), 1 436 2 version char(8), /* = STAR_DATA_VERSION_1 */ 1 437 2 star_optionsP ptr, /* ptr to caller-supplied star_options */ 1 438 /* structure. This makes */ 1 439 /* star_options.handler_dataP */ 1 440 /* available to the handler routine. */ 1 441 2 matched, /* count of matching entries: */ 1 442 3 ( 1 443 current, /* index of current entry in sort list */ 1 444 total, /* count of total entries. */ 1 445 links, /* count of total links. */ 1 446 segs, /* count of total non-archive, */ 1 447 /* non-extended entry segments. */ 1 448 dirs, /* count of total directories. */ 1 449 msfs, /* count of total multisegment files. */ 1 450 msf_comps, /* count of total msf components. */ 1 451 dm_files, /* count of total data mgt files. */ 1 452 archives, /* count of total archives. */ 1 453 arch_comps, /* count of total archive components. */ 1 454 extended_entries) fixed bin, /* count of total extended entries. */ 1 455 /* See Named Constants for */ 1 456 /* sort_options.sorting above. */ 1 457 3 mbz_matched (4) fixed bin, /* reserved for future use. */ 1 458 1 459 2 entry_data, /* Beginning of DATA_xxx return items. */ 1 460 3 data_desired fixed bin, /* amount of data in entry_data minor */ 1 461 /* structure which is valid. */ 1 462 3 depth fixed bin, /* depth of this entry below its */ 1 463 /* corresponding parent in */ 1 464 /* star_paths.value. */ 1 465 3 type char(32) unal, /* extended entry type for matching */ 1 466 /* entry. See ENTRY_TYPE_xxx */ 1 467 /* constants below for standard entry */ 1 468 /* types. Extended types are given */ 1 469 /* by entry type suffix (eg, mbx). */ 1 470 /* Data above available when */ 1 471 /* data_desired set to DATA_TYPE. */ 1 472 1 473 3 length fixed bin(35), /* length of entry (by entry type): */ 1 474 /* link => 0 */ 1 475 /* seg => bit count */ 1 476 /* dir => 0 */ 1 477 /* msf => sum of comp bit counts */ 1 478 /* msf comp => msf comp bit count */ 1 479 /* dm_file => 0 */ 1 480 /* arch => bit count of archive */ 1 481 /* arch comp => bit count of component */ 1 482 /* ext entry => 0 */ 1 483 3 count fixed bin(35), /* length of entry (by entry type): */ 1 484 /* link => 0 */ 1 485 /* seg => 0 */ 1 486 /* dir => inferior entry count */ 1 487 /* msf => number of components */ 1 488 /* msf comp => total msf components */ 1 489 /* dm_file => 0 */ 1 490 /* arch => number of components */ 1 491 /* arch comp => total arch components */ 1 492 /* ext entry => 0 */ 1 493 3 entryP ptr, /* ptr to an entry: */ 1 494 /* link => null */ 1 495 /* seg => ptr to segment */ 1 496 /* dir => null */ 1 497 /* msf => ptr to msf_manager_ */ 1 498 /* fcb_ptr argument */ 1 499 /* msf comp => ptr to msf component */ 1 500 /* dm_file => null */ 1 501 /* arch => ptr to archive */ 1 502 /* arch comp => ptr to component */ 1 503 /* ext entry => null */ 1 504 /* Data above available when */ 1 505 /* data_desired set to DATA_INITIATE. */ 1 506 1 507 star_dataP ptr automatic; /* ptr to star_data structure. */ 1 508 1 509 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 510 /* */ 1 511 /* Named constants for star_data.type: */ 1 512 /* type values describing the type of entry passed to caller-supplied handler routine. Type */ 1 513 /* strings for file system standard entry types (links, segments, dirs, dm_files, msfs) agree */ 1 514 /* with those returned by fs_util_$get_type. */ 1 515 /* */ 1 516 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 517 1 518 dcl (ENTRY_TYPE_ARCHIVE init ("-archive"), 1 519 ENTRY_TYPE_ARCHIVE_COMP init ("-archive_component"), 1 520 ENTRY_TYPE_DIRECTORY init ("-directory"), 1 521 ENTRY_TYPE_DM_FILE init ("-dm_file"), 1 522 ENTRY_TYPE_LINK init ("-link"), 1 523 ENTRY_TYPE_MSF init ("-multisegment_file"), 1 524 ENTRY_TYPE_MSF_COMP init ("-msf_component"), 1 525 ENTRY_TYPE_SEGMENT init ("-segment"), 1 526 ENTRY_TYPE_UNKNOWN init ("-unknown"), 1 527 ENTRY_TYPE_UNSET init ("") 1 528 ) char (32) unaligned int static options (constant); 1 529 1 530 dcl STANDARD_ENTRY_TYPES (9) char (32) unal/* array of standard entry type values. */ 1 531 int static options(constant) init ( 1 532 "-link", 1 533 "-segment", 1 534 "-directory", 1 535 "-multisegment_file", 1 536 "-msf_component", 1 537 "-dm_file", 1 538 "-archive", 1 539 "-archive_component", 1 540 "-unknown"); 1 541 1 542 /* END OF: fs_star_.incl.pl1 * * * * * * * * * * * * */ 1611 1612 2 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 2 2 2 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 2 4 2 5 /* This include file contains branch and link structures returned by 2 6* hcs_$status_ and hcs_$status_long. */ 2 7 2 8 dcl 1 status_branch aligned based (status_ptr), 2 9 2 short aligned, 2 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 2 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 2 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 2 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 2 14 3 dtu bit (36) unaligned, /* date/time last used */ 2 15 3 mode bit (5) unaligned, /* caller's effective access */ 2 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 2 17 3 pad1 bit (8) unaligned, 2 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 2 19 2 20 /* Limit of information returned by hcs_$status_ */ 2 21 2 22 2 long aligned, 2 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 2 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 2 25 3 lvid bit (36) unaligned, /* logical volume ID */ 2 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 2 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 2 28 3 pad2 bit (8) unaligned, 2 29 3 copy_switch bit (1) unaligned, /* copy switch */ 2 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 2 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 2 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 2 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 2 34 3 pad3 bit (5) unaligned, 2 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 2 36 3 uid bit (36) unaligned; /* unique ID */ 2 37 2 38 dcl 1 status_link aligned based (status_ptr), 2 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 2 40 2 nnames fixed bin (16) unaligned unsigned, 2 41 2 names_relp bit (18) unaligned, 2 42 2 dtem bit (36) unaligned, 2 43 2 dtd bit (36) unaligned, 2 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 2 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 2 46 2 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 2 48 based (pointer (status_area_ptr, status_branch.names_relp)), 2 49 /* array of names returned */ 2 50 status_pathname character (status_link.pathname_length) aligned 2 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 2 52 /* link target path */ 2 53 status_area_ptr pointer, 2 54 status_ptr pointer; 2 55 2 56 dcl (Link initial (0), 2 57 Segment initial (1), 2 58 Directory initial (2)) fixed bin internal static options (constant); 2 59 /* values for type fields declared above */ 2 60 2 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 1613 1614 1615 dcl 1 status aligned auto like status_branch; 1616 1617 end list_sub_tree; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/10/88 1526.1 list_sub_tree.pl1 >spec>install>1159>list_sub_tree.pl1 1611 1 10/10/88 0909.4 fs_star_.incl.pl1 >ldd>include>fs_star_.incl.pl1 1613 2 11/22/82 0955.7 status_structures.incl.pl1 >ldd>include>status_structures.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. ALLOW_AF constant fixed bin(17,0) initial dcl 266 ref 309 ALLOW_COMMAND constant fixed bin(17,0) initial dcl 266 set ref 121* 307 ALLOW_COMMAND_AF constant fixed bin(17,0) initial dcl 266 ref 311 ALT_ENTRY_TYPES 000272 constant char(12) initial array packed unaligned dcl 63 ref 919 919 920 ANOTHER_COMP constant fixed bin(17,0) initial dcl 1334 ref 1360 1395 ANOTHER_ENTRY constant fixed bin(17,0) initial dcl 1334 ref 1358 1379 CODE_ARG 000445 constant fixed bin(17,0) initial dcl 1038 set ref 1043* 1055* DOWN_DIR constant fixed bin(17,0) initial dcl 1334 ref 1352 1389 ENTRY_DONT_RETURN constant bit(36) initial dcl 1-152 ref 137 ENTRY_INAEE constant bit(36) initial dcl 1-152 ref 144 145 ENTRY_LIST_SUBENTRIES constant bit(36) initial dcl 1-152 ref 126 133 137 140 ENTRY_RETURN constant bit(36) initial dcl 1-152 ref 126 133 140 ENTRY_TYPE_ARCHIVE 000167 constant char(32) initial packed unaligned dcl 1-518 ref 163 1248 1305 1364 1379 ENTRY_TYPE_ARCHIVE_COMP 000157 constant char(32) initial packed unaligned dcl 1-518 ref 1243 1474 ENTRY_TYPE_DIRECTORY 000147 constant char(32) initial packed unaligned dcl 1-518 ref 163 1248 1300 1364 1379 ENTRY_TYPE_LINK 000137 constant char(32) initial packed unaligned dcl 1-518 ref 1474 ENTRY_TYPE_MSF 000127 constant char(32) initial packed unaligned dcl 1-518 ref 1248 ENTRY_TYPE_UNKNOWN 000117 constant char(32) initial packed unaligned dcl 1-518 ref 1474 ENTRY_TYPE_UNSET 014725 constant char(32) initial packed unaligned dcl 1-518 ref 633 1162 1217 1474 ERROR_REJECT constant fixed bin(17,0) initial dcl 1-285 ref 1121 FALSE constant bit(1) initial packed unaligned dcl 357 in procedure "ARG_get_extra_operand" ref 366 371 FALSE constant bit(1) initial packed unaligned dcl 418 in procedure "ARG_get_numeric_operand" ref 456 477 491 FALSE constant bit(1) initial packed unaligned dcl 518 in procedure "ARG_get_operand" ref 532 FALSE constant bit(1) initial packed unaligned dcl 74 in procedure "lst" ref 617 618 620 622 623 625 628 666 667 675 681 717 723 750 777 782 787 892 962 963 964 1077 1151 FALSE constant bit(1) initial packed unaligned dcl 330 in procedure "ARG_get" ref 339 FALSE constant bit(1) initial packed unaligned dcl 566 in procedure "ARG_vowel" ref 572 HANDLER_OK constant fixed bin(17,0) initial dcl 1-253 ref 1204 HANDLER_REJECT constant fixed bin(17,0) initial dcl 1-253 ref 1209 L 33 001536 automatic fixed bin(17,0) level 2 dcl 1517 set ref 1533* 1535* 1537 1538 1539 1542 1553 1568 1569 1570 LST_ENTRY_TYPES 000247 constant char(8) initial array packed unaligned dcl 76 ref 908 908 909 ME 000243 constant char(13) initial packed unaligned dcl 79 set ref 121* NEW_ARCHIVE constant fixed bin(17,0) initial dcl 1334 ref 1355 1395 NEW_SUBTREE constant fixed bin(17,0) initial dcl 1334 ref 1346 1364 NL 014724 constant char(1) initial packed unaligned dcl 1424 ref 1437 NONNEGATIVE_VALUES 000212 constant fixed bin(35,0) initial array dcl 401 ref 435 NO_ALLOWED_VALUES constant fixed bin(35,0) initial array dcl 395 ref 446 468 NO_CHASE 000212 constant fixed bin(1,0) initial dcl 1472 set ref 1479* NO_DEFAULT_VALUE 000271 constant fixed bin(35,0) initial dcl 394 set ref 423 451 468 685* PATH_ALLOW_NONDIR_STAR_NAMES constant bit(36) initial dcl 1-133 ref 125 POSITIVE_VALUES 000214 constant fixed bin(35,0) initial array dcl 398 set ref 435 447 448 685* PRINT_ENTRY_TYPES 000216 constant char(9) initial array packed unaligned dcl 80 set ref 1225 1298* 1303* Paction parameter fixed bin(17,0) dcl 1195 in procedure "HANDLER" set ref 1188 1204* 1209* Paction parameter fixed bin(17,0) dcl 1112 in procedure "ERROR_ROUTINE" set ref 1103 1121* Pallowed_values parameter fixed bin(35,0) array dcl 407 set ref 404 435 435 435 446 446 447 448 448 449 449 451 462 462 462 467 468 468 468 468* 483 483 483 483* Parg parameter char packed unaligned dcl 407 set ref 404 451* 451* 468* 468* 483* Pcode parameter fixed bin(35,0) dcl 1110 set ref 1103 1134* 1153* Pcomp parameter char packed unaligned dcl 1194 in procedure "HANDLER" set ref 1188 1284* 1288* 1294 1302 1307* Pcomp parameter char packed unaligned dcl 1109 in procedure "ERROR_ROUTINE" set ref 1103 1134* 1134* 1149* Pcomp parameter char packed unaligned dcl 1330 in procedure "HANDLER_depth" set ref 1322 1352 1358 1395* Pcount parameter fixed bin(17,0) dcl 1514 ref 1509 1524 1527 Pdefault_value parameter fixed bin(35,0) dcl 407 set ref 404 423 423 432 451 451* 468 468* 483 483* 483 Pdepth parameter fixed bin(17,0) dcl 1415 in procedure "NAMES_output" ref 1412 1430 Pdepth parameter fixed bin(17,0) dcl 1325 in procedure "HANDLER_depth" set ref 1322 1343 1349 1352 1364 1373* 1379 1379* 1389 1389* 1395 Pdescription parameter char packed unaligned dcl 407 set ref 404 423 430 451* 468* 468* 468* 482 483* 483* 483* Pdir parameter char packed unaligned dcl 1192 in procedure "HANDLER" set ref 1188 1239* 1245 1252 1257* 1284* 1288* 1303* 1307* 1479* 1484* 1484* Pdir parameter char packed unaligned dcl 1328 in procedure "HANDLER_depth" set ref 1322 1373* 1373* Pdir parameter char packed unaligned dcl 1107 in procedure "ERROR_ROUTINE" set ref 1103 1134* 1134* 1134* 1142 1143* 1149* 1149* Pent parameter char(32) array packed unaligned dcl 1193 in procedure "HANDLER" set ref 1188 1239* 1246 1253 1284* 1288* 1303* 1307* 1479* 1484* 1484* Pent parameter char(32) array packed unaligned dcl 1108 in procedure "ERROR_ROUTINE" set ref 1103 1134 1134* 1134* 1141 1149* 1149* Pent parameter char(32) array packed unaligned dcl 1329 in procedure "HANDLER_depth" set ref 1322 1373* 1373* 1389* 1433 1434 Plast_ent parameter structure level 1 dcl 1331 set ref 1322 Plen parameter char(5) packed unaligned dcl 1327 set ref 1322 1373* 1389* 1395* 1430 Plength parameter fixed bin(35,0) dcl 1515 ref 1509 1528 Pmessage parameter char packed unaligned dcl 1111 set ref 1103 1134 1134* 1154 1154* Pprefix1 parameter char packed unaligned dcl 1585 in procedure "TOTAL_print_end" ref 1582 1599 1602 Pprefix1 parameter char packed unaligned dcl 1512 in procedure "TOTAL_print" set ref 1509 1542* 1548 1553* Pprefix2 parameter char packed unaligned dcl 1512 in procedure "TOTAL_print" set ref 1509 1541 1541 1542 1542* 1549 1553* Pprefix2 parameter char packed unaligned dcl 1585 in procedure "TOTAL_print_end" ref 1582 1587 1599 1603 Pprefix3 parameter char packed unaligned dcl 1512 in procedure "TOTAL_print" set ref 1509 1542* 1550 1553* Pprefix3 parameter char packed unaligned dcl 1585 in procedure "TOTAL_print_end" ref 1582 1599 1604 Pstar_dataP parameter pointer dcl 1106 in procedure "ERROR_ROUTINE" set ref 1103 1123 1145* 1149* Pstar_dataP parameter pointer dcl 1191 in procedure "HANDLER" ref 1188 Ptyp parameter char(9) packed unaligned dcl 1326 set ref 1322 1373* 1389* 1395* 1430 Ptype parameter char packed unaligned dcl 1513 ref 1509 1526 PtypeX parameter fixed bin(17,0) dcl 1466 ref 1463 1489 1489 Ptypes parameter char packed unaligned dcl 884 ref 881 890 SPACES 014735 constant char(100) initial packed unaligned dcl 83 ref 1438 1529 1531 1562 1563 1564 1568 1569 1570 STANDARD_ENTRY_TYPES 000007 constant char(32) initial array packed unaligned dcl 1-530 ref 192 193 639 639 640 896 896 897 897 899 910 921 1213 1213 1213 1216 STARTING constant fixed bin(17,0) initial dcl 1334 ref 1343 1373 STAR_EXCLUDE_NAMES_VERSION_1 000200 constant char(8) initial packed unaligned dcl 1-236 set ref 694* STAR_EXTENDED_ENTRY_VERSION_1 000204 constant char(8) initial packed unaligned dcl 1-195 set ref 757* 935* STAR_MATCH_NAMES_VERSION_1 000202 constant char(8) initial packed unaligned dcl 1-216 set ref 730* STAR_OPTIONS_VERSION_1 000210 constant char(8) initial packed unaligned dcl 1-102 set ref 613* STAR_PATHS_VERSION_1 000206 constant char(8) initial packed unaligned dcl 1-116 set ref 796* TRUE 000271 constant bit(1) initial packed unaligned dcl 74 in procedure "lst" ref 138 621 624 626 671 672 676 679 713 714 718 721 748 775 780 785 814 817 823 826 829 900 901 903 911 912 914 922 923 925 930 1140 TRUE constant bit(1) initial packed unaligned dcl 330 in procedure "ARG_get" ref 337 TRUE constant bit(1) initial packed unaligned dcl 566 in procedure "ARG_vowel" ref 570 TRUE constant bit(1) initial packed unaligned dcl 1038 in procedure "ERR" ref 1046 1058 TRUE constant bit(1) initial packed unaligned dcl 418 in procedure "ARG_get_numeric_operand" ref 494 TRUE constant bit(1) initial packed unaligned dcl 518 in procedure "ARG_get_operand" ref 525 TRUE constant bit(1) initial packed unaligned dcl 357 in procedure "ARG_get_extra_operand" ref 368 TYPE_ARCHIVE constant fixed bin(17,0) initial dcl 66 ref 178 901 912 923 1303 TYPE_ARCHIVE_COMP constant fixed bin(17,0) initial dcl 66 ref 180 903 914 925 TYPE_DIRECTORY constant fixed bin(17,0) initial dcl 66 ref 184 1298 TYPE_DM_FILE constant fixed bin(17,0) initial dcl 66 ref 190 TYPE_LINK constant fixed bin(17,0) initial dcl 66 ref 182 TYPE_MSF constant fixed bin(17,0) initial dcl 66 ref 186 TYPE_MSF_COMP constant fixed bin(17,0) initial dcl 66 ref 188 TYPE_SEGMENT constant fixed bin(17,0) initial dcl 66 ref 176 UP_DIR constant fixed bin(17,0) initial dcl 1334 ref 1349 1379 action 000100 automatic fixed bin(17,0) dcl 1114 set ref 1145* 1149* addr builtin function dcl 56 ref 149 616 1479 1479 afS 000532 automatic bit(1) dcl 241 set ref 306* 307 309 312 after builtin function dcl 56 ref 894 1297 allowed parameter fixed bin(17,0) dcl 284 ref 281 307 309 311 arch_comps 15 based fixed bin(17,0) level 3 dcl 1-435 set ref 180* archive based bit(1) level 3 dcl 53 set ref 129 163 617* 671* 675* 814* 817* 1364 1379 archive_comp_type_found 000553 automatic bit(1) dcl 955 set ref 903* 914* 925* 962* 980 archive_set 001064 automatic bit(1) dcl 662 set ref 666* 672* 676* 812 archive_type_found 000554 automatic bit(1) dcl 956 set ref 901* 912* 923* 963* 993 archives 14 based fixed bin(17,0) level 3 in structure "star_data" dcl 1-435 in procedure "lst" set ref 178* archives 17 based bit(36) level 4 in structure "star_options" dcl 1-26 in procedure "lst" set ref 133* 137* 140* arg based char packed unaligned dcl 252 set ref 669 670 670 670 674 674 674 679 679 681 681 684 684 685* 690 690 691* 707 707 712 712 716 716 721 721 723 723 726 727* 743 743 748 748 748 748 748 750 750 750 753 753 754* 769 769 775 775 775 777 777 777 780 780 780 782 782 782 785 785 785 787 787 787 790* 803 argL 000533 automatic fixed bin(21,0) dcl 241 set ref 336* 669 670 670 670 674 674 674 679 679 681 681 684 684 685 685 690 690 691 691 707 707 712 712 716 716 721 721 723 723 726 727 727 743 743 748 748 748 748 748 750 750 750 753 753 754 754 769 769 775 775 775 777 777 777 780 780 780 782 782 782 785 785 785 787 787 787 790 790 803 argN 000534 automatic fixed bin(17,0) dcl 241 set ref 306* 334 361 426 522 548 argP 000536 automatic pointer dcl 241 set ref 336* 669 670 670 670 674 674 674 679 679 681 681 684 684 685 690 690 691 707 707 712 712 716 716 721 721 723 723 726 727 743 743 748 748 748 748 748 750 750 750 753 753 754 769 769 775 775 775 777 777 777 780 780 780 782 782 782 785 785 785 787 787 787 790 803 argX 000540 automatic fixed bin(17,0) dcl 241 set ref 314* 334 335* 335 336* 361 362* 362 363* 365* 365 426 427* 427 428* 431* 431 522 523* 523 524* 548 args based structure level 2 dcl 53 auto_hd 000100 automatic structure level 1 dcl 21 set ref 616 before builtin function dcl 56 ref 893 1297 bin builtin function dcl 56 ref 163 1154 1154 1364 1373 1379 1389 1395 1430 1430 caller parameter char packed unaligned dcl 284 in procedure "ARG_initialization" set ref 281 297* 300* caller 2 based structure level 2 in structure "star_options" dcl 1-26 in procedure "lst" char builtin function dcl 56 ref 1527 1528 cleanup 000524 stack reference condition dcl 60 ref 119 code based fixed bin(35,0) dcl 1029 in procedure "ERR" set ref 1044 1045 1045* 1056 1057 1057* code 000101 automatic fixed bin(35,0) dcl 1115 in procedure "ERROR_ROUTINE" set ref 1143* code 000726 automatic fixed bin(35,0) dcl 1468 in procedure "ENTRY_length" set ref 1479* 1480 1480 1484* 1485 code 000514 automatic fixed bin(35,0) dcl 46 in procedure "lst" set ref 160* 162 694* 696* 730* 732* 757* 759* 796* 798* 935* 937* code 001012 automatic fixed bin(35,0) dcl 289 in procedure "ARG_initialization" set ref 297* 299 300* code 000100 automatic fixed bin(35,0) dcl 1197 in procedure "HANDLER" set ref 1257* 1262* 1263 1271* code 001052 automatic fixed bin(35,0) dcl 610 in procedure "ARGS_init" set ref 613* 614* 643* codeP 000100 automatic pointer dcl 1029 set ref 1043* 1044 1045 1045 1055* 1056 1057 1057 com_err_ 000066 constant entry external dcl 291 ref 300 common_depthI 000101 automatic fixed bin(17,0) dcl 1198 set ref 1260* 1266* 1295 conversion 000102 stack reference condition dcl 416 ref 429 444 convert builtin function dcl 414 ref 443 convert_status_code_ 000010 constant entry external dcl 86 ref 1153 copy builtin function dcl 56 ref 1219 count 346 based fixed bin(17,0) array level 3 in structure "hd" dcl 53 in procedure "lst" set ref 195* 637* 1233* 1233 count 3 based fixed bin(17,0) level 2 in structure "match_names" dcl 1-216 in procedure "lst" set ref 735* 735 736 738* 738 739 744* 826 count 3 based fixed bin(17,0) level 2 in structure "exclude_names" dcl 1-236 in procedure "lst" set ref 699* 699 700 702* 702 703 708* 823 count 11 001536 automatic varying char(32) level 2 in structure "field" dcl 1517 in procedure "TOTAL_print" set ref 1527* 1529 1529* 1529 1529 1531 1531 1533 1535 1538 1566 1569 count 3 based fixed bin(17,0) level 2 in structure "extended_entry_types" dcl 1-195 in procedure "lst" set ref 770* 829 933 940* 940 941 count 3 based fixed bin(17,0) level 2 in structure "star_paths" dcl 1-116 in procedure "lst" set ref 130 135 795 802* 802 803 807 808* 813 countI 35 001536 automatic fixed bin(17,0) level 2 dcl 1517 set ref 1538* 1563 1569 ctl_arg parameter char packed unaligned dcl 513 set ref 510 528* cu_$arg_list_ptr 000070 constant entry external dcl 291 in procedure "ARG_initialization" ref 297 297 cu_$arg_list_ptr 000104 constant entry external dcl 1032 in procedure "ERR" ref 1047 1047 1060 1060 cu_$arg_ptr 000106 constant entry external dcl 1032 ref 1043 1055 cu_$generate_call 000110 constant entry external dcl 1032 ref 1047 1060 current 4 based fixed bin(17,0) level 3 dcl 1-435 ref 1132 1343 debug 1 based bit(1) level 3 dcl 53 set ref 618* 679* 681* 1364* 1379* depth 25 based fixed bin(17,0) level 3 in structure "star_data" dcl 1-435 in procedure "lst" set ref 1128 1131 1144* 1144 1146* 1146 1154 1154 1161 1208 1238 1307* depth 14 based fixed bin(17,0) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 163 163* 631* 1161* 1238* 1244 1251 1256 1284* 1288 1293 1302 depth 2 based fixed bin(17,0) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 126 163 619* 685* 1128 1208 1364 1379 depth parameter fixed bin(17,0) level 2 in structure "Plast_ent" dcl 1331 in procedure "HANDLER_depth" set ref 1349 1352 1364* depth 000166 automatic fixed bin(17,0) level 2 in structure "last_ent" dcl 1201 in procedure "HANDLER" set ref 1299* 1304* depthI 000102 automatic fixed bin(17,0) dcl 1198 set ref 1261* 1262 1263 1265 1265 1266 1267* 1267* 1268 1268* 1295* 1298* 1299* 1302 1303* 1304 depthN 000103 automatic fixed bin(17,0) dcl 1198 set ref 1244* 1251* 1256* 1261 1293* 1294* 1294 1295 description parameter char packed unaligned dcl 513 set ref 510 528 528* 528* 528* digits 000727 automatic picture(4) packed unaligned dcl 1469 set ref 1490* 1491 dim builtin function dcl 414 ref 435 435 446 447 447 468 468 483 483 dir 000104 automatic char(168) packed unaligned dcl 1199 in procedure "HANDLER" set ref 1245* 1252* 1257* 1262* 1271* 1271* 1296* 1296* 1297 1298* dir 000102 automatic char(168) packed unaligned dcl 1116 in procedure "ERROR_ROUTINE" set ref 1143* 1145* dirs 10 based fixed bin(17,0) level 3 in structure "star_data" dcl 1-435 in procedure "lst" set ref 184* dirs 13 based bit(36) level 4 in structure "star_options" dcl 1-26 in procedure "lst" set ref 126* 144* 144 divide builtin function dcl 56 ref 1537 1538 1539 dm_files 13 based fixed bin(17,0) level 3 dcl 1-435 set ref 190* ent 000154 automatic char(32) array packed unaligned dcl 1117 in procedure "ERROR_ROUTINE" set ref 1143* 1145* ent 000156 automatic char(32) array packed unaligned dcl 1200 in procedure "HANDLER" set ref 1246* 1253* 1257* 1262* 1271* 1296* 1297* 1298* entry_data 24 based structure level 2 dcl 1-435 entry_type 11 based structure level 3 dcl 1-26 error 56 based entry variable level 3 in structure "star_options" dcl 1-26 in procedure "lst" set ref 148* error 12 based bit(1) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 628* 1140* 1151* 1275 error_occurred_sw 000556 automatic bit(1) packed unaligned dcl 1024 set ref 1046* 1058* 1077* 1090 error_table_$active_function 000072 external static fixed bin(35,0) dcl 294 set ref 307* error_table_$bad_arg 000076 external static fixed bin(35,0) dcl 418 set ref 451* 468* error_table_$bad_opt 000044 external static fixed bin(35,0) dcl 104 set ref 790* error_table_$no_s_permission 000046 external static fixed bin(35,0) dcl 104 ref 1480 error_table_$noarg 000100 external static fixed bin(35,0) dcl 418 in procedure "ARG_get_numeric_operand" set ref 483* error_table_$noarg 000102 external static fixed bin(35,0) dcl 516 in procedure "ARG_get_operand" set ref 528* error_table_$not_act_fnc 000074 external static fixed bin(35,0) dcl 294 set ref 309* error_table_$root 000050 external static fixed bin(35,0) dcl 104 ref 1263 exclude_names based structure level 1 dcl 1-236 exclude_namesP 26 based pointer level 3 dcl 1-26 ref 692 699 699 700 700 702 702 703 703 708 708 823 823 exclude_names_size 000764 automatic fixed bin(17,0) dcl 1-236 set ref 693* 694* 696* exit_procedure parameter entry variable dcl 284 set ref 281 297* 302 expand_pathname_ 000022 constant entry external dcl 91 ref 1143 1257 1271 ext_ent 116 based structure level 2 dcl 53 extended_entry_types based structure level 1 dcl 1-195 extended_entry_typesP 22 based pointer level 3 dcl 1-26 ref 755 770 770 829 829 933 933 934 940 940 941 941 extended_entry_types_size 000762 automatic fixed bin(17,0) dcl 1-195 set ref 756* 757* 759* 934* 935* 937* extended_types_found 000555 automatic bit(1) dcl 957 set ref 930* 964* 1006 field 001536 automatic structure level 1 dcl 1517 first_name parameter char packed unaligned dcl 1416 ref 1412 1427 fs_star_$adjust_structure_size 000012 constant entry external dcl 87 ref 694 730 757 796 935 fs_star_$init 000014 constant entry external dcl 88 ref 613 fs_star_$select 000016 constant entry external dcl 89 ref 160 fs_star_$term 000020 constant entry external dcl 90 ref 850 get_line_length_$switch 000024 constant entry external dcl 92 ref 643 get_wdir_ 000026 constant entry external dcl 93 ref 809 handler 52 based entry variable level 3 dcl 1-26 set ref 147* handler_dataP 62 based pointer level 3 dcl 1-26 set ref 149* 1126 1207 hbound builtin function dcl 414 in procedure "ARG_get_numeric_operand" ref 435 448 462 467 hbound builtin function dcl 56 in procedure "lst" ref 192 193 193 639 795 796 798 896 908 919 1213 1216 1228 1231 1433 hcs_$get_uid_file 000030 constant entry external dcl 94 ref 1262 hcs_$quota_read 000032 constant entry external dcl 95 ref 1484 hcs_$status_ 000034 constant entry external dcl 97 ref 1479 hd based structure level 1 dcl 53 set ref 149 hdP 000516 automatic pointer dcl 47 set ref 126 129 138 143 149 163 163 163 163 163 163 163 163 163 163 171 171 174 176 178 180 182 184 186 188 190 192 193 193 195 195 195 203 203 616* 617 618 619 620 621 622 623 624 625 626 628 629 631 632 633 634 636 637 638 640 671 675 679 681 685 713 717 721 723 748 750 775 777 780 782 785 787 814 817 820 823 826 829 1126* 1128 1139 1140 1142 1149 1151 1154 1154 1154 1154 1154 1154 1161 1162 1207* 1208 1228 1228 1228 1228 1231 1232 1233 1233 1236 1238 1239 1240 1241 1243 1244 1248 1248 1248 1251 1256 1262 1263 1265 1268 1275 1275 1281 1284 1284 1288 1293 1297 1302 1364 1364 1364 1364 1364 1364 1364 1373 1373 1373 1379 1379 1379 1379 1379 1379 1379 1389 1389 1389 1395 1395 1395 1428 1430 1430 1488 1488 1489 1489 1533 1587 1587 inaee 3 based bit(1) level 3 dcl 53 set ref 143 620* 713* 717* 820* inaee_set 001065 automatic bit(1) dcl 663 set ref 667* 714* 718* 820 indentL 000310 automatic fixed bin(17,0) dcl 1418 set ref 1430* 1432 1438 1439 index builtin function dcl 56 ref 130 364 430 669 814 1541 ioa_ 000112 constant entry external dcl 1032 in procedure "ERR" ref 1059 ioa_ 000036 constant entry external dcl 99 in procedure "lst" ref 163 172 203 1132 1154 1364 1371 1373 1379 1389 1395 1587 last_ent 14 000100 automatic structure level 2 in structure "auto_hd" dcl 21 in procedure "lst" last_ent 000166 automatic structure level 1 dcl 1201 in procedure "HANDLER" set ref 1236* 1284* 1288* 1298* 1303* 1307* last_ent 14 based structure level 2 in structure "hd" dcl 53 in procedure "lst" set ref 1236 lbound builtin function dcl 56 in procedure "lst" ref 130 639 813 896 908 919 1213 1228 lbound builtin function dcl 414 in procedure "ARG_get_numeric_operand" ref 462 len 000560 automatic char(5) packed unaligned dcl 1185 set ref 163 1154 1154 1275* 1278* 1280* 1284* 1288* 1307* 1364 1373 1379 1389 1395 length 4 based bit(1) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 163* 203 621* 721* 723* 1154* 1154* 1275 1364* 1373* 1379* 1389* 1395* 1430 1533 1587 length 22 001536 automatic varying char(32) level 2 in structure "field" dcl 1517 in procedure "TOTAL_print" set ref 1528* 1529 1529 1531 1531* 1531 1531 1533 1539 1567 1570 length builtin function dcl 56 in procedure "lst" ref 163 163 163 897 1154 1154 1154 1154 1154 1154 1219 1219 1219 1219 1364 1364 1364 1373 1373 1373 1379 1379 1379 1389 1389 1389 1395 1395 1395 1430 1430 1430 1432 1435 1435 1444 1444 1587 1587 length builtin function dcl 1522 in procedure "TOTAL_print" ref 1529 1529 1529 1529 1531 1531 1531 1531 1533 1533 1533 1535 1535 1537 1538 1539 1541 1542 1542 1542 1553 1553 1557 1568 1569 1570 lengthI 36 001536 automatic fixed bin(17,0) level 2 dcl 1517 set ref 1539* 1564 1570 lengths 13 based fixed bin(35,0) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 174* 203* 629* 1488* 1488 lengths 371 based fixed bin(35,0) array level 3 in structure "hd" dcl 53 in procedure "lst" set ref 176* 178* 180* 182* 184* 186* 188* 190* 195* 638* 1489* 1489 1587 line1 000565 automatic varying char(160) dcl 1507 set ref 1545* 1545 1548* 1548 1553 1557 1558* 1558 1562* 1562 1565* 1565 1568* 1568 1587* 1602* line2 000636 automatic varying char(160) dcl 1507 set ref 1541 1542 1546* 1546 1549* 1549 1559* 1559 1563* 1563 1566* 1566 1569* 1569 1587 1587* 1603* line3 000707 automatic varying char(160) dcl 1507 set ref 1547* 1547 1550* 1550 1560* 1560 1564* 1564 1567* 1567 1570* 1570 1587* 1604* lineL 000311 automatic fixed bin(17,0) dcl 1419 set ref 1432* 1435 1439* 1444* 1444 links 6 based fixed bin(17,0) level 3 dcl 1-435 set ref 182* long 000164 automatic char(100) dcl 1118 set ref 1153* 1154* ltrim builtin function dcl 56 ref 890 1527 1528 match_names based structure level 1 dcl 1-216 match_namesP 24 based pointer level 3 dcl 1-26 ref 728 735 735 736 736 738 738 739 739 744 744 826 826 match_names_size 000763 automatic fixed bin(17,0) dcl 1-216 set ref 729* 730* 732* matched 4 based structure level 2 dcl 1-435 max builtin function dcl 56 ref 548 1219 1533 1535 max_count 2 based fixed bin(17,0) level 2 in structure "star_paths" dcl 1-116 in procedure "lst" ref 795 796 798 max_count 2 based fixed bin(17,0) level 2 in structure "extended_entry_types" dcl 1-195 in procedure "lst" ref 933 934 max_lineL 000520 automatic fixed bin(17,0) dcl 48 set ref 643* 1435 1542 1553 min builtin function dcl 56 ref 1430 msf_comps 12 based fixed bin(17,0) level 3 dcl 1-435 set ref 188* msfs 11 based fixed bin(17,0) level 3 in structure "star_data" dcl 1-435 in procedure "lst" set ref 186* msfs 14 based bit(36) level 4 in structure "star_options" dcl 1-26 in procedure "lst" set ref 126* name 000312 automatic varying char(32) dcl 1420 set ref 1434* 1435 1443 1444 nameX 000716 automatic fixed bin(17,0) dcl 1422 set ref 1433* 1434* names 000323 automatic varying char(1000) dcl 1421 in procedure "NAMES_output" set ref 1427* 1428 1432 1436* 1436 1437* 1437 1438* 1438 1441* 1441 1443* 1443 1446 names 5 based bit(1) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 622* 748* 750* 1428 null builtin function dcl 56 ref 643 643 692 708 728 744 755 770 823 826 829 866 867 1479 1479 num_op 000552 automatic fixed bin(35,0) dcl 393 set ref 423* 432* 443* 443 449 449 462 685 op based char packed unaligned dcl 252 set ref 364 364 430 443 451* 468* 700 703 736 739 763* 765* opL 000541 automatic fixed bin(21,0) dcl 241 set ref 363* 364 364 428* 430 443 451 451 468 468 524* 700 703 736 739 763 763 765 765 opP 000542 automatic pointer dcl 241 set ref 363* 364 364 428* 430 443 451 468 524* 700 703 736 739 763 765 pages 000730 automatic fixed bin(35,0) dcl 1470 set ref 1482* 1485* 1485 1488 1489 1490 path 15 based char(168) level 3 dcl 53 set ref 632* 1142 1149 1239* 1297 pathX 000521 automatic fixed bin(17,0) dcl 49 in procedure "lst" set ref 130* 130* 135 pathX 001066 automatic fixed bin(17,0) dcl 664 in procedure "ARGS_process" set ref 813* 814* path_allow 10 based bit(36) level 3 dcl 1-26 set ref 125* pathname_ 000040 constant entry external dcl 100 ref 1149 1239 1296 1373 1373 1484 1484 pathname_$component 000042 constant entry external dcl 101 ref 1134 1134 per_entry 30 based structure level 2 dcl 1-26 quota 000731 automatic fixed bin(18,0) dcl 1471 set ref 1484* quota_used 000732 automatic fixed bin(18,0) dcl 1471 set ref 1484* 1485 ret based varying char dcl 252 set ref 312* retL 000544 automatic fixed bin(21,0) dcl 241 set ref 306* 312 retP 000546 automatic pointer dcl 241 set ref 306* 312 rtrim builtin function dcl 56 ref 890 1219 1219 1219 1297 1427 1434 1526 sciP 000550 automatic pointer dcl 241 set ref 297* 306* 307* 309* 336* 363* 428* 451* 468* 483* 524* 528* 613* 614* 696* 732* 759* 790* 798* 851* 867* 937* 1125* 1134* search builtin function dcl 56 in procedure "lst" ref 364 search builtin function dcl 564 in procedure "ARG_vowel" ref 570 segs 12 based bit(36) level 4 in structure "star_options" dcl 1-26 in procedure "lst" set ref 145* 145 segs 7 based fixed bin(17,0) level 3 in structure "star_data" dcl 1-435 in procedure "lst" set ref 176* selection 6 based structure level 2 in structure "star_options" dcl 1-26 in procedure "lst" selection 6 based bit(1) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 138* 163 623* 823* 826* 829* 1284 1364 1379 short 000216 automatic char(8) dcl 1119 set ref 1153* size 000110 stack reference condition dcl 416 ref 429 444 ssu_$abort_subsystem 000052 constant entry external dcl 256 ref 1060 1060 ssu_$arg_ptr 000054 constant entry external dcl 256 ref 336 363 428 524 ssu_$destroy_invocation 000056 constant entry external dcl 256 ref 851 ssu_$print_message 000060 constant entry external dcl 256 ref 1047 1047 1134 ssu_$return_arg 000062 constant entry external dcl 256 ref 306 ssu_$standalone_invocation 000064 constant entry external dcl 256 ref 297 ssu_sciP 2 based pointer level 3 dcl 1-26 ref 1125 standard_type 001104 automatic bit(1) dcl 886 set ref 892* 900* 911* 922* 930 star_data based structure level 1 dcl 1-435 star_dataP 000766 automatic pointer dcl 1-435 set ref 160* 171 174 176 178 180 182 184 186 188 190 203 203 203 203 1123* 1124 1128 1131 1132 1144 1144 1146 1146 1154 1154 1161 1206 1208 1213 1217 1219 1219 1219 1228 1232 1238 1240 1307 1343 1474 1474 1474 1474 1483 star_options based structure level 1 dcl 1-26 star_optionsP 000760 automatic pointer dcl 1-26 in procedure "lst" set ref 125 126 126 130 130 130 133 135 137 140 144 144 145 145 147 148 149 160* 613* 692 694* 699 699 700 700 702 702 703 703 708 708 728 730* 735 735 736 736 738 738 739 739 744 744 755 757* 770 770 795 795 796* 796 798 802 802 803 803 807 808 809 813 813 814 823 823 826 826 829 829 850* 866* 933 933 934 935* 940 940 941 941 1124* 1125 1126 1206* 1207 star_optionsP 2 based pointer level 2 in structure "star_data" dcl 1-435 in procedure "lst" ref 1124 1206 star_paths based structure level 1 dcl 1-116 star_pathsP 6 based pointer level 3 dcl 1-26 ref 130 130 130 135 795 795 796 798 802 802 803 803 807 808 809 813 813 814 status 000770 automatic structure level 1 dcl 1615 set ref 1479 1479 status_branch based structure level 1 dcl 2-8 str parameter char packed unaligned dcl 562 ref 559 570 substr builtin function dcl 564 in procedure "ARG_vowel" ref 570 substr builtin function dcl 56 in procedure "lst" ref 897 897 1438 1529 1531 1562 1563 1564 1568 1569 1570 subtree 12 based structure level 2 dcl 53 sum builtin function dcl 56 ref 1587 total 5 based fixed bin(17,0) level 3 in structure "star_data" dcl 1-435 in procedure "lst" set ref 171 174* 203 203* 203 203 total 7 based bit(1) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 171 624* 775* 777* total_only 10 based bit(1) level 3 dcl 53 set ref 171 625* 780* 782* 1139 1281 typ 000562 automatic char(9) packed unaligned dcl 1186 set ref 163 163 1154 1154 1154 1154 1217* 1219 1219* 1219 1222* 1225* 1284* 1288* 1307* 1364 1364 1373 1373 1379 1379 1389 1389 1395 1395 type 26 based char(32) level 3 in structure "star_data" packed packed unaligned dcl 1-435 in procedure "lst" ref 1213 1217 1219 1219 1219 1228 1232 1240 1474 1474 1474 1474 1483 type 001536 automatic varying char(32) level 2 in structure "field" dcl 1517 in procedure "TOTAL_print" set ref 1526* 1533 1535 1537 1565 1568 type 67 based char(32) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 163 163 633* 1162* 1240* 1243 1248 1248 1248 type 116 based char(32) array level 3 in structure "hd" packed packed unaligned dcl 53 in procedure "lst" set ref 192 193 193 195* 636* 640* 1228 1228 1228 1228 1231 1232* type 11 based bit(1) level 3 in structure "hd" dcl 53 in procedure "lst" set ref 163* 163 626* 785* 787* 1154* 1154 1154* 1154 1364* 1364 1373* 1373 1379* 1379 1389* 1389 1395* 1395 1430 type 53 parameter char(32) level 2 in structure "Plast_ent" dcl 1331 in procedure "HANDLER_depth" ref 1364 1364 1379 1379 type 53 000166 automatic char(32) level 2 in structure "last_ent" dcl 1201 in procedure "HANDLER" set ref 1300* 1305* type 001105 automatic char(32) packed unaligned dcl 887 in procedure "EXTENDED_TYPE" set ref 893* 897 899* 909 910* 920 921* 941 typeI 34 001536 automatic fixed bin(17,0) level 2 dcl 1517 set ref 1537* 1562 1568 typeX 000522 automatic fixed bin(17,0) dcl 50 in procedure "lst" set ref 193* 193* 195 195 195* 896* 897 897 899 901 903* 908* 909 910 912 914* 919* 920 921 923 925* typeX 000270 automatic fixed bin(17,0) dcl 1202 in procedure "HANDLER" set ref 1213* 1213* 1216 1225 1228* 1228 1228* 1231 1232 1233 1233 1278* typeX 001053 automatic fixed bin(17,0) dcl 611 in procedure "ARGS_init" set ref 639* 640 640* types 001115 automatic varying char(1000) dcl 888 set ref 890* 891 893 894* 894 uids 77 based bit(36) array level 3 in structure "hd" dcl 53 in procedure "lst" set ref 634* 1241* 1262* 1263* 1265 1268* uids 63 000166 automatic bit(36) array level 2 in structure "last_ent" dcl 1201 in procedure "HANDLER" set ref 1265 1268 valX 000100 automatic fixed bin(17,0) dcl 412 set ref 462* 462* 467 value 4 based char(32) array level 2 in structure "extended_entry_types" packed packed unaligned dcl 1-195 in procedure "lst" set ref 941* value 4 based char(32) array level 2 in structure "match_names" packed packed unaligned dcl 1-216 in procedure "lst" set ref 736* 739* value 4 based char(32) array level 2 in structure "exclude_names" packed packed unaligned dcl 1-236 in procedure "lst" set ref 700* 703* value 4 based char(202) array level 2 in structure "star_paths" packed packed unaligned dcl 1-116 in procedure "lst" set ref 130 130 795 796 798 803* 809* 813 814 version parameter char packed unaligned dcl 284 set ref 281 297* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. DATA_INITIATE internal static fixed bin(17,0) initial dcl 1-414 DATA_TYPE internal static fixed bin(17,0) initial dcl 1-414 Directory internal static fixed bin(17,0) initial dcl 2-56 ENTRY_CHASE_ALL_LINKS internal static bit(36) initial dcl 1-152 ENTRY_CHASE_NONSTAR_LINKS internal static bit(36) initial dcl 1-152 ENTRY_DONT_CHASE_LINKS internal static bit(36) initial dcl 1-152 ENTRY_DONT_LIST_SUBENTRIES internal static bit(36) initial dcl 1-152 ENTRY_DONT_SELECT_MDIRS internal static bit(36) initial dcl 1-152 ENTRY_DONT_SELECT_NONNULL internal static bit(36) initial dcl 1-152 ENTRY_DONT_SELECT_NONOBJECTS internal static bit(36) initial dcl 1-152 ENTRY_DONT_SELECT_NON_MDIRS internal static bit(36) initial dcl 1-152 ENTRY_DONT_SELECT_NULL internal static bit(36) initial dcl 1-152 ENTRY_DONT_SELECT_OBJECTS internal static bit(36) initial dcl 1-152 ENTRY_INASE internal static bit(36) initial dcl 1-152 ENTRY_SELECT_ALL_DIRS internal static bit(36) initial dcl 1-152 ENTRY_SELECT_ALL_FILES internal static bit(36) initial dcl 1-152 ENTRY_SELECT_NULL_NONNULL internal static bit(36) initial dcl 1-152 ENTRY_TYPE_DM_FILE internal static char(32) initial packed unaligned dcl 1-518 ENTRY_TYPE_MSF_COMP internal static char(32) initial packed unaligned dcl 1-518 ENTRY_TYPE_SEGMENT internal static char(32) initial packed unaligned dcl 1-518 ERROR_ABORT internal static fixed bin(17,0) initial dcl 1-285 ERROR_OK internal static fixed bin(17,0) initial dcl 1-285 ERROR_STOP internal static fixed bin(17,0) initial dcl 1-285 HANDLER_ABORT internal static fixed bin(17,0) initial dcl 1-253 HANDLER_DONT_COUNT internal static fixed bin(17,0) initial dcl 1-253 HANDLER_DONT_EXPAND internal static fixed bin(17,0) initial dcl 1-253 HANDLER_EXPAND internal static fixed bin(17,0) initial dcl 1-253 HANDLER_EXPAND_DONT_COUNT internal static fixed bin(17,0) initial dcl 1-253 HANDLER_STOP internal static fixed bin(17,0) initial dcl 1-253 Link internal static fixed bin(17,0) initial dcl 2-56 PATH_ALLOW_ALL_STAR_NAMES internal static bit(36) initial dcl 1-133 PATH_ALLOW_ARCHIVE_COMPONENTS internal static bit(36) initial dcl 1-133 PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES internal static bit(36) initial dcl 1-133 PATH_ALLOW_ARCHIVE_STAR_NAMES internal static bit(36) initial dcl 1-133 PATH_ALLOW_BRANCH_STAR_NAMES internal static bit(36) initial dcl 1-133 PATH_ALLOW_DIR_STAR_NAMES internal static bit(36) initial dcl 1-133 PATH_ALLOW_ENTRY_STAR_NAMES internal static bit(36) initial dcl 1-133 SORT_BY_EXTENDED_ENTRY_TYPE internal static fixed bin(17,0) initial dcl 1-388 SORT_BY_NAME internal static fixed bin(17,0) initial dcl 1-388 SORT_BY_STANDARD_ENTRY_TYPE internal static fixed bin(17,0) initial dcl 1-388 SORT_ENTRIES_BEFORE_SUBENTRIES internal static fixed bin(17,0) initial dcl 1-388 SORT_FORWARD internal static fixed bin(17,0) initial dcl 1-388 SORT_OFF internal static fixed bin(17,0) initial dcl 1-388 SORT_REVERSE internal static fixed bin(17,0) initial dcl 1-388 STAR_DATA_VERSION_1 internal static char(8) initial packed unaligned dcl 1-425 Segment internal static fixed bin(17,0) initial dcl 2-56 star_paths_size automatic fixed bin(17,0) dcl 1-116 status_area_ptr automatic pointer dcl 2-47 status_entry_names based char(32) array dcl 2-47 status_link based structure level 1 dcl 2-38 status_pathname based char dcl 2-47 status_ptr automatic pointer dcl 2-47 NAMES DECLARED BY EXPLICIT CONTEXT. ARGS_init 004437 constant entry internal dcl 607 ref 122 ARGS_process 004657 constant entry internal dcl 659 ref 124 ARG_get 003104 constant entry internal dcl 327 ref 668 ARG_get_extra_operand 003142 constant entry internal dcl 354 ref 701 737 764 ARG_get_numeric_operand 003237 constant entry internal dcl 404 ref 685 ARG_get_operand 004230 constant entry internal dcl 510 ref 691 727 754 ARG_initialization 002664 constant entry internal dcl 281 ref 121 ARG_remaining_arg_count 004371 constant entry internal dcl 546 ref 693 729 756 ARG_vowel 004403 constant entry internal dcl 559 ref 468 468 483 483 528 528 BAD_OPT 003670 constant label dcl 468 ref 435 438 BAD_RANGE 003522 constant label dcl 451 ref 435 CLEANUP 006515 constant entry internal dcl 847 ref 119 209 CLEANUP_init 006542 constant entry internal dcl 863 ref 118 ENTRY_length 012647 constant entry internal dcl 1463 ref 1278 ERR 007216 constant entry internal dcl 1026 ref 451 468 483 528 790 798 ERROR_ROUTINE 007423 constant entry internal dcl 1103 ref 148 ERR_fatal 007277 constant entry internal dcl 1052 ref 307 309 614 696 732 759 937 ERR_init 007371 constant entry internal dcl 1074 ref 305 ERR_occurred 007403 constant entry internal dcl 1087 ref 833 EXIT 002646 constant label dcl 209 ref 224 833 EXTENDED_TYPE 006547 constant entry internal dcl 881 ref 763 765 EXTENDED_TYPE_archive_comp_given 007146 constant entry internal dcl 977 ref 817 EXTENDED_TYPE_archive_given 007163 constant entry internal dcl 990 ref 133 EXTENDED_TYPE_given 007200 constant entry internal dcl 1003 ref 820 EXTENDED_TYPE_init 007132 constant entry internal dcl 959 ref 644 772 HANDLER 010233 constant entry internal dcl 1188 ref 147 1145 1149 HANDLER_depth 011522 constant entry internal dcl 1322 ref 1284 1288 1298 1303 1307 NAMES_output 012403 constant entry internal dcl 1412 ref 1373 1389 PROCESS 000000 constant label array(7) dcl 1364 ref 1343 1346 1349 1352 1355 1358 1360 TEST_ARRAY 003634 constant label dcl 462 ref 448 TOTAL_print 013140 constant entry internal dcl 1509 ref 174 176 178 180 182 184 186 188 190 195 TOTAL_print_end 014012 constant entry internal dcl 1582 ref 198 200 1542 1553 TOTAL_print_init 014120 constant entry internal dcl 1599 ref 173 USE_DEFAULT_VALUE 004222 constant label dcl 494 ref 433 exit_proc 002654 constant entry internal dcl 222 ref 121 121 list_sub_tree 001424 constant entry external dcl 17 lst 001415 constant entry external dcl 17 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 15452 15566 14774 15462 Length 16122 14774 114 320 456 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lst 1374 external procedure is an external procedure. on unit on line 119 64 on unit exit_proc 64 internal procedure is assigned to an entry variable. ARG_initialization internal procedure shares stack frame of external procedure lst. ARG_get internal procedure shares stack frame of external procedure lst. ARG_get_extra_operand internal procedure shares stack frame of external procedure lst. ARG_get_numeric_operand 298 internal procedure enables or reverts conditions. on unit on line 429 65 on unit ARG_get_operand internal procedure shares stack frame of external procedure lst. ARG_remaining_arg_count internal procedure shares stack frame of external procedure lst. ARG_vowel 65 internal procedure is called by several nonquick procedures. ARGS_init internal procedure shares stack frame of external procedure lst. ARGS_process internal procedure shares stack frame of external procedure lst. CLEANUP 68 internal procedure is called by several nonquick procedures. CLEANUP_init internal procedure shares stack frame of external procedure lst. EXTENDED_TYPE internal procedure shares stack frame of external procedure lst. EXTENDED_TYPE_init internal procedure shares stack frame of external procedure lst. ERR 90 internal procedure is declared options(variable). ERR_init internal procedure shares stack frame of external procedure lst. ERROR_ROUTINE 320 internal procedure is assigned to an entry variable. HANDLER 998 internal procedure is assigned to an entry variable. HANDLER_depth internal procedure shares stack frame of internal procedure HANDLER. NAMES_output internal procedure shares stack frame of internal procedure HANDLER. ENTRY_length internal procedure shares stack frame of internal procedure HANDLER. TOTAL_print internal procedure shares stack frame of external procedure lst. TOTAL_print_end internal procedure shares stack frame of external procedure lst. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME ARG_get_numeric_operand 000100 valX ARG_get_numeric_operand ERR 000100 codeP ERR ERROR_ROUTINE 000100 action ERROR_ROUTINE 000101 code ERROR_ROUTINE 000102 dir ERROR_ROUTINE 000154 ent ERROR_ROUTINE 000164 long ERROR_ROUTINE 000216 short ERROR_ROUTINE HANDLER 000100 code HANDLER 000101 common_depthI HANDLER 000102 depthI HANDLER 000103 depthN HANDLER 000104 dir HANDLER 000156 ent HANDLER 000166 last_ent HANDLER 000270 typeX HANDLER 000310 indentL NAMES_output 000311 lineL NAMES_output 000312 name NAMES_output 000323 names NAMES_output 000716 nameX NAMES_output 000726 code ENTRY_length 000727 digits ENTRY_length 000730 pages ENTRY_length 000731 quota ENTRY_length 000732 quota_used ENTRY_length lst 000100 auto_hd lst 000514 code lst 000516 hdP lst 000520 max_lineL lst 000521 pathX lst 000522 typeX lst 000532 afS lst 000533 argL lst 000534 argN lst 000536 argP lst 000540 argX lst 000541 opL lst 000542 opP lst 000544 retL lst 000546 retP lst 000550 sciP lst 000552 num_op lst 000553 archive_comp_type_found lst 000554 archive_type_found lst 000555 extended_types_found lst 000556 error_occurred_sw lst 000560 len lst 000562 typ lst 000565 line1 lst 000636 line2 lst 000707 line3 lst 000760 star_optionsP lst 000762 extended_entry_types_size lst 000763 match_names_size lst 000764 exclude_names_size lst 000766 star_dataP lst 000770 status lst 001012 code ARG_initialization 001052 code ARGS_init 001053 typeX ARGS_init 001064 archive_set ARGS_process 001065 inaee_set ARGS_process 001066 pathX ARGS_process 001104 standard_type EXTENDED_TYPE 001105 type EXTENDED_TYPE 001115 types EXTENDED_TYPE 001536 field TOTAL_print THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_e_as r_ne_as alloc_char_temp cat_realloc_chars call_ent_var call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 signal_op enable_op shorten_stack ext_entry int_entry int_entry_desc set_chars_eis index_chars_eis search_eis any_to_any_truncate_ index_after_cs THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ convert_status_code_ cu_$arg_list_ptr cu_$arg_list_ptr cu_$arg_ptr cu_$generate_call expand_pathname_ fs_star_$adjust_structure_size fs_star_$init fs_star_$select fs_star_$term get_line_length_$switch get_wdir_ hcs_$get_uid_file hcs_$quota_read hcs_$status_ ioa_ ioa_ pathname_ pathname_$component ssu_$abort_subsystem ssu_$arg_ptr ssu_$destroy_invocation ssu_$print_message ssu_$return_arg ssu_$standalone_invocation THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$active_function error_table_$bad_arg error_table_$bad_opt error_table_$no_s_permission error_table_$noarg error_table_$noarg error_table_$not_act_fnc error_table_$root LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 17 001414 118 001431 119 001432 121 001454 122 001464 124 001465 125 001466 126 001471 129 001501 130 001503 132 001527 133 001531 135 001543 137 001550 138 001553 139 001556 140 001557 143 001562 144 001566 145 001570 147 001571 148 001574 149 001577 160 001601 162 001614 163 001616 171 001706 172 001720 173 001731 174 001742 176 002006 178 002053 180 002120 182 002170 184 002235 186 002302 188 002347 190 002416 192 002463 193 002470 195 002504 197 002547 198 002551 199 002562 200 002563 202 002574 203 002575 209 002646 211 002652 222 002653 224 002661 281 002664 297 002702 299 002747 300 002751 302 002777 305 003004 306 003005 307 003024 309 003051 311 003074 312 003076 314 003102 315 003103 327 003104 334 003106 335 003111 336 003112 337 003127 339 003135 354 003142 361 003144 362 003147 363 003150 364 003165 365 003213 366 003215 368 003223 371 003231 404 003236 423 003257 426 003273 427 003277 428 003300 429 003314 430 003330 431 003356 432 003360 433 003362 435 003365 438 003422 429 003425 443 003432 444 003443 446 003445 447 003473 448 003476 449 003505 451 003522 456 003625 460 003633 462 003634 466 003661 467 003663 468 003670 477 004042 480 004050 482 004051 483 004057 491 004214 494 004222 510 004230 522 004246 523 004251 524 004252 525 004267 528 004275 532 004363 546 004371 548 004373 559 004402 570 004416 572 004432 607 004437 613 004440 614 004473 616 004516 617 004520 618 004521 619 004522 620 004524 621 004525 622 004527 623 004530 624 004531 625 004532 626 004533 628 004534 629 004535 631 004536 632 004537 633 004542 634 004545 636 004557 637 004575 638 004607 639 004621 640 004627 641 004636 643 004640 644 004655 645 004656 659 004657 666 004660 667 004661 668 004662 669 004667 670 004703 671 004720 672 004722 673 004723 674 004724 675 004740 676 004741 677 004743 679 004744 681 004760 684 004773 685 005003 688 005051 690 005052 691 005062 692 005115 693 005122 694 005127 696 005164 699 005213 700 005216 701 005226 702 005233 703 005236 704 005246 706 005247 707 005250 708 005260 710 005267 712 005270 713 005300 714 005303 715 005304 716 005305 717 005315 718 005317 719 005321 721 005322 723 005336 726 005351 727 005355 728 005410 729 005415 730 005422 732 005457 735 005506 736 005511 737 005521 738 005527 739 005532 740 005542 742 005543 743 005544 744 005554 746 005563 748 005564 750 005614 753 005633 754 005643 755 005674 756 005701 757 005706 759 005745 763 005774 764 006007 765 006015 766 006030 768 006031 769 006032 770 006042 772 006051 773 006052 775 006053 777 006073 780 006112 782 006132 785 006151 787 006171 790 006210 792 006234 795 006235 796 006242 798 006303 802 006337 803 006342 805 006351 807 006352 808 006356 809 006360 812 006374 813 006376 814 006407 816 006425 817 006427 820 006436 823 006447 826 006462 829 006474 833 006506 835 006513 847 006514 850 006522 851 006531 853 006541 863 006542 866 006543 867 006545 869 006546 881 006547 890 006560 891 006615 892 006623 893 006624 894 006635 896 006660 897 006665 899 006701 900 006705 901 006707 903 006714 906 006717 908 006721 909 006727 910 006735 911 006743 912 006745 914 006752 917 006755 919 006757 920 006765 921 006773 922 007001 923 007003 925 007010 928 007013 930 007015 933 007021 934 007026 935 007031 937 007070 940 007117 941 007122 942 007130 943 007131 959 007132 962 007135 963 007136 964 007137 966 007140 977 007146 980 007151 990 007163 993 007166 1003 007200 1006 007203 1026 007215 1043 007223 1044 007241 1045 007243 1046 007246 1047 007251 1048 007275 1052 007276 1055 007304 1056 007323 1057 007325 1058 007330 1059 007333 1060 007344 1062 007370 1074 007371 1077 007374 1078 007375 1087 007403 1090 007406 1103 007422 1121 007450 1123 007453 1124 007457 1125 007461 1126 007463 1128 007466 1131 007473 1132 007476 1134 007511 1136 007641 1139 007642 1140 007644 1141 007646 1142 007664 1143 007673 1144 007720 1145 007724 1146 007756 1148 007761 1149 007762 1151 010047 1153 010052 1154 010066 1161 010221 1162 010226 1164 010231 1188 010232 1204 010253 1206 010256 1207 010263 1208 010265 1209 010271 1210 010273 1213 010274 1215 010311 1216 010313 1217 010316 1219 010330 1222 010375 1224 010401 1225 010402 1228 010407 1230 010433 1231 010435 1232 010440 1233 010451 1236 010453 1238 010460 1239 010463 1240 010526 1241 010532 1243 010544 1244 010550 1245 010553 1246 010561 1247 010602 1248 010603 1251 010617 1252 010621 1253 010627 1254 010650 1256 010651 1257 010654 1260 010703 1261 010704 1262 010711 1263 010740 1265 010751 1266 010757 1267 010761 1268 010767 1269 010773 1270 010776 1271 010777 1273 011021 1275 011024 1278 011036 1280 011047 1281 011052 1284 011055 1288 011122 1293 011172 1294 011173 1295 011204 1296 011215 1297 011235 1298 011306 1299 011356 1300 011360 1301 011363 1302 011365 1303 011400 1304 011450 1305 011452 1307 011455 1309 011521 1322 011522 1343 011540 1346 011553 1349 011555 1352 011561 1355 011572 1358 011574 1360 011604 1364 011606 1371 011704 1373 011715 1377 012060 1379 012061 1389 012157 1393 012307 1395 012310 1399 012402 1412 012403 1427 012414 1428 012436 1430 012451 1432 012473 1433 012475 1434 012507 1435 012544 1436 012552 1437 012561 1438 012570 1439 012602 1440 012604 1441 012605 1443 012617 1444 012631 1445 012635 1446 012637 1463 012647 1474 012651 1479 012700 1480 012756 1482 012771 1483 012775 1484 013002 1485 013102 1488 013110 1489 013116 1490 013124 1491 013133 1509 013140 1524 013170 1526 013174 1527 013216 1528 013247 1529 013300 1531 013327 1533 013354 1535 013372 1537 013377 1538 013403 1539 013410 1541 013415 1542 013426 1545 013456 1546 013470 1547 013502 1548 013514 1549 013527 1550 013541 1552 013554 1553 013555 1557 013603 1558 013605 1559 013617 1560 013631 1562 013643 1563 013655 1564 013667 1565 013701 1566 013713 1567 013725 1568 013737 1569 013755 1570 013773 1572 014011 1582 014012 1587 014035 1599 014117 1602 014143 1603 014155 1604 014166 1605 014177 ----------------------------------------------------------- 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