THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT fs_star_ Compiled by: Multics PL/I Compiler, Release 30, of February 16, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/06/88 1420.7 mst Thu Options: optimize map 1 /****^ ******************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* ******************************************** */ 6 7 /****^ HISTORY COMMENTS: 8* 1) change(88-09-17,GDixon), approve(88-09-17,MCR7987), 9* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 10* A) Implement fs_star_, phases 1, as described in MTB781-01. 11* 2) change(88-09-19,GDixon), approve(88-09-20,MCR8007), 12* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 13* A) Implement remainder of phase 1, and implement phase 2, as described 14* in MTB781-02. 15* END HISTORY COMMENTS */ 16 17 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 18 /* */ 19 /* fs_star_: */ 20 /* The fs_star_ subroutine provides for uniform selection of file system entries, using star */ 21 /* names to select and exclude entries with additional selection by entry type. Multisegment files */ 22 /* and archives can be expanded to allow component-by-component processing; directories can be */ 23 /* expanded to allow processing of a directory subtree. Selected entries can be sorted in several */ 24 /* different ways, and then passed to a caller-provided handler routine for processing (subtree */ 25 /* listing or file initiation, etc). */ 26 /* */ 27 /* Implementation Notes: */ 28 /* fs_star_ is being implemented in several phases. For MR12.2, directory star names, and */ 29 /* sorting of entries are not yet implemented. .data_desired = DATA_INITIATE and .entry_type = */ 30 /* ENTRY_DONT_SELECT_NULL, ENTRY_DONT_SELECT_NONNULL, ENTRY_DONT_SELECT_OBJECTS, */ 31 /* ENTRY_DONT_SELECT_NONOBJECTS, ENTRY_DONT_SELECT_MDIRS, and ENTRY_DONT_SELECT_NONMDIRS are not */ 32 /* implemented either. */ 33 /* */ 34 /* A decision was made not to document this subroutine for external use by customers until all */ 35 /* features were complete. As a result, the only documentation for the subroutine exists in */ 36 /* MTB781-02. Refer to that MTB for complete details. */ 37 /* */ 38 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 39 40 fs_star_: 41 procedure(); 42 return; 43 44 /* PARAMETERS */ 45 dcl Pcaller_name char(*) parm; /* caller's name, if we create ssu_. */ 46 /* (In) */ 47 dcl Pcaller_version char(*) parm; /* caller's version, if we create ssu_. */ 48 /* (In) */ 49 dcl Pcode fixed bin(35) parm; /* status code. (Out) */ 50 dcl Pssu_sciP ptr parm; /* ptr to ssu sci_ptr for this group */ 51 /* of fs_star_ activations. If null, */ 52 /* we will create standalone ssu_ */ 53 /* for the caller. (In) */ 54 dcl Pstar_dataP ptr parm; /* ptr to star_data structure. */ 55 /* (Out points to star_data.matched) */ 56 dcl Pstar_optionsP ptr parm; /* ptr to star_options structure. */ 57 /* (Out from $init, In to all other eps)*/ 58 dcl Pstar_options_version char(8) parm; /* version of star_options the caller */ 59 /* is prepared to handle. (In) */ 60 dcl Pstructure_name char(*) parm; /* name of structure whose size is to be */ 61 /* adjusted. (In) */ 62 dcl Pstructure_version char(8) parm; /* name/version of structure for which */ 63 /* $adjust_structure_size must get */ 64 /* space. (In) */ 65 dcl Pnew_size fixed bin parm; /* number of elements desired in adjusted*/ 66 /* structure.array. (In) */ 67 /* =0 ==> make structure array as large */ 68 /* as possible. */ 69 70 /* AUTOMATIC SCALARS */ 71 dcl code fixed bin(35) auto; 72 dcl ssu_sciP ptr auto; /* ssu sci_ptr for our use. */ 73 dcl standalone_invocationS bit(1) auto; /* true => fs_star_ had to create a */ 74 /* standalone invocation of ssu_ */ 75 76 dcl 1 struct_header aligned auto, /* standard header beginning all structs */ 77 2 version char(8), /* in fs_star_.incl.pl1, except for */ 78 2 max_count fixed bin, /* star_options. */ 79 2 count fixed bin; 80 81 /* BASED */ 82 dcl 1 epath aligned based (epathP), 83 2 version char(8), 84 2 max_count fixed bin, 85 2 count fixed bin, 86 2 value (epath_size refer (epath.max_count)), 87 3 dir char(168) unal, 88 3 dir_type fixed bin(2), 89 3 dir_uid bit(36) aligned, 90 3 ent (1) char(32) unal, 91 3 ent_type fixed bin(2), 92 3 comp char(32) unal, 93 3 comp_type fixed bin(2), 94 epathP ptr auto, 95 epath_size fixed bin auto, 96 EPATH_VERSION_1 init("EPATH_V1") char(8) int static options(constant); 97 98 dcl 1 exn aligned based (fsd.exnP), 99 2 version char(8), 100 2 count fixed bin, /* copy of exclude_names structure with */ 101 2 array (exclude_names.count refer (exn.count)), 102 3 value char(32) unal, /* star_type added. */ 103 3 type fixed bin(2), 104 EXN_VERSION_1 init("EXN_VER1") char(8) int static options(constant); 105 106 dcl 1 fsd aligned based(fsdP),/* fs_star_data */ 107 2 version char(8), /* = FSD_VERSION_1 */ 108 2 next_spaceP ptr, /* next free space in star_options seg. */ 109 /* Used by $select and */ 110 /* $adjust_structure_size to determine */ 111 /* where to get space for next allocate.*/ 112 2 we_created_ssuS bit(1), /* $init called */ 113 /* ssu_$standalone_invocation. */ 114 2 fsd_pad fixed bin, /* pad to even word boundary. */ 115 2 star_dataP ptr, /* ptr to working star_data structure. */ 116 2 archP ptr, /* ptr to an archive being read. */ 117 2 epathP ptr, /* ptr to epath structure. */ 118 2 mnP ptr, /* ptr to mn structure. */ 119 2 exnP ptr, /* ptr to exn structure. */ 120 2 temp_segsP (10) ptr, /* ptrs to temp segs obtained from ssu_ */ 121 /* that must be released. */ 122 2 areasP (1) ptr; /* ptrs to areas obtained from ssu_ */ 123 /* that must be released. */ 124 dcl fsdP ptr; 125 dcl FSD_VERSION_1 init("FSD_VER1") char(8) int static options(constant); 126 127 dcl 1 mn aligned based (fsd.mnP), 128 2 version char(8), 129 2 count fixed bin, /* copy of match_names structure with */ 130 2 array (match_names.count refer (mn.count)), 131 3 value char(32) unal, /* star_type added for each value. */ 132 3 type fixed bin(2), 133 MN_VERSION_1 init("MN_VER1") char(8) int static options(constant); 134 135 dcl 1 sd aligned like star_data based(star_dataP); 136 137 dcl 1 so aligned like star_options based(star_optionsP); 138 139 /* BUILTINS and CONDITIONS */ 140 dcl (addr, addwordno, currentsize, dimension, divide, hbound, lbound, length, ltrim, max, mod, null, 141 pointer, rtrim, search, size, substr, sum, wordno) 142 builtin; 143 dcl cleanup condition; 144 145 /* ENTRIES */ 146 dcl archive_$next_component entry (ptr, fixed bin(24), ptr, fixed bin(24), char(*), 147 fixed bin(35)); 148 dcl check_star_name_ entry (char(*), bit(36), fixed bin(2), fixed bin(35)); 149 dcl cu_$arg_count entry (fixed bin, fixed bin(35)); 150 dcl cu_$arg_list_ptr entry returns(ptr); 151 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin(21), fixed bin(35)); 152 dcl cu_$generate_call entry (entry, ptr); 153 dcl expand_pathname_$component entry (char(*), char(*), char(*), char(*), fixed bin(35)); 154 dcl fs_util_$get_type entry (char(*), char(*), char(*), fixed bin(35)); 155 dcl hcs_$get_uid_file entry (char(*), char(*), bit(36) aligned, fixed bin(35)); 156 dcl hcs_$star_ entry (char(*), char(*), fixed bin(2), ptr, fixed bin, ptr, 157 ptr, fixed bin(35)); 158 dcl hcs_$status_ entry (char(*), char(*), fixed bin(1), ptr, ptr, 159 fixed bin(35)); 160 dcl hcs_$status_minf entry (char(*), char(*), fixed bin(1), fixed bin(2), 161 fixed bin(24), fixed bin(35)); 162 dcl hcs_$truncate_seg entry (ptr, fixed bin(19), fixed bin(35)); 163 dcl initiate_file_ entry (char(*), char(*), bit(*), ptr, fixed bin(24), 164 fixed bin(35)); 165 dcl ioa_$general_rs entry (ptr, fixed bin, fixed bin, char(*), fixed bin(21), 166 bit(1) aligned, bit(1) aligned); 167 dcl ioa_$rsnpnnl entry() options(variable); 168 dcl match_star_name_ entry (char(*), char(*), fixed bin(35)); 169 dcl pathname_ entry (char(*), char(*)) returns(char(168)); 170 dcl pathname_$component entry (char(*), char(*), char(*)) returns(char(194)); 171 dcl ssu_$destroy_invocation entry (ptr); 172 dcl ssu_$get_area entry (ptr, ptr, char(*), ptr); 173 dcl ssu_$get_temp_segment entry (ptr, char(*), ptr); 174 dcl ssu_$null_entry entry (); 175 dcl ssu_$print_message entry() options(variable); 176 dcl ssu_$release_area entry (ptr, ptr); 177 dcl ssu_$release_temp_segment entry (ptr, ptr); 178 dcl ssu_$standalone_invocation entry (ptr, char(*), char(*), ptr, entry, fixed bin(35)); 179 dcl sub_err_ entry() options(variable); 180 dcl terminate_file_ entry (ptr, fixed bin(24), bit(*), fixed bin(35)); 181 182 /* NAMED CONSTANTS */ 183 dcl (EP_ADJUST init(1), 184 EP_INIT init(2), 185 EP_REINIT init(3), 186 EP_SELECT init(4), 187 EP_TERM init(5)) fixed bin int static options(constant); 188 dcl EP_NAME (5) char(32) int static options(constant) init( 189 "fs_star_$adjust_structure_size", 190 "fs_star_$init", 191 "fs_star_$reinit", 192 "fs_star_$select", 193 "fs_star_$term"); 194 dcl (FALSE init("0"b), 195 TRUE init("1"b)) bit(1) int static options(constant); 196 dcl NO_CHASE init(0) fixed bin(1) int static options(constant); 197 dcl NO_NAMES init(-1) fixed bin(2) int static options(constant); 198 dcl (NOT_MSF init("0"b), 199 IS_MSF init("1"b)) bit(1) int static options(constant); 200 201 /* EXTERNAL STATIC */ 202 dcl (error_table_$archive_pathname, 203 error_table_$argerr, 204 error_table_$fatal_error, 205 error_table_$improper_data_format, 206 error_table_$inconsistent, 207 error_table_$noalloc, 208 error_table_$noentry, 209 error_table_$nomatch, 210 error_table_$nostars, 211 error_table_$null_name_component, 212 error_table_$root, 213 error_table_$smallarg, 214 error_table_$too_many_names, 215 error_table_$unimplemented_version, 216 error_table_$unsupported_operation) 217 fixed bin(35) ext static; 218 dcl sys_info$max_seg_size fixed bin(35) ext static; 219 220 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 221 /* */ 222 /* check_star_name.incl.pl1 */ 223 /* must appear before ARCHIVE_PATH_expand, which uses its constants in label array references. */ 224 /* It is being placed at the beginning of the program for this reason, rather than with the other */ 225 /* include files at the end of the program. */ 226 /* */ 227 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 228 1 1 /* BEGIN: check_star_name.incl.pl1 * * * * * */ 1 2 1 3 /****^ HISTORY COMMENTS: 1 4* 1) change(86-08-14,JSLove), approve(86-08-14,MCR7518), 1 5* audit(86-08-14,FCSmith), install(86-10-02,MR12.0-1174): 1 6* Created, to support check_star_name_ entrypoint. 1 7* 2) change(87-06-01,GDixon), approve(87-07-13,MCR7740), 1 8* audit(87-06-24,Hartogs), install(87-08-04,MR12.1-1056): 1 9* Change structures and bit structures to be unaligned, to match the 1 10* check_star_name_ parameters to which such strings are passed. 1 11* END HISTORY COMMENTS */ 1 12 1 13 /* format: style3,comcol71,ifthenstmt,indcomtxt,indproc,idind30 */ 1 14 1 15 declare 1 check_star aligned based, 1 16 2 reject_wild bit (1) unaligned, 1 17 2 ignore_archive bit (1) unaligned, 1 18 2 process_archive bit (1) unaligned, 1 19 2 ignore_entrypoint bit (1) unaligned, 1 20 2 process_entrypoint bit (1) unaligned, 1 21 2 ignore_path bit (1) unaligned, 1 22 2 process_path bit (1) unaligned, 1 23 2 ignore_equal bit (1) unaligned, 1 24 2 ignore_length bit (1) unaligned, 1 25 2 ignore_nonascii bit (1) unaligned, 1 26 2 ignore_null bit (1) unaligned, 1 27 2 unimplemented bit (25) unaligned; 1 28 1 29 declare ( 1 30 CHECK_STAR_ENTRY_DEFAULT initial ("00010001000"b), /* Behavior of check_star_name_$entry (obsolete). */ 1 31 CHECK_STAR_IGNORE_ALL initial ("01010101111"b), /* Check for *** and classify only. */ 1 32 CHECK_STAR_IGNORE_ARCHIVE initial ("01000000000"b), /* Do not reject archive convention "::". */ 1 33 CHECK_STAR_IGNORE_ENTRYPOINT initial ("00010000000"b), /* Do not reject "$" or "|" characters. */ 1 34 CHECK_STAR_IGNORE_EQUAL initial ("00000001000"b), /* Do not reject "=" or "%" characters. */ 1 35 CHECK_STAR_IGNORE_LENGTH initial ("00000000100"b), /* Do not reject star names longer than 32 chars. */ 1 36 CHECK_STAR_IGNORE_NONASCII initial ("00000000010"b), /* No not reject star names with nonASCII chars. */ 1 37 CHECK_STAR_IGNORE_NULL initial ("00000000001"b), /* Do not reject names with null components. */ 1 38 CHECK_STAR_IGNORE_PATH initial ("00000100000"b), /* Do not reject "<" or ">" characters. */ 1 39 CHECK_STAR_PATH_DEFAULT initial ("00110011100"b), /* Behavior of check_star_name_$path (obsolete). */ 1 40 CHECK_STAR_PROCESS_ARCHIVE initial ("00100000000"b), /* Process "::" as archive delimiter. */ 1 41 CHECK_STAR_PROCESS_ENTRYPOINT initial ("00001000000"b), /* Ignore trailing entrypoint if present. */ 1 42 CHECK_STAR_PROCESS_PATH initial ("00000010000"b), /* Ignore leading directory path if present. */ 1 43 CHECK_STAR_REJECT_WILD initial ("10000000000"b), /* Return error_table_$nostars if type not zero. */ 1 44 CHECK_STAR_UNIMPLEMENTED initial ("001FFFFFF"b4) /* Nonexistent test flags. Reject them. */ 1 45 ) bit (36) static options (constant); 1 46 1 47 declare ( 1 48 STAR_TYPE_MATCHES_EVERYTHING initial (2), 1 49 STAR_TYPE_USE_MATCH_PROCEDURE initial (1), 1 50 STAR_TYPE_USE_PL1_COMPARE initial (0) 1 51 ) fixed bin (2) static options (constant); 1 52 1 53 /* END OF: check_star_name.incl.pl1 * * * * * */ 229 230 231 dcl STAR_TYPE_UNSET init(-1) fixed bin int static options(constant); 232 233 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 234 /* */ 235 /* ENTRY POINT: adjust_structure_size */ 236 /* $init allocates space only for the star_paths structure. This entrypoint allocates space for */ 237 /* the exclude_names, extended_entry_types, and match_names structures. It can also enlarge any */ 238 /* of these structures beyond their current extents. */ 239 /* */ 240 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 241 242 adjust_structure_size: 243 entry (Pstar_optionsP, Pstructure_name, Pstructure_version, Pnew_size, Pcode); 244 245 Pcode = 0; /* initialize output parm. */ 246 247 call ENTRY_POINT_setup (EP_ADJUST); /* access fsd structure. */ 248 249 call STRUCT_name_version_size_check (Pstructure_name, Pstructure_version, Pnew_size); 250 /* make sure structure name and version */ 251 /* parms match up correctly. */ 252 253 call STRUCT_allocate (Pstructure_name, Pstructure_version, Pnew_size, EP_ADJUST); 254 /* allocate starting location for */ 255 /* structure we are getting. */ 256 257 ADJUST_EXIT: 258 return; 259 260 261 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 262 /* */ 263 /* SUPPORT PROCEDURES for $adjust_structure_size entrypoint */ 264 /* */ 265 /* SUPPORT PROCEDURE: ADJUST_error */ 266 /* Set Pcode parm and do nonlocal transfer to exit immediately from fs_star_. */ 267 /* */ 268 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 269 270 ADJUST_error: 271 procedure (Pcode_in); 272 273 dcl Pcode_in fixed bin(35) parm; 274 275 if Pcode_in = 0 then return; 276 if Pcode = 0 then 277 Pcode = Pcode_in; 278 go to ADJUST_EXIT; 279 end ADJUST_error; 280 281 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 282 283 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 284 /* */ 285 /* SUPPORT PROCEDURE: STRUCT_name_version_size_check */ 286 /* Validates that Pstructure_name and Pstructure_version parms correspond with one another. */ 287 /* Checks for a negative structure size. $adjust_structure_size returns with error codes if */ 288 /* either check fails its criteria. */ 289 /* */ 290 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 291 292 STRUCT_name_version_size_check: 293 procedure (Pstruct_name, Pstruct_version, Pstruct_size); 294 295 dcl Pstruct_name char(*) parm, 296 Pstruct_version char(8) parm, 297 Pstruct_size fixed bin parm; 298 299 if Pstruct_name = "exclude_names" & Pstruct_version = STAR_EXCLUDE_NAMES_VERSION_1 then; 300 else if Pstruct_name = "extended_entry_types" & Pstruct_version = STAR_EXTENDED_ENTRY_VERSION_1 then; 301 else if Pstruct_name = "match_names" & Pstruct_version = STAR_MATCH_NAMES_VERSION_1 then; 302 else if Pstruct_name = "star_paths" & Pstruct_version = STAR_PATHS_VERSION_1 then; 303 else call ADJUST_error (error_table_$argerr); 304 305 if Pstruct_size < 0 then 306 call ADJUST_error (error_table_$smallarg); 307 308 if Pstruct_version = STAR_EXCLUDE_NAMES_VERSION_1 then do; 309 if star_options.exclude_namesP ^= null then 310 if exclude_names.count > Pstruct_size then 311 call ADJUST_error (error_table_$inconsistent); 312 end; 313 else if Pstruct_version = STAR_EXTENDED_ENTRY_VERSION_1 then do; 314 if star_options.extended_entry_typesP ^= null then 315 if extended_entry_types.count > Pstruct_size then 316 call ADJUST_error (error_table_$inconsistent); 317 end; 318 else if Pstruct_version = STAR_MATCH_NAMES_VERSION_1 then do; 319 if star_options.match_namesP ^= null then 320 if match_names.count > Pstruct_size then 321 call ADJUST_error (error_table_$inconsistent); 322 end; 323 else if Pstruct_version = STAR_PATHS_VERSION_1 then do; 324 if star_options.star_pathsP ^= null then 325 if star_paths.count > Pstruct_size then 326 call ADJUST_error (error_table_$inconsistent); 327 end; 328 329 end STRUCT_name_version_size_check; 330 331 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 332 333 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 334 /* */ 335 /* ENTRY POINT: init */ 336 /* Initializes storage and functions needed to use fs_star_. This includes the following steps: */ 337 /* */ 338 /* 1) Validate the caller-requested version ID. */ 339 /* 2) If the caller did not already have an ssu_ invocation, then create one on his behalf for use */ 340 /* by fs_star_. */ 341 /* 3) Get the first temporary segment used by fs_star_. This one will hold the star_options, fsd, */ 342 /* and star_paths structures. */ 343 /* 4) Initialize these structures and return them to the caller. */ 344 /* */ 345 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 346 347 init: 348 entry (Pssu_sciP, Pcaller_name, Pcaller_version, Pstar_options_version, Pstar_optionsP, Pcode); 349 350 Pstar_optionsP = null; /* set output arguments */ 351 Pcode = 0; 352 353 call INIT_cleanup_setup(); 354 on cleanup call INIT_cleanup(); /* establish cleanup handler. */ 355 356 if Pstar_options_version = STAR_OPTIONS_VERSION_1 then; /* check for known star_options version */ 357 else call INIT_error (error_table_$unimplemented_version); 358 359 if ssu_sciP = null then do; /* caller doesn't have its own ssu_ */ 360 standalone_invocationS = TRUE; /* invocation? We'll create one. */ 361 call ssu_$standalone_invocation (ssu_sciP, Pcaller_name, Pcaller_version, null, ERROR_unexpected, 362 code); 363 call INIT_error (code); 364 end; 365 366 call ssu_$get_temp_segment (ssu_sciP, "star_options", star_optionsP); 367 so.version = STAR_OPTIONS_VERSION_1; /* create, initialize star_options */ 368 so.caller.ssu_sciP = ssu_sciP; 369 370 call FSD_init(); 371 372 so.star_pathsP = null; 373 call STRUCT_allocate ("star_paths", STAR_PATHS_VERSION_1, 10, EP_INIT); 374 375 so.selection.path_allow = PATH_ALLOW_ENTRY_STAR_NAMES; /* continue initialization of */ 376 so.selection.entry_type = ENTRY_RETURN; /* star_options structure. */ 377 so.selection.extended_entry_typesP = null; 378 so.selection.match_namesP = null; 379 so.selection.exclude_namesP = null; 380 381 so.per_entry.sorting = SORT_OFF; 382 so.per_entry.handler = ssu_$null_entry; 383 so.per_entry.error = ssu_$null_entry; 384 so.per_entry.handler_dataP = null; 385 so.per_entry.data_desired = DATA_TYPE; 386 so.per_entry.data_version = STAR_DATA_VERSION_1; 387 so.mbz = ""b; 388 389 Pstar_optionsP = star_optionsP; 390 return; 391 392 INIT_EXIT: 393 call INIT_cleanup(); 394 Pstar_optionsP = null; 395 return; 396 397 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 398 /* */ 399 /* SUPPORT PROCEDURES for the $init entrypoint: */ 400 /* */ 401 /* SUPPORT PROCEDURE: INIT_cleanup */ 402 /* cleans up changes which $init made to the runtime environment, in case when $init failed or */ 403 /* was aborted (its activation was released by a nonlocal goto). */ 404 /* */ 405 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 406 407 INIT_cleanup: 408 procedure; 409 if standalone_invocationS then 410 call ssu_$destroy_invocation (ssu_sciP); 411 else if star_optionsP ^= null then 412 call ssu_$release_temp_segment (ssu_sciP, star_optionsP); 413 end INIT_cleanup; 414 415 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 416 /* */ 417 /* SUPPORT PROCEDURE: INIT_cleanup_setup */ 418 /* initializes variables referenced by the INIT_cleanup routine. */ 419 /* */ 420 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 421 422 INIT_cleanup_setup: 423 procedure; 424 standalone_invocationS = FALSE; 425 ssu_sciP = Pssu_sciP; 426 star_optionsP = null; 427 end INIT_cleanup_setup; 428 429 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 430 /* */ 431 /* SUPPORT PROCEDURE: INIT_error */ 432 /* routine to check error codes. If zero, the routine returns. If nonzero, it sets $init's */ 433 /* Pcode output parm and exits from $init. */ 434 /* */ 435 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 436 437 INIT_error: 438 procedure (Pcode_in); 439 440 dcl Pcode_in fixed bin(35) parm; 441 442 if Pcode_in = 0 then return; 443 if Pcode = 0 then 444 Pcode = Pcode_in; 445 go to INIT_EXIT; 446 end INIT_error; 447 448 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 449 450 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 451 /* */ 452 /* ENTRY POINT: reinit */ 453 /* Frees all allocated space, plus structures associated with star_options (eg, star_paths, */ 454 /* match_names, exclude_names and extended_entry_types structures). A new star_paths structure */ 455 /* (with 10-element array) is allocated. All other elements of star_options remain as they were */ 456 /* set prior to the call to $reinit. */ 457 /* */ 458 /* * * * * * * * * * * * * * * * * * * * * aller's */ 538 /* error routine is called to report the error, and expansion stops. */ 539 /* 2) Uses archive_$next_component to scan through all components of the archive. */ 540 /* 3) For each component, the component name is compared with the user's archive component starname, */ 541 /* using match_star_name_ when necessary. Matching components are counted and passed to the */ 542 /* caller's handler routine. Nonmatching components are skipped. */ 543 /* 4) Finally, the archive is terminate. Note that this procedure does not need its own cleanup on */ 544 /* unit, because fs_star_$term acts as a cleanup on unit (established by the caller), and it will */ 545 /* terminate the segment if it finds fsd.archP nonnull. */ 546 /* */ 547 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 548 549 ARCHIVE_PATH_expand: 550 procedure (Pdepth, Pfree_areaP, Ppath, Pent, Psort_order); 551 552 dcl Pdepth fixed bin parm; /* INPUT PARAMETERS */ 553 dcl Pfree_areaP ptr parm; 554 dcl 1 Ppath aligned like epath.value parm; 555 dcl Pent (*) char(32) unal parm; 556 dcl Psort_order fixed bin parm; 557 558 /* AUTOMATIC */ 559 dcl archL fixed bin(24) auto; /* length of an archive. */ 560 dcl code fixed bin(35) auto; 561 dcl compL fixed bin(24) auto; /* length of a component */ 562 dcl compP ptr auto; /* ptr to a component. */ 563 dcl comp_name char(32) auto; /* name of a component. */ 564 dcl snN fixed bin auto; 565 dcl snP ptr auto; 566 dcl sn (snN) char(32) based (snP); 567 568 fsd.archP = null; 569 if Ppath.ent_type ^= STAR_TYPE_MATCHES_EVERYTHING then do; 570 status_area_ptr = TEMP_AREA_get(); /* hcs_$star_ returns only entry names */ 571 status_ptr = addr(auto_status); /* which match the star name. We must */ 572 call hcs_$status_ (Ppath.dir, Pent(1), NO_CHASE, /* return all names, so get them now. */ 573 status_ptr, status_area_ptr, code); 574 if code = 0 then do; 575 snP = addr(status_names); 576 snN = dimension(status_names,1); 577 end; 578 else do; 579 snP = addr(Pent); 580 snN = dimension(Pent,1); 581 end; 582 end; 583 else do; 584 snP = addr(Pent); 585 snN = dimension(Pent,1); 586 end; 587 588 sd.entry_data.type = ENTRY_TYPE_ARCHIVE; 589 call initiate_file_ (Ppath.dir, Pent(1), R_ACCESS, fsd.archP, archL, code); 590 call ARCHIVE_PATH_error (Pdepth-1, code, Ppath.dir, sn, "", "initiating archive"); 591 compP = null; 592 593 if archL = 0 then; 594 else do while (TRUE); 595 call archive_$next_component (fsd.archP, archL, compP, compL, comp_name, code); 596 call ARCHIVE_PATH_error (Pdepth, code, Ppath.dir, sn, "", "reading archive"); 597 if compP = null then 598 go to FINAL_ARCH_ENTRY; 599 go to ARCH_NAME (Ppath.comp_type); 600 601 ARCH_NAME (STAR_TYPE_USE_PL1_COMPARE): 602 if comp_name = Ppath.comp then 603 go to MATCHING_ARCH_ENTRY; 604 else 605 go to NEXT_ARCH_ENTRY; 606 607 ARCH_NAME (STAR_TYPE_USE_MATCH_PROCEDURE): 608 call match_star_name_ (comp_name, Ppath.comp, code); 609 if code = 0 then 610 go to MATCHING_ARCH_ENTRY; 611 else 612 go to NEXT_ARCH_ENTRY; 613 614 ARCH_NAME (STAR_TYPE_MATCHES_EVERYTHING): 615 MATCHING_ARCH_ENTRY: 616 if ((so.entry_type.arch_comps & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then; 617 else do; 618 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_ARCHIVE_COMP, 698 call ssu_$print_message (ssu_sciP, error_table_$unsupported_operation, 699 "fs_star_ error routine returned unknown action code (=^d).", action); 700 if Pcode = 0 then 701 Pcode = error_table_$unsupported_operation; 702 go to SELECT_EXIT; 703 end; 704 end; 705 end ARCHIVE_PATH_error; 706 707 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 708 709 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 710 /* */ 711 /* SUPPORT PROCEDURE: ARCHIVE_PATH_handler */ 712 /* This procedure calls the caller-supplied star_options.handler procedure for each selected */ 713 /* entry. The caller's handler may return an action code which controls how fs_star_ continues */ 714 /* in its processing of the entry. */ 715 /* */ 716 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 717 718 ARCHIVE_PATH_handler: 719 procedure (Pdir, Pents, Pcomp); 720 721 dcl Pdir char(168) parm; 722 dcl Pents (*) char(32) unal parm; 723 dcl Pcomp char(32) parm; 724 725 dcl action fixed bin auto; 726 727 if ^SELECT_further (star_data.entry_data.type, (Pcomp)) then 728 go to REMOVE_ARCH_ENTRY; 729 730 call so.handler (addr(star_data), Pdir, Pents, Pcomp, action); 731 732 if action = HANDLER_OK then; 733 else if action = HANDLER_REJECT then 734 go to REMOVE_ARCH_ENTRY; 735 else if action = HANDLER_DONT_EXPAND then; 736 else if action = HANDLER_EXPAND then; 737 else if action = HANDLER_EXPAND_DONT_COUNT then 738 go to REMOVE_ARCH_ENTRY; 739 else if action = HANDLER_DONT_COUNT then 740 go to REMOVE_ARCH_ENTRY; 741 else if action = HANDLER_STOP then 742 go to SELECT_EXIT; 743 else if action = HANDLER_ABORT then 744 go to REMOVE_ARCH_ENTRY_AND_EXIT; 745 else 746 call SELECT_error (error_table_$unsupported_operation, 747 "fs_star_ handler routine returned unknown action code (=^d).", action); 748 749 end ARCHIVE_PATH_handler; 750 751 end ARCHIVE_PATH_expand; 752 753 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 754 755 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 756 /* */ 757 /* SUPPORT PROCEDURE: EVAL_PATHS_expand */ 758 /* For each evaluated, sorted input path, this procedure calls PATH_expand to expand the entry. */ 759 /* It first gets an area pointer from ssu_ for use in calls to hcs_$star_ and */ 760 /* archive_$list_components. */ 761 /* */ 762 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 763 764 EVAL_PATHS_expand: 765 procedure(); 766 767 dcl code fixed bin(35) auto; 768 dcl free_areaP ptr auto; 769 dcl matched_before fixed bin auto; 770 dcl pathX fixed bin auto; 771 772 free_areaP = TEMP_AREA_get(); 773 774 do pathX = lbound (epath.value,1) to epath.count; 775 matched_before = sd.matched.current; 776 call PATH_expand (1, NOT_MSF, free_areaP, epath.value(pathX), so.sorting.dir_ents(1)); 777 if sd.matched.current - matched_before = 0 then do; /* Report nomatch errors only for paths */ 778 /* caller specified. */ 779 if epath.ent_type(pathX) = STAR_TYPE_USE_PL1_COMPARE then do; 780 call hcs_$status_minf (epath.dir(pathX), epath.en* * * * * * * * * * * */ 857 /* */ 858 /* star_structures.incl.pl1 */ 859 /* must be included in PATH_expand because PATH_expand is called recursively, and each recursion */ 860 /* needs copies of automatic variables declared in this include file. It must be included before */ 861 /* the TYPE labels so those label array constants can include named constants declared in this */ 862 /* include file. For example, TYPE(star_SEGMENT): */ 863 /* */ 864 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 865 2 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 2 2 2 3 /* This include file contains structures for the hcs_$star_, 2 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 2 5* 2 6* Written 23 October 1978 by Monte Davidoff. 2 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 2 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 2 9**/ 2 10 2 11 /* automatic */ 2 12 2 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 2 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 2 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 2 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 2 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 2 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 2 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 2 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 2 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 2 22 2 23 /* based */ 2 24 2 25 /* hcs_$star_ entry structure */ 2 26 2 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 2 28 2 type fixed binary (2) unsigned unaligned, 2 29 /* storage system type */ 2 30 2 nnames fixed binary (16) unsigned unaligned, 2 31 /* number of names of entry that match star_name */ 2 32 2 nindex fixed binary (18) unsigned unaligned; 2 33 /* index of first name in star_names */ 2 34 2 35 /* hcs_$star_ name structure */ 2 36 2 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 2 38 2 39 /* hcs_$star_list_ branch structure */ 2 40 2 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 42 2 type fixed binary (2) unsigned unaligned, 2 43 /* storage system type */ 2 44 2 nnames fixed binary (16) unsigned unaligned, 2 45 /* number of names of entry that match star_name */ 2 46 2 nindex fixed binary (18) unsigned unaligned, 2 47 /* index of first name in star_list_names */ 2 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 2 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 2 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 53 2 pad bit (7) unaligned, 2 54 2 records fixed binary (18) unsigned unaligned; 2 55 /* records used by branch */ 2 56 2 57 /* hcs_$star_dir_list_ branch structure */ 2 58 2 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 60 2 type fixed binary (2) unsigned unaligned, 2 61 /* storage system type */ 2 62 2 nnames fixed binary (16) unsigned unaligned, 2 63 /* number of names of entry that match star_name */ 2 64 2 nindex fixed binary (18) unsigned unaligned, 2 65 /* index of first name in star_list_names */ 2 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 2 67 2 pad bit (36) unaligned, 2 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 71 2 bit_count fixed binary (24) unaligned; 2 72 /* bit count of the branch */ 2 73 2 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 2 75 2 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 77 2 type fixed binary (2) unsigned unaligned, 2 78 /* storage system type */ 2 79 2 nnames fixed binary (16) unsigned unaligned, 2 80 /* number of names of entry that match star_name */ 2 81 2 nindex fixed binary (18) unsigned unaligned, 2 82 /* index of first name in star_list_names */ 2 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 2 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 2 85 2 pathname_len fixed binary (18) unsigned unaligned, 2 86 /* length of the pathname of the link */ 2 87 2 pathname_index fixed binary (18) unsigned unaligned; 2 88 /* index of start of pathname in star_list_names */ 2 89 2 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 2 91 2 92 declare star_list_names char (32) based (star_list_names_ptr) 2 93 dimension (star_links (star_branch_count + star_link_count).nindex 2 94 + star_links (star_branch_count + star_link_count).nnames 2 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 2 96 * binary ( 2 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 2 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 2 99 2 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 2 101 2 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 2 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 2 104 2 105 /* internal static */ 2 106 2 107 /* star_select_sw values */ 2 108 2 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 2 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 2 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 2 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 2 113 fixed binary (3) internal static options (constant) initial (5); 2 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 2 115 fixed binary (3) internal static options (constant) initial (7); 2 116 2 117 /* storage system types */ 2 118 2 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 2 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 2 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 2 122 2 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 866 867 868 dcl (fs_star_ARCHIVE init(3), /* NAMED CONSTANTS which add to the dir */ 869 fs_star_MSF init(4), /* entry types defined in the above */ 870 fs_star_MSF_COMP init(5), /* star_structures.incl.pl1, used in */ 871 fs_star_DM_FILE init(6), /* TYPE label array constants below. */ 872 fs_star_EXTENDED_ENTRY init(7) 873 ) fixed bin int static options(constant); 874 875 dcl 1 ROOT_ENTRY aligned int static options(constant), 876 2 type fixed bin(2) uns unal init(star_DIRECTORY), 877 2 nnames fixed bin(16) uns unal init(1), 878 2 nindex fixed bin(18) uns unal init(1), 879 ROOT_NAME char(32) int static options(constant) init(""); 880 /* This is information that hcs_$star_ */ 881 /* should return about the root (>). */ 882 883 sd.entry_data.type = ENTRY_TYPE_DIRECTORY; /* Set for use by PATH_error for errors */ 884 /* reported prior to entering do-group. */ 885 886 call hcs_$star_ (Ppath.dir, Ppath.ent(1), star_ALL_ENTRIES, addr(free_area), star_entry_count, 887 star_entry_ptr, star_names_ptr, code); /* Expansion of starname. */ 888 889 890 if code = error_table_$nomatch then do; /* Don't report no_match errors but check*/ 891 if (Ppath.dir = ">") & (Ppath.ent(1) = "") then do; /* for searching the root dir (>) */ 892 star_entry_count = 1; /* Must fake root dir (>); hcs_$star_ */ 893 star_entry_ptr = addr(ROOT_ENTRY); /* doesn't understand it as a directory.*/ 894 star_names_ptr = addr(ROOT_NAME); 895 code = 0; 896 go to PROCESS_STAR_ENTRIES; 897 end; 898 end; 899 900 else if code ^= 0 then /* Report other errors against dir itself*/ 901 call PATH_error (Pdepth, code, Ppath.dir, "", NO_NAMES, "", "", 0); 902 903 else do; /* Process entries selected by starname. */ 904 PROCESS_STAR_ENTRIES: 905 do starX = 1 to star_entry_count while (Psort_order = SORT_REVERSE), 906 star_entry_count to 1 by -1 while (Psort_order ^= SORT_REVERSE); 907 seP = addr(star_entries(starX)); /* Overlay entry names MATCHING starname,*/ 908 snP = addr(star_names(se.nindex)); /* and data returned by hcs_$star_. */ 909 snN = se.nnames; 910 if star_LINK <= se.type | se.type <= star_DIRECTORY then; 911 else call PATH_error (Pdepth, error_table_$improper_data_format, Ppath.dir, sn, 912 Ppath.ent_type, "", "hcs_$star_ returned unknown dir entry type (=^d)", (se.type)); 913 go to TYPE (se.type); /* Process entries by standard entry type*/ 914 /* returned by hcs_$star_, and by */ 915 /* extended entry types... */ 916 917 TYPE (star_LINK): 918 if (so.entry_type.links & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN then; 919 else do; 920 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_LINK, Pdepth); 921 if ((so.entry_type.links & ENTRY_CHASE_ALL_LINKS) = ENTRY_CHASE_ALL_LINKS) then do; 922 CHASE_LINKS: call hcs_$status_minf (Ppath.dir, sn(1), CHASE, type, bc, code); 923 call PATH_error (Pdepth, code, Ppath.dir, sn, Ppath.ent_type, "", 924 "calling hcs_$status_minf", 0); 925 if (type = star_LINK) & 926 ((so.entry_type.links & ENTRY_DONT_SELECT_NULL) = ENTRY_DONT_SELECT_NULL) then 927 go to REMOVE_ENTRY; 928 else if (type ^= star_LINK) & 929 ((so.links & ENTRY_DONT_SELECT_NONNULL) = ENTRY_DONT_SELECT_NONNULL) then 930 go to REMOVE_ENTRY; 931 call PATH_MATCH_ENTRY_remove(); 932 if star_LINK <= type | type <= star_DIRECTORY then; 933 else call PATH_error (Pdepth, error_table_$improper_data_format, Ppath.dir, sn, 934 Ppath.ent_type, "", "hcs_$status_minf returned unknown dir entry type (=^d)", type); 935 go to TYPE (type); 936 end; 937 else if ((so.entry_type.links & ENTRY_CHASE_NONSTAR_LINKS) = ENTRY_CHASE_NONSTAR_LINKS) & 938 (Ppath.ent_type = STAR_TYPE_USE_PL1_COMPARE) then 939 go to CHASE_LINKS; 940 else do; 941 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 942 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 943 call PATH_MATCH_ENTRY_remove(); 944 end; 945 end; 946 go to NEXT_ENTRY; 947 948 TYPE (star_SEGMENT): 949 do nameX = lbound(sn,1) to hbound(sn, 1); /* Is segment an archive? */ 950 if PATH_suffix (sn(nameX), ".archive") then 951 go to TYPE (fs_star_ARCHIVE); 952 end; 953 if Pparent_is_msf then /* Is is an MSF component? */ 954 go to TYPE (fs_star_MSF_COMP); 955 if ((so.entry_type.segs & ENTRY_INAEE) = ENTRY_INAEE) then do; 956 call fs_util_$get_type (Ppath.dir, sn(1), fs_util_type, code); 957 if code = 0 then 958 if fs_util_type ^= ENTRY_TYPE_SEGMENT then 959 go to TYPE (fs_star_EXTENDED_ENTRY); /* Only report extended entries if caller*/ 960 end; /* asked for these. */ 961 if ((so.entry_type.segs & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then; 962 else do; 963 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_SEGMENT, Pdepth); 964 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 965 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 966 call PATH_MATCH_ENTRY_remove(); 967 end; 968 go to NEXT_ENTRY; 969 970 TYPE (fs_star_MSF_COMP): 971 if ((so.entry_type.msf_comps & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then; 972 else do; 973 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_MSF_COMP, Pdepth); 974 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 975 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 976 call PATH_MATCH_ENTRY_remove(); 977 end; 978 go to NEXT_ENTRY; 979 980 TYPE (fs_star_ARCHIVE): 981 if ((so.entry_type.archives & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then 982 action = HANDLER_OK; 983 else do; 984 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_ARCHIVE, Pdepth); 985 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 986 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 987 call PATH_MATCH_ENTRY_remove(); 988 end; 989 if (((so.entry_type.archives & ENTRY_LIST_SUBENTRIES) = ENTRY_LIST_SUBENTRIES) & 990 (action ^= HANDLER_DONT_EXPAND)) | 991 (action = HANDLER_EXPAND) | (action = HANDLER_EXPAND_DONT_COUNT) then do; 992 path = Ppath; 993 path.ent(1) = sn(nameX); 994 path.ent_type = STAR_TYPE_USE_PL1_COMPARE; 995 if path.comp = "" then do; 996 path.comp = "**"; 997 path.comp_type = STAR_TYPE_MATCHES_EVERYTHING; 998 end; 999 call ARCHIVE_PATH_expand (Pdepth+1, addr(free_area), path, sn, Psort_order); 1000 end; 1001 go to NEXT_ENTRY; 1002 1003 TYPE (star_DIRECTORY): 1004 call fs_util_$get_type (Ppath.dir, sn(1), fs_util_type, code); 1005 if code = 0 then do; /* We could determine if a dir is really */ 1006 if fs_util_type = ENTRY_TYPE_MSF then /* an MSF or DM file, but fs_util_ does */ 1007 go to TYPE (fs_star_MSF); /* it better. Don't reinvent the wheel.*/ 1008 if fs_util_type = ENTRY_TYPE_DM_FILE then 1009 go to TYPE (fs_star_DM_FILE); 1010 if ((so.entry_type.dirs & ENTRY_INAEE) = ENTRY_INAEE) then 1011 if fs_util_type ^= ENTRY_TYPE_DIRECTORY then 1012 go to TYPE (fs_star_EXTENDED_ENTRY); /* Only report extended entries if caller*/ 1013 end; /* asked for these. */ 1014 if ((so.entry_type.dirs & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then 1015 action = HANDLER_OK; /* Report directory to caller. */ 1016 else do; 1017 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_DIRECTORY, Pdepth); 1018 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 1019 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 1020 call PATH_MATCH_ENTRY_remove(); 1021 end; 1022 if (((so.entry_type.dirs & ENTRY_LIST_SUBENTRIES) = ENTRY_LIST_SUBENTRIES) & 1023 (action ^= HANDLER_DONT_EXPAND)) | /* Expand, if caller asked us to. */ 1024 (action = HANDLER_EXPAND) | (action = HANDLER_EXPAND_DONT_COUNT) then do; 1025 path.dir = rtrim(pathname_(Ppath.dir, sn(1))); 1026 path.dir_type = STAR_TYPE_USE_PL1_COMPARE; 1027 path.dir_uid = ""b; 1028 path.ent(1) = "**"; 1029 path.ent_type = STAR_TYPE_MATCHES_EVERYTHING; 1030 path.comp = ""; 1031 path.comp_type = STAR_TYPE_USE_PL1_COMPARE; 1032 call PATH_expand (Pdepth+1, NOT_MSF, Pfree_areaP, path, Psort_order); 1033 end; 1034 go to NEXT_ENTRY; 1035 1036 TYPE (fs_star_MSF): 1037 if ((so.entry_type.msfs & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then 1038 action = HANDLER_OK; 1039 else do; 1040 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_MSF, Pdepth); 1041 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 1042 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 1043 call PATH_MATCH_ENTRY_remove(); 1044 end; 1045 if (((so.entry_type.msfs & ENTRY_LIST_SUBENTRIES) = ENTRY_LIST_SUBENTRIES) & 1046 (action ^= HANDLER_DONT_EXPAND)) | 1047 (action = HANDLER_EXPAND) | (action = HANDLER_EXPAND_DONT_COUNT) then do; 1048 path.dir = rtrim(pathname_(Ppath.dir, sn(1))); 1049 path.dir_type = STAR_TYPE_USE_PL1_COMPARE; 1050 path.dir_uid = ""b; 1051 path.ent(1) = "**"; 1052 path.ent_type = STAR_TYPE_MATCHES_EVERYTHING; 1053 path.comp = ""; 1054 path.comp_type = STAR_TYPE_USE_PL1_COMPARE; 1055 call PATH_expand (Pdepth+1, IS_MSF, Pfree_areaP, path, Psort_order); 1056 end; 1057 go to NEXT_ENTRY; 1058 1059 TYPE (fs_star_DM_FILE): 1060 if ((so.entry_type.dm_files & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then 1061 go to NEXT_ENTRY; 1062 call PATH_MATCH_ENTRY_add (ENTRY_TYPE_DM_FILE, Pdepth); 1063 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 1064 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 1065 call PATH_MATCH_ENTRY_remove(); 1066 go to NEXT_ENTRY; 1067 1068 TYPE (fs_star_EXTENDED_ENTRY): 1069 if ((so.entry_type.extended_entries & ENTRY_DONT_RETURN) = ENTRY_DONT_RETURN) then 1070 go to NEXT_ENTRY; 1071 call PATH_MATCH_ENTRY_add (fs_util_type, Pdepth); 1072 call PATH_handler (Ppath.dir, sn, Ppath.ent_type, "", action); 1073 if action = HANDLER_EXPAND_DONT_COUNT | action = HANDLER_DONT_COUNT then 1074 call PATH_MATCH_ENTRY_remove(); 1075 go to NEXT_ENTRY; 1076 1077 REMOVE_ENTRY: 1078 call PATH_MATCH_ENTRY_remove(); 1079 1080 NEXT_ENTRY: 1081 end; 1082 1083 if star_names_ptr ^= addr(ROOT_NAME) then do; 1084 if star_names_ptr ^= null then 1085 free star_names in (free_area); 1086 if star_entry_ptr ^= null then 1087 free star_entries in (free_area); 1088 end; 1089 end; 1090 return; 1091 1092 REMOVE_ENTRY_AND_EXIT: 1093 call PATH_MATCH_ENTRY_remove(); 1094 go to SELECT_EXIT; 1095 1096 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1097 1098 PATH_expand_error: 1099 entry (Pdepth, Pcode_in, Ppath, Pent_type, Pmessage, Pioa_arg); 1100 1101 dcl Pcode_in fixed bin(35) parm; 1102 dcl Pent_type fixed bin(2) parm; 1103 dcl Pmessage char(*) parm; 1104 dcl Pioa_arg fixed bin(2) parm; 1105 1106 call PATH_error (Pdepth, Pcode_in, Ppath.dir, Ppath.ent, Pent_type, Ppath.comp, Pmessage, Pioa_arg); 1107 return; 1108 1109 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1110 1111 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1112 /* */ 1113 /* SUPPORT PROCEDURE: PATH_error */ 1114 /* If Pcode_in = 0, then return. */ 1115 /* Otherwise, expand error message and invoke caller's error handler. */ 1116 /* If caller did not provide an error handler, then print error ourselves. */ 1117 /* If caller's action code is ERROR_OK or ERROR_REJECT, then continue by processing the next */ 1118 /* pathname. */ 1119 /* If his action code is ERROR_STOP or ERROR_ABORT, then set Pcode parm of $select and do nonlocal */ 1120 /* transfer to exit immediately from fs_star_. */ 1121 /* */ 1122 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1123 1124 PATH_error: 1125 procedure (Pdepth, Pcode_in, Pdir, Pent, Pent_type, Pcomp, Pmessage, Pioa_arg); 1126 1127 dcl Pdepth fixed bin parm; 1128 dcl Pcode_in fixed bin(35) parm; 1129 dcl Pdir char(*) parm; 1130 dcl Pent (*) char(32) unal parm; 1131 dcl Pent_type fixed bin(2) parm; 1132 dcl Pcomp char(32) parm; 1133 dcl Pmessage char(*) parm; 1134 dcl Pioa_arg fixed bin(2) parm; 1135 1136 dcl action fixed bin auto; 1137 dcl code fixed bin(35) auto; 1138 dcl expanded_message char(200) varying; 1139 1140 if Pcode_in = 0 then return; 1141 1142 star_data.entry_data.depth = Pdepth; 1143 call ioa_$rsnpnnl (Pmessage, expanded_message, 0, Pioa_arg); 1144 1145 if so.error = ssu_$null_entry then do; /* caller did NOT provide an error */ 1146 call ssu_$print_message (ssu_sciP, Pcode_in, "^[ in ^a ^;^s^]^[^a^s^;^s^a^]^[^/(^a)^;^s^]", 1147 sd.entry_data.type ^= ENTRY_TYPE_UNKNOWN, ltrim(sd.entry_data.type,"-"), 1148 Pent(lbound(Pent,1))="", Pdir, pathname_$component (Pdir, Pent(lbound(Pent,1)), Pcomp), 1149 expanded_message^="", expanded_message); 1150 action = ERROR_REJECT; 1151 end; 1152 else do; 1153 if Pent_type = NO_NAMES | Pent_type = STAR_TYPE_MATCHES_EVERYTHING then do; 1154 call so.error (addr(star_data), Pdir, Pent, Pcomp, Pcode_in, (expanded_message), action); 1155 end; 1156 else do; /* hcs_$star_ returns only entry names */ 1157 status_area_ptr = TEMP_AREA_get(); /* which match the star name. We must */ 1158 status_ptr = addr(auto_status); /* return all names, so get them now. */ 1159 call hcs_$status_ (Pdir, Pent(1), NO_CHASE, status_ptr, status_area_ptr, code); 1160 if code = 0 then do; 1161 call so.error (addr(star_data), Pdir, status_names, Pcomp, Pcode_in, 1162 (expanded_message), action); 1163 free status_entry_names in (status_area); 1164 end; 1165 else 1166 call so.error (addr(star_data), Pdir, Pent, Pcomp, Pcode_in, (expanded_message), action); 1167 end; 1168 end; 1169 1170 if Pent_type = NO_NAMES then do; /* Caller has not entered do-group to */ 1171 /* process entries from hcs_$star_. */ 1172 if action = ERROR_STOP | action = ERROR_ABORT then /* Only honor STOP/ABORT action, by */ 1173 go to SELECT_EXIT; /* exiting fs_star_$select; otherwise */ 1174 else return; /* just return to caller, who will */ 1175 end; /* continue with next input path. */ 1176 1177 else do; /* Caller has entered do-group. */ 1178 if action = ERROR_OK then /* Count errant entry. */ 1179 go to NEXT_ENTRY; 1180 else if action = ERROR_REJECT then /* Remove errant entry from count. */ 1181 go to REMOVE_ENTRY; 1182 else if action = ERROR_STOP then /* Exit fs_star_$select immediately. */ 1183 go to SELECT_EXIT; 1184 else if action = ERROR_ABORT then /* Remove errant entry from count, then */ 1185 go to REMOVE_ENTRY_AND_EXIT; /* exit fs_star_$select. */ 1186 else do; /* Unknown action code value. */ 1187 call ssu_$print_message (ssu_sciP, error_table_$unsupported_operation, 1188 "fs_star_ error routine returned unknown action code (=^d).", action); 1189 if Pcode = 0 then 1190 Pcode = error_table_$unsupported_operation; 1191 go to SELECT_EXIT; 1192 end; 1193 end; 1194 end PATH_error; 1195 1196 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1197 1198 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1199 /* */ 1200 /* SUPPORT PROCEDURE: PATH_handler */ 1201 /* This procedure calls the caller-supplied star_options.handler procedure for each selected */ 1202 /* entry. The caller's handler may return an action code which controls how fs_star_ continues */ 1203 /* in its processing of the entry. Every PATH_handler caller must handle the following actions */ 1204 /* in a manner appropriate to the type of entry: */ 1205 /* HANDLER_DONT_EXPAND */ 1206 /* no error, but handler does not want dir/archive/msf expanded. */ 1207 /* HANDLER_EXPAND */ 1208 /* no error, but expand dir/archive/msf even if this is contrary to what */ 1209 /* star_options.entry_type says for this type of entry. */ 1210 /* HANDLER_EXPAND_DONT_COUNT */ 1211 /* no error, but handler does not accept the entry. It should not be counted but should be */ 1212 /* expanded. */ 1213 /* HANDLER_DONT_COUNT */ 1214 /* no error, but handler does not want entry counted. Expansion depends upon what */ 1215 /* star_options.entry_type says for this type of entry. */ 1216 /* */ 1217 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1218 1219 PATH_handler: 1220 procedure (Pdir, Pents, Pent_type, Pcomp, Paction); 1221 1222 dcl Pdir char(168) parm; 1223 dcl Pents (*) char(32) unal parm; 1224 dcl Pent_type fixed bin(2) parm; 1225 dcl Pcomp char(32) parm; 1226 dcl Paction fixed bin parm; 1227 dcl code fixed bin(35) auto; 1228 1229 if Pent_type = NO_NAMES | Pent_type = STAR_TYPE_MATCHES_EVERYTHING then do; 1230 if ^SELECT_further (star_data.entry_data.type, Pents) then 1231 Paction = HANDLER_DONT_COUNT; 1232 else 1233 call so.handler (addr(star_data), Pdir, Pents, Pcomp, Paction); 1234 end; 1235 else do; /* hcs_$star_ returns only names which */ 1236 status_area_ptr = TEMP_AREA_get(); /* match the star name. We must return */ 1237 status_ptr = addr(auto_status); /* all names, so get them now. */ 1238 call hcs_$status_ (Pdir, Pents(1), NO_CHASE, status_ptr, status_area_ptr, code); 1239 if code = 0 then do; 1240 if ^SELECT_further (star_data.entry_data.type, status_names) then 1241 Paction = HANDLER_DONT_COUNT; 1242 else 1243 call so.handler (addr(star_data), Pdir, status_names, Pcomp, Paction); 1244 free status_entry_names in (status_area); 1245 end; 1246 else do; 1247 if ^SELECT_further (star_data.entry_data.type, Pents) then 1248 Paction = HANDLER_DONT_COUNT; 1249 else 1250 call so.handler (addr(star_data), Pdir, Pents, Pcomp, Paction); 1251 end; 1252 end; 1253 1254 if Paction = HANDLER_OK then 1255 return; 1256 else if Paction = HANDLER_REJECT then 1257 go to REMOVE_ENTRY; 1258 else if Paction = HANDLER_DONT_EXPAND then; /* These 4 action codes must be */ 1259 else if Paction = HANDLER_EXPAND then; /* handled by */ 1260 else if Paction = HANDLER_EXPAND_DONT_COUNT then; /* each caller of */ 1261 else if Paction = HANDLER_DONT_COUNT then; /* PATH_handler. */ 1262 else if Paction = HANDLER_STOP then 1263 go to SELECT_EXIT; 1264 else if Paction = HANDLER_ABORT then 1265 go to REMOVE_ENTRY_AND_EXIT; 1266 else 1267 call SELECT_error (error_table_$unsupported_operation, 1268 "fs_star_ handler routine returned unknown action code (=^d).", Paction); 1269 1270 end PATH_handler; 1271 1272 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1273 1274 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1275 /* */ 1276 /* SUPPORT PROCEDURE: PATH_suffix */ 1277 /* This procedure determines whether a given entry name ends in a given suffix (eg, .archive). */ 1278 /* */ 1279 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1280 1281 PATH_suffix: 1282 procedure (Pname, Psuffix) returns (bit(1) aligned); 1283 1284 dcl Pname char(32) unal parm; 1285 dcl Psuffix char(*) parm; 1286 1287 dcl nameL fixed bin auto; 1288 dcl suffixL fixed bin auto; 1289 dcl suffixI fixed bin auto; 1290 1291 nameL = length (rtrim (Pname)); 1292 suffixL = length (rtrim (Psuffix)); 1293 suffixI = max(1, nameL - suffixL + 1); 1294 if substr(Pname, suffixI) = substr(Psuffix, 1, suffixL) then 1295 return (TRUE); 1296 else 1297 return (FALSE); 1298 end PATH_suffix; 1299 1300 end PATH_expand; 1301 1302 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1303 1304 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1305 /* */ 1306 /* SUPPORT PROCEDURES: PATH_MATCH_ENTRY_add, PATH_MATCH_ENTRY_remove */ 1307 /* These procedure entry points add/remove the current entry to the entry counts in */ 1308 /* star_data.matched. _add takes an Pentry_type parameter, stores it in star_data.entry_data.type, */ 1309 /* and then increments the corresponding element of star_data.matched. _remove uses */ 1310 /* star_data.entry_data.type to decrement the corresponding element of star_data.matched. */ 1311 /* */ 1312 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1313 1314 PATH_MATCH_ENTRY_add: 1315 procedure (Pentry_type, Pdepth); 1316 1317 dcl Pentry_type char(32) unal parm; 1318 dcl Pdepth fixed bin parm; 1319 1320 dcl addend fixed bin auto; 1321 dcl entry_type char(32) auto; 1322 1323 entry_type, sd.entry_data.type = Pentry_type; 1324 sd.entry_data.depth = Pdepth; 1325 addend = +1; 1326 go to SET_MATCHED; 1327 1328 PATH_MATCH_ENTRY_remove: 1329 entry; 1330 1331 entry_type = sd.entry_data.type; 1332 sd.entry_data.type = ENTRY_TYPE_UNSET; 1333 addend = -1; 1334 go to SET_MATCHED; 1335 1336 SET_MATCHED: 1337 sd.matched.current = sd.matched.current + addend; 1338 if entry_type = ENTRY_TYPE_LINK then 1339 sd.matched.links = sd.matched.links + addend; 1340 else if entry_type = ENTRY_TYPE_SEGMENT then 1341 sd.matched.segs = sd.matched.segs + addend; 1342 else if entry_type = ENTRY_TYPE_DIRECTORY then 1343 sd.matched.dirs = sd.matched.dirs + addend; 1344 else if entry_type = ENTRY_TYPE_MSF then 1345 sd.matched.msfs = sd.matched.msfs + addend; 1346 else if entry_type = ENTRY_TYPE_MSF_COMP then 1347 sd.matched.msf_comps = sd.matched.msf_comps + addend; 1348 else if entry_type = ENTRY_TYPE_DM_FILE then 1349 sd.matched.dm_files = sd.matched.dm_files + addend; 1350 else if entry_type = ENTRY_TYPE_ARCHIVE then 1351 sd.matched.archives = sd.matched.archives + addend; 1352 else if entry_type = ENTRY_TYPE_ARCHIVE_COMP then 1353 sd.matched.arch_comps = sd.matched.arch_comps + addend; 1354 else 1355 sd.matched.extended_entries = sd.matched.extended_entries + addend; 1356 1357 end PATH_MATCH_ENTRY_add; 1358 1359 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1360 1361 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1362 /* */ 1363 /* SUPPORT PROCEDURE: SELECT_error */ 1364 /* If Pcode_in = 0, then return. */ 1365 /* Otherwise, expand error message and invoke caller's error handler. Ignore his action code, */ 1366 /* since calls to SELECT_error are always immediately fatal. */ 1367 /* If caller did not provide an error handler, then print error ourselves. */ 1368 /* Set Pcode parm of $select and do nonlocal transfer to exit immediately from fs_star_. */ 1369 /* */ 1370 /* Syntax: call SELECT_error (code, IOA_CTL_STR, args); */ 1371 /* */ 1372 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1373 1374 SELECT_error: 1375 procedure options(variable); 1376 1377 dcl Pcode_inP ptr auto; /* AUTOMATIC */ 1378 dcl action fixed bin auto; 1379 dcl code fixed bin(35) auto; 1380 dcl message_space char(500); 1381 dcl message_len fixed bin(21); 1382 1383 /* BASED */ 1384 dcl Pcode_in fixed bin(35) based (Pcode_inP); 1385 dcl message char (message_len) based (addr(message_space)); 1386 1387 /* NAMED CONSTANTS */ 1388 dcl (DONT_PAD, DONT_NL) init ("0"b) bit(1) aligned int static options(constant); 1389 1390 call cu_$arg_ptr (1, Pcode_inP, 0, code); 1391 if Pcode_in = 0 then return; 1392 1393 call ioa_$general_rs (cu_$arg_list_ptr(), 2, 3, message_space, message_len, DONT_PAD, DONT_NL); 1394 1395 if so.error = ssu_$null_entry then 1396 call ssu_$print_message (ssu_sciP, Pcode_in, message); 1397 else 1398 call so.error (addr(star_data), "", "", "", Pcode_in, message, action); 1399 /* Ignore action here, since all calls */ 1400 /* to this procedure are fatal if */ 1401 /* Pcode_in is nonzero. */ 1402 if Pcode = 0 then 1403 Pcode = Pcode_in; 1404 go to SELECT_EXIT; 1405 end SELECT_error; 1406 1407 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1408 1409 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1410 /* */ 1411 /* SUPPORT PROCEDURE: SELECT_further */ 1412 /* This function makes further checks on selected entries to determine whether they are selected */ 1413 /* by values in the match_names structure, excluded by values in the exclude_names structure, and */ 1414 /* selected by values in the extended_entry_types structure. */ 1415 /* */ 1416 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1417 1418 SELECT_further: 1419 procedure (Pentry_type, Pnames) returns(bit(1) aligned); 1420 1421 dcl Pentry_type char(32) unal parm; 1422 dcl Pnames (*) char(32) unal parm; 1423 1424 dcl (nameX, matchX) fixed bin auto; 1425 1426 if fsd.mnP ^= null then do; 1427 do nameX = lbound(Pnames,1) to hbound(Pnames,1); 1428 do matchX = lbound(mn.value,1) to hbound(mn.value,1); 1429 go to MATCH(mn.type(matchX)); 1430 1431 MATCH (STAR_TYPE_USE_PL1_COMPARE): 1432 if Pnames(nameX) = mn.value(matchX) then 1433 go to MATCH_FOUND; 1434 go to MATCH_NEXT; 1435 1436 MATCH (STAR_TYPE_USE_MATCH_PROCEDURE): 1437 call match_star_name_ (Pnames(nameX), mn.value(matchX), code); 1438 if code = 0 then 1439 go to MATCH_FOUND; 1440 go to MATCH_NEXT; 1441 1442 MATCH_NEXT: end; 1443 end; 1444 return (FALSE); 1445 end; 1446 MATCH_FOUND: 1447 MATCH (STAR_TYPE_MATCHES_EVERYTHING): 1448 1449 if fsd.exnP ^= null then do; 1450 do nameX = lbound(Pnames,1) to hbound(Pnames,1); 1451 do matchX = lbound(exn.value,1) to hbound(exn.value,1); 1452 go to EXCL(exn.type(matchX)); 1453 1454 EXCL (STAR_TYPE_USE_PL1_COMPARE): 1455 if Pnames(nameX) = exn.value(matchX) then 1456 go to EXCL_FOUND; 1457 go to EXCL_NEXT; 1458 1459 EXCL (STAR_TYPE_USE_MATCH_PROCEDURE): 1460 call match_star_name_ (Pnames(nameX), exn.value(matchX), code); 1461 if code = 0 then 1462 go to EXCL_FOUND; 1463 go to EXCL_NEXT; 1464 1465 EXCL_NEXT: end; 1466 end; 1467 go to EXCL_NOT_FOUND; 1468 EXCL_FOUND: 1469 EXCL (STAR_TYPE_MATCHES_EVERYTHING): 1470 return (FALSE); 1471 end; 1472 EXCL_NOT_FOUND: 1473 1474 if so.extended_entry_typesP ^= null then do; 1475 if extended_entry_types.count > 0 then do; 1476 do matchX = lbound(extended_entry_types.value,1) to extended_entry_types.count; 1477 if Pentry_type = extended_entry_types.value(matchX) then 1478 go to ET_OK; 1479 end; 1480 return (FALSE); 1481 end; 1482 end; 1483 ET_OK: 1484 return (TRUE); 1485 1486 end SELECT_further; 1487 1488 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1489 1490 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1491 /* */ 1492 /* SELECT_further_init: */ 1493 /* This procedure copies match_names.value and exclude_names.value arrays into mn and exn */ 1494 /* structures, in order to associate a starname type with each array element. Any errors in format */ 1495 /* of the star names are reported via SELECT_error. */ 1496 /* */ 1497 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1498 1499 SELECT_further_init: 1500 procedure(); 1501 1502 dcl code fixed bin(35) auto; 1503 dcl matchX fixed bin auto; 1504 1505 if so.exclude_namesP ^= null then do; 1506 if exclude_names.version ^= STAR_EXCLUDE_NAMES_VERSION_1 then 1507 call SELECT_error (error_table_$unimplemented_version, 1508 "exclude_names.version (=""^a"") must be STAR_EXCLUDE_NAMES_VERSION_1 (=""^a"").", 1509 exclude_names.version, STAR_EXCLUDE_NAMES_VERSION_1); 1510 if exclude_names.count > 0 then do; 1511 call STRUCT_allocate ("exn", EXN_VERSION_1, exclude_names.count, EP_SELECT); 1512 do matchX = lbound(exn.array,1) to hbound(exn.array,1); 1513 exn.value(matchX) = exclude_names.value(matchX); 1514 call check_star_name_ (exn.value(matchX), CHECK_STAR_ENTRY_DEFAULT, exn.type(matchX),code); 1515 call SELECT_error (code, "Invalid exclude_names.value ^a", exn.value(matchX)); 1516 end; 1517 end; 1518 end; 1519 1520 if so.match_namesP ^= null then do; 1521 if match_names.version ^= STAR_MATCH_NAMES_VERSION_1 then 1522 call SELECT_error (error_table_$unimplemented_version, 1523 "match_names.version (=""^a"") must be STAR_MATCH_NAMES_VERSION_1 (=""^a"").", 1524 match_names.version, STAR_MATCH_NAMES_VERSION_1); 1525 if match_names.count > 0 then do; 1526 call STRUCT_allocate ("mn", MN_VERSION_1, match_names.count, EP_SELECT); 1527 do matchX = lbound(mn.array,1) to hbound(mn.array,1); 1528 mn.value(matchX) = match_names.value(matchX); 1529 call check_star_name_ (mn.value(matchX), CHECK_STAR_ENTRY_DEFAULT, mn.type(matchX), code); 1530 call SELECT_error (code, "Invalid match_names.value ^a", mn.value(matchX)); 1531 end; 1532 end; 1533 end; 1534 1535 if so.extended_entry_typesP ^= null then do; 1536 if extended_entry_types.version ^= STAR_EXTENDED_ENTRY_VERSION_1 then 1537 call SELECT_error (error_table_$unimplemented_version, 1538 "extended_entry_types.version (=""^a"") must be STAR_EXTENDED_ENTRY_VERSION_1(=""^a"").", 1539 extended_entry_types.version, STAR_EXTENDED_ENTRY_VERSION_1); 1540 end; 1541 1542 end SELECT_further_init; 1543 1544 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1545 1546 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1547 /* */ 1548 /* SUPPORT PROCEDURE: STAR_PATHS_evaluate */ 1549 /* Procedure which analyzes incoming star_paths.value array, expanding each pathname, breaking it */ 1550 /* down into dir/ent/arch_comp parts, determining the star-type of each part, etc. Directory star */ 1551 /* names are not fully supported; archive component names are rejected, though full analysis */ 1552 /* support for archive component names IS provided below. (It is missing in other internal */ 1553 /* procedures, however.) Duplicate pathnames are eliminated, as final step in the evaluation. */ 1554 /* */ 1555 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1556 1557 STAR_PATHS_evaluate: 1558 procedure(); 1559 1560 dcl code fixed bin(35) auto, 1561 (pathX, prevX, star_pathX) fixed bin auto; 1562 1563 if ((so.path_allow & PATH_ALLOW_DIR_STAR_NAMES) = PATH_ALLOW_DIR_STAR_NAMES) then 1564 /* diagnose path support not implemented */ 1565 /* in phase 1. */ 1566 call SELECT_error (error_table_$unsupported_operation, 1567 "star_options.path_allow does not support directory star names."); 1568 1569 if so.star_pathsP = null then /* diagnose input pathname errors */ 1570 call SELECT_error (error_table_$argerr, "star_options.star_pathsP is a null pointer."); 1571 if star_paths.count > star_paths.max_count then 1572 call SELECT_error (error_table_$inconsistent, 1573 "star_paths.count (=^d) > star_paths.max_count (=^d)", star_paths.count, star_paths.max_count); 1574 if star_paths.count <= 0 then 1575 call SELECT_error (error_table_$argerr, 1576 "star_paths.count (=^d) must be positive.", star_paths.count); 1577 1578 call STRUCT_allocate ("evaluated_paths", EPATH_VERSION_1, star_paths.count, EP_SELECT); 1579 1580 call STAR_PATHS_error_init(); 1581 1582 pathX = 0; 1583 do star_pathX = lbound(star_paths.value,1) to star_paths.count; 1584 epath.count, pathX = pathX + 1; 1585 call expand_pathname_$component (star_paths.value(star_pathX), epath.dir(pathX), 1586 epath.ent(pathX,1), epath.comp(pathX), code); 1587 call STAR_PATHS_error (code, ENTRY_TYPE_UNKNOWN, star_paths.value(star_pathX), "", "", ""); 1588 1589 1590 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1591 /* */ 1592 /* Directory star names (ie, stars in any directory entry name except the last) are not fully */ 1593 /* implemented in phase 1 of fs_star_. When implemented, dir stars should probably be expanded */ 1594 /* here. This would mean the epath.value array could be larger than star_path.value. Its size will */ 1595 /* have to be increased (to full seg) above, epath.count will have to be compared to */ 1596 /* epath.max_count, and structure size will have to be adjusted downward once all epath entries are */ 1597 /* set. */ 1598 /* */ 1599 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1600 1601 if (search(epath.dir(pathX), "*?") > 0) & 1602 ^((so.path_allow & PATH_ALLOW_DIR_STAR_NAMES) = PATH_ALLOW_DIR_STAR_NAMES) then do; 1603 epath.dir_type(pathX) = STAR_TYPE_USE_MATCH_PROCEDURE; 1604 call STAR_PATHS_error (error_table_$nostars, ENTRY_TYPE_UNKNOWN, 1605 epath.dir(pathX), epath.ent(pathX,*), epath.comp(pathX), "invalid directory star name"); 1606 end; 1607 else 1608 epath.dir_type(pathX) = STAR_TYPE_USE_PL1_COMPARE; 1609 call hcs_$get_uid_file (epath.dir(pathX), "", epath.dir_uid(pathX), code); 1610 if code = error_table_$root then 1611 epath.dir_uid(pathX) = "777777777777"b3; 1612 else 1613 call STAR_PATHS_error (code, ENTRY_TYPE_UNKNOWN, epath.dir(pathX), "", "", ""); 1614 1615 call check_star_name_ (epath.ent(pathX,1), CHECK_STAR_ENTRY_DEFAULT, epath.ent_type(pathX), 1616 code); 1617 if (code = error_table_$null_name_component) & (epath.dir(pathX) = ">") then 1618 epath.ent_type(pathX) = STAR_TYPE_USE_PL1_COMPARE; 1619 else 1620 call STAR_PATHS_error (code, ENTRY_TYPE_UNKNOWN, epath.dir(pathX), epath.ent(pathX,*), 1621 epath.comp(pathX), "invalid entryname"); 1622 if (epath.ent_type(pathX) ^= STAR_TYPE_USE_PL1_COMPARE) & 1623 ^((so.path_allow & PATH_ALLOW_ENTRY_STAR_NAMES) = PATH_ALLOW_ENTRY_STAR_NAMES) then 1624 call STAR_PATHS_error (error_table_$nostars, ENTRY_TYPE_UNKNOWN, 1625 epath.dir(pathX), epath.ent(pathX,*), epath.comp(pathX), "invalid entryname"); 1626 1627 if epath.comp(pathX) ^= "" then do; 1628 if ^((so.path_allow & PATH_ALLOW_ARCHIVE_COMPONENTS) = PATH_ALLOW_ARCHIVE_COMPONENTS) then 1629 call STAR_PATHS_error (error_table_$archive_pathname, ENTRY_TYPE_UNKNOWN, 1630 epath.dir(pathX), epath.ent(pathX,*), epath.comp(pathX), ""); 1631 call check_star_name_ (epath.comp(pathX), CHECK_STAR_ENTRY_DEFAULT, 1632 epath.comp_type(pathX), code); 1633 call STAR_PATHS_error (code, ENTRY_TYPE_UNKNOWN, epath.dir(pathX), 1634 epath.ent(pathX,*), epath.comp(pathX), "invalid archive component name"); 1635 if (epath.comp_type(pathX) ^= STAR_TYPE_USE_PL1_COMPARE) & 1636 ^((so.path_allow & PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES) = PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES) then 1637 call STAR_PATHS_error (code, ENTRY * * * */ 1727 1728 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1729 /* */ 1730 /* ENTRY POINT: term */ 1731 /* Cleans up from the fs_star_ operations by releasing all associated storage created by ssu_, and */ 1732 /* by destroying the ssu_ invocation use by fs_star_ (if fs_star_ created it on the caller's */ 1733 /* behalf). */ 1734 /* */ 1735 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1736 1737 term: 1738 entry (Pstar_optionsP); 1739 1740 if Pstar_optionsP = null then return; 1741 1742 call ENTRY_POINT_setup (EP_TERM); 1743 1744 call FSD_reinit(); 1745 if fsd.we_created_ssuS then 1746 call ssu_$destroy_invocation (ssu_sciP); 1747 else 1748 call ssu_$release_temp_segment (ssu_sciP, star_optionsP); 1749 return; 1750 1751 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1752 1753 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1754 /* */ 1755 /* SUPPORT PROCEDURES for all entrypoints: */ 1756 /* */ 1757 /* SUPPORT PROCEDURE: ENTRY_POINT_setup */ 1758 /* initialize pointers to all important structures. */ 1759 /* */ 1760 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1761 1762 ENTRY_POINT_setup: 1763 procedure (Pcalling_ep); 1764 1765 dcl Pcalling_ep fixed bin parm; 1766 1767 star_optionsP = Pstar_optionsP; /* access fixed structures */ 1768 if star_optionsP = null then do; 1769 if Pcalling_ep = EP_ADJUST then 1770 call ADJUST_error (error_table_$argerr); 1771 else if Pcalling_ep = EP_SELECT then 1772 call SELECT_error (error_table_$argerr, "star_optionsP parameter is a null pointer."); 1773 else 1774 call ERROR_unexpected (error_table_$argerr, EP_NAME(Pcalling_ep), ACTION_CANT_RESTART, 1775 null, 0, "star_optionsP parameter is a null pointer."); 1776 end; 1777 else if star_options.version ^= STAR_OPTIONS_VERSION_1 then do; 1778 if Pcalling_ep = EP_ADJUST then 1779 call ADJUST_error (error_table_$unimplemented_version); 1780 else if Pcalling_ep = EP_SELECT then 1781 call SELECT_error (error_table_$unimplemented_version, 1782 "star_options.version (=^a) must be STAR_OPTIONS_VERSION_1 (=^a).", 1783 star_options.version, STAR_OPTIONS_VERSION_1); 1784 else 1785 call ERROR_unexpected (error_table_$unimplemented_version, EP_NAME(Pcalling_ep), 1786 ACTION_CANT_RESTART, null, 0, 1787 "star_options.version (=^a) must be STAR_OPTIONS_VERSION_1 (=^a).", 1788 star_options.version, STAR_OPTIONS_VERSION_1); 1789 end; 1790 1791 ssu_sciP = so.ssu_sciP; 1792 fsdP = so.fs_star_dataP; 1793 1794 end ENTRY_POINT_setup; 1795 1796 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1797 1798 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1799 /* */ 1800 /* SUPPORT PROCEDURE: ERROR_unexpected */ 1801 /* This procedure makes a final effort to abort in a meaningful way, when all else fails. It */ 1802 /* calls sub_err_ to report an unexpected condition to the user. Its calling sequence is the same */ 1803 /* as sub_err_. */ 1804 /* */ 1805 /* Syntax: call ERROR_unexpected (code, name, sub_err_flag, info_ptr, retal, ioa_ctl_str, ioa_args); */ 1806 /* */ 1807 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1808 1809 ERROR_unexpected: 1810 procedure options (variable); 1811 1812 dcl argsN fixed bin auto; 1813 dcl code fixed bin(35) auto; 1814 1815 call cu_$arg_count (argsN, code); 1816 if argsN = 0 then /* ssu_$standalone_invocation abort. */ 1817 call sub_err_ (error_table_$fatal_error, "fs_star_", ACTION_CANT_RESTART, null, 0, 1818 "fs_star_'s ssu_ standalone invocation aborted."); 1819 else 1820 call cu_$generate_call (sub_err_, cu_$arg_list_ptr()); 1821 end ERROR_unexpected; 1822 1823 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1824 1825 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1826 /* */ 1827 /* SUPPORT PROCEDURE: FSD_init */ 1828 /* This procedure initializes the fs_star_ internal data structure, fsd. */ 1829 /* */ 1830 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1831 1832 FSD_init: 1833 procedure(); 1834 1835 so.caller.fs_star_dataP, 1836 fsdP = STRUCT_get_space ("fsd", size(fsd), EP_INIT); /* create fs_star_ data structure in */ 1837 fsd.version = FSD_VERSION_1; /* temp seg following star_options. */ 1838 call STRUCT_get_next_space (addr(fsd), currentsize(fsd)); 1839 fsd.we_created_ssuS = standalone_invocationS; /* initialize the structure so */ 1840 fsd.fsd_pad = 0; /* $adjust_structure_size will work. */ 1841 fsd.star_dataP = null; 1842 fsd.archP = null; 1843 fsd.epathP = null; 1844 fsd.mnP = null; 1845 fsd.exnP = null; 1846 fsd.temp_segsP(*) = null; 1847 fsd.areasP(*) = null; 1848 return; 1849 1850 1851 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1852 /* */ 1853 /* SUPPORT PROCEDURE: FSD_reinit */ 1854 /* This support procedure entry point resets the fs_star_ internal data structure, fsd, to the */ 1855 /* state it was set to by fs_star_$init. */ 1856 /* */ 1857 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1858 1859 FSD_reinit: 1860 entry(); 1861 1862 fsd.version = FSD_VERSION_1; 1863 call STRUCT_get_next_space (addr(fsd), currentsize(fsd)); 1864 /* fsd.we_created_ssuS remains unchanged by $reinit. */ 1865 fsd.fsd_pad = 0; 1866 fsd.star_dataP = null; 1867 if fsd.archP ^= null then /* if an archive segment was initiated */ 1868 call terminate_file_ (fsd.archP, 0, /* and not terminated (due to nonlocal */ 1869 TERM_FILE_TERM, code); /* goto, then terminate it now. */ 1870 fsd.epathP = null; 1871 fsd.mnP = null; 1872 fsd.exnP = null; 1873 call TEMP_SEGS_AREAS_term(); /* reset .temp_segsP and .areasP */ 1874 call hcs_$truncate_seg (fsd.next_spaceP, wordno(fsd.next_spaceP), code); 1875 /* get rid of extra pages at end of temp */ 1876 return; /* seg containing star_options structure*/ 1877 end FSD_init; 1878 1879 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1880 1881 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1882 /* */ 1883 /* SUPPORT PROCEDURE: STRUCT_allocate */ 1884 /* Initializes space for a given structure, setting structure refer extents to maximum size if the */ 1885 /* caller gives an array_size of 0. */ 1886 /* */ 1887 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1888 1889 STRUCT_allocate: 1890 procedure (Pstruct_name, Pstruct_version, Pstruct_array_size, Pcalling_ep); 1891 1892 dcl Pstruct_name char(*) parm, 1893 Pstruct_version char(8) parm, 1894 Pstruct_array_size fixed bin parm, 1895 Pcalling_ep fixed bin parm; 1896 1897 dcl Pnew_struct ptr auto, 1898 struct_elem_size fixed bin auto; 1899 1900 if Pstruct_version = EPATH_VERSION_1 then do; 1901 epath_size = Pstruct_array_size; 1902 if epath_size = 0 then do; 1903 epath_size = 1; 1904 struct_elem_size = size(epath) - size(struct_header); 1905 epath_size = 1906 divide (sys_info$max_seg_size - currentsize(struct_header), struct_elem_size, 17, 0); 1907 end; 1908 if fsd.epathP = null then do; 1909 fsd.epathP, epathP = STRUCT_get_space (Pstruct_name, size(epath), Pcalling_ep); 1910 epath.version = Pstruct_version; 1911 epath.max_count = epath_size; 1912 epath.count = 0; 1913 call STRUCT_get_next_space (addr(epath), currentsize(epath)); 1914 end; 1915 else do; 1916 epathP = fsd.epathP; 1917 Pnew_struct = STRUCT_get_space (Pstruct_name, size(epath), Pcalling_ep); 1918 Pnew_struct -> epath.version = Pstruct_version; 1919 Pnew_struct -> epath.max_count = epath.max_count; 1920 Pnew_struct -> epath.count = epath.count; 1921 if epath.count > 0 then 1922 Pnew_struct -> epath.value = epath.value; 1923 Pnew_struct -> epath.max_count = epath_size; 1924 fsd.epathP, epathP = Pnew_struct; 1925 call STRUCT_get_next_space (addr(epath), currentsize(epath)); 1926 end; 1927 end; 1928 1929 else if Pstruct_version = STAR_EXCLUDE_NAMES_VERSION_1 then do; 1930 exclude_names_size = Pstruct_array_size; 1931 if exclude_names_size = 0 then do; 1932 exclude_names_size = 1; 1933 struct_elem_size = size(exclude_names) - size(struct_header); 1934 exclude_names_size = 1935 divide (sys_info$max_seg_size - currentsize(struct_header), struct_elem_size, 17, 0); 1936 end; 1937 if so.exclude_namesP = null then do; 1938 so.exclude_namesP = STRUCT_get_space (Pstruct_name, size(exclude_names), Pcalling_ep); 1939 exclude_names.version = Pstruct_version; 1940 exclude_names.max_count = exclude_names_size; 1941 exclude_names.count = 0; 1942 call STRUCT_get_next_space (addr(exclude_names), currentsize(exclude_names)); 1943 end; 1944 else do; 1945 Pnew_struct = STRUCT_get_space (Pstruct_name, size(exclude_names), Pcalling_ep); 1946 Pnew_struct -> exclude_names.version = Pstruct_version; 1947 Pnew_struct -> exclude_names.max_count = exclude_names.max_count; 1948 Pnew_struct -> exclude_names.count = exclude_names.count; 1949 if exclude_names.count > 0 then 1950 Pnew_struct -> exclude_names.value = exclude_names.value; 1951 Pnew_struct -> exclude_names.max_count = exclude_names_size; 1952 so.exclude_namesP = Pnew_struct; 1953 call STRUCT_get_next_space (addr(exclude_names), currentsize(exclude_names)); 1954 end; 1955 end; 1956 1957 else if Pstruct_version = EXN_VERSION_1 then do; 1958 fsd.exnP = STRUCT_get_space (Pstruct_name, size(exn), Pcalling_ep); 1959 exn.version = Pstruct_version; 1960 exn.count = Pstruct_array_size; 1961 call STRUCT_get_next_space (addr(exn), currentsize(exn)); 1962 exn.value(*) = ""; 1963 exn.type(*) = STAR_TYPE_UNSET; 1964 end; 1965 1966 else if Pstruct_version = STAR_EXTENDED_ENTRY_VERSION_1 then do; 1967 extended_entry_types_size = Pstruct_array_size; 1968 if extended_entry_types_size = 0 then do; 1969 extended_entry_types_size = 1; 1970 struct_elem_size = size(extended_entry_types) - size(struct_header); 1971 extended_entry_types_size = 1972 divide (sys_info$max_seg_size - currentsize(struct_header), struct_elem_size, 17, 0); 1973 end; 1974 if so.extended_entry_typesP = null then do; 1975 so.extended_entry_typesP = 1976 STRUCT_get_space (Pstruct_name, size(extended_entry_types), Pcalling_ep); 1977 extended_entry_types.version = Pstruct_version; 1978 extended_entry_types.max_count = extended_entry_types_size; 1979 extended_entry_types.count = 0; 1980 call STRUCT_get_next_space (addr(extended_entry_types), currentsize(extended_entry_types)); 1981 end; 1982 else do; 1983 Pnew_struct = 1984 STRUCT_get_space (Pstruct_name, size(extended_entry_types), Pcalling_ep); 1985 Pnew_struct -> extended_entry_types.version = Pstruct_version; 1986 Pnew_struct -> extended_entry_types.max_count = extended_entry_types.max_count; 1987 Pnew_struct -> extended_entry_types.count = extended_entry_types.count; 1988 if extended_entry_types.count > 0 then 1989 Pnew_struct -> extended_entry_types.value = extended_entry_types.value; 1990 Pnew_struct -> extended_entry_types.max_count = extended_entry_types_size; 1991 so.extended_entry_typesP = Pnew_struct; 1992 call STRUCT_get_next_space (addr(extended_entry_types), currentsize(extended_entry_types)); 1993 end; 1994 end; 1995 1996 else if Pstruct_version = STAR_MATCH_NAMES_VERSION_1 then do; 1997 match_names_size = Pstruct_array_size; 1998 if match_names_size = 0 then do; 1999 match_names_size = 1; 2000 struct_elem_size = size(match_names) - size(struct_header); 2001 match_names_size = 2002 divide (sys_info$max_seg_size - currentsize(struct_header), struct_elem_size, 17, 0); 2003 end; 2004 if so.match_namesP = null then do; 2005 so.match_namesP = STRUCT_get_space (Pstruct_name, size(match_names), Pcalling_ep); 2006 match_names.version = Pstruct_version; 2007 match_names.max_count = match_names_size; 2008 match_names.count = 0; 2009 call STRUCT_get_next_space (addr(match_names), currentsize(match_names)); 2010 end; 2011 else do; 2012 Pnew_struct = STRUCT_get_space (Pstruct_name, size(match_names), Pcalling_ep); 2013 Pnew_struct -> match_names.version = Pstruct_version; 2014 Pnew_struct -> match_names.max_count = match_names.max_count; 2015 Pnew_struct -> match_names.count = match_names.count; 2016 if match_names.count > 0 then 2017 Pnew_struct -> match_names.value = match_names.value; 2018 Pnew_struct -> match_names.max_count = match_names_size; 2019 so.match_namesP = Pnew_struct; 2020 call STRUCT_get_next_space (addr(match_names), currentsize(match_names)); 2021 end; 2022 end; 2023 2024 else if Pstruct_version = MN_VERSION_1 then do; 2025 fsd.mnP = STRUCT_get_space (Pstruct_name, size(mn), Pcalling_ep); 2026 mn.version = Pstruct_version; 2027 mn.count = Pstruct_array_size; 2028 call STRUCT_get_next_space (addr(mn), currentsize(mn)); 2029 mn.value(*) = ""; 2030 mn.type(*) = STAR_TYPE_UNSET; 2031 end; 2032 2033 else if Pstruct_version = STAR_DATA_VERSION_1 then do; 2034 if fsd.star_dataP = null then do; 2035 fsd.star_dataP = STRUCT_get_space (Pstruct_name, size(star_data), Pcalling_ep); 2036 star_dataP = fsd.star_dataP; 2037 call STRUCT_get_next_space (addr(star_data), currentsize(star_data)); 2038 end; 2039 else do; 2040 star_dataP = fsd.star_dataP; 2041 end; 2042 star_data.version = Pstruct_version; 2043 star_data.star_opt * * * * * * * * * * * * * * * * * * * * * * */ 2190 /* */ 2191 /* SUPPORT PROCEDURE: TEMP_AREA_get */ 2192 /* get an extensible area from ssu_ and store a pointer to it in fs_star_data for later release. */ 2193 /* */ 2194 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2195 2196 TEMP_AREA_get: 2197 procedure () returns (ptr); 2198 2199 if fsd.areasP(1) = null then 2200 call ssu_$get_area (ssu_sciP, null, "star expand area", fsd.areasP(1)); 2201 return (fsd.areasP(1)); 2202 end TEMP_AREA_get; 2203 2204 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2205 /* */ 2206 /* SUPPORT PROCEDURE: TEMP_SEG_get */ 2207 /* get a temporary segment from ssu_ and store pointer to it in fs_star_data for later release. */ 2208 /* */ 2209 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2210 2211 TEMP_SEG_get: 2212 procedure (Pstruct_name, Pcalling_ep) returns(ptr); 2213 2214 dcl Pstruct_name char(*) parm, 2215 Pcalling_ep fixed bin parm; 2216 2217 dcl temp_segX fixed bin auto; 2218 2219 do temp_segX = lbound(fsd.temp_segsP,1) to hbound(fsd.temp_segsP,1) 2220 while (fsd.temp_segsP(temp_segX) ^= null); 2221 end; 2222 2223 if temp_segX > hbound(fsd.temp_segsP,1) then do; 2224 if Pcalling_ep = EP_SELECT then 2225 call SELECT_error (error_table_$noalloc, 2226 "Cannot use more than ^d temporary segments.", hbound(fsd.temp_segsP,1)); 2227 else if Pcalling_ep = EP_REINIT | Pcalling_ep = EP_TERM then 2228 call ERROR_unexpected (error_table_$noalloc, EP_NAME(Pcalling_ep), ACTION_CANT_RESTART, 2229 null, 0, "Cannot use more than ^d temporary segments.", hbound(fsd.temp_segsP,1)); 2230 else do; 2231 call ERROR_unexpected (error_table_$noalloc, EP_NAME(Pcalling_ep), ACTION_CAN_RESTART, 2232 null, 0, "Cannot use more than ^d temporary segments.", hbound(fsd.temp_segsP,1)); 2233 if Pcalling_ep = EP_ADJUST then 2234 call ADJUST_error (error_table_$noalloc); 2235 else if Pcalling_ep = EP_INIT then 2236 call INIT_error (error_table_$noalloc); 2237 end; 2238 return (null); 2239 end; 2240 2241 call ssu_$get_temp_segment (ssu_sciP, Pstruct_name, fsd.temp_segsP(temp_segX)); 2242 2243 return (fsd.temp_segsP(temp_segX)); 2244 end TEMP_SEG_get; 2245 2246 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2247 2248 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2249 /* */ 2250 /* SUPPORT PROCEDURE: TEMP_SEGS_AREAS_term */ 2251 /* Releases any temp segments and areas acquired by fs_star_, other than the temp segment holding */ 2252 /* the star_options and fsd structures. */ 2253 /* */ 2254 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2255 2256 TEMP_SEGS_AREAS_term: 2257 procedure(); 2258 2259 dcl Itemp fixed bin; 2260 2261 do Itemp = lbound(fsd.temp_segsP,1) to hbound(fsd.temp_segsP,1); 2262 if fsd.temp_segsP(Itemp) ^= null then do; 2263 call ssu_$release_temp_segment (ssu_sciP, fsd.temp_segsP(Itemp)); 2264 fsd.temp_segsP(Itemp) = null; 2265 end; 2266 end; 2267 do Itemp = lbound(fsd.areasP,1) to hbound(fsd.areasP,1); 2268 if fsd.areasP(Itemp) ^= null then do; 2269 call ssu_$release_area (ssu_sciP, fsd.areasP(Itemp)); 2270 fsd.are */ 4 100 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 101 4 102 dcl STAR_OPTIONS_VERSION_1 init("STAROPT1") char(8) int static options(constant); 4 103 4 104 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 105 /* */ 4 106 /* star_paths: */ 4 107 /* array of directory entry pathnames (or archive component pathnames) which does initial */ 4 108 /* pathname selection, based upon starnames in dir part (dir>**>ent), final entryname (dir>**), */ 4 109 /* and/or archive component part (dir>ent.archive::**) of pathname. These starnames select the */ 4 110 /* initial set of entries to which further selection criteria are applied. */ 4 111 /* star_options.path_allow setting controls which type of pathname (dir entry or archive */ 4 112 /* component) is allowed, and which parts may contain stars. */ 4 113 /* */ 4 114 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 115 4 116 dcl 1 star_paths aligned based (star_options.star_pathsP), 4 117 2 version char(8), /* = STAR_PATHS_VERSION_1 */ 4 118 2 max_count fixed bin, /* maximum size of value array for the */ 4 119 /* current allocation of star_paths. */ 4 120 2 count fixed bin, /* current size of value array. */ 4 121 2 value (star_paths_size refer (star_paths.max_count)) char(202) unal, 4 122 /* dir>**>ent>**::** */ 4 123 star_paths_size fixed bin auto, 4 124 STAR_PATHS_VERSION_1 init("STARPTH1") char(8) int static options(constant); 4 125 4 126 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 127 /* */ 4 128 /* Named Constants for star_options.path_allow: */ 4 129 /* select the types of pathnames are allowed, and which pathname components may contain stars. */ 4 130 /* */ 4 131 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 132 4 133 dcl (PATH_ALLOW_DIR_STAR_NAMES init("1"b), /* dir>**>ent */ 4 134 PATH_ALLOW_ENTRY_STAR_NAMES init("01"b), /* dir>** */ 4 135 PATH_ALLOW_ARCHIVE_COMPONENTS init("001"b), /* dir>ent::comp */ 4 136 PATH_ALLOW_ARCHIVE_STAR_NAMES init("0001"b), /* dir>ent::** */ 4 137 PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES init("0011"b), /* dir>ent::** or dir>ent::comp */ 4 138 PATH_ALLOW_NONDIR_STAR_NAMES init("0111"b), /* dir>**::** */ 4 139 PATH_ALLOW_BRANCH_STAR_NAMES init("1100"b), /* dir>**>** */ 4 140 PATH_ALLOW_ALL_STAR_NAMES init("1111"b)) /* dir>**>**::** */ 4 141 bit(36) aligned int static options(constant); 4 142 4 143 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 144 /* */ 4 145 /* Named Constants for star_options.selection.entry_type: */ 4 146 /* for entries matching the starname, selection by entry type, control expansion, etc. */ 4 147 /* One named constant from each group may be ORed together to form a value to be assigned to */ 4 148 /* each star_options.entry_type.XXX value (eg, star_options.entry_type.segs). */ 4 149 /* */ 4 150 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 151 4 152 dcl (ENTRY_DONT_RETURN init("1"b), /* Don't return entries of this type. */ 4 153 ENTRY_RETURN init("0"b), /* Return entries of this type. */ 4 154 4 155 ENTRY_LIST_SUBENTRIES init("01"b), /* List components of matching ents. */ 4 156 ENTRY_DONT_LIST_SUBENTRIES init("00"b), /* Don't list components of match ents. */ 4 157 /* Applies to: dirs, ar4), /* Sort by standard entry type. */ 4 396 SORT_BY_EXTENDED_ENTRY_TYPE init(5), /* Sort by extended entry type. */ 4 397 SORT_ENTRIES_BEFORE_SUBENTRIES init(6)) /* Sort all entries in a directory before*/ 4 398 /* looking for any subentries. By */ 4 399 /* default, subentries below an entry */ 4 400 /* are expanded immediately after the */ 4 401 /* entry is encountered in the sorted */ 4 402 /* sequence of directory entries. */ 4 403 fixed bin int static options(constant); 4 404 4 405 4 406 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 407 /* */ 4 408 /* Named Constants for star_options.data_desired: */ 4 409 /* values control the amount of data returned to caller's entry handler routine in */ 4 410 /* star_data.entry_data. */ 4 411 /* */ 4 412 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 413 4 414 dcl (DATA_TYPE init (1), /* Entry type, only. */ 4 415 DATA_INITIATE init (2)) /* Entry type, length and count */ 4 416 fixed bin int static options(constant); 4 417 4 418 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 419 /* */ 4 420 /* Named constant for star_options.data_version: */ 4 421 /* caller-specified version of star_data he is willing to accept. */ 4 422 /* */ 4 423 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 424 4 425 dcl STAR_DATA_VERSION_1 init ("STARDAT1") char(8) int static options(constant); 4 426 /* star_data version 1 structure. */ 4 427 4 428 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 429 /* */ 4 430 /* star_data: */ 4 431 /* information provided to caller-supplied entry handler routine for each selected entry. */ 4 432 /* */ 4 433 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 434 4 435 dcl 1 star_data aligned based (star_dataP), 4 436 2 version char(8), /* = STAR_DATA_VERSION_1 */ 4 437 2 star_optionsP ptr, /* ptr to caller-supplied star_options */ 4 438 /* structure. This makes */ 4 439 /* star_options.handler_dataP */ 4 440 /* available to the handler routine. */ 4 441 2 matched, /* count of matching entries: */ 4 442 3 ( 4 443 current, /* index of current entry in sort list */ 4 444 total, /* count of total entries. */ 4 445 links, /* count of total links. */ 4 446 segs, /* count of total non-archive, */ 4 447 /* non-extended entry segments. */ 4 448 dirs, /* count of total directories. */ 4 449 msfs, /* count of total multisegment files. */ 4 450 msf_comps, /* count of total msf components. */ 4 451 dm_files, /* count of total data mgt files. */ 4 452 archives, /* count of total archives. */ 4 453 arch_comps, /* count of total archive components. */ 4 454 extended_entries) fixed bin, /* count of total extended entries. */ 4 455 /* See Named Constants for */ 4 456 /* sort_options.sorting above. */ 4 457 3 mbz_matched (4) fixed bin, /* reserved for future use. */ 4 458 4 459 2 entry_data, /* Beginning of DATA_xxx return items. */ 4 460 3 data_desired fixed bin, /* amount of data in entry_data minor */ 4 461 /* structure which is valid. */ 4 462 3 depth fixed bin, /* depth of this entry below its */ 4 463 /* corresponding parent in */ parameter fixed bin(17,0) dcl 1226 set ref 1219 1230* 1232* 1240* 1242* 1247* 1249* 1254 1256 1258 1259 1260 1261 1262 1264 1266* Pcaller_name parameter char packed unaligned dcl 45 set ref 347 361* Pcaller_version parameter char packed unaligned dcl 47 set ref 347 361* Pcalling_ep parameter fixed bin(17,0) dcl 2121 in procedure "STRUCT_get_space" set ref 2118 2131* 2137* 2142 2145 2145 2145 2150 2153 2155 Pcalling_ep parameter fixed bin(17,0) dcl 1892 in procedure "STRUCT_allocate" set ref 1889 1909* 1917* 1938* 1945* 1958* 1975* 1983* 2005* 2012* 2025* 2035* 2065* 2072* 2085 2088 2088 2088 2092 2094 2096 Pcalling_ep parameter fixed bin(17,0) dcl 2214 in procedure "TEMP_SEG_get" ref 2211 2224 2227 2227 2227 2231 2233 2235 Pcalling_ep parameter fixed bin(17,0) dcl 1765 in procedure "ENTRY_POINT_setup" ref 1762 1769 1771 1773 1778 1780 1784 Pcode parameter fixed bin(35,0) dcl 49 set ref 242 245* 276 276* 347 351* 443 443* 485 490* 523 523* 700 700* 1189 1189* 1402 1402* 1692 1692* Pcode_in parameter fixed bin(35,0) dcl 1128 in procedure "PATH_error" set ref 1124 1140 1146* 1154* 1161* 1165* Pcode_in parameter fixed bin(35,0) dcl 273 in procedure "ADJUST_error" ref 270 275 276 Pcode_in parameter fixed bin(35,0) dcl 660 in procedure "ARCHIVE_PATH_error" set ref 656 668 672* 678* Pcode_in parameter fixed bin(35,0) dcl 440 in procedure "INIT_error" ref 437 442 443 Pcode_in based fixed bin(35,0) dcl 1384 in procedure "SELECT_error" set ref 1391 1395* 1397* 1402 Pcode_in parameter fixed bin(35,0) dcl 1101 in procedure "PATH_expand" set ref 1098 1106* Pcode_in parameter fixed bin(35,0) dcl 1681 in procedure "STAR_PATHS_error" set ref 1678 1691 1692 1697* 1704* Pcode_inP 000100 automatic pointer dcl 1377 set ref 1390* 1391 1395 1397 1402 Pcomp parameter char(32) packed unaligned dcl 1685 in procedure "STAR_PATHS_error" set ref 1678 1697* 1697* 1704* Pcomp parameter char(32) packed unaligned dcl 1225 in procedure "PATH_handler" set ref 1219 1232* 1242* 1249* Pcomp parameter char(32) packed unaligned dcl 663 in procedure "ARCHIVE_PATH_error" set ref 656 672* 672* 678* Pcomp parameter char(32) packed unaligned dcl 723 in procedure "ARCHIVE_PATH_handler" set ref 718 727 730* Pcomp parameter char(32) packed unaligned dcl 1132 in procedure "PATH_error" set ref 1124 1146* 1146* 1154* 1161* 1165* Pdepth parameter fixed bin(17,0) dcl 552 in procedure "ARCHIVE_PATH_expand" set ref 549 590 596* 618* Pdepth parameter fixed bin(17,0) dcl 829 in procedure "PATH_expand" set ref 826 900* 911* 920* 923* 933* 963* 973* 984* 999 1017* 1032 1040* 1055 1062* 1071* 1098 1106* Pdepth parameter fixed bin(17,0) dcl 1318 in procedure "PATH_MATCH_ENTRY_add" ref 1314 1324 Pdepth parameter fixed bin(17,0) dcl 659 in procedure "ARCHIVE_PATH_error" ref 656 670 Pdepth parameter fixed bin(17,0) dcl 1127 in procedure "PATH_error" ref 1124 1142 Pdir parameter char(168) packed unaligned dcl 1222 in procedure "PATH_handler" set ref 1219 1232* 1238* 1242* 1249* Pdir parameter char packed unaligned dcl 1683 in procedure "STAR_PATHS_error" set ref 1678 1697* 1697* 1697* 1704* Pdir parameter char packed unaligned dcl 1129 in procedure "PATH_error" set ref 1124 1146* 1146* 1146* 1154* 1159* 1161* 1165* Pdir parameter char packed unaligned dcl 661 in procedure "ARCHIVE_PATH_error" set ref 656 672* 672* 672* 678* Pdir parameter char(168) packed unaligned dcl 721 in procedure "ARCHIVE_PATH_handler" set ref 718 730* Pent parameter char(32) array packed unaligned dcl 1130 in procedure "PATH_error" set ref 1124 1146 1146 1146 1146* 1146 1146* 1154* 1159* 1165* Pent parameter char(32) array packed unaligned dcl 555 in procedure "ARCHIVE_PATH_expand" set ref 549 572* 579 580 584 585 589* 630 Pent parameter char(32) array packed unaligned dcl 662 in procedure "ARCHIVE_PATH_error" set ref 656 672 672 672 672* 672 672* 678* Pent parameter char(32) array packed unaligned dcl 1684 in procedure "STAR_PATHS_error" set ref 1678 1697 1697* 1697* 1704* Pent_type parameter fixed bin(2,0) dcl 1224 in procedure "PATH_handler" ref 1219 1229 1229 Pent_type parameter fixed bin(2,0) dcl 1102 in procedure "PATH_expand" set ref 1098 1106* Pent_type parameter fixed bin(2,0) dcl 1131 in procedure "PATH_error" ref 1124 1153 1153 1170 Pentry_type parameter char(32) packed unaligned dcl 1421 in procedure "SELECT_further" ref 1418 1477 Pentry_type parameter char(32) packed unaligned dcl 1682 in procedure "STAR_PATHS_error" ref 1678 1703 Pentry_type parameter char(32) packed unaligned dcl 1317 in procedure "PATH_MATCH_ENTRY_add" ref 1314 1323 Pents parameter char(32) array packed unaligned dcl 1223 in procedure "PATH_handler" set ref 1219 1230* 1232* 1238* 1247* 1249* Pents parameter char(32) array packed unaligned dcl 722 in procedure "ARCHIVE_PATH_handler" set ref 718 730* Pfree_areaP parameter pointer dcl 553 in procedure "ARCHIVE_PATH_expand" ref 549 Pfree_areaP parameter pointer dcl 831 in procedure "PATH_expand" set ref 826 886 886 999 999 1032* 1055* 1084 1086 Pioa_arg parameter fixed bin(2,0) dcl 1134 in procedure "PATH_error" set ref 1124 1143* Pioa_arg parameter fixed bin(2,0) dcl 1104 in procedure "PATH_expand" set ref 1098 1106* Pmessage parameter char packed unaligned dcl 1103 in procedure "PATH_expand" set ref 1098 1106* Pmessage parameter char packed unaligned dcl 1686 in procedure "STAR_PATHS_error" set ref 1678 1697 1697* 1704* Pmessage parameter char packed unaligned dcl 664 in procedure "ARCHIVE_PATH_error" set ref 656 672 672* 678* Pmessage parameter char packed unaligned dcl 1133 in procedure "PATH_error" set ref 1124 1143* Pname parameter char(32) packed unaligned dcl 1284 ref 1281 1291 1294 Pnames parameter char(32) array packed unaligned dcl 1422 set ref 1418 1427 1427 1431 1436* 1450 1450 1454 1459* Pnew_size parameter fixed bin(17,0) dcl 65 set ref 242 249* 253* Pnew_struct 000332 automatic pointer dcl 1897 set ref 1917* 1918 1919 1920 1921 1923 1924 1945* 1946 1947 1948 1949 1951 1952 1983* 1985 1986 1987 1988 1990 1991 2012* 2013 2014 2015 2016 2018 2019 2072* 2073 2074 2075 2076 2078 2079 Pparent_is_msf parameter bit(1) packed unaligned dcl 830 ref 826 953 Ppath parameter structure level 1 dcl 832 in procedure "PATH_expand" set ref 826 992 1098 Ppath parameter structure level 1 dcl 554 in procedure "ARCHIVE_PATH_expand" set ref 549 Psort_order parameter fixed bin(17,0) dcl 556 in procedure "ARCHIVE_PATH_expand" ref 549 Psort_order parameter fixed bin(17,0) dcl 833 in procedure "PATH_expand" set ref 826 904 999* 1032* 1055* 1080 Pssu_sciP parameter pointer dcl 50 ref 347 425 Pstar_dataP parameter pointer dcl 54 set ref 485 489* 502* Pstar_optionsP parameter pointer dcl 56 set ref 242 347 350* 389* 394* 460 485 1737 1740 1767 Pstar_options_version parameter char(8) packed unaligned dcl 58 ref 347 356 PstructP parameter pointer dcl 2175 ref 2172 2181 2183 Pstruct_array_size parameter fixed bin(17,0) dcl 1892 ref 1889 1901 1930 1960 1967 1997 2027 2046 2057 Pstruct_name parameter char packed unaligned dcl 2121 in procedure "STRUCT_get_space" set ref 2118 2126 2131* 2137* 2142* 2145* 2150* Pstruct_name parameter char packed unaligned dcl 1892 in procedure "STRUCT_allocate" set ref 1889 1909* 1917* 1938* 1945* 1958* 1975* 1983* 2005* 2012* 2025* 2035* 2065* 2072* 2085* 2088* 2092* Pstruct_name parameter char packed unaligned dcl 2214 in procedure "TEMP_SEG_get" set ref 2211 2241* Pstruct_name parameter char packed unaligned dcl 295 in procedure "STRUCT_name_version_size_check" ref 292 299 300 301 302 Pstruct_size parameter fixed bin(18,0) dcl 2175 in procedure "STRUCT_get_next_space" ref 2172 2180 2180 Pstruct_size parameter fixed bin(17,0) dcl 295 in procedure "STRUCT_name_version_size_check" ref 292 305 309 314 319 324 Pstruct_size parameter fixed bin(18,0) dcl 2121 in procedure "STRUCT_get_space" set ref 2118 2134 2138 2142* 2145* 2150* Pstruct_version parameter char(8) packed unaligned dcl 1892 in procedure "STRUCT_allocate" ref 1889 1900 1910 1918 1929 1939 1946 1957 1959 1966 1977 1985 1996 2006 2013 2024 2026 2033 2042 2056 2066 2073 Pstruct_version parameter char(8) packed unaligned dcl 295 in procedure "STRUCT_name_version_size_check" ref 292 299 300 301 302 308 313 318 323 Pstructure_name parameter char packed unaligned dcl 60 set ref 242 249* 253* Pstructure_version parameter char(8) packed unaligned dcl 62 set ref 242 249* 253* Psuffix parameter char packed unaligned dcl 1285 ref 1281 1292 1294 ROOT_ENTRY 000003 constant structure level 1 dcl 875 set ref 893 ROOT_NAME 020726 constant char(32) initial packed unaligned dcl 875 set ref 894 1083 R_ACCESS 000151 constant bit(3) initial packed unaligned dcl 3-11 set ref 589* SORT_OFF constant fixed bin(17,0) initial dcl 4-388 ref 381 SORT_REVERSE constant fixed bin(17,0) initial dcl 4-388 ref 904 1080 STAR_DATA_VERSION_1 000132 constant char(8) initial packed unaligned dcl 4-425 set ref 386 492 492* 2033 STAR_EXCLUDE_NAMES_VERSION_1 000134 constant char(8) initial packed unaligned dcl 4-236 set ref 299 308 1506 1506* 1929 STAR_EXTENDED_ENTRY_VERSION_1 000140 constant char(8) initial packed unaligned dcl 4-195 set ref 300 313 1536 1536* 1966 STAR_MATCH_NAMES_VERSION_1 000136 constant char(8) initial packed unaligned dcl 4-216 set ref 301 318 1521 1521* 1996 STAR_OPTIONS_VERSION_1 000146 constant char(8) initial packed unaligned dcl 4-102 set ref 356 367 1777 1780* 1784* STAR_PATHS_VERSION_1 000144 constant char(8) initial packed unaligned dcl 4-116 set ref 302 323 373* 468* 2056 STAR_TYPE_MATCHES_EVERYTHING constant fixed bin(2,0) initial dcl 1-47 ref 569 614 997 1029 1052 1153 1229 1446 1468 1645 1645 1648 1648 STAR_TYPE_UNSET constant fixed bin(17,0) initial dcl 231 ref 1963 2030 STAR_TYPE_USE_MATCH_PROCEDURE constant fixed bin(2,0) initial dcl 1-47 ref 607 1436 1459 1603 STAR_TYPE_USE_PL1_COMPARE constant fixed bin(2,0) initial dcl 1-47 ref 601 779 937 994 1026 1031 1049 1054 1431 1454 1607 1617 1622 1635 1640 TERM_FILE_TERM 000142 constant bit(3) initial packed unaligned dcl 7-14 set ref 633* 1867* TRUE 000151 constant bit(1) initial packed unaligned dcl 194 ref 360 594 1294 1483 1695 action 000146 automatic fixed bin(17,0) dcl 725 in procedure "ARCHIVE_PATH_handler" set ref 730* 732 733 735 736 737 739 741 743 745* action 000320 automatic fixed bin(17,0) dcl 1136 in procedure "PATH_error" set ref 1150* 1154* 1161* 1165* 1172 1172 1178 1180 1182 1184 1187* action 000136 automatic fixed bin(17,0) dcl 666 in procedure "ARCHIVE_PATH_error" set ref 676* 678* 683 683 689 691 693 695 698* action 000266 automatic fixed bin(17,0) dcl 1688 in procedure "STAR_PATHS_error" set ref 1704* 1707 1707 action 000150 automatic fixed bin(17,0) dcl 835 in procedure "PATH_expand" set ref 941* 942 942 964* 965 965 974* 975 975 980* 985* 986 986 989 989 989 1014* 1018* 1019 1019 1022 1022 1022 1036* 1041* 1042 1042 1045 1045 1045 1063* 1064 1064 1072* 1073 1073 action 000102 automatic fixed bin(17,0) dcl 1378 in procedure "SELECT_error" set ref 1397* addend 000436 automatic fixed bin(17,0) dcl 1320 set ref 1325* 1333* 1336 1338 1340 1342 1344 1346 1348 1350 1352 1354 addr builtin function dcl 140 ref 502 571 575 579 584 630 678 678 730 730 886 886 893 894 907 908 999 999 1083 1154 1154 1158 1161 1161 1165 1165 1232 1232 1237 1242 1242 1249 1249 1395 1397 1397 1397 1704 1704 1838 1838 1863 1863 1913 1913 1925 1925 1942 1942 1953 1953 1961 1961 1980 1980 1992 1992 2009 2009 2020 2020 2028 2028 2037 2037 2043 2069 2069 2080 2080 2126 addwordno builtin function dcl 140 ref 2126 2183 archL 000106 automatic fixed bin(24,0) dcl 559 set ref 589* 593 595* 633* archP 10 based pointer level 2 dcl 106 set ref 568* 589* 595* 633 633* 1842* 1867 1867* arch_comps 20 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 614 arch_comps 15 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1352* 1352 archive_$next_component 000010 constant entry external dcl 146 ref 595 archives 14 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1350* 1350 archives 17 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 980 989 areasP 44 based pointer array level 2 dcl 106 set ref 1847* 2199 2199* 2201 2267 2267 2268 2269* 2270* argsN 000100 automatic fixed bin(17,0) dcl 1812 set ref 1815* 1816 array 3 based structure array level 2 in structure "mn" dcl 127 in procedure "fs_star_" set ref 1527 1527 array 3 based structure array level 2 in structure "exn" dcl 98 in procedure "fs_star_" set ref 1512 1512 auto_status 000142 automatic structure level 1 dcl 2283 set ref 571 1158 1237 bc 000151 automatic fixed bin(24,0) dcl 835 set ref 922* caller 2 based structure level 2 dcl 137 check_star_name_ 000012 constant entry external dcl 148 ref 1514 1529 1615 1631 cleanup 000120 stack reference condition dcl 143 ref 354 code 000100 automatic fixed bin(35,0) dcl 71 in procedure "fs_star_" set ref 361* 363* 1436* 1438 1459* 1461 1867* 1874* code 000236 automatic fixed bin(35,0) dcl 1502 in procedure "SELECT_further_init" set ref 1514* 1515* 1529* 1530* code 000101 automatic fixed bin(35,0) dcl 1813 in procedure "ERROR_unexpected" set ref 1815* code 000103 automatic fixed bin(35,0) dcl 1379 in procedure "SELECT_error" set ref 1390* code 000321 automatic fixed bin(35,0) dcl 1137 in procedure "PATH_error" set ref 1159* 1160 code 000414 automatic fixed bin(35,0) dcl 1227 in procedure "PATH_handler" set ref 1238* 1239 code 000107 automatic fixed bin(35,0) dcl 560 in procedure "ARCHIVE_PATH_expand" set ref 572* 574 589* 590* 595* 596* 607* 609 633* code 000250 automatic fixed bin(35,0) dcl 1560 in procedure "STAR_PATHS_evaluate" set ref 1585* 1587* 1609* 1610 1612* 1615* 1617 1619* 1631* 1633* 1635* code 000212 automatic fixed bin(35,0) dcl 767 in procedure "EVAL_PATHS_expand" set ref 780* 781 781 code 000152 automatic fixed bin(35,0) dcl 835 in procedure "PATH_expand" set ref 886* 890 895* 900 900* 922* 923* 956* 957 1003* 1005 comp 65 000164 automatic char(32) level 2 in structure "path" packed packed unaligned dcl 835 in procedure "PATH_expand" set ref 995 996* 1030* 1053* comp 65 parameter char(32) level 2 in structure "Ppath" packed packed unaligned dcl 554 in procedure "ARCHIVE_PATH_expand" set ref 601 607* comp 71 based char(32) array level 3 in structure "epath" packed packed unaligned dcl 82 in procedure "fs_star_" set ref 1585* 1604* 1619* 1622* 1627 1628* 1631* 1633* 1635* 1648 1648 comp 65 parameter char(32) level 2 in structure "Ppath" packed packed unaligned dcl 832 in procedure "PATH_expand" set ref 1106* compL 000110 automatic fixed bin(24,0) dcl 561 set ref 595* compP 000112 automatic pointer dcl 562 set ref 591* 595* 597 comp_name 000114 automatic char(32) packed unaligned dcl 563 set ref 595* 601 607* 619* comp_type 101 based fixed bin(2,0) array level 3 in structure "epath" dcl 82 in procedure "fs_star_" set ref 1631* 1635 1640* 1648 1648 comp_type 75 000164 automatic fixed bin(2,0) level 2 in structure "path" dcl 835 in procedure "PATH_expand" set ref 997* 1031* 1054* comp_type 75 parameter fixed bin(2,0) level 2 in structure "Ppath" dcl 554 in procedure "ARCHIVE_PATH_expand" ref 599 count 3 based fixed bin(17,0) level 2 in structure "star_paths" dcl 4-116 in procedure "fs_star_" set ref 324 1571 1571* 1574 1574* 1578* 1583 2068* 2075* 2075 2076 count 3 based fixed bin(17,0) level 2 in structure "extended_entry_types" dcl 4-195 in procedure "fs_star_" set ref 314 1475 1476 1979* 1987* 1987 1988 count 2 based fixed bin(17,0) level 2 in structure "exn" dcl 98 in procedure "fs_star_" set ref 1451 1512 1960* 1961 1961 1962 1963 count 3 based fixed bin(17,0) level 2 in structure "epath" dcl 82 in procedure "fs_star_" set ref 774 1584* 1651* 1912* 1920* 1920 1921 count 2 based fixed bin(17,0) level 2 in structure "mn" dcl 127 in procedure "fs_star_" set ref 1428 1527 2027* 2028 2028 2029 2030 count 37 based fixed bin(35,0) level 3 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2052* count 3 based fixed bin(17,0) level 2 in structure "match_names" dcl 4-216 in procedure "fs_star_" set ref 319 1525 1526* 2008* 2015* 2015 2016 2025 2025 count 37 based fixed bin(35,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 521* count 3 based fixed bin(17,0) level 2 in structure "exclude_names" dcl 4-236 in procedure "fs_star_" set ref 309 1510 1511* 1941* 1948* 1948 1949 1958 1958 cu_$arg_count 000014 constant entry external dcl 149 ref 1815 cu_$arg_list_ptr 000016 constant entry external dcl 150 ref 1393 1393 1819 1819 cu_$arg_ptr 000020 constant entry external dcl 151 ref 1390 cu_$generate_call 000022 constant entry external dcl 152 ref 1819 current 4 based fixed bin(17,0) level 3 dcl 135 set ref 517 775 777 1336* 1336 currentsize builtin function dcl 140 ref 1838 1838 1863 1863 1905 1913 1913 1925 1925 1934 1942 1942 1953 1953 1961 1961 1971 1980 1980 1992 1992 2001 2009 2009 2020 2020 2028 2028 2037 2037 2061 2069 2069 2080 2080 data_desired 64 based fixed bin(17,0) level 3 in structure "so" dcl 137 in procedure "fs_star_" set ref 385* 496 496* 501* data_desired 24 based fixed bin(17,0) level 3 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2046* data_version 65 based char(8) level 3 packed packed unaligned dcl 137 set ref 386* 492 492* 501* depth 25 based fixed bin(17,0) level 3 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 670* 1142* 2049* depth 25 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1324* dimension builtin function dcl 140 ref 576 580 585 dir 4 based char(168) array level 3 in structure "epath" packed packed unaligned dcl 82 in procedure "fs_star_" set ref 780* 1585* 1601 1604* 1609* 1612* 1617 1619* 1622* 1628* 1633* 1635* dir parameter char(168) level 2 in structure "Ppath" packed packed unaligned dcl 554 in procedure "ARCHIVE_PATH_expand" set ref 572* 589* 590* 596* 619* dir 000164 automatic char(168) level 2 in structure "path" packed packed unaligned dcl 835 in procedure "PATH_expand" set ref 1025* 1048* dir parameter char(168) level 2 in structure "Ppath" packed packed unaligned dcl 832 in procedure "PATH_expand" set ref 886* 891 900* 911* 922* 923* 933* 941* 956* 964* 974* 985* 1003* 1018* 1025* 1041* 1048* 1063* 1072* 1106* dir_ents 31 based fixed bin(17,0) array level 4 dcl 137 set ref 776* dir_type 52 000164 automatic fixed bin(2,0) level 2 in structure "path" dcl 835 in procedure "PATH_expand" set ref 1026* 1049* dir_type 56 based fixed bin(2,0) array level 3 in structure "epath" dcl 82 in procedure "fs_star_" set ref 1603* 1607* dir_uid 57 based bit(36) array level 3 in structure "epath" dcl 82 in procedure "fs_star_" set ref 1609* 1610* 1644 1644 dir_uid 53 000164 automatic bit(36) level 2 in structure "path" dcl 835 in procedure "PATH_expand" set ref 1027* 1050* dirs 13 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 1010 1014 1022 dirs 10 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1342* 1342 divide builtin function dcl 140 ref 1905 1934 1971 2001 2061 dm_files 13 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1348* 1348 dm_files 16 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 1059 ent 54 parameter char(32) array level 2 in structure "Ppath" packed packed unaligned dcl 832 in procedure "PATH_expand" set ref 886* 891 1106* ent 60 based char(32) array level 3 in structure "epath" packed packed unaligned dcl 82 in procedure "fs_star_" set ref 780* 1585* 1604* 1615* 1619* 1622* 1628* 1633* 1635* 1645 1645 ent 54 000164 automatic char(32) array level 2 in structure "path" packed packed unaligned dcl 835 in procedure "PATH_expand" set ref 993* 1028* 1051* ent_type 70 based fixed bin(2,0) array level 3 in structure "epath" dcl 82 in procedure "fs_star_" set ref 779 1615* 1617* 1622 1645 1645 ent_type 64 parameter fixed bin(2,0) level 2 in structure "Ppath" dcl 832 in procedure "PATH_expand" set ref 911* 923* 933* 937 941* 964* 974* 985* 1018* 1041* 1063* 1072* ent_type 64 000164 automatic fixed bin(2,0) level 2 in structure "path" dcl 835 in procedure "PATH_expand" set ref 994* 1029* 1052* ent_type 64 parameter fixed bin(2,0) level 2 in structure "Ppath" dcl 554 in procedure "ARCHIVE_PATH_expand" ref 569 entryP 40 based pointer level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 522* entryP 40 based pointer level 3 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2053* entry_data 24 based structure level 2 in structure "sd" dcl 135 in procedure "fs_star_" entry_data 24 based structure level 2 in structure "star_data" dcl 4-435 in procedure "fs_star_" entry_type 000437 automatic char(32) packed unaligned dcl 1321 in procedure "PATH_MATCH_ENTRY_add" set ref 1323* 1331* 1338 1340 1342 1344 1346 1348 1350 1352 entry_type 11 based structure level 3 in structure "so" dcl 137 in procedure "fs_star_" set ref 376* epath based structure level 1 dcl 82 set ref 1904 1909 1909 1913 1913 1913 1913 1917 1917 1925 1925 1925 1925 epathP 000112 automatic pointer dcl 82 in procedure "fs_star_" set ref 774 774 776 779 780 780 781 783 786 1584 1585 1585 1585 1601 1603 1604 1604 1604 1607 1609 1609 1610 1612 1615 1615 1617 1617 1619 1619 1619 1622 1622 1622 1622 1627 1628 1628 1628 1631 1631 1633 1633 1633 1635 1635 1635 1635 1640 1643 1644 1644 1645 1645 1645 1645 1648 1648 1648 1648 1651 1904 1909 1909 1909* 1910 1911 1912 1913 1913 1913 1913 1916* 1917 1917 1919 1920 1921 1921 1924* 1925 1925 1925 1925 epathP 12 based pointer level 2 in structure "fsd" dcl 106 in procedure "fs_star_" set ref 1843* 1870* 1908 1909* 1916 1924* epath_size 000114 automatic fixed bin(17,0) dcl 82 set ref 1901* 1902 1903* 1904 1905* 1909 1909 1911 1917 1917 1923 error 56 based entry variable level 3 dcl 137 set ref 383* 671 678 1145 1154 1161 1165 1395 1397 1696 1704 error_table_$archive_pathname 000102 external static fixed bin(35,0) dcl 202 set ref 1628* error_table_$argerr 000104 external static fixed bin(35,0) dcl 202 set ref 303* 1569* 1574* 1769* 1771* 1773* error_table_$fatal_error 000106 external static fixed bin(35,0) dcl 202 set ref 1816* 2085* 2088* 2092* 2094* 2096* error_table_$improper_data_format 000110 external static fixed bin(35,0) dcl 202 set ref 911* 933* error_table_$inconsistent 000112 external static fixed bin(35,0) dcl 202 set ref 309* 314* 319* 324* 1571* error_table_$noalloc 000114 external static fixed bin(35,0) dcl 202 set ref 2224* 2227* 2231* 2233* 2235* error_table_$noentry 000116 external static fixed bin(35,0) dcl 202 set ref 783* error_table_$nomatch 000120 external static fixed bin(35,0) dcl 202 set ref 523 781* 786* 890 error_table_$nostars 000122 external static fixed bin(35,0) dcl 202 set ref 1604* 1622* error_table_$null_name_component 000124 external static fixed bin(35,0) dcl 202 ref 1617 error_table_$root 000126 external static fixed bin(35,0) dcl 202 ref 781 1610 error_table_$smallarg 000130 external static fixed bin(35,0) dcl 202 set ref 305* error_table_$too_many_names 000132 external static fixed bin(35,0) dcl 202 set ref 2142* 2145* 2150* 2153* 2155* error_table_$unimplemented_version 000134 external static fixed bin(35,0) dcl 202 set ref 357* 492* 1506* 1521* 1536* 1778* 1780* 1784* error_table_$unsupported_operation 000136 external static fixed bin(35,0) dcl 202 set ref 496* 698* 700 745* 1187* 1189 1266* 1563* exclude_names based structure level 1 dcl 4-236 set ref 1933 1938 1938 1942 1942 1942 1942 1945 1945 1953 1953 1953 1953 exclude_namesP 26 based pointer level 3 in structure "so" dcl 137 in procedure "fs_star_" set ref 379* 471* 1505 1937 1938* 1952* exclude_namesP 26 based pointer level 3 in structure "star_options" dcl 4-26 in procedure "fs_star_" set ref 309 309 1506 1506 1510 1511 1513 1933 1938 1938 1939 1940 1941 1942 1942 1942 1942 1945 1945 1947 1948 1949 1949 1953 1953 1953 1953 1958 1958 exclude_names_size 000133 automatic fixed bin(17,0) dcl 4-236 set ref 1930* 1931 1932* 1933 1934* 1938 1938 1940 1945 1945 1951 exn based structure level 1 dcl 98 set ref 1958 1958 1961 1961 1961 1961 exnP 16 based pointer level 2 dcl 106 set ref 1446 1451 1451 1452 1454 1459 1512 1512 1513 1514 1514 1515 1845* 1872* 1958* 1958 1958 1959 1960 1961 1961 1961 1961 1962 1963 expand_pathname_$component 000024 constant entry external dcl 153 ref 1585 expanded_message 000322 automatic varying char(200) dcl 1138 set ref 1143* 1146 1146* 1154 1161 1165 extended_entries 16 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure 1870 1871 1872 1874 1874 1874 1908 1909 1916 1924 1958 1958 1958 1959 1960 1961 1961 1961 1961 1962 1963 2025 2025 2025 2026 2027 2028 2028 2028 2028 2029 2030 2034 2035 2036 2040 2128 2181 2183 2199 2199 2201 2219 2219 2219 2223 2224 2224 2227 2227 2231 2231 2241 2243 2261 2261 2262 2263 2264 2267 2267 2268 2269 2270 fsd_pad 5 based fixed bin(17,0) level 2 dcl 106 set ref 1840* 1865* handler 52 based entry variable level 3 dcl 137 set ref 382* 730 1232 1242 1249 handler_dataP 62 based pointer level 3 dcl 137 set ref 384* hbound builtin function dcl 140 ref 948 1427 1428 1450 1451 1512 1527 2219 2223 2224 2224 2227 2227 2231 2231 2261 2267 hcs_$get_uid_file 000030 constant entry external dcl 155 ref 1609 hcs_$star_ 000032 constant entry external dcl 156 ref 886 hcs_$status_ 000034 constant entry external dcl 158 ref 572 1159 1238 hcs_$status_minf 000036 constant entry external dcl 160 ref 780 922 hcs_$truncate_seg 000040 constant entry external dcl 162 ref 1874 initiate_file_ 000042 constant entry external dcl 163 ref 589 ioa_$general_rs 000044 constant entry external dcl 165 ref 1393 ioa_$rsnpnnl 000046 constant entry external dcl 167 ref 1143 lbound builtin function dcl 140 ref 672 672 672 774 948 1146 1146 1146 1427 1428 1450 1451 1476 1512 1527 1583 1643 2219 2261 2267 length 36 based fixed bin(35,0) level 3 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2051* length builtin function dcl 140 in procedure "fs_star_" ref 1291 1292 length 36 based fixed bin(35,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 520* links 11 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 917 921 925 928 937 links 6 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1338* 1338 ltrim builtin function dcl 140 ref 672 672 1146 1146 matchX 000237 automatic fixed bin(17,0) dcl 1503 in procedure "SELECT_further_init" set ref 1512* 1513 1513 1514 1514 1515* 1527* 1528 1528 1529 1529 1530* matchX 000457 automatic fixed bin(17,0) dcl 1424 in procedure "SELECT_further" set ref 1428* 1429 1431 1436* 1451* 1452 1454 1459* 1476* 1477* match_names based structure level 1 dcl 4-216 set ref 2000 2005 2005 2009 2009 2009 2009 2012 2012 2020 2020 2020 2020 match_namesP 24 based pointer level 3 in structure "so" dcl 137 in procedure "fs_star_" set ref 378* 470* 1520 2004 2005* 2019* match_namesP 24 based pointer level 3 in structure "star_options" dcl 4-26 in procedure "fs_star_" set ref 319 319 1521 1521 1525 1526 1528 2000 2005 2005 2006 2007 2008 2009 2009 2009 2009 2012 2012 2014 2015 2016 2016 2020 2020 2020 2020 2025 2025 match_names_size 000132 automatic fixed bin(17,0) dcl 4-216 set ref 1997* 1998 1999* 2000 2001* 2005 2005 2007 2012 2012 2018 match_star_name_ 000050 constant entry external dcl 168 ref 607 1436 1459 matched 4 based structure level 2 in structure "sd" dcl 135 in procedure "fs_star_" matched 4 based structure level 2 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2044* matched_before 000216 automatic fixed bin(17,0) dcl 769 set ref 775* 777 max builtin function dcl 140 ref 1293 max_count 2 based fixed bin(17,0) level 2 in structure "star_paths" dcl 4-116 in procedure "fs_star_" set ref 1571 1571* 2067* 2069 2069 2074* 2074 2076 2076 2076 2076 2076 2078* 2080 2080 max_count 2 based fixed bin(17,0) level 2 in structure "exclude_names" dcl 4-236 in procedure "fs_star_" set ref 1940* 1942 1942 1947* 1947 1949 1949 1949 1949 1949 1951* 1953 1953 max_count 2 based fixed bin(17,0) level 2 in structure "epath" dcl 82 in procedure "fs_star_" set ref 1911* 1913 1913 1919* 1919 1921 1923* 1925 1925 max_count 2 based fixed bin(17,0) level 2 in structure "match_names" dcl 4-216 in procedure "fs_star_" set ref 2007* 2009 2009 2014* 2014 2016 2016 2016 2016 2016 2018* 2020 2020 max_count 2 based fixed bin(17,0) level 2 in structure "extended_entry_types" dcl 4-195 in procedure "fs_star_" set ref 1978* 1980 1980 1986* 1986 1988 1988 1988 1988 1988 1990* 1992 1992 mbz 67 based bit(36) level 2 dcl 137 set ref 387* 472* mbz_matched 17 based fixed bin(17,0) array level 3 dcl 4-435 set ref 2045* message based char packed unaligned dcl 1385 set ref 1395* 1397* message_len 000301 automatic fixed bin(21,0) dcl 1381 set ref 1393* 1395 1395 1397 1397 message_space 000104 automatic char(500) packed unaligned dcl 1380 set ref 1393* 1395 1397 mn based structure level 1 dcl 127 set ref 2025 2025 2028 2028 2028 2028 mnP 14 based pointer level 2 dcl 106 set ref 1426 1428 1428 1429 1431 1436 1527 1527 1528 1529 1529 1530 1844* 1871* 2025* 2025 2025 2026 2027 2028 2028 2028 2028 2029 2030 mod builtin function dcl 140 ref 2180 msf_comps 15 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 970 msf_comps 12 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1346* 1346 msfs 11 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1344* 1344 msfs 14 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 1036 1045 nameL 000424 automatic fixed bin(17,0) dcl 1287 set ref 1291* 1293 nameX 000163 automatic fixed bin(17,0) dcl 835 in procedure "PATH_expand" set ref 948* 950* 993 nameX 000456 automatic fixed bin(17,0) dcl 1424 in procedure "SELECT_further" set ref 1427* 1431 1436* 1450* 1454 1459* names_relp 0(18) based bit(18) level 3 packed packed unaligned dcl 5-8 ref 575 576 630 1161 1163 1240 1242 1244 next_spaceP 2 based pointer level 2 dcl 106 set ref 1874* 1874 1874 2128 2181* 2183* nindex 0(18) based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 849 ref 908 nnames 0(02) based fixed bin(16,0) level 3 in structure "status_branch" packed packed unsigned unaligned dcl 5-8 in procedure "fs_star_" ref 576 630 1161 1163 1240 1242 1244 nnames 0(02) based fixed bin(16,0) array level 2 in structure "star_entries" packed packed unsigned unaligned dcl 2-27 in procedure "PATH_expand" set ref 1084 nnames 0(02) based fixed bin(16,0) level 2 in structure "se" packed packed unsigned unaligned dcl 849 in procedure "PATH_expand" ref 909 null builtin function dcl 140 ref 309 314 319 324 350 359 361 361 372 377 378 379 384 394 411 426 467 469 470 471 489 522 568 591 597 633 1084 1086 1426 1446 1472 1505 1520 1535 1569 1740 1768 1773 1773 1784 1784 1816 1816 1841 1842 1843 1844 1845 1846 1847 1866 1867 1870 1871 1872 1908 1937 1974 2004 2034 2053 2064 2088 2088 2092 2092 2131 2145 2145 2150 2150 2181 2199 2199 2199 2219 2227 2227 2231 2231 2238 2262 2264 2268 2270 path 000164 automatic structure level 1 dcl 835 set ref 992* 999* 1032* 1055* pathX 000251 automatic fixed bin(17,0) dcl 1560 in procedure "STAR_PATHS_evaluate" set ref 1582* 1584 1584* 1585 1585 1585 1601 1603 1604 1604 1604 1607 1609 1609 1610 1612 1615 1615 1617 1617 1619 1619 1619 1622 1622 1622 1622 1627 1628 1628 1628 1631 1631 1633 1633 1633 1635 1635 1635 1635 1640 1643 1644 1645 1645 1648 1648 1651 1651* pathX 000217 automatic fixed bin(17,0) dcl 770 in procedure "EVAL_PATHS_expand" set ref 774* 776 779 780 780 781 783 786* path_allow 10 based bit(36) level 3 dcl 137 set ref 375* 1563 1601 1622 1628 1635 pathname_ 000052 constant entry external dcl 169 ref 1025 1048 pathname_$component 000054 constant entry external dcl 170 ref 672 672 1146 1146 1697 1697 per_entry 30 based structure level 2 dcl 137 pointer builtin function dcl 140 ref 575 576 630 1161 1163 1240 1242 1244 prevX 000252 automatic fixed bin(17,0) dcl 1560 set ref 1643* 1644 1645 1645 1648 1648* rtrim builtin function dcl 140 ref 1025 1048 1291 1292 saved_entry_type 000267 automatic char(32) packed unaligned dcl 1689 set ref 1702* 1705 sd based structure level 1 dcl 135 se based structure level 1 dcl 849 seP 000262 automatic pointer dcl 835 set ref 907* 908 909 910 910 911 913 search builtin function dcl 140 ref 1601 segs 12 based bit(36) level 4 in structure "so" dcl 137 in procedure "fs_star_" set ref 955 961 segs 7 based fixed bin(17,0) level 3 in structure "sd" dcl 135 in procedure "fs_star_" set ref 1340* 1340 selection 6 based structure level 2 in structure "star_options" dcl 4-26 in procedure "fs_star_" selection 6 based structure level 2 in structure "so" dcl 137 in procedure "fs_star_" short based structure level 2 dcl 5-8 size builtin function dcl 140 ref 1835 1835 1904 1904 1909 1909 1917 1917 1933 1933 1938 1938 1945 1945 1958 1958 1970 1970 1975 1975 1983 1983 2000 2000 2005 2005 2012 2012 2025 2025 2035 2035 2060 2060 2065 2065 2072 2072 2126 sn based char(32) array packed unaligned dcl 566 in procedure "ARCHIVE_PATH_expand" set ref 590* 596* 619* sn based char(32) array packed unaligned dcl 850 in procedure "PATH_expand" set ref 911* 922* 923* 933* 941* 948 948 950* 956* 964* 974* 985* 993 999* 1003* 1018* 1025* 1041* 1048* 1063* 1072* snN 000264 automatic fixed bin(17,0) dcl 835 in procedure "PATH_expand" set ref 909* 911 923 933 941 948 964 974 985 999 1018 1041 1063 1072 snN 000124 automatic fixed bin(17,0) dcl 564 in procedure "ARCHIVE_PATH_expand" set ref 576* 580* 585* 590 596 619 snP 000126 automatic pointer dcl 565 in procedure "ARCHIVE_PATH_expand 1232 1232 1240 1242 1242 1247 1249 1249 1323 1324 1331 1332 1336 1336 1338 1338 1340 1340 1342 1342 1344 1344 1346 1346 1348 1348 1350 1350 1352 1352 1354 1354 1397 1397 1702 1703 1704 1704 1705 2035 2035 2036* 2037 2037 2037 2037 2040* 2042 2043 2044 2045 2046 2049 2050 2051 2052 2053 star_dataP 6 based pointer level 2 in structure "fsd" dcl 106 in procedure "fs_star_" set ref 1841* 1866* 2034 2035* 2036 2040 star_entries based structure array level 1 dcl 2-27 set ref 907 1086 star_entry_count 000272 automatic fixed bin(17,0) dcl 2-14 set ref 886* 892* 904 904 1084 1086 star_entry_ptr 000274 automatic pointer dcl 2-15 set ref 886* 893* 907 1084 1086 1086 star_names based char(32) array packed unaligned dcl 2-37 set ref 908 1084 star_names_ptr 000276 automatic pointer dcl 2-19 set ref 886* 894* 908 1083 1084 1084 star_options based structure level 1 dcl 4-26 set ref 2126 2126 star_optionsP 2 based pointer level 2 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2043* star_optionsP 000126 automatic pointer dcl 4-26 in procedure "fs_star_" set ref 309 309 314 314 319 319 324 324 366* 367 368 372 375 376 377 378 379 381 382 383 384 385 386 387 389 411 411* 426* 467 469 470 471 472 492 492 496 496 501 501 614 671 678 730 776 917 921 925 928 937 955 961 970 980 989 1010 1014 1022 1036 1045 1059 1068 1145 1154 1161 1165 1232 1242 1249 1395 1397 1472 1475 1476 1476 1477 1505 1506 1506 1510 1511 1513 1520 1521 1521 1525 1526 1528 1535 1536 1536 1563 1569 1571 1571 1571 1571 1574 1574 1578 1583 1583 1585 1587 1601 1622 1628 1635 1696 1704 1747* 1767* 1768 1777 1780 1784 1791 1792 1835 1933 1937 1938 1938 1938 1939 1940 1941 1942 1942 1942 1942 1945 1945 1947 1948 1949 1949 1952 1953 1953 1953 1953 1958 1958 1970 1974 1975 1975 1975 1977 1978 1979 1980 1980 1980 1980 1983 1983 1986 1987 1988 1988 1991 1992 1992 1992 1992 2000 2004 2005 2005 2005 2006 2007 2008 2009 2009 2009 2009 2012 2012 2014 2015 2016 2016 2019 2020 2020 2020 2020 2025 2025 2043 2060 2064 2065 2065 2065 2066 2067 2068 2069 2069 2069 2069 2072 2072 2074 2075 2076 2076 2079 2080 2080 2080 2080 2126 2126 star_pathX 000253 automatic fixed bin(17,0) dcl 1560 set ref 1583* 1585 1587* star_paths based structure level 1 dcl 4-116 set ref 2060 2065 2065 2069 2069 2069 2069 2072 2072 2080 2080 2080 2080 star_pathsP 6 based pointer level 3 in structure "star_options" dcl 4-26 in procedure "fs_star_" set ref 324 324 467* 1571 1571 1571 1571 1574 1574 1578 1583 1583 1585 1587 2060 2065 2065 2066 2067 2068 2069 2069 2069 2069 2072 2072 2074 2075 2076 2076 2080 2080 2080 2080 star_pathsP 6 based pointer level 3 in structure "so" dcl 137 in procedure "fs_star_" set ref 372* 1569 2064 2065* 2079* star_paths_error 000254 automatic bit(1) packed unaligned dcl 1676 set ref 1695* 1714* 1719 star_paths_size 000130 automatic fixed bin(17,0) dcl 4-116 set ref 2057* 2058 2059* 2060 2061* 2065 2065 2067 2072 2072 2078 status_area based area(1024) dcl 2284 ref 630 1163 1244 status_area_ptr 000136 automatic pointer dcl 5-47 set ref 570* 572* 575 576 630 630 1157* 1159* 1161 1163 1163 1236* 1238* 1240 1242 1244 1244 status_branch based structure level 1 dcl 5-8 status_entry_names based char(32) array dcl 5-47 ref 630 1163 1244 status_names based char(32) array packed unaligned dcl 2285 set ref 575 576 1161* 1240* 1242* status_ptr 000140 automatic pointer dcl 5-47 set ref 571* 572* 575 576 576 630 630 1158* 1159* 1161 1161 1163 1163 1237* 1238* 1240 1240 1242 1242 1244 1244 structP 000344 automatic pointer dcl 2124 set ref 2126* 2128* 2131 2131* 2134 2134 2137* 2138 2138 struct_elem_size 000334 automatic fixed bin(17,0) dcl 1897 set ref 1904* 1905 1933* 1934 1970* 1971 2000* 2001 2060* 2061 struct_header 000105 automatic structure level 1 dcl 76 ref 1904 1905 1933 1934 1970 1971 2000 2001 2060 2061 sub_err_ 000076 constant entry external dcl 179 ref 1816 1819 1819 substr builtin function dcl 140 ref 1294 1294 suffixI 000426 automatic fixed bin(17,0) dcl 1289 set ref 1293* 1294 suffixL 000425 automatic fixed bin(17,0) dcl 1288 set ref 1292* 1293 1294 sum builtin function dcl 140 ref 1084 sys_info$max_seg_size 000140 external static fixed bin(35,0) dcl 218 ref 1905 1934 1971 2001 2061 2134 2138 2181 temp_segX 000364 automatic fixed bin(17,0) dcl 2217 set ref 2219* 2219* 2223 2241 2243 temp_segsP 20 based pointer array level 2 dcl 106 set ref 1846* 2219 2219 2219 2223 2224 2224 2227 2227 2231 2231 2241* 2243 2261 2261 2262 2263* 2264* terminate_file_ 000100 constant entry external dcl 180 ref 633 1867 total 5 based fixed bin(17,0) level 3 dcl 135 set ref 517* 523 type 13 based fixed bin(2,0) array level 3 in structure "mn" dcl 127 in procedure "fs_star_" set ref 1429 1529* 2030* type based fixed bin(2,0) level 2 in structure "se" packed packed unsigned unaligned dcl 849 in procedure "PATH_expand" ref 910 910 911 913 type 26 based char(32) level 3 in structure "sd" packed packed unaligned dcl 135 in procedure "fs_star_" set ref 519* 588* 672 672 672 681 883* 1146 1146 1146 1323* 1331 1332* 1702 1703* 1705* type 13 based fixed bin(2,0) array level 3 in structure "exn" dcl 98 in procedure "fs_star_" set ref 1452 1514* 1963* type 26 based char(32) level 3 in structure "star_data" packed packed unaligned dcl 4-435 in procedure "fs_star_" set ref 727* 1230* 1240* 1247* 2050* type 000271 automatic fixed bin(2,0) dcl 835 in procedure "PATH_expand" set ref 922* 925 928 932 932 933* 935 value 3 based char(32) array level 3 in structure "exn" packed packed unaligned dcl 98 in procedure "fs_star_" set ref 1451 1451 1454 1459* 1513* 1514* 1515* 1962* value 4 based char(32) array level 2 in structure "extended_entry_types" packed packed unaligned dcl 4-195 in procedure "fs_star_" set ref 1476 1477 1988* 1988 value 4 based char(32) array level 2 in structure "match_names" packed packed unaligned dcl 4-216 in procedure "fs_star_" set ref 1528 2016* 2016 value 4 based structure array level 2 in structure "epath" dcl 82 in procedure "fs_star_" set ref 774 776* 781* 783* 786* 1643 1921* 1921 value 4 based char(32) array level 2 in structure "exclude_names" packed packed unaligned dcl 4-236 in procedure "fs_star_" set ref 1513 1949* 1949 value 3 based char(32) array level 3 in structure "mn" packed packed unaligned dcl 127 in procedure "fs_star_" set ref 1428 1428 1431 1436* 1528* 1529* 1530* 2029* value 4 based char(202) array level 2 in structure "star_paths" packed packed unaligned dcl 4-116 in procedure "fs_star_" set ref 1583 1585* 1587* 2076* 2076 version based char(8) level 2 in structure "star_data" dcl 4-435 in procedure "fs_star_" set ref 2042* version based char(8) level 2 in structure "star_paths" dcl 4-116 in procedure "fs_star_" set ref 2066* 2073* version based char(8) level 2 in structure "extended_entry_types" dcl 4-195 in procedure "fs_star_" set ref 1536 1536* 1977* 1985* version based char(8) level 2 in structure "match_names" dcl 4-216 in procedure "fs_star_" set ref 1521 1521* 2006* 2013* version based char(8) level 2 in structure "exclude_names" dcl 4-236 in procedure "fs_star_" set ref 1506 1506* 1939* 1946* version based char(8) level 2 in structure "fsd" dcl 106 in procedure "fs_star_" set ref 1837* 1862* version based char(8) level 2 in structure "epath" dcl 82 in procedure "fs_star_" set ref 1910* 1918* version based char(8) level 2 in structure "star_options" dcl 4-26 in procedure "fs_star_" set ref 1777 1780* 1784* version based char(8) level 2 in structure "mn" dcl 127 in procedure "fs_star_" set ref 2026* version based char(8) level 2 in structure "so" dcl 137 in procedure "fs_star_" set ref 367* version based char(8) level 2 in structure "exn" dcl 98 in procedure "fs_star_" set ref 1959* we_created_ssuS 4 based bit(1) level 2 dcl 106 set ref 1745 1839* wordno builtin function dcl 140 ref 1874 1874 2134 2138 2181 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 6-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 6-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 6-7 A_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 CHECK_STAR_IGNORE_ALL internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_ARCHIVE internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_ENTRYPOINT internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_EQUAL internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_LENGTH internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_NONASCII internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_NULL internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_IGNORE_PATH internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PATH_DEFAULT internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PROCESS_ARCHIVE internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PROCESS_ENTRYPOINT internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_PROCESS_PATH internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_REJECT_WILD internal static bit(36) initial packed unaligned dcl 1-29 CHECK_STAR_UNIMPLEMENTED internal static bit(36) initial packed unaligned dcl 1-29 DATA_INITIATE internal static fixed bin(17,0) initial dcl 4-414 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 3-33 Directory internal static fixed bin(17,0) initial dcl 5-56 ENTRY_DONT_CHASE_LINKS internal static bit(36) initial dcl 4-152 ENTRY_DONT_LIST_SUBENTRIES internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_MDIRS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_NONOBJECTS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_NON_MDIRS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_OBJECTS internal static bit(36) initial dcl 4-152 ENTRY_INASE internal static bit(36) initial dcl 4-152 ENTRY_SELECT_ALL_DIRS internal static bit(36) initial dcl 4-152 ENTRY_SELECT_ALL_FILES internal static bit(36) initial dcl 4-152 ENTRY_SELECT_NULL_NONNULL internal static bit(36) initial dcl 4-152 E_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 Link internal static fixed bin(17,0) initial dcl 5-56 M_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 N_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 PATH_ALLOW_ALL_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_ARCHIVE_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_BRANCH_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_NONDIR_STAR_NAMES internal static bit(36) initial dcl 4-133 REW_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 RW_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 SA_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 3-30 SMA_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 SORT_BY_EXTENDED_ENTRY_TYPE internal static fixed bin(17,0) initial dcl 4-388 SORT_BY_NAME internal static fixed bin(17,0) initial dcl 4-388 SORT_BY_STANDARD_ENTRY_TYPE internal static fixed bin(17,0) initial dcl 4-388 SORT_ENTRIES_BEFORE_SUBENTRIES internal static fixed bin(17,0) initial dcl 4-388 SORT_FORWARD internal static fixed bin(17,0) initial dcl 4-388 STANDARD_ENTRY_TYPES internal static char(32) initial array packed unaligned dcl 4-530 S_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 Segment internal static fixed bin(17,0) initial dcl 5-56 TERM_FILE_BC internal static bit(2) initial packed unaligned dcl 7-12 TERM_FILE_DELETE internal static bit(5) initial packed unaligned dcl 7-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial packed unaligned dcl 7-16 TERM_FILE_TRUNC internal static bit(1) initial packed unaligned dcl 7-11 TERM_FILE_TRUNC_BC internal static bit(2) initial packed unaligned dcl 7-13 TERM_FILE_TRUNC_BC_TERM internal static bit(3) initial packed unaligned dcl 7-15 W_ACCESS internal static bit(3) initial packed unaligned dcl 3-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 3-36 check_star based structure level 1 dcl 1-15 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-114 star_BRANCHES_ONLY internal static fixed bin(2,0) initial dcl 2-110 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 2-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-112 star_branch_count automatic fixed bin(17,0) dcl 2-13 star_dir_list_branch based structure array level 1 dcl 2-59 star_link_count automatic fixed bin(17,0) dcl 2-17 star_link_pathname based char packed unaligned dcl 2-102 star_links based structure array level 1 dcl 2-76 star_linkx automatic fixed bin(17,0) dcl 2-18 star_list_branch based structure array level 1 dcl 2-41 star_list_branch_ptr automatic pointer dcl 2-16 star_list_names based char(32) array packed unaligned dcl 2-92 star_list_names_ptr automatic pointer dcl 2-20 star_select_sw automatic fixed bin(3,0) dcl 2-21 status_link based structure level 1 dcl 5-38 status_pathname based char dcl 5-47 terminate_file_switches based structure level 1 packed packed unaligned dcl 7-4 NAMES DECLARED BY EXPLICIT CONTEXT. ADJUST_EXIT 001305 constant label dcl 257 ref 278 ADJUST_error 002122 constant entry internal dcl 270 ref 303 305 309 314 319 324 1769 1778 2094 2153 2233 ARCHIVE_PATH_error 003263 constant entry internal dcl 656 ref 590 596 ARCHIVE_PATH_expand 002441 constant entry internal dcl 549 ref 999 ARCHIVE_PATH_handler 003666 constant entry internal dcl 718 ref 619 ARCH_NAME 000000 constant label array(0:2) dcl 601 ref 599 CHASE_LINKS 005042 constant label dcl 922 ref 937 ENTRY_POINT_setup 014244 constant entry internal dcl 1762 ref 247 463 488 1742 ERROR_unexpected 014516 constant entry internal dcl 1809 ref 361 361 1773 1784 2088 2092 2145 2150 2227 2231 ET_OK 011637 constant label dcl 1483 ref 1477 EVAL_PATHS_expand 004055 constant entry internal dcl 764 ref 513 EVAL_PATHS_sort 004454 constant entry internal dcl 803 ref 511 EXCL 000017 constant label array(0:2) dcl 1454 ref 1452 EXCL_FOUND 011575 constant label dcl 1468 ref 1454 1461 EXCL_NEXT 011570 constant label dcl 1465 ref 1457 1463 EXCL_NOT_FOUND 011600 constant label dcl 1472 ref 1467 FINAL_ARCH_ENTRY 003200 constant label dcl 630 ref 597 685 FSD_init 014631 constant entry internal dcl 1832 ref 370 FSD_reinit 014723 constant entry internal dcl 1859 ref 465 1744 INIT_EXIT 001607 constant label dcl 392 ref 445 INIT_cleanup 002362 constant entry internal dcl 407 ref 354 392 INIT_cleanup_setup 002416 constant entry internal dcl 422 ref 353 INIT_error 002427 constant entry internal dcl 437 ref 357 363 2096 2155 2235 MATCH 000014 constant label array(0:2) dcl 1431 ref 1429 MATCHING_ARCH_ENTRY 003123 constant label dcl 614 ref 601 609 MATCH_FOUND 011441 constant label dcl 1446 ref 1431 1438 MATCH_NEXT 011432 constant label dcl 1442 ref 1434 1440 NEXT_ARCH_ENTRY 003177 constant label dcl 627 ref 604 611 621 625 689 NEXT_ENTRY 007000 constant label dcl 1080 ref 946 968 978 1001 1034 1057 1059 1066 1068 1075 1178 NEXT_PATH 013762 constant label dcl 1657 ref 1699 1707 PATH_MATCH_ENTRY_add 010715 constant entry internal dcl 1314 ref 618 920 963 973 984 1017 1040 1062 1071 PATH_MATCH_ENTRY_remove 010740 constant entry internal dcl 1328 ref 623 637 931 942 965 975 986 1019 1042 1064 1073 1077 1092 PATH_error 007165 constant entry internal dcl 1124 ref 900 911 923 933 1106 PATH_expand 004457 constant entry internal dcl 826 ref 776 1032 1055 PATH_expand_error 007100 constant entry internal dcl 1098 ref 781 783 786 PATH_handler 010117 constant entry internal dcl 1219 ref 941 964 974 985 1018 1041 1063 1072 PATH_suffix 010626 constant entry internal dcl 1281 ref 950 PROCESS_STAR_ENTRIES 004657 constant label dcl 904 ref 896 REMOVE_ARCH_ENTRY 003175 constant label dcl 623 ref 691 727 733 737 739 REMOVE_ARCH_ENTRY_AND_EXIT 003257 constant label dcl 637 set ref 695 743 REMOVE_ENTRY 006777 constant label dcl 1077 ref 925 928 1180 1256 REMOVE_ENTRY_AND_EXIT 007073 constant label dcl 1092 ref 1184 1264 SELECT_EXIT 002032 constant label dcl 517 set ref 639 683 693 702 741 1094 1172 1182 1191 1262 1404 1709 1719 SELECT_error 011042 constant entry internal dcl 1374 ref 492 496 745 1266 1506 1515 1521 1530 1536 1563 1569 1571 1574 1771 1780 2085 2142 2224 SELECT_further 011301 constant entry internal dcl 1418 ref 727 1230 1240 1247 SELECT_further_init 011643 constant entry internal dcl 1499 ref 508 SET_MATCHED 010754 constant label dcl 1336 ref 1326 1334 STAR_PATHS_error 013766 constant entry internal dcl 1678 ref 1587 1604 1612 1619 1622 1628 1633 1635 STAR_PATHS_error_conditional_exit 014240 constant entry internal dcl 1717 ref 1660 STAR_PATHS_error_init 014235 constant entry internal dcl 1712 ref 1580 STAR_PATHS_evaluate 012323 constant entry internal dcl 1557 ref 504 STRUCT_allocate 015021 constant entry internal dcl 1889 ref 253 373 468 501 1511 1526 1578 STRUCT_get_next_space 017666 constant entry internal dcl 2172 ref 1838 1863 1913 1925 1942 1953 1961 1980 1992 2009 2020 2028 2037 2069 2080 STRUCT_get_space 017323 constant entry internal dcl 2118 ref 1835 1909 1917 1938 1945 1958 1975 1983 2005 2012 2025 2035 2065 2072 STRUCT_name_version_size_check 002134 constant entry internal dcl 292 ref 249 TEMP_AREA_get 017720 constant entry internal dcl 2196 ref 570 772 1157 1236 TEMP_SEGS_AREAS_term 020274 constant entry internal dcl 2256 ref 1873 TEMP_SEG_get 017771 constant entry internal dcl 2211 ref 2131 2137 TYPE 000004 constant label array(0:7) dcl 917 ref 913 935 950 953 957 1006 1008 1010 adjust_structure_size 001213 constant entry external dcl 242 fs_star_ 001200 constant entry external dcl 40 init 001314 constant entry external dcl 347 reinit 001621 constant entry external dcl 460 select 001663 constant entry external dcl 485 term 002056 constant entry external dcl 1737 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 21604 21746 20740 21614 Length 22500 20740 142 515 643 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fs_star_ 1058 external procedure is an external procedure. ADJUST_error internal procedure shares stack frame of external procedure fs_star_. STRUCT_name_version_size_check internal procedure shares stack frame of external procedure fs_star_. on unit on line 354 64 on unit INIT_cleanup 74 internal procedure is called by several nonquick procedures. INIT_cleanup_setup internal procedure shares stack frame of external procedure fs_star_. INIT_error internal procedure shares stack frame of external procedure fs_star_. ARCHIVE_PATH_expand internal procedure shares stack frame of internal procedure PATH_expand. ARCHIVE_PATH_error internal procedure shares stack frame of internal procedure PATH_expand. ARCHIVE_PATH_handler internal procedure shares stack frame of internal procedure PATH_expand. EVAL_PATHS_expand internal procedure shares stack frame of external procedure fs_star_. EVAL_PATHS_sort internal procedure shares stack frame of external procedure fs_star_. PATH_expand 976 internal procedure calls itself recursively. PATH_error internal procedure shares stack frame of internal procedure PATH_expand. PATH_handler internal procedure shares stack frame of internal procedure PATH_expand. PATH_suffix internal procedure shares stack frame of internal procedure PATH_expand. PATH_MATCH_ENTRY_add internal procedure shares stack frame of internal procedure PATH_expand. SELECT_error 272 internal procedure is declared options(variable). SELECT_further internal procedure shares stack frame of internal procedure PATH_expand. SELECT_further_init internal procedure shares stack frame of external procedure fs_star_. STAR_PATHS_evaluate internal procedure shares stack frame of external procedure fs_star_. STAR_PATHS_error internal procedure shares stack frame of external procedure fs_star_. STAR_PATHS_error_init internal procedure shares stack frame of external procedure fs_star_. ENTRY_POINT_setup internal procedure shares stack frame of external procedure fs_star_. ERROR_unexpected 116 internal procedure is assigned to an entry variable, and is declared options(variable). FSD_init internal procedure shares stack frame of external procedure fs_star_. STRUCT_allocate internal procedure shares stack frame of external procedure fs_star_. STRUCT_get_space internal procedure shares stack frame of external procedure fs_star_. STRUCT_get_next_space internal procedure shares stack frame of external procedure fs_star_. TEMP_AREA_get 88 internal procedure is called by several nonquick procedures. TEMP_SEG_get internal procedure shares stack frame of external procedure fs_star_. TEMP_SEGS_AREAS_term internal procedure shares stack frame of external procedure fs_star_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME ERROR_unexpected 000100 argsN ERROR_unexpected 000101 code ERROR_unexpected PATH_expand 000106 archL ARCHIVE_PATH_expand 000107 code ARCHIVE_PATH_expand 000110 compL ARCHIVE_PATH_expand 000112 compP ARCHIVE_PATH_expand 000114 comp_name ARCHIVE_PATH_expand 000124 snN ARCHIVE_PATH_expand 000126 snP ARCHIVE_PATH_expand 000136 action ARCHIVE_PATH_error 000146 action ARCHIVE_PATH_handler 000150 action PATH_expand 000151 bc PATH_expand 000152 code PATH_expand 000153 fs_util_type PATH_expand 000163 nameX PATH_expand 000164 path PATH_expand 000262 seP PATH_expand 000264 snN PATH_expand 000266 snP PATH_expand 000270 starX PATH_expand 000271 type PATH_expand 000272 star_entry_count PATH_expand 000274 star_entry_ptr PATH_expand 000276 star_names_ptr PATH_expand 000320 action PATH_error 000321 code PATH_error 000322 expanded_message PATH_error 000414 code PATH_handler 000424 nameL PATH_suffix 000425 suffixL PATH_suffix 000426 suffixI PATH_suffix 000436 addend PATH_MATCH_ENTRY_add 000437 entry_type PATH_MATCH_ENTRY_add 000456 nameX SELECT_further 000457 matchX SELECT_further SELECT_error 000100 Pcode_inP SELECT_error 000102 action SELECT_error 000103 code SELECT_error 000104 message_space SELECT_error 000301 message_len SELECT_error fs_star_ 000100 code fs_star_ 000102 ssu_sciP fs_star_ 000104 standalone_invocationS fs_star_ 000105 struct_header fs_star_ 000112 epathP fs_star_ 000114 epath_size fs_star_ 000116 fsdP fs_star_ 000126 star_optionsP fs_star_ 000130 star_paths_size fs_star_ 000131 extended_entry_types_size fs_star_ 000132 match_names_size fs_star_ 000133 exclude_names_size fs_star_ 000134 star_dataP fs_star_ 000136 status_area_ptr fs_star_ 000140 status_ptr fs_star_ 000142 auto_status fs_star_ 000212 code EVAL_PATHS_expand 000214 free_areaP EVAL_PATHS_expand 000216 matched_before EVAL_PATHS_expand 000217 pathX EVAL_PATHS_expand 000236 code SELECT_further_init 000237 matchX SELECT_further_init 000250 code STAR_PATHS_evaluate 000251 pathX STAR_PATHS_evaluate 000252 prevX STAR_PATHS_evaluate 000253 star_pathX STAR_PATHS_evaluate 000254 star_paths_error STAR_PATHS_evaluate 000266 action STAR_PATHS_error 000267 saved_entry_type STAR_PATHS_error 000332 Pnew_struct STRUCT_allocate 000334 struct_elem_size STRUCT_allocate 000344 structP STRUCT_get_space 000354 space_size STRUCT_get_next_space 000364 temp_segX TEMP_SEG_get 000374 Itemp TEMP_SEGS_AREAS_term THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_char_temp alloc_temp call_ent_var_desc call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 bound_ck_signal mpfx2 mdfx1 signal_op enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc divide_fx3 op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. archive_$next_component check_star_name_ cu_$arg_count cu_$arg_list_ptr cu_$arg_ptr cu_$generate_call expand_pathname_$component fs_util_$get_type hcs_$get_uid_file hcs_$star_ hcs_$status_ hcs_$status_minf hcs_$truncate_seg initiate_file_ ioa_$general_rs ioa_$rsnpnnl match_star_name_ pathname_ pathname_$component ssu_$destroy_invocation ssu_$get_area ssu_$get_temp_segment ssu_$null_entry ssu_$print_message ssu_$release_area ssu_$release_temp_segment ssu_$standalone_invocation sub_err_ terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$archive_pathname error_table_$argerr error_table_$fatal_error error_table_$improper_data_format error_table_$inconsistent error_table_$noalloc error_table_$noentry error_table_$nomatch error_table_$nostars error_table_$null_name_component error_table_$root error_table_$smallarg error_table_$too_many_names error_table_$unimplemented_version error_table_$unsupported_operation sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 40 001177 42 001205 242 001206 245 001233 247 001234 249 001236 253 001260 257 001305 347 001306 350 001341 351 001343 353 001344 354 001345 356 001367 357 001376 359 001405 360 001411 361 001413 363 001456 366 001460 367 001505 368 001511 370 001513 372 001514 373 001517 375 001530 376 001533 377 001544 378 001546 379 001547 381 001550 382 001566 383 001573 384 001575 385 001577 386 001601 387 001604 389 001605 390 001606 392 001607 394 001613 395 001615 460 001616 463 001631 465 001633 467 001634 468 001637 469 001650 470 001653 471 001654 472 001655 474 001656 485 001657 488 001675 489 001677 490 001702 492 001703 496 001737 501 001772 502 002023 504 002026 508 002027 511 002030 513 002031 517 002032 519 002035 520 002040 521 002041 522 002042 523 002044 527 002053 1737 002054 1740 002066 1742 002072 1744 002074 1745 002075 1747 002110 1749 002121 270 002122 275 002124 276 002127 278 002133 292 002134 299 002145 300 002163 301 002174 302 002205 303 002216 305 002225 308 002237 309 002247 312 002267 313 002270 314 002272 317 002312 318 002313 319 002315 322 002335 323 002336 324 002340 329 002360 407 002361 409 002367 411 002401 413 002415 422 002416 424 002417 425 002420 426 002424 427 002426 437 002427 442 002431 443 002434 445 002440 549 002441 568 002445 569 002451 570 002456 571 002465 572 002471 574 002541 575 002543 576 002552 577 002556 579 002557 580 002562 582 002572 584 002573 585 002575 588 002605 589 002612 590 002664 591 002742 593 002744 594 002747 595 002750 596 003005 597 003062 599 003066 601 003072 604 003076 607 003077 609 003120 611 003122 614 003123 618 003132 619 003143 621 003174 623 003175 625 003176 627 003177 630 003200 633 003223 635 003256 637 003257 639 003260 656 003263 668 003301 670 003305 671 003311 672 003327 676 003515 677 003520 678 003521 681 003565 683 003573 685 003607 689 003610 691 003612 693 003614 695 003621 698 003624 700 003655 702 003663 718 003666 727 003672 730 003741 732 004000 733 004003 735 004005 736 004010 737 004013 739 004015 741 004017 743 004024 745 004027 749 004054 764 004055 772 004056 774 004064 775 004075 776 004100 777 004124 779 004130 780 004136 781 004202 783 004276 785 004363 786 004364 789 004451 791 004453 803 004454 806 004455 826 004456 883 004467 886 004474 890 004542 891 004546 892 004557 893 004561 894 004563 895 004565 896 004566 898 004567 900 004570 904 004657 907 004675 908 004701 909 004707 910 004713 911 004722 913 005011 917 005014 920 005023 921 005034 922 005042 923 005101 925 005167 928 005177 931 005207 932 005210 933 005215 935 005302 937 005304 941 005313 942 005357 946 005365 948 005366 950 005375 952 005432 953 005434 955 005444 956 005452 957 005501 961 005511 963 005520 964 005531 965 005575 968 005603 970 005604 973 005613 974 005624 975 005670 978 005676 980 005677 984 005710 985 005721 986 005765 989 005773 992 006011 993 006015 994 006024 995 006026 996 006032 997 006035 999 006037 1001 006105 1003 006106 1005 006135 1006 006137 1008 006145 1010 006153 1014 006167 1017 006200 1018 006211 1019 006255 1022 006263 1025 006301 1026 006340 1027 006342 1028 006343 1029 006346 1030 006350 1031 006353 1032 006355 1034 006400 1036 006401 1040 006412 1041 006423 1042 006467 1045 006475 1048 006513 1049 006552 1050 006554 1051 006555 1052 006560 1053 006562 1054 006565 1055 006567 1057 006612 1059 006613 1062 006621 1063 006632 1064 006676 1066 006704 1068 006705 1071 006713 1072 006724 1073 006770 1075 006776 1077 006777 1080 007000 1083 007023 1084 007031 1086 007064 1090 007072 1092 007073 1094 007074 1098 007077 1106 007116 1107 007164 1124 007165 1140 007203 1142 007207 1143 007213 1145 007242 1146 007261 1150 007450 1151 007453 1153 007454 1154 007462 1155 007536 1157 007540 1158 007547 1159 007553 1160 007623 1161 007625 1163 007722 1164 007737 1165 007740 1167 010017 1170 010020 1172 010024 1174 010040 1178 010041 1180 010043 1182 010045 1184 010052 1187 010055 1189 010106 1191 010114 1219 010117 1229 010123 1230 010131 1232 010163 1234 010222 1236 010223 1237 010233 1238 010237 1239 010307 1240 010311 1242 010362 1244 010436 1245 010452 1247 010453 1249 010506 1254 010545 1256 010551 1258 010553 1259 010556 1260 010561 1261 010564 1262 010567 1264 010574 1266 010600 1270 010625 1281 010626 1291 010637 1292 010653 1293 010667 1294 010676 1296 010713 1314 010715 1323 010717 1324 010733 1325 010735 1326 010737 1328 010740 1331 010741 1332 010746 1333 010751 1334 010753 1336 010754 1338 010757 1340 010765 1342 010773 1344 011001 1346 011007 1348 011015 1350 011023 1352 011031 1354 011037 1357 011040 1374 011041 1390 011047 1391 011066 1393 011070 1395 011142 1397 011205 1402 011271 1404 011276 1418 011301 1426 011305 1427 011313 1428 011323 1429 011335 1431 011344 1434 011365 1436 011366 1438 011426 1440 011431 1442 011432 1443 011434 1444 011436 1446 011441 1450 011447 1451 011461 1452 011473 1454 011502 1457 011523 1459 011524 1461 011564 1463 011567 1465 011570 1466 011572 1467 011574 1468 011575 1472 011600 1475 011606 1476 011611 1477 011617 1479 011632 1480 011634 1483 011637 1499 011643 1505 011644 1506 011651 1510 011706 1511 011712 1512 011737 1513 011751 1514 011766 1515 012020 1516 012050 1520 012052 1521 012057 1525 012114 1526 012120 1527 012145 1528 012157 1529 012174 1530 012226 1531 012256 1535 012260 1536 012265 1542 012322 1557 012323 1563 012324 1569 012351 1571 012376 1574 012432 1578 012462 1580 012513 1582 012514 1583 012515 1584 012527 1585 012534 1587 012606 1601 012670 1603 012714 1604 012720 1606 012775 1607 012776 1609 013002 1610 013037 1612 013050 1615 013127 1617 013164 1619 013203 1622 013265 1627 013362 1628 013373 1631 013454 1633 013511 1635 013571 1639 013661 1640 013662 1643 013666 1644 013677 1645 013710 1648 013730 1651 013754 1655 013760 1657 013762 1660 013764 1661 013765 1678 013766 1691 014004 1692 014010 1695 014014 1696 014016 1697 014034 1699 014147 1702 014150 1703 014154 1704 014160 1705 014224 1707 014230 1709 014234 1712 014235 1714 014236 1715 014237 1717 014240 1719 014241 1721 014243 1762 014244 1767 014246 1768 014251 1769 014255 1771 014270 1773 014313 1776 014357 1777 014360 1778 014364 1780 014377 1784 014432 1791 014506 1792 014511 1794 014514 1809 014515 1815 014523 1816 014533 1819 014604 1821 014630 1832 014631 1835 014632 1837 014645 1838 014651 1839 014657 1840 014662 1841 014663 1842 014665 1843 014666 1844 014667 1845 014670 1846 014671 1847 014706 1848 014722 1859 014723 1862 014724 1863 014730 1865 014736 1866 014740 1867 014742 1870 014773 1871 014776 1872 014777 1873 015000 1874 015001 1876 015020 1889 015021 1900 015032 1901 015042 1902 015044 1903 015045 1904 015047 1905 015051 1908 015063 1909 015070 1910 015125 1911 015133 1912 015135 1913 015136 1914 015146 1916 015147 1917 015151 1918 015202 1919 015210 1920 015213 1921 015215 1923 015225 1924 015227 1925 015232 1927 015242 1929 015243 1930 015245 1931 015247 1932 015250 1933 015252 1934 015254 1937 015266 1938 015273 1939 015324 1940 015333 1941 015335 1942 015336 1943 015346 1945 015347 1946 015400 1947 015406 1948 015412 1949 015414 1951 015475 1952 015501 1953 015503 1955 015515 1957 015516 1958 015520 1959 015554 1960 015563 1961 015565 1962 015574 1963 015612 1964 015632 1966 015633 1967 015635 1968 015637 1969 015640 1970 015642 1971 015644 1974 015656 1975 015663 1977 015714 1978 015723 1979 015725 1980 015726 1981 015736 1983 015737 1985 015770 1986 015776 1987 016002 1988 016004 1990 016065 1991 016071 1992 016073 1994 016105 1996 016106 1997 016110 1998 016112 1999 016113 2000 016115 2001 016117 2004 016131 2005 016136 2006 016167 2007 016176 2008 016200 2009 016201 2010 016211 2012 016212 2013 016243 2014 016251 2015 016255 2016 016257 2018 016337 2019 016343 2020 016345 2022 016357 2024 016360 2025 016362 2026 016416 2027 016425 2028 016427 2029 016436 2030 016454 2031 016474 2033 016475 2034 016477 2035 016504 2036 016533 2037 016536 2038 016544 2040 016545 2042 016547 2043 016555 2044 016557 2045 016603 2046 016615 2049 016620 2050 016621 2051 016624 2052 016625 2053 016626 2054 016630 2056 016631 2057 016633 2058 016635 2059 016636 2060 016640 2061 016646 2064 016660 2065 016665 2066 016720 2067 016727 2068 016731 2069 016732 2070 016744 2072 016745 2073 017000 2074 017006 2075 017012 2076 017014 2078 017073 2079 017076 2080 017100 2082 017114 2085 017115 2088 017146 2092 017224 2094 017275 2096 017311 2101 017322 2118 017323 2126 017334 2128 017347 2131 017352 2134 017377 2137 017411 2138 017432 2142 017444 2145 017500 2150 017561 2153 017635 2155 017651 2160 017662 2172 017666 2180 017670 2181 017676 2183 017712 2185 017716 2196 017717 2199 017725 2201 017763 2211 017771 2219 020002 2221 020015 2223 020017 2224 020022 2227 020055 2231 020135 2233 020210 2235 020224 2238 020235 2241 020241 2243 020266 2256 020274 2261 020275 2262 020303 2263 020312 2264 020324 2266 020330 2267 020332 2268 020337 2269 020346 2270 020360 2272 020364 2273 020366 ----------------------------------------------------------- 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