COMPILATION LISTING OF SEGMENT hcom_process_path_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 04/26/87 1553.4 mst Sun Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1985 * 4* * * 5* *********************************************************** */ 6 7 /****^ HISTORY COMMENTS: 8* 1) change(85-09-03,LJAdams), approve(85-11-06,MCR7278), 9* audit(86-02-19,Gilcrease), install(86-02-19,MR12.0-1021): 10* Program to process the pathnames(archive or 11* non-archive) passed from the history comment program. 12* 2) change(85-11-13,LJAdams), approve(85-11-13,MCR7278), 13* audit(86-02-19,Gilcrease), install(86-02-19,MR12.0-1021): 14* In "process_star_name" added check to not process directories only 15* segments. 16* 3) change(86-08-27,LJAdams), approve(86-08-27,MCR7526), 17* audit(86-11-05,GDixon), install(86-11-12,MR12.0-1213): 18* In process_archive_comp routine changed arch_janitor so that d.seg.Pseg is 19* always reset to Pseg so that if an error occurred archive_$next_component 20* will have the proper component ptr as input. 21* 4) change(87-03-17,LJAdams), approve(87-04-22,MCR7653), 22* audit(87-04-02,Gilcrease), install(87-04-26,MR12.1-1026): 23* Fixed problem with no error message being displayed if a nonexistant 24* component was asked for in an archive. (phx20689) 25* END HISTORY COMMENTS */ 26 27 hcom_process_path_: 28 proc (Pd); 29 30 /* B U I L T I N */ 31 dcl (addr, before, divide, null, reverse, sum) 32 builtin; 33 34 35 /* C O N D I T I O N S */ 36 dcl cleanup condition; 37 38 39 /* E X T E R N A L E N T R I E S */ 40 dcl access_$reset entry (ptr, fixed bin (35)), 41 access_$set_temporarily entry (char (*), char (*), fixed bin (2), bit (*), ptr, fixed bin (35)), 42 archive entry options (variable), 43 archive_$next_component entry (ptr, fixed bin (24), ptr, fixed bin (24), char (*), fixed bin (35)), 44 check_star_name_$entry entry (char (*), fixed bin (35)), 45 expand_pathname_$component entry (char (*), char (*), char (*), char (*), fixed bin (35)), 46 get_equal_name_$component entry (char (*), char (*), char (*), char (*), char (32), char (32), 47 fixed bin (35)), 48 get_pdir_ entry () returns (char (168)), 49 get_system_free_area_ entry () returns (ptr), 50 hcom_process_seg_ entry (ptr, label), 51 hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, 52 fixed bin (35)), 53 hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), fixed bin (35)), 54 initiate_file_ entry (char (*), char (*), bit (*), ptr, fixed bin (24), fixed bin (35)), 55 initiate_file_$component entry (char (*), char (*), char (*), bit (*), ptr, fixed bin (24), 56 fixed bin (35)), 57 initiate_file_$create entry (char (*), char (*), bit (*), ptr, bit (1) aligned, fixed bin (24), 58 fixed bin (35)), 59 match_star_name_ entry (char (*), char (*), fixed bin (35)), 60 pathname_ entry (char (*), char (*)) returns (char (168)), 61 pathname_$component entry (char (*), char (*), char (*)) returns (char (194)), 62 terminate_file_ entry (ptr, fixed bin (24), bit (*), fixed bin (35)); 63 64 65 /* N A M E D C O N S T A N T S */ 66 dcl BITS_PER_CHAR fixed bin int static options (constant) init (9); 67 dcl FALSE bit (1) int static options (constant) init ("0"b); 68 dcl TRUE bit (1) int static options (constant) init ("1"b); 69 70 71 /* E X T E R N A L S T A T I C */ 72 dcl (error_table_$bad_arg, 73 error_table_$badstar, 74 error_table_$no_component, 75 error_table_$no_w_permission, 76 error_table_$zero_length_seg) 77 fixed bin (35) ext static; 78 79 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 80 /* */ 81 /* Name: hcom_process_path_ */ 82 /* */ 83 /* Overall module structure: */ 84 /* */ 85 /* hcom_process_path_ */ 86 /* | */ 87 /* call process_star_name(); */ 88 /* | */ 89 /* call process_seg_by_case(); */ 90 /* | */ 91 /* SELECTED SEG ENTRYNAME AND COMPONENT NAME */ 92 /* NONARCHIVE ONE ARCHIVE COMP STAR ARCHIVE COMP */ 93 /* ===================================================== */ 94 /* | | | */ 95 /* | call process_archive_comp(); */ 96 /* | | */ 97 /* call process_one_seg(); */ 98 /* */ 99 /* The modules are shown in the code below in the order shown above. */ 100 /* */ 101 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 102 103 104 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 105 /* */ 106 /* hcom_process_path_: */ 107 /* */ 108 /* This is the starting point in processing pathnames (both source and -original paths). */ 109 /* This initial section of code is responsible for expanding the source and original */ 110 /* paths into absolute, archive pathnames. The code then calls process_star_name, for */ 111 /* both star and nonstar entrynames. */ 112 /* */ 113 /* The input paths are in d.source and d.orig structures, and the expanded dir/ent/comp */ 114 /* are placed in those structures as well. */ 115 /* If errors have occurred the label ERROR_RETURN_LABEL is being used to activate the */ 116 /* cleanup handlers invoked by those programs that are being wiped off the stack by the*/ 117 /* unwinder as it does a non-local "goto" to the label specified by the calling program*/ 118 /* */ 119 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 120 121 122 dcl code fixed bin (35); 123 124 call expand_pathname_$component (d.source.path, d.source.dir, d.source.ent, d.source.comp, code); 125 call d.check_error$fatal (code, CALLER, "^/^a", d.source.path); 126 127 if d.orig.path ^= "" then do; 128 call expand_pathname_$component (d.orig.path, d.orig.dir, d.orig.ent, d.orig.comp, code); 129 call d.check_error$fatal (code, CALLER, "^/-orig ^a", d.orig.path); 130 end; 131 132 call process_star_name (); 133 return; 134 135 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 136 137 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 138 139 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 140 /* */ 141 /* process_star_name: */ 142 /* */ 143 /* This procedure examines the source entryname to determine if it is a starname. For a */ 144 /* nonstar entryname, it moves source d.source.dir/ent/comp into d.seg_arch.dir/ent/comp */ 145 /* and calls process_seg_by_case. */ 146 /* */ 147 /* For a star entryname, this procedure expands the entryname into one or more matching */ 148 /* segments in the given source dir. The segments may be either archives or nonarchive */ 149 /* segments. For each matching segment, d.seg_arch.dir/ent/comp is filled in to */ 150 /* identify the matching segment, and process_seg_by_case is called to process that */ 151 /* segment. The procedure is responsible for cleaning up allocations made by hcs_$star_ */ 152 /* in processing the starname. */ 153 /* */ 154 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 155 156 process_star_name: 157 proc; 158 159 dcl Ientry fixed bin, 160 Parea ptr, 161 code fixed bin (35); 162 163 dcl area area based (Parea); 164 165 call check_star_name_$entry (d.source.ent, d.source.ent_type); 166 if d.source.ent_type = error_table_$badstar then 167 call d.check_error$fatal (d.source.ent_type, CALLER, "^/^a", 168 d.source.path); 169 170 if d.source.ent_type = NONSTAR then do; 171 d.seg_arch = d.source, by name; 172 call process_seg_by_case (NON_STAR_RETURN); 173 NON_STAR_RETURN: 174 return; 175 end; 176 177 Parea = get_system_free_area_ (); 178 star_entry_ptr, star_names_ptr = null; 179 on cleanup call star_janitor (); 180 181 call hcs_$star_ (d.source.dir, d.source.ent, star_BRANCHES_ONLY, addr (area), 182 star_entry_count, star_entry_ptr, star_names_ptr, code); 183 call d.check_error$fatal (code, CALLER, 184 "^/(^a)^/^3xListing entries matching source path.", 185 pathname_ (d.source.dir, d.source.ent)); 186 187 d.seg_arch.dir = d.source.dir; 188 d.seg_arch.comp = d.source.comp; 189 do Ientry = 1 to star_entry_count; 190 if star_entries (Ientry).type = star_SEGMENT then do; 191 d.seg_arch.ent = star_names (star_entries (Ientry).nindex); 192 call process_seg_by_case (STAR_RETURN); 193 end; 194 STAR_RETURN: 195 end; 196 call star_janitor (); 197 return; 198 199 star_janitor: 200 proc; 201 if star_entry_ptr ^= null then do; 202 free star_names in (area), 203 star_entries in (area); 204 star_entry_ptr, star_names_ptr = null; 205 end; 206 end star_janitor; 207 208 end process_star_name; 209 210 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 211 212 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 213 214 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 215 /* */ 216 /* process_seg_by_case: */ 217 /* */ 218 /* This procedure receives the name of a single source segment (in */ 219 /* d.seg_arch.dir/ent/comp) as its input. The procedure determines whether the segment */ 220 /* is an archive or a nonarchive segment. For archive segments, it determines whether a */ 221 /* star, nonstar or null string archive component name is given. A null string */ 222 /* component name can be given if the entry name explicitly ends with .archive and no */ 223 /* archive pathname is given. In this situation, a component name of "**" is assumed, */ 224 /* meaning that all archive components are processed. */ 225 /* */ 226 /* For nonarchive segments, processing consists of initiating the source file, checking */ 227 /* for proper access to perform the specified operation (MODIFY or NO_MODIFY), setting */ 228 /* d.seg.dir/ent/Pseg/Lseg_in to identify the segment, and calling process_one_seg. */ 229 /* */ 230 /* For archive components, processing consists of initiating the archive, checking for */ 231 /* proper access to perform the specified operation (MODIFY or NO_MODIFY), applying the */ 232 /* star convention on the archive component name, and processing the components which */ 233 /* match by setting d.seg.dir/ent/comp/Pseg/Lseg_in and calling process_archive_comp. */ 234 /* */ 235 /* Cleanup handlers are established to terminate the archive or nonarchive segment, and */ 236 /* to restore access if it was forced in order to perform a MODIFY operation. */ 237 /* */ 238 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 239 240 241 process_seg_by_case: 242 proc (ERROR_RETURN_LABEL); 243 244 dcl ERROR_RETURN_LABEL label variable; 245 246 dcl Paccess ptr, 247 bc fixed bin (24), 248 mode bit (36), 249 terminate_mode bit (5); 250 251 if d.seg_arch.comp = "" then do; /* no archive component name given. */ 252 if reverse (before (reverse (d.seg_arch.ent), ".")) = "archive" then do; 253 d.seg_arch.comp = "**"; /* an archive, with no component path given, */ 254 d.seg_arch.comp_type = STARSTAR; /* means process all components. */ 255 end; 256 else /* not an archive. */ 257 d.seg_arch.comp_type = NOCOMP; 258 end; 259 else do; /* archive component name given. */ 260 call check_star_name_$entry (d.seg_arch.comp, d.seg_arch.comp_type); 261 if d.seg_arch.comp_type = error_table_$badstar then 262 call d.check_error$fatal (d.seg_arch.comp_type, CALLER, "^/^a", 263 d.source.path); /* Report path in error msg exactly as user typed */ 264 end; 265 266 if d.op.type = MODIFY then do; 267 mode = RW_ACCESS; 268 terminate_mode = TERM_FILE_TRUNC_BC_TERM; 269 end; 270 else do; 271 mode = R_ACCESS; 272 terminate_mode = TERM_FILE_TERM; 273 end; 274 275 Paccess = null; 276 d.seg_arch.Pseg = null; 277 on cleanup call seg_janitor (TERM_FILE_TERM); 278 279 call initiate_file_ (d.seg_arch.dir, d.seg_arch.ent, mode, 280 d.seg_arch.Pseg, d.seg_arch.Lsegbc, code); 281 if d.op.type = MODIFY & code = error_table_$no_w_permission then do; 282 call access_$set_temporarily (d.seg_arch.dir, d.seg_arch.ent, 283 (star_SEGMENT), mode, Paccess, code); 284 if code = 0 then 285 call initiate_file_ (d.seg_arch.dir, d.seg_arch.ent, mode, 286 d.seg_arch.Pseg, d.seg_arch.Lsegbc, code); 287 else 288 code = error_table_$no_w_permission; 289 end; 290 call d.check_error$fatal (code, CALLER, "^/^a", 291 pathname_ (d.seg_arch.dir, d.seg_arch.ent)); 292 d.seg_arch.Lseg = divide (d.seg_arch.Lsegbc, BITS_PER_CHAR, 21, 0); 293 if d.seg_arch.Lseg = 0 then 294 call d.check_error$fatal (error_table_$zero_length_seg, CALLER, "^/^a", 295 pathname_ (d.seg_arch.dir, d.seg_arch.ent)); 296 297 goto PROC (d.seg_arch.comp_type); 298 299 PROC (-1): /* nonarchive seg */ 300 d.seg = d.seg_arch, by name; 301 d.seg.Lseg_in = d.seg_arch.Lseg; 302 call process_one_seg (ERROR_RETURN_LABEL, d.seg.Pseg); 303 call seg_janitor (terminate_mode); 304 SEG_ERROR_EXIT: 305 return; 306 307 PROC (0): /* NONSTAR COMPONENT */ 308 PROC (1): /* STAR COMPONENT */ 309 PROC (2): /* STARSTAR COMPONENT */ 310 311 dcl Smatch_found bit (1); 312 313 d.seg.dir = d.seg_arch.dir; 314 d.seg.ent = d.seg_arch.ent; 315 d.seg.Pseg = null; 316 317 Smatch_found = FALSE; 318 319 call archive_$next_component (d.seg_arch.Pseg, d.seg_arch.Lsegbc, 320 d.seg.Pseg, bc, d.seg.comp, code); 321 call d.check_error$fatal (code, CALLER, "^/Processing: ^a", 322 pathname_$component (d.seg_arch.dir, d.seg_arch.ent, d.seg_arch.comp)); 323 do while (d.seg.Pseg ^= null); 324 d.seg.Lseg_in = divide (bc, BITS_PER_CHAR, 21, 0); 325 goto MATCH (d.seg_arch.comp_type); 326 327 MATCH (0): 328 if d.seg.comp = d.seg_arch.comp then 329 go to MATCH (2); 330 else 331 go to NOMATCH; 332 333 MATCH (1): 334 call match_star_name_ (d.seg.comp, d.seg_arch.comp, code); 335 if code ^= 0 then 336 goto NOMATCH; 337 338 MATCH (2): 339 Smatch_found = TRUE; 340 call process_archive_comp (NOMATCH); 341 342 NOMATCH: 343 call archive_$next_component (d.seg_arch.Pseg, d.seg_arch.Lsegbc, 344 d.seg.Pseg, bc, d.seg.comp, code); 345 call d.check_error$fatal (code, CALLER, "^/Processing: ^a", 346 pathname_$component (d.seg_arch.dir, d.seg_arch.ent, d.seg_arch.comp)); 347 end; 348 349 if ^Smatch_found then do; 350 code = error_table_$no_component; 351 call d.check_error$fatal (code, CALLER, "^/Processing: ^a", 352 pathname_$component (d.seg_arch.dir, d.seg_arch.ent, d.seg_arch.comp)); 353 end; 354 355 call seg_janitor (TERM_FILE_TERM); 356 return; 357 358 seg_janitor: 359 proc (terminate_mode); 360 361 dcl code fixed bin (35), 362 terminate_mode bit (*); 363 364 if d.seg_arch.Pseg ^= null then do; 365 call terminate_file_ (d.seg_arch.Pseg, d.seg.Lseg_out * BITS_PER_CHAR, terminate_mode, code); 366 d.seg_arch.Pseg = null; 367 end; 368 if Paccess ^= null then do; 369 call access_$reset (Paccess, code); 370 Paccess = null; 371 end; 372 end seg_janitor; 373 374 end process_seg_by_case; 375 376 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 377 378 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 379 380 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 381 /* */ 382 /* process_archive_comp: */ 383 /* */ 384 /* This routine is responsible for making a copy of an archive component when a MODIFY */ 385 /* operation (eg, hcom add, add_field, format, install or replace_field) operation is */ 386 /* being performed. Since archive components cannot be updated in place, a temporary */ 387 /* copy of the archive component is made in the process directory, this temp copy is */ 388 /* modified (by calling process_one_seg), and then the temp copy is updated back into */ 389 /* the archive. After the archive command is called, the revised bit count of the */ 390 /* archive is obtained for use in obtaining the next matching archive component. */ 391 /* */ 392 /* Note that, to function properly, this strategy depends upon the archive command */ 393 /* always updating the component by putting it in the exact same place as its earlier */ 394 /* version. Thus, the pointer to the beginning of the unmodified and modified */ 395 /* components is the same; only the component bit count differs following the */ 396 /* modification, and that bit count is no longer of interest to us. What is interesting */ 397 /* is that the overall archive bit count has changed. That is why we obtain the new */ 398 /* archive bit count following each archive update operation. */ 399 /* */ 400 /* This procedure is responsible for cleaning up the temporary copy of the component, */ 401 /* and for manipulating d.seg.Pseg to point to the temporary copy while the modify */ 402 /* operation is in progress, and to the archived component after the modify is complete. */ 403 /* */ 404 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 405 406 407 process_archive_comp: 408 proc (ERROR_RETURN_LABEL); 409 410 dcl ERROR_RETURN_LABEL label variable; 411 412 dcl code fixed bin (35), 413 pdir char (168), 414 seg char (d.seg.Lseg_in) based (d.seg.Pseg), 415 Pseg ptr; 416 417 if d.op.type = NO_MODIFY then do; /* read-type operations can be done on archive */ 418 call process_one_seg (ERROR_RETURN_LABEL, d.seg.Pseg); 419 /* components in place. */ 420 return; 421 end; 422 423 Pseg = d.seg.Pseg; 424 d.seg.Pseg = null; 425 on cleanup call arch_janitor (); 426 427 pdir = get_pdir_ (); 428 call initiate_file_$create (pdir, d.seg.comp, RW_ACCESS, d.seg.Pseg, 429 "0"b, 0, code); 430 if d.seg.Pseg = null then 431 call d.check_error$fatal (code, CALLER, 432 "Creating temporary segment in process directory."); 433 seg = Pseg -> seg; 434 435 call process_one_seg (ERROR_RETURN_LABEL, Pseg); 436 437 if d.seg.Lseg_in = d.seg.Lseg_out then /* If component was not changed during processing */ 438 if Pseg -> seg = seg then do; /* then don't update the archive. */ 439 call arch_janitor (); 440 revert cleanup; 441 d.seg.Pseg = Pseg; 442 return; 443 end; 444 445 call terminate_file_ (d.seg.Pseg, d.seg.Lseg_out * BITS_PER_CHAR, 446 TERM_FILE_TRUNC_BC, code); 447 call d.check_error$fatal (code, CALLER, 448 "Terminating a temporary segment in the process directory."); 449 450 call archive ("ud", pathname_ (d.seg_arch.dir, d.seg_arch.ent), 451 pathname_ (pdir, d.seg.comp)); 452 d.seg.Pseg = null; 453 revert cleanup; 454 d.seg.Pseg = Pseg; 455 456 call hcs_$status_mins (d.seg_arch.Pseg, (0), d.seg_arch.Lsegbc, code); 457 call d.check_error$fatal (code, CALLER, "^/^a^/^3xGetting bit count for updated archive.", 458 pathname_ (d.seg_arch.dir, d.seg_arch.ent)); 459 return; 460 461 462 arch_janitor: 463 proc; 464 465 dcl code fixed bin (35); 466 467 if d.seg.Pseg ^= null then 468 call terminate_file_ (d.seg.Pseg, d.seg.Lseg_out * BITS_PER_CHAR, TERM_FILE_DELETE, code); 469 470 d.seg.Pseg = Pseg; 471 472 end arch_janitor; 473 474 end process_archive_comp; 475 476 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 477 478 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 479 480 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 481 /* */ 482 /* process_one_seg: */ 483 /* */ 484 /* This procedure applies the equal convention to the -original pathname, initiates the */ 485 /* original segment/component, and calls hcom_process_seg_ to perform the actual */ 486 /* operation on the source segment/component. It is responsible for terminating the */ 487 /* original segment/component upon completion of the operation. */ 488 /* */ 489 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 490 491 492 process_one_seg: 493 proc (ERROR_RETURN_LABEL, APseg); 494 495 dcl ERROR_RETURN_LABEL label variable, 496 APseg ptr; 497 498 dcl bc fixed bin (24), 499 code fixed bin (35); 500 501 if d.orig.path = "" then do; 502 call hcom_process_seg_ (addr (d), ERROR_RETURN_LABEL); 503 return; 504 end; 505 506 d.orig_seg.dir = d.orig.dir; 507 call get_equal_name_$component (d.seg.ent, d.seg.comp, 508 d.orig.ent, d.orig.comp, d.orig_seg.ent, d.orig_seg.comp, code); 509 call d.check_error$fatal (code, CALLER, 510 "-orig ^a^/when applied to source path^/(^a).", d.orig.path, 511 pathname_$component (d.seg.dir, d.seg.ent, d.seg.comp)); 512 513 d.orig_seg.Pseg = null; 514 on cleanup call one_seg_janitor (); 515 516 call initiate_file_$component (d.orig_seg.dir, d.orig_seg.ent, 517 d.orig_seg.comp, R_ACCESS, d.orig_seg.Pseg, bc, code); 518 if d.orig_seg.Pseg = APseg then 519 call d.check_error$fatal (error_table_$bad_arg, CALLER, "^/-orig ^a^/is the same as the source^/(^a).", 520 pathname_$component (d.orig_seg.dir, d.orig_seg.comp, d.orig_seg.ent), 521 pathname_$component (d.seg.dir, d.seg.comp, d.seg.ent)); 522 call d.check_error$fatal (code, CALLER, "^/-orig ^a", 523 pathname_$component (d.orig_seg.dir, d.orig_seg.ent, d.orig_seg.comp)); 524 d.orig_seg.Lseg_in = divide (bc, BITS_PER_CHAR, 21, 0); 525 526 call hcom_process_seg_ (addr (d), ERROR_RETURN_LABEL); 527 call one_seg_janitor (); 528 return; 529 530 one_seg_janitor: 531 proc; 532 dcl code fixed bin (35); 533 534 if d.orig_seg.Pseg ^= null then do; 535 call terminate_file_ (d.orig_seg.Pseg, 0, TERM_FILE_TERM, code); 536 d.orig_seg.Pseg = null; 537 end; 538 end one_seg_janitor; 539 540 end process_one_seg; 541 542 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 543 1 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 1 2* 1 3* Values for the "access mode" argument so often used in hardcore 1 4* James R. Davis 26 Jan 81 MCR 4844 1 5* Added constants for SM access 4/28/82 Jay Pattin 1 6* Added text strings 03/19/85 Chris Jones 1 7**/ 1 8 1 9 1 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 1 11 dcl ( 1 12 N_ACCESS init ("000"b), 1 13 R_ACCESS init ("100"b), 1 14 E_ACCESS init ("010"b), 1 15 W_ACCESS init ("001"b), 1 16 RE_ACCESS init ("110"b), 1 17 REW_ACCESS init ("111"b), 1 18 RW_ACCESS init ("101"b), 1 19 S_ACCESS init ("100"b), 1 20 M_ACCESS init ("010"b), 1 21 A_ACCESS init ("001"b), 1 22 SA_ACCESS init ("101"b), 1 23 SM_ACCESS init ("110"b), 1 24 SMA_ACCESS init ("111"b) 1 25 ) bit (3) internal static options (constant); 1 26 1 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 1 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 1 29 1 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 1 31 static options (constant); 1 32 1 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 1 34 static options (constant); 1 35 1 36 dcl ( 1 37 N_ACCESS_BIN init (00000b), 1 38 R_ACCESS_BIN init (01000b), 1 39 E_ACCESS_BIN init (00100b), 1 40 W_ACCESS_BIN init (00010b), 1 41 RW_ACCESS_BIN init (01010b), 1 42 RE_ACCESS_BIN init (01100b), 1 43 REW_ACCESS_BIN init (01110b), 1 44 S_ACCESS_BIN init (01000b), 1 45 M_ACCESS_BIN init (00010b), 1 46 A_ACCESS_BIN init (00001b), 1 47 SA_ACCESS_BIN init (01001b), 1 48 SM_ACCESS_BIN init (01010b), 1 49 SMA_ACCESS_BIN init (01011b) 1 50 ) fixed bin (5) internal static options (constant); 1 51 1 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 544 545 2 1 /* START OF: hcom_data.incl.pl1 * * * * * * * * * * * * * * * * */ 2 2 2 3 2 4 /****^ HISTORY COMMENTS: 2 5* 1) change(85-10-02,LJAdams), approve(85-11-06,MCR7278), 2 6* audit(86-02-19,Gilcrease), install(86-02-19,MR12.0-1021): 2 7* Provides data structure for the history comment 2 8* programs. 2 9* 2) change(86-04-17,LJAdams), approve(86-04-17,MCR7386), 2 10* audit(86-06-05,Gilcrease), install(86-06-05,MR12.0-1071): 2 11* Added d.ag.ctl.fill to indicate if summary is to be filled or not. 2 12* Added fill bit to src_array to indicate to fill/not fill comment. 2 13* 3) change(86-04-30,LJAdams), approve(86-05-05,MCR7386), 2 14* audit(86-06-05,Gilcrease), install(86-06-05,MR12.0-1071): 2 15* Added parameter to d.ag.vdt to contain error message. 2 16* 4) change(86-05-05,LJAdams), approve(86-05-05,MCR7386), 2 17* audit(86-06-05,Gilcrease), install(86-06-05,MR12.0-1071): 2 18* Added switch to indicate if a critical fix number had been found while 2 19* parsing. 2 20* END HISTORY COMMENTS */ 2 21 2 22 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 23 /* */ 2 24 /* This include file contains the arguments needed for processing history comments. */ 2 25 /* */ 2 26 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 27 2 28 2 29 dcl 1 d aligned based(Pd), 2 30 2 ag, 2 31 3 op, 2 32 4 name fixed bin, 2 33 4 type bit(1), /* 0 = NO_MODIFY, 1 = MODIFY */ 2 34 3 vdt entry (char(*) var, char(*) var, char(*) var, bit(1), char(*) var, 2 35 char(*) var, char(100) var) variable, 2 36 /* = nothing for -nvdt */ 2 37 3 ctl, 2 38 4 errors bit(1) unal, 2 39 4 fill bit(1) unal, 2 40 4 renumber bit(1) unal, 2 41 4 mbz bit(33) unal, 2 42 3 source, 2 43 4 path char(202) unal, 2 44 4 dir char(168) unal, 2 45 4 ent char(32) unal, 2 46 4 ent_type fixed bin(35), /* 0 = NONSTAR, 1 = STAR, 2 = STARSTAR */ 2 47 4 comp char(32) unal, 2 48 3 orig like d.source, 2 49 3 input, 2 50 4 select, 2 51 5 sm fixed bin(2), 2 52 5 apv fixed bin(2), 2 53 5 aud fixed bin(2), 2 54 5 in fixed bin(2), /* 0 = NOxxx, 1 = CLEARxxx */ 2 55 /* 2 = OPERANDxxx, 3 = INPUTxxx */ 2 56 4 value like src_array.comments, 2 57 3 output, 2 58 (4 cdt, 2 59 4 cpi, 2 60 4 apvdt, 2 61 4 apvi, 2 62 4 auddt, 2 63 4 audpi, 2 64 4 indt, 2 65 4 ini, 2 66 4 sm) bit(1) unal, 2 67 4 mbz bit(27) unal, 2 68 2 com_spec, 2 69 3 selected unal, 2 70 4 all bit(1), 2 71 4 old bit(1), 2 72 4 new bit(1), 2 73 4 cpt bit(1), 2 74 4 icpt bit(1), 2 75 4 apv bit(1), 2 76 4 unapv bit(1), 2 77 4 aud bit(1), 2 78 4 unaud bit(1), 2 79 4 in bit(1), 2 80 4 unin bit(1), 2 81 4 mbz bit(25), 2 82 3 matched unaligned like d.com_spec.selected, 2 83 3 Nrange fixed bin, 2 84 3 range (10), 2 85 4 from, 2 86 5 set fixed bin(2), /* 0 = UNSET, 1 = SET, 2 = LAST */ 2 87 5 no fixed bin, 2 88 5 op fixed bin(2), /* 0 = UNSET, 1 = PLUS 2 = MINUS */ 2 89 5 addend fixed bin, 2 90 5 result fixed bin, 2 91 4 to like d.com_spec.range.from, 2 92 4 matched fixed bin(1), 2 93 2 94 2 field_array (9) fixed bin, 2 95 2 check_error$fatal entry options(variable) variable, 2 96 2 set_return_arg entry (char(*)) variable, 2 97 2 add_to_return_arg entry (char(*)) variable, 2 98 2 add_to_return_arg_var entry (char(*) var) variable, 2 99 2 Saf bit(1), /* switch to indicate active function */ 2 100 2 101 2 Scfix bit(1), /* switch to indicate critical fix input */ 2 102 2 Scfix_found bit(1), 2 103 2 Ssite bit(1), /* switch to indicate site */ 2 104 2 seg_arch, /* info for seg or achive used by */ 2 105 3 dir char(168) unal, /* hcom_process_path_ */ 2 106 3 ent char(32) unal, 2 107 3 comp char(32) unal, 2 108 3 comp_type fixed bin(35), /* -1 = NOCOMP, 0 = NONSTAR */ 2 109 /* 1 = STAR, 2 = STARSTAR */ 2 110 3 Pseg ptr, 2 111 3 Lseg fixed bin(21), 2 112 3 Lsegbc fixed bin(24), 2 113 2 114 2 seg, /* info for specific seg or archive component */ 2 115 3 dir char(168) unal, /* used by hcom_process_seg_. */ 2 116 3 ent char(32) unal, 2 117 3 comp char(32) unal, 2 118 3 Pseg ptr, 2 119 3 Lseg_in fixed bin(21), 2 120 3 Lseg_out fixed bin(21), 2 121 3 ec_version fixed bin, /* if type is 3 (an exec_com), this will be its */ 2 122 /* version, as obtained from get_ec_version_ */ 2 123 3 type fixed bin, /* the language type of the entry */ 2 124 3 text_pos fixed bin(21), /* this will be the char pos of the first */ 2 125 /* non-version char in an exec_com */ 2 126 3 cmt_bgn char(8) var, /* comment begin character(s) */ 2 127 3 cmt_end char(8) var, /* comment end character(s) */ 2 128 3 Pbox ptr, 2 129 3 Loldbox fixed bin(21), 2 130 3 Lnewbox fixed bin(21), 2 131 2 orig_seg like d.seg, /* info for original seg/comp used by */ 2 132 /* hcom_process_seg_ */ 2 133 2 134 2 temp_seg, 2 135 3 Pcomp_info ptr, 2 136 3 Pformed_string ptr, 2 137 3 Porig_array ptr, 2 138 3 Pout_string ptr, 2 139 3 Presult ptr, 2 140 3 Psort_copy ptr, 2 141 3 Psrc_array ptr, 2 142 temp_seg_array (7) ptr aligned based (addr(d.temp_seg)), 2 143 2 144 Pd ptr; 2 145 2 146 dcl CALLER char(15) int static options(constant) init("history_comment"), 2 147 2 148 (NOTSET init(0), /* values for d.ag.op.name */ 2 149 ADD init(1), 2 150 ADD_FIELD init(2), 2 151 CHECK init(3), 2 152 COMPARE init(4), 2 153 DISPLAY init(5), 2 154 EXISTS init(6), 2 155 FORMAT init(7), 2 156 GET init(8), 2 157 INSTALL init(9), 2 158 REPLACE_FIELD init(10)) fixed bin int static options(constant), 2 159 (MODIFY init("1"b), /* values for d.ag.op.type */ 2 160 NO_MODIFY init("0"b)) bit(1) int static options(constant), 2 161 (CLEARxxx init(1), /* values for d.ag.input.select */ 2 162 INPUTxxx init(3), 2 163 NOxxx init(0), 2 164 OPERANDxxx init(2)) fixed bin(2) int static options(constant), 2 165 (NOCOMP init(-1), /* values for d.ag.ent_type, and */ 2 166 NONSTAR init(0), /* d.seg_arch.comp_type */ 2 167 STAR init(1), 2 168 STARSTAR init(2)) fixed bin(35) int static options(constant), 2 169 ALL bit(36) aligned int static options(constant) init("1"b), 2 170 /* value comparable to string(d.com_spec.selected)*/ 2 171 (LAST init(2), /* values for d.ag.com_spec.range.set */ 2 172 SET init(1), 2 173 UNSET init(0)) fixed bin(2) int static options(constant), 2 174 (MINUS init(2), /* values for d.ag.com_spec.range.op */ 2 175 PLUS init(1)) fixed bin(2) int static options(constant); 2 176 2 177 dcl oper (10,2) char(16) varying int static options(constant) init ( 2 178 "add", "~", /* 1 Operations */ 2 179 "add_field", "af", /* 2 */ 2 180 "check", "ck", /* 3 */ 2 181 "compare", "cmp", /* 4 */ 2 182 "display", "ds", /* 5 */ 2 183 "exists", "~", /* 6 */ 2 184 "format", "fmt", /* 7 */ 2 185 "get", "~", /* 8 */ 2 186 "install", "~", /* 9 */ 2 187 "replace_field", "rpf"); /* 10 */ 2 188 2 189 dcl 1 src_array based(Psrc_array) aligned, 2 190 2 Ncoms fixed bin, 2 191 2 comments (0 refer (src_array.Ncoms)), 2 192 3 change_dt char(8), 2 193 3 seqno pic "9999", 2 194 3 fill bit(1), 2 195 3 selected bit(1), 2 196 3 Ieq fixed bin, 2 197 3 comment_no fixed bin, 2 198 3 change_person char(24) varying, 2 199 3 approve_dt char(8), 2 200 3 approve_value char(24) varying, 2 201 3 audit_dt char(8), 2 202 3 audit_person char(24) varying, 2 203 3 install_dt char(8), 2 204 3 install_id char(24) varying, 2 205 3 summary char(2000) varying, 2 206 3 err_msg (5) char(80) varying; 2 207 2 208 2 209 dcl Psrc_array ptr; 2 210 2 211 /* END OF: hcom_data.incl.pl1 * * * * * * * * * * * * * * * * */ 546 547 3 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 3 2 3 3 /* This include file contains structures for the hcs_$star_, 3 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 3 5* 3 6* Written 23 October 1978 by Monte Davidoff. 3 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 3 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 3 9**/ 3 10 3 11 /* automatic */ 3 12 3 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 3 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 3 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 3 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 3 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 3 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 3 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 3 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 3 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 3 22 3 23 /* based */ 3 24 3 25 /* hcs_$star_ entry structure */ 3 26 3 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 3 28 2 type fixed binary (2) unsigned unaligned, 3 29 /* storage system type */ 3 30 2 nnames fixed binary (16) unsigned unaligned, 3 31 /* number of names of entry that match star_name */ 3 32 2 nindex fixed binary (18) unsigned unaligned; 3 33 /* index of first name in star_names */ 3 34 3 35 /* hcs_$star_ name structure */ 3 36 3 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 3 38 3 39 /* hcs_$star_list_ branch structure */ 3 40 3 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 3 42 2 type fixed binary (2) unsigned unaligned, 3 43 /* storage system type */ 3 44 2 nnames fixed binary (16) unsigned unaligned, 3 45 /* number of names of entry that match star_name */ 3 46 2 nindex fixed binary (18) unsigned unaligned, 3 47 /* index of first name in star_list_names */ 3 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 3 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 3 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 3 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 3 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 3 53 2 pad bit (7) unaligned, 3 54 2 records fixed binary (18) unsigned unaligned; 3 55 /* records used by branch */ 3 56 3 57 /* hcs_$star_dir_list_ branch structure */ 3 58 3 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 3 60 2 type fixed binary (2) unsigned unaligned, 3 61 /* storage system type */ 3 62 2 nnames fixed binary (16) unsigned unaligned, 3 63 /* number of names of entry that match star_name */ 3 64 2 nindex fixed binary (18) unsigned unaligned, 3 65 /* index of first name in star_list_names */ 3 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 3 67 2 pad bit (36) unaligned, 3 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 3 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 3 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 3 71 2 bit_count fixed binary (24) unaligned; 3 72 /* bit count of the branch */ 3 73 3 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 3 75 3 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 3 77 2 type fixed binary (2) unsigned unaligned, 3 78 /* storage system type */ 3 79 2 nnames fixed binary (16) unsigned unaligned, 3 80 /* number of names of entry that match star_name */ 3 81 2 nindex fixed binary (18) unsigned unaligned, 3 82 /* index of first name in star_list_names */ 3 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 3 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 3 85 2 pathname_len fixed binary (18) unsigned unaligned, 3 86 /* length of the pathname of the link */ 3 87 2 pathname_index fixed binary (18) unsigned unaligned; 3 88 /* index of start of pathname in star_list_names */ 3 89 3 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 3 91 3 92 declare star_list_names char (32) based (star_list_names_ptr) 3 93 dimension (star_links (star_branch_count + star_link_count).nindex 3 94 + star_links (star_branch_count + star_link_count).nnames 3 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 3 96 * binary ( 3 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 3 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 3 99 3 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 3 101 3 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 3 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 3 104 3 105 /* internal static */ 3 106 3 107 /* star_select_sw values */ 3 108 3 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 3 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 3 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 3 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 3 113 fixed binary (3) internal static options (constant) initial (5); 3 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 3 115 fixed binary (3) internal static options (constant) initial (7); 3 116 3 117 /* storage system types */ 3 118 3 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 3 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 3 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 3 122 3 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 548 549 4 1 /* BEGIN INCLUDE FILE ... terminate_file.incl.pl1 */ 4 2 /* format: style2,^inddcls,idind32 */ 4 3 4 4 declare 1 terminate_file_switches based, 4 5 2 truncate bit (1) unaligned, 4 6 2 set_bc bit (1) unaligned, 4 7 2 terminate bit (1) unaligned, 4 8 2 force_write bit (1) unaligned, 4 9 2 delete bit (1) unaligned; 4 10 4 11 declare TERM_FILE_TRUNC bit (1) internal static options (constant) initial ("1"b); 4 12 declare TERM_FILE_BC bit (2) internal static options (constant) initial ("01"b); 4 13 declare TERM_FILE_TRUNC_BC bit (2) internal static options (constant) initial ("11"b); 4 14 declare TERM_FILE_TERM bit (3) internal static options (constant) initial ("001"b); 4 15 declare TERM_FILE_TRUNC_BC_TERM bit (3) internal static options (constant) initial ("111"b); 4 16 declare TERM_FILE_FORCE_WRITE bit (4) internal static options (constant) initial ("0001"b); 4 17 declare TERM_FILE_DELETE bit (5) internal static options (constant) initial ("00001"b); 4 18 4 19 /* END INCLUDE FILE ... terminate_file.incl.pl1 */ 550 551 552 end hcom_process_path_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/26/87 1553.4 hcom_process_path_.pl1 >spec>install>1026>hcom_process_path_.pl1 544 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 546 2 06/05/86 1155.4 hcom_data.incl.pl1 >ldd>include>hcom_data.incl.pl1 548 3 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 550 4 04/06/83 1239.4 terminate_file.incl.pl1 >ldd>include>terminate_file.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. APseg parameter pointer dcl 495 ref 492 518 BITS_PER_CHAR constant fixed bin(17,0) initial dcl 66 ref 292 324 365 445 467 524 CALLER 000012 constant char(15) initial unaligned dcl 2-146 set ref 125* 129* 166* 183* 261* 290* 293* 321* 345* 351* 430* 447* 457* 509* 518* 522* ERROR_RETURN_LABEL parameter label variable dcl 244 in procedure "process_seg_by_case" set ref 241 302* ERROR_RETURN_LABEL parameter label variable dcl 495 in procedure "process_one_seg" set ref 492 502* 526* ERROR_RETURN_LABEL parameter label variable dcl 410 in procedure "process_archive_comp" set ref 407 418* 435* FALSE constant bit(1) initial unaligned dcl 67 ref 317 Ientry 000100 automatic fixed bin(17,0) dcl 159 set ref 189* 190 191* Lseg 2074 based fixed bin(21,0) level 3 dcl 2-29 set ref 292* 293 301 Lseg_in 2172 based fixed bin(21,0) level 3 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 301* 324* 433 433 437 437 437 Lseg_in 2306 based fixed bin(21,0) level 3 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 524* Lseg_out 2173 based fixed bin(21,0) level 3 dcl 2-29 set ref 365 437 445 467 Lsegbc 2075 based fixed bin(24,0) level 3 dcl 2-29 set ref 279* 284* 292 319* 342* 456* MODIFY constant bit(1) initial unaligned dcl 2-146 ref 266 281 NOCOMP constant fixed bin(35,0) initial dcl 2-146 ref 256 NONSTAR constant fixed bin(35,0) initial dcl 2-146 ref 170 NO_MODIFY constant bit(1) initial unaligned dcl 2-146 ref 417 Paccess 000100 automatic pointer dcl 246 set ref 275* 282* 368 369* 370* Parea 000102 automatic pointer dcl 159 set ref 177* 181 181 202 202 Pd parameter pointer dcl 2-29 ref 27 124 124 124 124 125 125 127 128 128 128 128 129 129 165 165 166 166 166 166 170 171 171 181 181 183 183 183 183 183 187 187 188 188 191 251 252 253 254 256 260 260 261 261 261 261 266 276 279 279 279 279 281 282 282 284 284 284 284 290 290 290 290 290 292 292 293 293 293 293 293 293 297 299 299 301 301 302 313 313 314 314 315 319 319 319 319 321 321 321 321 321 321 321 323 324 325 327 327 333 333 342 342 342 342 345 345 345 345 345 345 345 351 351 351 351 351 351 351 364 365 365 366 417 418 423 424 428 428 430 430 433 433 433 437 437 437 437 437 441 445 445 447 450 450 450 450 450 450 452 454 456 456 457 457 457 457 457 467 467 467 470 501 502 502 506 506 507 507 507 507 507 507 509 509 509 509 509 509 509 509 513 516 516 516 516 518 518 518 518 518 518 518 518 518 518 518 518 518 518 522 522 522 522 522 522 522 524 526 526 534 535 536 Pseg 2170 based pointer level 3 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 302* 315* 319* 323 342* 418* 423 424* 428* 430 433 437 441* 445* 452* 454* 467 467* 470* Pseg 2304 based pointer level 3 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 513* 516* 518 534 535* 536* Pseg 2072 based pointer level 3 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 276* 279* 284* 319* 342* 364 365* 366* 456* Pseg 000154 automatic pointer dcl 412 in procedure "process_archive_comp" set ref 423* 433 435* 437 441 454 470 RW_ACCESS 000016 constant bit(3) initial unaligned dcl 1-11 set ref 267 428* R_ACCESS 000017 constant bit(3) initial unaligned dcl 1-11 set ref 271 516* STARSTAR constant fixed bin(35,0) initial dcl 2-146 ref 254 Smatch_found 000105 automatic bit(1) unaligned dcl 307 set ref 317* 338* 349 TERM_FILE_DELETE 000007 constant bit(5) initial unaligned dcl 4-17 set ref 467* TERM_FILE_TERM 000010 constant bit(3) initial unaligned dcl 4-14 set ref 272 277* 355* 535* TERM_FILE_TRUNC_BC 000011 constant bit(2) initial unaligned dcl 4-13 set ref 445* TERM_FILE_TRUNC_BC_TERM constant bit(3) initial unaligned dcl 4-15 ref 268 TRUE 000017 constant bit(1) initial unaligned dcl 68 ref 338 access_$reset 000010 constant entry external dcl 40 ref 369 access_$set_temporarily 000012 constant entry external dcl 40 ref 282 addr builtin function dcl 31 ref 181 181 502 502 526 526 ag based structure level 2 dcl 2-29 archive 000014 constant entry external dcl 40 ref 450 archive_$next_component 000016 constant entry external dcl 40 ref 319 342 area based area(1024) dcl 163 set ref 181 181 202 202 bc 000100 automatic fixed bin(24,0) dcl 498 in procedure "process_one_seg" set ref 516* 524 bc 000102 automatic fixed bin(24,0) dcl 246 in procedure "process_seg_by_case" set ref 319* 324 342* before builtin function dcl 31 ref 252 check_error$fatal 1752 based entry variable level 2 dcl 2-29 set ref 125 129 166 183 261 290 293 321 345 351 430 447 457 509 518 522 check_star_name_$entry 000020 constant entry external dcl 40 ref 165 260 cleanup 000000 stack reference condition dcl 36 ref 179 277 425 440 453 514 code 000104 automatic fixed bin(35,0) dcl 159 in procedure "process_star_name" set ref 181* 183* code 000100 automatic fixed bin(35,0) dcl 361 in procedure "seg_janitor" set ref 365* 369* code 000101 automatic fixed bin(35,0) dcl 498 in procedure "process_one_seg" set ref 507* 509* 516* 522* code 000100 automatic fixed bin(35,0) dcl 122 in procedure "hcom_process_path_" set ref 124* 125* 128* 129* 279* 281 282* 284 284* 287* 290* 319* 321* 333* 335 342* 345* 350* 351* code 000100 automatic fixed bin(35,0) dcl 465 in procedure "arch_janitor" set ref 467* code 000100 automatic fixed bin(35,0) dcl 532 in procedure "one_seg_janitor" set ref 535* code 000100 automatic fixed bin(35,0) dcl 412 in procedure "process_archive_comp" set ref 428* 430* 445* 447* 456* 457* com_spec 1557 based structure level 2 dcl 2-29 comments 1 based structure array level 2 dcl 2-189 comp 333 based char(32) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 128* 507* comp 155 based char(32) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 124* 188 comp 2060 based char(32) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 188* 251 253* 260* 321* 321* 327 333* 345* 345* 351* 351* comp 2160 based char(32) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 319* 327 333* 342* 428* 450* 450* 507* 509* 509* 518* 518* comp 2274 based char(32) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 507* 516* 518* 518* 522* 522* comp_type 2070 based fixed bin(35,0) level 3 dcl 2-29 set ref 254* 256* 260* 261 261* 297 325 d based structure level 1 dcl 2-29 set ref 502 502 526 526 dir 71(18) based char(168) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 124* 181* 183* 183* 187 dir 2212 based char(168) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 506* 516* 518* 518* 522* 522* dir 1776 based char(168) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 187* 279* 282* 284* 290* 290* 293* 293* 313 321* 321* 345* 345* 351* 351* 450* 450* 457* 457* dir 2076 based char(168) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 313* 509* 509* 518* 518* dir 247(18) based char(168) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 128* 506 divide builtin function dcl 31 ref 292 324 524 ent 2264 based char(32) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 507* 516* 518* 518* 522* 522* ent 143(18) based char(32) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 124* 165* 181* 183* 183* ent 2050 based char(32) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 191* 252 279* 282* 284* 290* 290* 293* 293* 314 321* 321* 345* 345* 351* 351* 450* 450* 457* 457* ent 2150 based char(32) level 3 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 314* 507* 509* 509* 518* 518* ent 321(18) based char(32) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 128* 507* ent_type 154 based fixed bin(35,0) level 4 dcl 2-29 set ref 165* 166 166* 170 error_table_$bad_arg 000056 external static fixed bin(35,0) dcl 72 set ref 518* error_table_$badstar 000060 external static fixed bin(35,0) dcl 72 ref 166 261 error_table_$no_component 000062 external static fixed bin(35,0) dcl 72 ref 350 error_table_$no_w_permission 000064 external static fixed bin(35,0) dcl 72 ref 281 287 error_table_$zero_length_seg 000066 external static fixed bin(35,0) dcl 72 set ref 293* expand_pathname_$component 000022 constant entry external dcl 40 ref 124 128 from 1562 based structure array level 4 dcl 2-29 get_equal_name_$component 000024 constant entry external dcl 40 ref 507 get_pdir_ 000026 constant entry external dcl 40 ref 427 get_system_free_area_ 000030 constant entry external dcl 40 ref 177 hcom_process_seg_ 000032 constant entry external dcl 40 ref 502 526 hcs_$star_ 000034 constant entry external dcl 40 ref 181 hcs_$status_mins 000036 constant entry external dcl 40 ref 456 initiate_file_ 000040 constant entry external dcl 40 ref 279 284 initiate_file_$component 000042 constant entry external dcl 40 ref 516 initiate_file_$create 000044 constant entry external dcl 40 ref 428 match_star_name_ 000046 constant entry external dcl 40 ref 333 mode 000103 automatic bit(36) unaligned dcl 246 set ref 267* 271* 279* 282* 284* nindex 0(18) based fixed bin(18,0) array level 2 packed unsigned unaligned dcl 3-27 ref 191 nnames 0(02) based fixed bin(16,0) array level 2 packed unsigned unaligned dcl 3-27 ref 202 null builtin function dcl 31 ref 178 201 204 275 276 315 323 364 366 368 370 424 430 452 467 513 534 536 op based structure level 3 dcl 2-29 orig 165 based structure level 3 dcl 2-29 orig_seg 2212 based structure level 2 dcl 2-29 path 165 based char(202) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 127 128* 129* 501 509* path 7 based char(202) level 4 in structure "d" packed unaligned dcl 2-29 in procedure "hcom_process_path_" set ref 124* 125* 166* 261* pathname_ 000050 constant entry external dcl 40 ref 183 183 290 290 293 293 450 450 450 450 457 457 pathname_$component 000052 constant entry external dcl 40 ref 321 321 345 345 351 351 509 509 518 518 518 518 522 522 pdir 000101 automatic char(168) unaligned dcl 412 set ref 427* 428* 450* 450* range 1562 based structure array level 3 dcl 2-29 reverse builtin function dcl 31 ref 252 252 seg based char unaligned dcl 412 in procedure "process_archive_comp" set ref 433* 433 437 437 seg 2076 based structure level 2 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 299* seg_arch 1776 based structure level 2 dcl 2-29 set ref 171* 299 selected 1557 based structure level 3 packed unaligned dcl 2-29 source 7 based structure level 3 dcl 2-29 set ref 171 src_array based structure level 1 dcl 2-189 star_BRANCHES_ONLY 000051 constant fixed bin(2,0) initial dcl 3-110 set ref 181* star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 3-120 ref 190 282 star_entries based structure array level 1 dcl 3-27 ref 202 star_entry_count 000101 automatic fixed bin(17,0) dcl 3-14 set ref 181* 189 202 202 star_entry_ptr 000102 automatic pointer dcl 3-15 set ref 178* 181* 190 191 201 202 202 204* star_names based char(32) array unaligned dcl 3-37 ref 191 202 star_names_ptr 000104 automatic pointer dcl 3-19 set ref 178* 181* 191 202 204* sum builtin function dcl 31 ref 202 terminate_file_ 000054 constant entry external dcl 40 ref 365 445 467 535 terminate_mode 000104 automatic bit(5) unaligned dcl 246 in procedure "process_seg_by_case" set ref 268* 272* 303* terminate_mode parameter bit unaligned dcl 361 in procedure "seg_janitor" set ref 358 365* type based fixed bin(2,0) array level 2 in structure "star_entries" packed unsigned unaligned dcl 3-27 in procedure "hcom_process_path_" ref 190 type 1 based bit(1) level 4 in structure "d" dcl 2-29 in procedure "hcom_process_path_" set ref 266 281 417 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ADD internal static fixed bin(17,0) initial dcl 2-146 ADD_FIELD internal static fixed bin(17,0) initial dcl 2-146 ALL internal static bit(36) initial dcl 2-146 A_ACCESS internal static bit(3) initial unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 CHECK internal static fixed bin(17,0) initial dcl 2-146 CLEARxxx internal static fixed bin(2,0) initial dcl 2-146 COMPARE internal static fixed bin(17,0) initial dcl 2-146 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-33 DISPLAY internal static fixed bin(17,0) initial dcl 2-146 EXISTS internal static fixed bin(17,0) initial dcl 2-146 E_ACCESS internal static bit(3) initial unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 FORMAT internal static fixed bin(17,0) initial dcl 2-146 GET internal static fixed bin(17,0) initial dcl 2-146 INPUTxxx internal static fixed bin(2,0) initial dcl 2-146 INSTALL internal static fixed bin(17,0) initial dcl 2-146 LAST internal static fixed bin(2,0) initial dcl 2-146 MINUS internal static fixed bin(2,0) initial dcl 2-146 M_ACCESS internal static bit(3) initial unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 NOTSET internal static fixed bin(17,0) initial dcl 2-146 NOxxx internal static fixed bin(2,0) initial dcl 2-146 N_ACCESS internal static bit(3) initial unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 OPERANDxxx internal static fixed bin(2,0) initial dcl 2-146 PLUS internal static fixed bin(2,0) initial dcl 2-146 Psrc_array automatic pointer dcl 2-209 REPLACE_FIELD internal static fixed bin(17,0) initial dcl 2-146 REW_ACCESS internal static bit(3) initial unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-30 SET internal static fixed bin(2,0) initial dcl 2-146 SMA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 STAR internal static fixed bin(35,0) initial dcl 2-146 S_ACCESS internal static bit(3) initial unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 TERM_FILE_BC internal static bit(2) initial unaligned dcl 4-12 TERM_FILE_FORCE_WRITE internal static bit(4) initial unaligned dcl 4-16 TERM_FILE_TRUNC internal static bit(1) initial unaligned dcl 4-11 UNSET internal static fixed bin(2,0) initial dcl 2-146 W_ACCESS internal static bit(3) initial unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 oper internal static varying char(16) initial array dcl 2-177 star_ALL_ENTRIES internal static fixed bin(2,0) initial dcl 3-111 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 3-114 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 3-121 star_LINK internal static fixed bin(2,0) initial unsigned dcl 3-119 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 3-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 3-112 star_branch_count automatic fixed bin(17,0) dcl 3-13 star_dir_list_branch based structure array level 1 dcl 3-59 star_link_count automatic fixed bin(17,0) dcl 3-17 star_link_pathname based char unaligned dcl 3-102 star_links based structure array level 1 dcl 3-76 star_linkx automatic fixed bin(17,0) dcl 3-18 star_list_branch based structure array level 1 dcl 3-41 star_list_branch_ptr automatic pointer dcl 3-16 star_list_names based char(32) array unaligned dcl 3-92 star_list_names_ptr automatic pointer dcl 3-20 star_select_sw automatic fixed bin(3,0) dcl 3-21 temp_seg_array based pointer array dcl 2-29 terminate_file_switches based structure level 1 packed unaligned dcl 4-4 NAMES DECLARED BY EXPLICIT CONTEXT. MATCH 000004 constant label array(0:2) dcl 327 ref 325 327 NOMATCH 002073 constant label dcl 342 ref 330 335 340 340 NON_STAR_RETURN 000526 constant label dcl 173 ref 172 172 PROC 000000 constant label array(-1:2) dcl 299 ref 297 SEG_ERROR_EXIT 001660 constant label dcl 304 STAR_RETURN 000777 constant label dcl 194 ref 192 192 arch_janitor 003151 constant entry internal dcl 462 ref 425 439 hcom_process_path_ 000212 constant entry external dcl 27 one_seg_janitor 003745 constant entry internal dcl 530 ref 514 527 process_archive_comp 002421 constant entry internal dcl 407 ref 340 process_one_seg 003230 constant entry internal dcl 492 ref 302 418 435 process_seg_by_case 001065 constant entry internal dcl 241 ref 172 192 process_star_name 000410 constant entry internal dcl 156 ref 132 seg_janitor 002313 constant entry internal dcl 358 ref 277 303 355 star_janitor 001007 constant entry internal dcl 199 ref 179 196 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4442 4532 4021 4452 Length 5070 4021 70 321 420 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME hcom_process_path_ 118 external procedure is an external procedure. process_star_name 186 internal procedure enables or reverts conditions. on unit on line 179 64 on unit star_janitor 66 internal procedure is called by several nonquick procedures. process_seg_by_case 233 internal procedure enables or reverts conditions. on unit on line 277 72 on unit seg_janitor 86 internal procedure is called by several nonquick procedures. process_archive_comp 256 internal procedure enables or reverts conditions. on unit on line 425 64 on unit arch_janitor 84 internal procedure is called by several nonquick procedures. process_one_seg 251 internal procedure enables or reverts conditions. on unit on line 514 64 on unit one_seg_janitor 84 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME arch_janitor 000100 code arch_janitor hcom_process_path_ 000100 code hcom_process_path_ 000101 star_entry_count hcom_process_path_ 000102 star_entry_ptr hcom_process_path_ 000104 star_names_ptr hcom_process_path_ one_seg_janitor 000100 code one_seg_janitor process_archive_comp 000100 code process_archive_comp 000101 pdir process_archive_comp 000154 Pseg process_archive_comp process_one_seg 000100 bc process_one_seg 000101 code process_one_seg process_seg_by_case 000100 Paccess process_seg_by_case 000102 bc process_seg_by_case 000103 mode process_seg_by_case 000104 terminate_mode process_seg_by_case 000105 Smatch_found process_seg_by_case process_star_name 000100 Ientry process_star_name 000102 Parea process_star_name 000104 code process_star_name seg_janitor 000100 code seg_janitor THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. 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 mpfx2 enable_op shorten_stack ext_entry int_entry int_entry_desc reverse_cs set_chars_eis op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. access_$reset access_$set_temporarily archive archive_$next_component check_star_name_$entry expand_pathname_$component get_equal_name_$component get_pdir_ get_system_free_area_ hcom_process_seg_ hcs_$star_ hcs_$status_mins initiate_file_ initiate_file_$component initiate_file_$create match_star_name_ pathname_ pathname_$component terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$badstar error_table_$no_component error_table_$no_w_permission error_table_$zero_length_seg LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 27 000207 124 000217 125 000254 127 000305 128 000314 129 000347 132 000402 133 000406 156 000407 165 000415 166 000437 170 000475 171 000503 172 000514 173 000526 177 000527 178 000536 179 000542 181 000564 183 000640 187 000722 188 000731 189 000734 190 000743 191 000751 192 000765 194 000777 196 001001 197 001005 199 001006 201 001014 202 001022 204 001056 206 001063 241 001064 251 001072 252 001102 253 001130 254 001134 255 001136 256 001137 258 001141 260 001142 261 001156 266 001214 267 001223 268 001225 269 001227 271 001230 272 001232 275 001236 276 001240 277 001241 279 001267 281 001330 282 001343 284 001401 287 001445 290 001450 292 001526 293 001535 297 001611 299 001617 301 001632 302 001636 303 001650 304 001660 313 001661 314 001664 315 001667 317 001671 319 001672 321 001727 323 002012 324 002022 325 002025 327 002027 330 002033 333 002034 335 002054 338 002057 340 002061 342 002073 345 002132 347 002215 349 002216 350 002220 351 002223 355 002301 356 002311 358 002312 364 002326 365 002337 366 002367 368 002376 369 002403 370 002414 372 002417 407 002420 417 002426 418 002434 420 002446 423 002447 424 002451 425 002453 427 002475 428 002504 430 002554 433 002607 435 002621 437 002633 439 002650 440 002654 441 002655 442 002663 445 002664 447 002714 450 002743 452 003035 453 003043 454 003044 456 003050 457 003070 459 003147 462 003150 467 003156 470 003216 472 003226 492 003227 501 003235 502 003245 503 003260 506 003261 507 003264 509 003321 513 003410 514 003416 516 003440 518 003504 522 003630 524 003714 526 003723 527 003737 528 003743 530 003744 534 003752 535 003763 536 004010 538 004017 ----------------------------------------------------------- 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