COMPILATION LISTING OF SEGMENT le Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-05-05_1832.09_Fri_mdt Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1986 * 4* * * 5* *********************************************************** */ 6 7 8 /****^ HISTORY COMMENTS: 9* 1) change(86-08-12,Elhard), approve(86-08-12,MCR7505), 10* audit(86-12-10,DGHowe), install(86-12-10,MR12.0-1241): 11* Originally written as the command interface to le. 12* 2) change(86-12-19,Elhard), approve(86-12-19,PBF7505), 13* audit(86-12-22,DGHowe), install(87-01-05,MR12.0-1256): 14* Changed to use "linkage_editor" in error messages rather than "le". 15* END HISTORY COMMENTS */ 16 17 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll78,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 18 19 linkage_editor: 20 le: 21 proc; 22 23 /*** ****************************************************************/ 24 /*** */ 25 /*** Name: linkage_editor, le */ 26 /*** Syntax: le paths {-control_args} */ 27 /*** Function: le is the command interface to the le_ linkage */ 28 /*** editor subroutine. Its function is to parse the */ 29 /*** command line arguments and create the le_ input */ 30 /*** structure. */ 31 /*** */ 32 /*** ****************************************************************/ 33 34 /* constants */ 35 36 dcl true bit (1) static options (constant) init ("1"b); 37 dcl false bit (1) static options (constant) init ("0"b); 38 39 dcl ARCHIVE_SUFFIX char (8) static options (constant) 40 init (".archive"); 41 42 /* procedures */ 43 44 dcl archive_$next_component entry (ptr, fixed bin (24), ptr, fixed bin (24), 45 char (*), fixed bin (35)); 46 dcl check_star_name_$entry entry (char (*), fixed bin (35)); 47 dcl com_err_ entry () options (variable); 48 dcl cu_$arg_count entry (fixed bin, fixed bin (35)); 49 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), 50 fixed bin (35)); 51 dcl cv_dec_check_ entry (char (*), fixed bin (35)) 52 returns (fixed bin (35)); 53 dcl expand_pathname_ entry (char (*), char (*), char (*), 54 fixed bin (35)); 55 dcl expand_pathname_$component 56 entry (char (*), char (*), char (*), char (*), 57 fixed bin (35)); 58 dcl get_system_free_area_ entry () returns (ptr); 59 dcl get_temp_segment_ entry (char (*), ptr, fixed bin (35)); 60 dcl get_wdir_ entry () returns (char (168)); 61 dcl hcs_$star_dir_list_ entry (char (*), char (*), fixed bin (3), ptr, 62 fixed bin, fixed bin, ptr, ptr, fixed bin (35)); 63 dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), 64 fixed bin (2), fixed bin (24), fixed bin (35)); 65 dcl initiate_file_ entry (char (*), char (*), bit (*), ptr, 66 fixed bin (24), fixed bin (35)); 67 dcl initiate_file_$component 68 entry (char (*), char (*), char (*), bit (*), 69 ptr, fixed bin (24), fixed bin (35)); 70 dcl ioa_ entry () options (variable); 71 dcl le_ entry (ptr, fixed bin, fixed bin (35)); 72 dcl match_star_name_ entry (char (*), char (*), fixed bin (35)); 73 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 74 dcl pathname_$component entry (char (*), char (*), char (*)) 75 returns (char (194)); 76 dcl release_temp_segment_ entry (char (*), ptr, fixed bin (35)); 77 dcl terminate_file_ entry (ptr, fixed bin (24), bit (*), 78 fixed bin (35)); 79 80 /* external */ 81 82 dcl error_table_$bad_conversion 83 external fixed bin (35); 84 dcl error_table_$badopt external fixed bin (35); 85 dcl error_table_$dirseg external fixed bin (35); 86 dcl error_table_$msf external fixed bin (35); 87 dcl error_table_$noarg external fixed bin (35); 88 dcl error_table_$nomatch external fixed bin (35); 89 dcl le_data_$version_string external char (64) varying; 90 dcl le_et_$too_many_options external fixed bin (35); 91 dcl sys_info$max_seg_size external fixed bin (35); 92 dcl linkage_editor_severity_ 93 external fixed bin (35); 94 95 /* based */ 96 97 dcl arg char (argl) based (argp); 98 dcl 01 lei aligned based (leip), 99 02 header aligned like le_input.header, 100 02 opt dim (0 refer (lei.n_opts)) like le_option; 101 102 /* automatic */ 103 104 dcl argl fixed bin (21) automatic; 105 dcl argp ptr automatic; 106 dcl argx fixed bin automatic; 107 dcl ec fixed bin (35) automatic; 108 dcl has_delete bit (1) automatic; 109 dcl has_global bit (1) automatic; 110 dcl has_retain bit (1) automatic; 111 dcl i fixed bin automatic; 112 dcl leip ptr automatic; 113 dcl nargs fixed bin automatic; 114 dcl severity fixed bin automatic; 115 dcl version_flag bit (1) automatic; 116 117 /* conditions */ 118 119 dcl cleanup condition; 120 121 /* builtin */ 122 123 dcl after builtin; 124 dcl before builtin; 125 dcl binary builtin; 126 dcl currentsize builtin; 127 dcl divide builtin; 128 dcl index builtin; 129 dcl length builtin; 130 dcl null builtin; 131 dcl rtrim builtin; 132 dcl size builtin; 133 dcl string builtin; 134 dcl substr builtin; 135 dcl unspec builtin; 136 137 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 138 139 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 140 141 142 /* make sure that the le_info temp seg goes away on a release */ 143 144 leip = null; 145 146 on cleanup 147 begin; 148 if leip ^= null 149 then call release_temp_segment_ ("le", leip, ec); 150 end; 151 152 /* see how many arguments we have */ 153 154 call cu_$arg_count (nargs, ec); 155 if ec ^= 0 156 then call abort (ec, ""); 157 158 /* print a usage message if invoked with no arguments */ 159 160 if nargs = 0 161 then call abort (0, "Usage: le path{s} {-control_args}"); 162 163 call get_temp_segment_ ("le", leip, ec); 164 165 /* set up default values */ 166 167 lei.version = le_input_version_1; 168 lei.header.name = "linkage_editor"; 169 lei.output_file.dir = get_wdir_ (); 170 lei.output_file.entry = "a.out"; 171 lei.abort_severity = 3; 172 lei.display_severity = 0; 173 lei.component_size = 255; 174 lei.bindfile.name = ""; 175 lei.bindfile.dt_updated = 0; 176 lei.bindfile.dt_modified = 0; 177 178 string (lei.header.flags) = ""b; 179 lei.flags.auto_segnames = true; 180 181 version_flag = true; 182 has_global = false; 183 has_retain = false; 184 has_delete = false; 185 186 /* scan through the arguments and process them */ 187 188 argx = 1; 189 do while (argx <= nargs); 190 191 /* read the argument */ 192 193 call cu_$arg_ptr (argx, argp, argl, ec); 194 195 /* first handle input pathnames */ 196 197 if index (arg, "-") ^= 1 198 then do; 199 200 /* evaluate path as seg/dir/archive/starname/archive_starname */ 201 202 call expand_le_path (PATH, arg, leip, ec); 203 if ec ^= 0 204 then call abort (ec, arg); 205 end; 206 207 /* now handle library paths and other ctl args which take arguments */ 208 209 else if arg = "-library" | arg = "-lb" 210 then do; 211 212 /* make sure there is a next argument */ 213 214 if argx = nargs 215 then call abort (error_table_$noarg, 216 "library specification expected."); 217 218 /* get the next argument */ 219 220 argx = argx + 1; 221 call cu_$arg_ptr (argx, argp, argl, ec); 222 223 /* expand pathname into discrete option entries */ 224 225 call expand_le_path (LIBRARY, arg, leip, ec); 226 if ec ^= 0 227 then call abort (ec, arg); 228 end; 229 230 else if arg = "-retain" | arg = "-ret" 231 then do; 232 233 has_retain = true; 234 235 /* if there is no next argument, treat as global retain */ 236 237 if argx = nargs 238 then call add_ep (RETAIN, "", false, leip, ec); 239 else do; 240 241 /* otherwise fetch the next argument */ 242 243 argx = argx + 1; 244 call cu_$arg_ptr (argx, argp, argl, ec); 245 246 /* if it is another control arg, treat as global retain */ 247 /* and back up the argument count so the next control arg */ 248 /* gets processed properly. */ 249 250 if index (arg, "-") = 1 251 then do; 252 call add_ep (RETAIN, "", false, leip, ec); 253 argx = argx - 1; 254 end; 255 256 /* otherwise, add a retain for the entrpoint specified */ 257 258 else call add_ep (RETAIN, arg, false, leip, ec); 259 end; 260 end; 261 262 else if arg = "-delete" | arg = "-dl" 263 then do; 264 265 has_delete = true; 266 267 /* if there is no next arg, treat as a global delete */ 268 269 if argx = nargs 270 then call add_ep (DELETE, "", false, leip, ec); 271 else do; 272 273 /* otherwise, fetch the next argument */ 274 275 argx = argx + 1; 276 call cu_$arg_ptr (argx, argp, argl, ec); 277 278 /* if it is a control argument, treat as a global delete */ 279 /* and back up the arg index so the next arg is processed */ 280 /* properly. */ 281 282 if index (arg, "-") = 1 283 then do; 284 call add_ep (DELETE, "", false, leip, ec); 285 argx = argx - 1; 286 end; 287 288 /* otherwise, add the delete option for the given entrypoint */ 289 290 else call add_ep (DELETE, arg, false, leip, ec); 291 end; 292 end; 293 294 else if arg = "-output_file" | arg = "-of" 295 then do; 296 297 /* make sure there is a next argument */ 298 299 if argx = nargs 300 then call abort (error_table_$noarg, 301 "Output file pathname expected."); 302 303 /* fetch the output filename */ 304 305 argx = argx + 1; 306 call cu_$arg_ptr (argx, argp, argl, ec); 307 308 /* expand it to a dirname and entryname */ 309 310 call expand_pathname_ (arg, lei.output_file.dir, 311 lei.output_file.entry, ec); 312 if ec ^= 0 313 then call abort (ec, arg); 314 end; 315 316 else if arg = "-component_size" | arg = "-compsz" 317 then do; 318 319 /* make sure there is a next argument */ 320 321 if argx = nargs 322 then call abort (error_table_$noarg, "Component size expected."); 323 324 /* fetch the component size */ 325 326 argx = argx + 1; 327 call cu_$arg_ptr (argx, argp, argl, ec); 328 329 /* try converting it and make sure it is a number */ 330 331 lei.component_size = cv_dec_check_ (arg, ec); 332 if ec ^= 0 333 then call abort (error_table_$bad_conversion, arg); 334 335 /* make sure it is in the range 4-255 */ 336 337 if lei.component_size > 255 | lei.component_size < 4 338 then call abort (error_table_$badopt, "-component_size " || arg); 339 end; 340 341 else if arg = "-display_severity" | arg = "-dsv" 342 then do; 343 344 /* make sure there is a next argument */ 345 346 if argx = nargs 347 then call abort (error_table_$noarg, "Display severity expected."); 348 349 /* fetch the severity */ 350 351 argx = argx + 1; 352 call cu_$arg_ptr (argx, argp, argl, ec); 353 354 /* try converting it and make sure it is a number */ 355 356 lei.display_severity = cv_dec_check_ (arg, ec); 357 if ec ^= 0 358 then call abort (error_table_$bad_conversion, arg); 359 360 /* make sure it is in the range 1 - 5 */ 361 362 if lei.display_severity > 5 | lei.display_severity < 1 363 then call abort (error_table_$badopt, "-display_severity " || arg); 364 end; 365 366 else if arg = "-abort_severity" | arg = "-asv" 367 then do; 368 369 /* make sure there is a next argument */ 370 371 if argx = nargs 372 then call abort (error_table_$noarg, "Abort severity expected."); 373 374 /* fetch the severity */ 375 376 argx = argx + 1; 377 call cu_$arg_ptr (argx, argp, argl, ec); 378 379 /* try converting it and make sure it is a number */ 380 381 lei.abort_severity = cv_dec_check_ (arg, ec); 382 if ec ^= 0 383 then call abort (error_table_$bad_conversion, arg); 384 385 /* make sure it is in the range 0 - 3 */ 386 387 if lei.abort_severity > 3 | lei.abort_severity < 0 388 then call abort (error_table_$badopt, "-abort_severity " || arg); 389 end; 390 391 /* now handle args with no parameters */ 392 393 else if arg = "-force" | arg = "-fc" 394 then lei.flags.force = true; 395 396 else if arg = "-no_force" | arg = "-nfc" 397 then lei.flags.force = false; 398 399 else if arg = "-list" | arg = "-ls" 400 then do; 401 lei.flags.list = true; 402 lei.flags.map = false; 403 end; 404 405 else if arg = "-map" 406 then do; 407 lei.flags.map = true; 408 lei.flags.list = false; 409 end; 410 411 else if arg = "-no_list" | arg = "-nls" 412 then do; 413 lei.flags.map = false; 414 lei.flags.list = false; 415 end; 416 417 else if arg = "-version" | arg = "-vers" 418 then version_flag = true; 419 420 else if arg = "-no_version" | arg = "-nvers" 421 then version_flag = false; 422 423 else if arg = "-debug" | arg = "-db" 424 then lei.flags.debug = true; 425 426 else if arg = "-no_debug" | arg = "-ndb" 427 then lei.flags.debug = false; 428 429 else if arg = "-auto_segnames" | arg = "-asn" 430 then lei.flags.auto_segnames = true; 431 432 else if arg = "-no_auto_segnames" | arg = "-nasn" 433 then lei.flags.auto_segnames = false; 434 435 else call abort (error_table_$badopt, arg); 436 437 argx = argx + 1; 438 439 end; 440 441 /* make sure everything is kosher, and fill in things like the */ 442 /* component that a given entrypoint is found in. */ 443 444 call validate_opts (leip); 445 446 /* print the version message if requested */ 447 448 if version_flag 449 then call ioa_ ("^a", le_data_$version_string); 450 451 /* call le_ to actually assemble the new binary */ 452 453 call le_ (leip, severity, ec); 454 455 linkage_editor_severity_ = severity; 456 457 if ec ^= 0 458 then do; 459 call ioa_ ("^/An error of severity ^d has occurred.", severity); 460 call abort (ec, ""); 461 end; 462 463 /* release the temp segment if required */ 464 465 ABORT: 466 if leip ^= null 467 then do; 468 469 /* terminate all of the files initiated */ 470 471 do i = 1 to lei.n_opts; 472 if lei.opt (i).type = PATH | lei.opt (i).type = LIBRARY 473 then call terminate_file_ (lei.opt (i).optp, lei.opt (i).bc, 474 TERM_FILE_TERM, ec); 475 end; 476 call release_temp_segment_ ("le", leip, ec); 477 leip = null; 478 end; 479 480 return; 481 482 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 483 484 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 485 486 487 expand_le_path: 488 proc (type, /** PATH or LIBRARY (in ) */ 489 path, /** path to expand (in ) */ 490 leip, /** le_info pointer (i/o) */ 491 ec); /** error code (out) */ 492 493 /*** ****************************************************************/ 494 /*** */ 495 /*** Name: expand_le_path */ 496 /*** Input: type, path, leip */ 497 /*** Function: given a le input or library path specification, */ 498 /*** expand it into a set of discrete paths and add */ 499 /*** them to the option list in the lei structure. */ 500 /*** Output: leip, ec */ 501 /*** */ 502 /*** ****************************************************************/ 503 504 /* parameters */ 505 506 dcl type fixed bin parameter; 507 dcl path char (*) parameter; 508 dcl leip ptr parameter; 509 dcl ec fixed bin (35) parameter; 510 511 /* automatic */ 512 513 dcl archive bit (1) automatic; 514 dcl bc fixed bin (24) automatic; 515 dcl cn char (32) automatic; 516 dcl dn char (168) automatic; 517 dcl en char (32) automatic; 518 dcl pathname char (194) automatic; 519 dcl segp ptr automatic; 520 521 /* expand the pathname into a dirname/entryname/starname or */ 522 /* dirname/starname combination. */ 523 524 call expand_pathname_$component (path, dn, en, cn, ec); 525 if ec ^= 0 526 then return; 527 528 /* if there is a component, we have either an archive path or an */ 529 /* archive component starname. */ 530 531 if cn ^= "" 532 then do; 533 534 /* check the component name for star status */ 535 536 call check_star_name_$entry (cn, ec); 537 if ec = 0 538 then do; 539 540 /* simple archive component pathname */ 541 542 call initiate_file_$component (dn, en, cn, R_ACCESS, segp, bc, ec); 543 if ec ^= 0 544 then return; 545 pathname = pathname_$component (dn, en, cn); 546 547 /* add the option to the le_input structure */ 548 549 call add_opt (type, cn, pathname, bc, segp, ""b, leip, ec); 550 return; 551 end; 552 else if ec = 1 | ec = 2 553 then do; 554 555 /* archive component starname of some variety */ 556 557 call expand_le_archive_star (type, dn, en, cn, leip, ec); 558 return; 559 end; 560 else return; 561 end; 562 563 /* we have a non-archive path, see if it is a starname */ 564 565 call check_star_name_$entry (en, ec); 566 if ec = 0 567 then do; 568 569 /* if not a starname, then try to initiate it */ 570 571 call initiate_file_ (dn, en, R_ACCESS, segp, bc, ec); 572 if ec = error_table_$dirseg 573 then do; 574 575 /* the target is a directory, if it is a MSF, return an */ 576 /* error code. */ 577 578 call hcs_$status_minf (dn, en, 0, 0, bc, ec); 579 if bc > 0 580 then do; 581 582 /* target is an MSF, return an error code */ 583 584 ec = error_table_$msf; 585 return; 586 end; 587 588 /* target is a directory so assume dir>** */ 589 590 dn = pathname_ (dn, en); 591 call expand_le_star (type, dn, "**", leip, ec); 592 return; 593 end; 594 else if ec = 0 595 then do; 596 597 /* target is a segment, see if it has a .archive suffix. */ 598 /* if it does, treat it as archive_segment_path::**, */ 599 /* otherwise, just add the segment itself. */ 600 601 pathname = pathname_ (dn, en); 602 archive = false; 603 if length (rtrim (en)) > length (ARCHIVE_SUFFIX) 604 then if substr (en, 605 length (rtrim (en)) - length (ARCHIVE_SUFFIX) + 1, 606 length (ARCHIVE_SUFFIX)) = ARCHIVE_SUFFIX 607 then archive = true; 608 609 if archive 610 then call expand_le_archive_star (type, dn, en, "**", leip, ec); 611 else call add_opt (type, en, pathname, bc, segp, ""b, leip, ec); 612 return; 613 end; 614 else return; 615 end; 616 else if ec = 1 | ec = 2 617 then do; 618 619 /* the entryname is a starname of some sort, expand the */ 620 /* starname into discrete segments and add them to the */ 621 /* option list in le_input. */ 622 623 call expand_le_star (type, dn, en, leip, ec); 624 return; 625 end; 626 else return; 627 628 end expand_le_path; 629 630 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 631 632 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 633 634 635 expand_le_archive_star: 636 proc (type, /** option type (in ) */ 637 dname, /** dir name (in ) */ 638 ename, /** entry name (in ) */ 639 sname, /** component starname (in ) */ 640 leip, /** le_input pointer (i/o) */ 641 ec); /** error_code (out) */ 642 643 /*** ****************************************************************/ 644 /*** */ 645 /*** Name: expand_le_archive_star */ 646 /*** Input: type, dname, ename, sname, leip */ 647 /*** Function: expands an archive component starname into a set */ 648 /*** of discrete option entries in the le_input */ 649 /*** structure. */ 650 /*** Output: leip, ec */ 651 /*** */ 652 /*** ****************************************************************/ 653 654 /* parameters */ 655 656 dcl type fixed bin parameter; 657 dcl dname char (*) parameter; 658 dcl ename char (*) parameter; 659 dcl sname char (*) parameter; 660 dcl leip ptr parameter; 661 dcl ec fixed bin (35) parameter; 662 663 /* automatic */ 664 665 dcl archive_bc fixed bin (24) automatic; 666 dcl archivep ptr automatic; 667 dcl c_bc fixed bin (24) automatic; 668 dcl complete_archive bit (1) automatic; 669 dcl cname char (32) automatic; 670 dcl cp ptr automatic; 671 dcl no_match bit (1) automatic; 672 dcl pathname char (194) automatic; 673 674 /* first initiate the archive itself */ 675 676 call initiate_file_ (dname, ename, R_ACCESS, archivep, archive_bc, ec); 677 if ec ^= 0 678 then return; 679 680 /* save some time by checking for a complete archive match now */ 681 682 call check_star_name_$entry (sname, ec); 683 if ec = 2 684 then do; 685 pathname = pathname_ (dname, ename); 686 complete_archive = true; 687 end; 688 else complete_archive = false; 689 690 /* preset the component info */ 691 692 cp = null; 693 c_bc = 0; 694 cname = ""; 695 no_match = true; 696 697 /* get the first component */ 698 699 call archive_$next_component (archivep, archive_bc, cp, c_bc, cname, ec); 700 if ec ^= 0 701 then return; 702 703 /* scan through the components adding the matching ones */ 704 705 do while (cp ^= null); 706 if ^complete_archive 707 then do; 708 709 /* the starname does not necessarily match everything so */ 710 /* compare the component name against the starname */ 711 712 call match_star_name_ (cname, sname, ec); 713 if ec = 0 714 then do; 715 716 /* the name matches, so generate the path and add the option */ 717 718 no_match = false; 719 pathname = pathname_$component (dname, ename, cname); 720 call add_opt (type, cname, pathname, c_bc, cp, ""b, leip, ec); 721 if ec ^= 0 722 then return; 723 end; 724 end; 725 else do; 726 727 /* all of the components are being added so just add the */ 728 /* option with the common pathname */ 729 730 no_match = false; 731 call add_opt (type, cname, pathname, c_bc, cp, ""b, leip, ec); 732 if ec ^= 0 733 then return; 734 end; 735 736 /* get the next archive component */ 737 738 call archive_$next_component (archivep, archive_bc, cp, c_bc, cname, ec); 739 if ec ^= 0 740 then return; 741 end; 742 743 /* generate an error code if no components were found matching the */ 744 /* starname given. */ 745 746 if no_match 747 then ec = error_table_$nomatch; 748 749 end expand_le_archive_star; 750 751 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 752 753 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 754 755 756 expand_le_star: 757 proc (type, /** option type (in ) */ 758 dname, /** directory name (in ) */ 759 sname, /** starname (in ) */ 760 leip, /** le_input pointer (i/o) */ 761 ec); /** error code (out) */ 762 763 /*** ****************************************************************/ 764 /*** */ 765 /*** Name: expand_le_star */ 766 /*** Input: type, dname, sname, leip */ 767 /*** Function: expands a starname and searches the directory for */ 768 /*** single segments matching the starname. */ 769 /*** Output: leip, ec */ 770 /*** */ 771 /*** ****************************************************************/ 772 773 /* parameters */ 774 775 dcl type fixed bin parameter; 776 dcl dname char (*) parameter; 777 dcl sname char (*) parameter; 778 dcl leip ptr parameter; 779 dcl ec fixed bin (35) parameter; 780 781 /* based */ 782 783 dcl sys_area area based (sys_areap); 784 785 /* automatic */ 786 787 dcl archive bit (1) automatic; 788 dcl bc fixed bin (24) automatic; 789 dcl compx fixed bin automatic; 790 dcl ename char (32) automatic; 791 dcl last fixed bin automatic; 792 dcl pathname char (168) automatic; 793 dcl segp ptr automatic; 794 dcl sys_areap ptr automatic; 795 796 sys_areap = get_system_free_area_ (); 797 798 star_list_branch_ptr = null; 799 star_list_names_ptr = null; 800 801 /* make sure the star structures get freed if we get unwound */ 802 803 on cleanup 804 begin; 805 if star_list_names_ptr ^= null 806 then free star_list_names in (sys_area); 807 if star_list_branch_ptr ^= null 808 then free star_dir_list_branch in (sys_area); 809 end; 810 811 /* perform the starname directory search */ 812 813 star_select_sw = star_ALL_ENTRIES; 814 call hcs_$star_dir_list_ (dname, sname, star_select_sw, sys_areap, 815 star_branch_count, star_link_count, star_list_branch_ptr, 816 star_list_names_ptr, ec); 817 if ec ^= 0 818 then return; 819 820 /* scan through each matching branch/link */ 821 822 do compx = 1 to star_branch_count + star_link_count; 823 824 /* if the branch is a directory, we ignore it. */ 825 826 if star_dir_list_branch (compx).type = star_DIRECTORY 827 then ; 828 else do; 829 830 ename = star_list_names (star_dir_list_branch (compx).nindex); 831 832 archive = false; 833 if length (rtrim (ename)) > length (ARCHIVE_SUFFIX) 834 then if substr (ename, 835 length (rtrim (ename)) - length (ARCHIVE_SUFFIX) + 1, 836 length (ARCHIVE_SUFFIX)) = ARCHIVE_SUFFIX 837 then archive = true; 838 839 if archive 840 then do; 841 842 /* the segment has a .archive suffix, so treat it as */ 843 /* archive_name::** */ 844 845 last = lei.n_opts; 846 call expand_le_archive_star (type, dname, ename, "**", leip, ec); 847 848 /* if the archive was found via a link, flag all the */ 849 /* components found there so we can eliminate them if it */ 850 /* is decided we shouldn't have chased links. */ 851 852 if star_dir_list_branch (compx).type = star_LINK 853 then 854 do i = last + 1 to lei.n_opts; 855 lei.opt (i).flags.link = true; 856 end; 857 end; 858 else do; 859 860 /* either a segment branch or a link, initiate it and add */ 861 /* it to the option list in le_input */ 862 863 call initiate_file_ (dname, ename, R_ACCESS, segp, bc, ec); 864 if ec ^= 0 865 then goto free_and_return; 866 pathname = pathname_ (dname, ename); 867 call add_opt (type, ename, pathname, bc, segp, ""b, leip, ec); 868 if ec ^= 0 869 then goto free_and_return; 870 if star_dir_list_branch (compx).type = star_LINK 871 then lei.opt (lei.n_opts).flags.link = true; 872 end; 873 end; 874 end; 875 876 /* free the star structures */ 877 878 free_and_return: 879 free star_list_names in (sys_area); 880 free star_dir_list_branch in (sys_area); 881 882 end expand_le_star; 883 884 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 885 886 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 887 888 889 add_ep: 890 proc (type, /** option type (in ) */ 891 ep_name, /** entrypoint name (in ) */ 892 inhibit, /** inhibit errors (in ) */ 893 leip, /** le_input pointer (i/o) */ 894 ec); /** error code (out) */ 895 896 /*** ****************************************************************/ 897 /*** */ 898 /*** Name: add_ep */ 899 /*** Input: type, ep_name, inhibit, leip */ 900 /*** Function: adds an entrypoint name to be retained or deleted */ 901 /*** to the option list after converting ambiguous */ 902 /*** specifications into a standard format. */ 903 /*** Output: leip, ec */ 904 /*** */ 905 /*** ****************************************************************/ 906 907 /* parameters */ 908 909 dcl type fixed bin parameter; 910 dcl ep_name char (*) parameter; 911 dcl inhibit bit (1) parameter; 912 dcl leip ptr parameter; 913 dcl ec fixed bin (35) parameter; 914 915 /* automatic */ 916 917 dcl entrypoint char (168) automatic; 918 dcl segname char (256) varying; 919 dcl offsetname char (256) varying; 920 921 /* convert the name given to segname$offsetname format if necessary */ 922 923 if ep_name = "" 924 then entrypoint = "**$**"; 925 else if index (ep_name, "$") = 0 926 then entrypoint = "**$" || ep_name; 927 else do; 928 929 /* extract the segname and offsetname portions */ 930 931 segname = before (ep_name, "$"); 932 offsetname = after (ep_name, "$"); 933 934 /* check out the segname as a starname, and convert to standard format */ 935 936 call check_star_name_$entry ((segname), ec); 937 if ec = 2 938 then segname = "**"; 939 940 /* check out the offsetname as a starname, and convert null offsetnames */ 941 /* and global starnames into a ** format */ 942 943 if offsetname = "" 944 then offsetname = "**"; 945 else do; 946 call check_star_name_$entry ((offsetname), ec); 947 if ec = 2 948 then offsetname = "**"; 949 end; 950 951 entrypoint = segname || "$" || offsetname; 952 end; 953 954 /* add it to the option list */ 955 956 if inhibit 957 then call add_opt (type, "", entrypoint, 0, null, "0001"b, leip, ec); 958 else call add_opt (type, "", entrypoint, 0, null, ""b, leip, ec); 959 960 if entrypoint = "**$**" 961 then has_global = true; 962 963 end add_ep; 964 965 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 966 967 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 968 969 970 add_opt: 971 proc (type, /** option type (in ) */ 972 name, /** name string (in ) */ 973 path, /** path or ep string (in ) */ 974 bc, /** bit count (in ) */ 975 optp, /** option pointer (in ) */ 976 flags, /** flags (in ) */ 977 leip, /** li_info pointer (i/o) */ 978 ec); /** error code (out) */ 979 980 /*** ****************************************************************/ 981 /*** */ 982 /*** Name: add_opt */ 983 /*** Input: type, name, path, bc, optp, flags, leip */ 984 /*** Function: adds an option to the le_input option table. The */ 985 /*** only error returned by this routine is if the */ 986 /*** table cannot hold the new entry. */ 987 /*** Output: ec */ 988 /*** */ 989 /*** ****************************************************************/ 990 991 /* parameters */ 992 993 dcl type fixed bin parameter; 994 dcl name char (*) parameter; 995 dcl path char (*) parameter; 996 dcl bc fixed bin (24) parameter; 997 dcl optp ptr parameter; 998 dcl flags bit (*) parameter; 999 dcl leip ptr parameter; 1000 dcl ec fixed bin (35) parameter; 1001 1002 /* based */ 1003 1004 dcl 01 lei aligned based (leip), 1005 02 header aligned like le_input.header, 1006 02 opt dim (0 refer (lei.n_opts)) like le_option; 1007 1008 /* see if adding another entry will overflow the temp seg */ 1009 1010 if currentsize (lei) + size (le_option) > sys_info$max_seg_size 1011 then do; 1012 ec = le_et_$too_many_options; 1013 return; 1014 end; 1015 else ec = 0; 1016 1017 /* add the new option to the le_input structure */ 1018 1019 lei.n_opts = lei.n_opts + 1; 1020 lei.opt (lei.n_opts).type = type; 1021 lei.opt (lei.n_opts).name = name; 1022 lei.opt (lei.n_opts).path_or_ep = path; 1023 unspec (lei.opt (lei.n_opts).flags) = flags; 1024 lei.opt (lei.n_opts).bc = bc; 1025 lei.opt (lei.n_opts).optp = optp; 1026 1027 end add_opt; 1028 1029 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1030 1031 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1032 1033 1034 validate_opts: 1035 proc (leip); /** le_input pointer (in ) */ 1036 1037 /*** ****************************************************************/ 1038 /*** */ 1039 /*** Name: validate_opts */ 1040 /*** Input: leip */ 1041 /*** Function: make sure that the options in the le_input option */ 1042 /*** array are all valid. In particular, that we have */ 1043 /*** some input paths, and that there is an explicit */ 1044 /*** statement regarding the entrypoint **$main_ */ 1045 /*** Output: leip */ 1046 /*** */ 1047 /*** ****************************************************************/ 1048 1049 /* parameters */ 1050 1051 dcl leip ptr parameter; 1052 1053 /* based */ 1054 1055 dcl 01 lei aligned based (leip), 1056 02 header like le_input.header, 1057 02 opt dim (0 refer (lei.n_opts)) like le_option; 1058 1059 /* automatic */ 1060 1061 dcl ec fixed bin (35) automatic; 1062 dcl o fixed bin automatic; 1063 dcl path_count fixed bin automatic; 1064 dcl found bit (1) automatic; 1065 1066 path_count = 0; 1067 1068 /* pass 1: make sure we have at least 1 PATH option */ 1069 1070 do o = 1 to lei.n_opts; 1071 if lei.opt (o).type = PATH 1072 then path_count = path_count + 1; 1073 end; 1074 1075 if path_count = 0 1076 then call abort (error_table_$noarg, 1077 "At least 1 input path must be specified."); 1078 1079 /* pass 2: add in a -retain main_ option if no other specification */ 1080 /* is given for main_ */ 1081 1082 found = false; 1083 1084 do o = 1 to lei.n_opts while (^found); 1085 1086 /* see if this is a "-retain **$main_" or "-delete **$main_" argument */ 1087 1088 if lei.opt (o).type = RETAIN | lei.opt (o).type = DELETE 1089 then found = (lei.opt (o).path_or_ep = "**$main_"); 1090 end; 1091 1092 if ^found 1093 then call add_ep (RETAIN, "**$main_", true, leip, ec); 1094 1095 /* assume global deletion if just retains specified, and global */ 1096 /* retention otherwise. */ 1097 1098 if ^has_global 1099 then if has_retain & ^has_delete 1100 then call add_ep (DELETE, "", false, leip, ec); 1101 else call add_ep (RETAIN, "", false, leip, ec); 1102 1103 end validate_opts; 1104 1105 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1106 1107 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1108 1109 1110 abort: 1111 proc (ec, /** error code (in ) */ 1112 msg); /** error message (in ) */ 1113 1114 /*** ****************************************************************/ 1115 /*** */ 1116 /*** Name: abort */ 1117 /*** Input: ec, msg */ 1118 /*** Function: aborts execution of le and returns after printing */ 1119 /*** a message on error_output. */ 1120 /*** Output: none */ 1121 /*** */ 1122 /*** ****************************************************************/ 1123 1124 /* parameters */ 1125 1126 dcl ec fixed bin (35) parameter; 1127 dcl msg char (*) parameter; 1128 1129 call com_err_ (ec, "linkage_editor", msg); 1130 goto ABORT; 1131 1132 end abort; 1133 1134 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1135 1136 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 1137 1138 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 */ 1139 2 1 /**** START OF: le_input.incl.pl1 * * * * * */ 2 2 2 3 /****^ HISTORY COMMENTS: 2 4* 1) change(86-08-12,Elhard), approve(86-08-12,MCR7505), 2 5* audit(86-12-10,DGHowe), install(86-12-10,MR12.0-1241): 2 6* Orignally written to define the le_ input structures. 2 7* END HISTORY COMMENTS */ 2 8 2 9 /*** ****************************************************************/ 2 10 /*** */ 2 11 /*** Name: le_input */ 2 12 /*** Function: This include file declares the input structure to */ 2 13 /*** to the le_ subroutine. The structure consists of */ 2 14 /*** a set of standard data, and a variable length */ 2 15 /*** array of options. The options have a type field */ 2 16 /*** which specified what the option means. The */ 2 17 /*** options can have the following types: */ 2 18 /*** */ 2 19 /*** PATH - specified a single input component */ 2 20 /*** to be bound in with the object */ 2 21 /*** name - is the name of the component */ 2 22 /*** path_or_ep - is the pathname to the component */ 2 23 /*** this may be an archive component */ 2 24 /*** pathname. */ 2 25 /*** flags - link is used by the le command to */ 2 26 /*** keep track of the pathnames that */ 2 27 /*** were found via links for chase */ 2 28 /*** processing. */ 2 29 /*** bc - is the bit count of the component */ 2 30 /*** optp - is a pointer to the component */ 2 31 /*** */ 2 32 /*** LIBRARY - specifies a single library */ 2 33 /*** component. Library components are */ 2 34 /*** only included if they are referred */ 2 35 /*** to by a PATH component or a library */ 2 36 /*** component that is referenced and */ 2 37 /*** therefor included. */ 2 38 /*** name - same as for PATH. */ 2 39 /*** path_or_ep - same as for PATH. */ 2 40 /*** flags - same as for PATH. */ 2 41 /*** bc - same as for PATH. */ 2 42 /*** optp - same as for PATH. */ 2 43 /*** */ 2 44 /*** ADDNAME - specifies a name to be added to the */ 2 45 /*** bound object. */ 2 46 /*** name - is the name to be added to the */ 2 47 /*** bound unit */ 2 48 /*** */ 2 49 /*** SYNONYM - specifies a synonym to be added to */ 2 50 /*** a particular component. This is */ 2 51 /*** reflected as a segname definition */ 2 52 /*** added to the block for that */ 2 53 /*** component. */ 2 54 /*** name - specifies the name of the component */ 2 55 /*** to which you are adding a name. */ 2 56 /*** path_or_ep - is the name being added */ 2 57 /*** */ 2 58 /*** RETAIN - gives a starname to be used when */ 2 59 /*** determining if a definition should */ 2 60 /*** be retained. If the definition */ 2 61 /*** matches the starname and no more */ 2 62 /*** specific info is given, the name is */ 2 63 /*** retained. */ 2 64 /*** flags - the "inhibit_error" flag indicates */ 2 65 /*** that it is not an error if this */ 2 66 /*** option is unused. */ 2 67 /*** path_or_ep - is the starname to match */ 2 68 /*** */ 2 69 /*** DELETE - gives a starname to be used when */ 2 70 /*** determining if a definition should */ 2 71 /*** be retained. If the definition */ 2 72 /*** matches the starname and no more */ 2 73 /*** specific info is given, the name is */ 2 74 /*** deleted. */ 2 75 /*** flags - the "inhibit_error" flag indicates */ 2 76 /*** that it is not an error if this */ 2 77 /*** option is unused. */ 2 78 /*** path_or_ep - is the starname to match. */ 2 79 /*** */ 2 80 /*** NO_LINK - gives a starname to be used when */ 2 81 /*** determining if a definition should */ 2 82 /*** be retained. If the definition */ 2 83 /*** matches the starname and no more */ 2 84 /*** specific info is given, the name is */ 2 85 /*** retained and references to the */ 2 86 /*** definition within the bound uni */ 2 87 /*** are not resolved but are generated */ 2 88 /*** as external links. */ 2 89 /*** flags - the "inhibit_error" flag indicates */ 2 90 /*** that it is not an error if this */ 2 91 /*** option is unused. */ 2 92 /*** path_or_ep - is the starname to match */ 2 93 /*** */ 2 94 /*** TABLE - specifies that the table for a */ 2 95 /*** particular component is to be */ 2 96 /*** retained. */ 2 97 /*** name - is the name of the component to */ 2 98 /*** which the option applies. If name */ 2 99 /*** is "", this is a global option and */ 2 100 /*** applies to all component for which */ 2 101 /*** a specific option does not exist. */ 2 102 /*** */ 2 103 /*** NO_TABLE - specifies that the table for a */ 2 104 /*** particular component is to be */ 2 105 /*** deleted. */ 2 106 /*** name - is the name of the component to */ 2 107 /*** which the option applies. If name */ 2 108 /*** is "", this is a global option and */ 2 109 /*** applies to all component for which */ 2 110 /*** a specific option does not exist. */ 2 111 /*** */ 2 112 /*** ****************************************************************/ 2 113 2 114 dcl 01 le_input aligned based, 2 115 02 header aligned, 2 116 03 version char (8), 2 117 03 name char (32), 2 118 03 flags aligned, 2 119 04 perprocess_static bit (1) unaligned, 2 120 04 force bit (1) unaligned, 2 121 04 debug bit (1) unaligned, 2 122 04 list bit (1) unaligned, 2 123 04 map bit (1) unaligned, 2 124 04 auto_segnames bit (1) unaligned, 2 125 04 mbz bit (30) unaligned, 2 126 03 output_file unaligned, 2 127 04 dir char (168), 2 128 04 entry char (32), 2 129 03 component_size fixed bin, 2 130 03 display_severity fixed bin, 2 131 03 abort_severity fixed bin, 2 132 03 bindfile aligned, 2 133 04 name char (32), 2 134 04 dt_updated fixed bin (71), 2 135 04 dt_modified fixed bin (71), 2 136 03 pad bit (36), 2 137 03 n_opts fixed bin, 2 138 02 opt dim (0 refer (le_input.n_opts)) like le_option; 2 139 2 140 dcl 01 le_option aligned based, 2 141 02 name char (32) unaligned, 2 142 02 path_or_ep char (194) unaligned, 2 143 02 flags unaligned, 2 144 03 link bit (1), 2 145 03 ignore bit (1), 2 146 03 used bit (1), 2 147 03 inhibit_error bit (1), 2 148 03 mbz bit (5), 2 149 02 type fixed bin (8) unaligned, 2 150 02 bc fixed bin (24), 2 151 02 optp ptr; 2 152 2 153 dcl le_input_version_1 char (8) static options (constant) 2 154 init ("le_ 1.0 "); 2 155 2 156 /* constants for the defined option types */ 2 157 2 158 dcl PATH fixed bin static options (constant) init (1); 2 159 dcl LIBRARY fixed bin static options (constant) init (2); 2 160 dcl ADDNAME fixed bin static options (constant) init (3); 2 161 dcl SYNONYM fixed bin static options (constant) init (4); 2 162 dcl RETAIN fixed bin static options (constant) init (5); 2 163 dcl DELETE fixed bin static options (constant) init (6); 2 164 dcl NO_LINK fixed bin static options (constant) init (7); 2 165 dcl TABLE fixed bin static options (constant) init (8); 2 166 dcl NO_TABLE fixed bin static options (constant) init (9); 2 167 2 168 /**** END OF: le_input.incl.pl1 * * * * * */ 1140 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 */ 1141 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 */ 1142 1143 1144 end le; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/05/00 1832.0 le.pl1 >udd>sm>ds>w>ml>le.pl1 1139 1 04/11/85 1552.6 access_mode_values.incl.pl1 >ldd>incl>access_mode_values.incl.pl1 1140 2 12/10/86 1416.8 le_input.incl.pl1 >ldd>incl>le_input.incl.pl1 1141 3 06/10/82 1145.5 star_structures.incl.pl1 >ldd>incl>star_structures.incl.pl1 1142 4 04/06/83 1339.4 terminate_file.incl.pl1 >ldd>incl>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. ARCHIVE_SUFFIX 000004 constant char(8) initial packed unaligned dcl 39 ref 603 603 603 603 833 833 833 833 DELETE 000016 constant fixed bin(17,0) initial dcl 2-163 set ref 269* 284* 290* 1088 1098* LIBRARY 000023 constant fixed bin(17,0) initial dcl 2-159 set ref 225* 472 PATH 000061 constant fixed bin(17,0) initial dcl 2-158 set ref 202* 472 1071 RETAIN 000041 constant fixed bin(17,0) initial dcl 2-162 set ref 237* 252* 258* 1088 1092* 1101* R_ACCESS 000006 constant bit(3) initial packed unaligned dcl 1-11 set ref 542* 571* 676* 863* TERM_FILE_TERM 000000 constant bit(3) initial packed unaligned dcl 4-14 set ref 472* abort_severity 77 based fixed bin(17,0) level 3 dcl 98 set ref 171* 381* 387 387 after builtin function dcl 123 ref 932 archive 000100 automatic bit(1) packed unaligned dcl 787 in procedure "expand_le_star" set ref 832* 833* 839 archive 000146 automatic bit(1) packed unaligned dcl 513 in procedure "expand_le_path" set ref 602* 603* 609 archive_$next_component 000010 constant entry external dcl 44 ref 699 738 archive_bc 000100 automatic fixed bin(24,0) dcl 665 set ref 676* 699* 738* archivep 000102 automatic pointer dcl 666 set ref 676* 699* 738* arg based char packed unaligned dcl 97 set ref 197 202* 203* 209 209 225* 226* 230 230 250 258* 262 262 282 290* 294 294 310* 312* 316 316 331* 332* 337 341 341 356* 357* 362 366 366 381* 382* 387 393 393 396 396 399 399 405 411 411 417 417 420 420 423 423 426 426 429 429 432 432 435* argl 000100 automatic fixed bin(21,0) dcl 104 set ref 193* 197 202 202 203 203 209 209 221* 225 225 226 226 230 230 244* 250 258 258 262 262 276* 282 290 290 294 294 306* 310 310 312 312 316 316 327* 331 331 332 332 337 341 341 352* 356 356 357 357 362 366 366 377* 381 381 382 382 387 393 393 396 396 399 399 405 411 411 417 417 420 420 423 423 426 426 429 429 432 432 435 435 argp 000102 automatic pointer dcl 105 set ref 193* 197 202 203 209 209 221* 225 226 230 230 244* 250 258 262 262 276* 282 290 294 294 306* 310 312 316 316 327* 331 332 337 341 341 352* 356 357 362 366 366 377* 381 382 387 393 393 396 396 399 399 405 411 411 417 417 420 420 423 423 426 426 429 429 432 432 435 argx 000104 automatic fixed bin(17,0) dcl 106 set ref 188* 189 193* 214 220* 220 221* 237 243* 243 244* 253* 253 269 275* 275 276* 285* 285 299 305* 305 306* 321 326* 326 327* 346 351* 351 352* 371 376* 376 377* 437* 437 auto_segnames 12(05) based bit(1) level 4 packed packed unaligned dcl 98 set ref 179* 429* 432* bc 207 based fixed bin(24,0) array level 3 in structure "lei" dcl 98 in procedure "le" set ref 472* bc 000147 automatic fixed bin(24,0) dcl 514 in procedure "expand_le_path" set ref 542* 549* 571* 578* 579 611* bc 000101 automatic fixed bin(24,0) dcl 788 in procedure "expand_le_star" set ref 863* 867* bc parameter fixed bin(24,0) dcl 996 in procedure "add_opt" ref 970 1024 bc 207 based fixed bin(24,0) array level 3 in structure "lei" dcl 1004 in procedure "add_opt" set ref 1024* before builtin function dcl 124 ref 931 binary builtin function dcl 125 ref 805 878 bindfile 100 based structure level 3 dcl 98 c_bc 000104 automatic fixed bin(24,0) dcl 667 set ref 693* 699* 720* 731* 738* check_star_name_$entry 000012 constant entry external dcl 46 ref 536 565 682 936 946 cleanup 000120 stack reference condition dcl 119 ref 146 803 cn 000150 automatic char(32) packed unaligned dcl 515 set ref 524* 531 536* 542* 545* 549* 557* cname 000106 automatic char(32) packed unaligned dcl 669 set ref 694* 699* 712* 719* 720* 731* 738* com_err_ 000014 constant entry external dcl 47 ref 1129 complete_archive 000105 automatic bit(1) packed unaligned dcl 668 set ref 686* 688* 706 component_size 75 based fixed bin(17,0) level 3 dcl 98 set ref 173* 331* 337 337 compx 000102 automatic fixed bin(17,0) dcl 789 set ref 822* 826 830 852 870* cp 000116 automatic pointer dcl 670 set ref 692* 699* 705 720* 731* 738* cu_$arg_count 000016 constant entry external dcl 48 ref 154 cu_$arg_ptr 000020 constant entry external dcl 49 ref 193 221 244 276 306 327 352 377 currentsize builtin function dcl 126 ref 1010 cv_dec_check_ 000022 constant entry external dcl 51 ref 331 356 381 debug 12(02) based bit(1) level 4 packed packed unaligned dcl 98 set ref 423* 426* dir 13 based char(168) level 4 packed packed unaligned dcl 98 set ref 169* 310* display_severity 76 based fixed bin(17,0) level 3 dcl 98 set ref 172* 356* 362 362 divide builtin function dcl 127 ref 805 878 dn 000160 automatic char(168) packed unaligned dcl 516 set ref 524* 542* 545* 557* 571* 578* 590* 590* 591* 601* 609* 623* dname parameter char packed unaligned dcl 657 in procedure "expand_le_archive_star" set ref 635 676* 685* 719* dname parameter char packed unaligned dcl 776 in procedure "expand_le_star" set ref 756 814* 846* 863* 866* dt_modified 112 based fixed bin(71,0) level 4 dcl 98 set ref 176* dt_updated 110 based fixed bin(71,0) level 4 dcl 98 set ref 175* ec parameter fixed bin(35,0) dcl 779 in procedure "expand_le_star" set ref 756 814* 817 846* 863* 864 867* 868 ec 000105 automatic fixed bin(35,0) dcl 107 in procedure "le" set ref 148* 154* 155 155* 163* 193* 202* 203 203* 221* 225* 226 226* 237* 244* 252* 258* 269* 276* 284* 290* 306* 310* 312 312* 327* 331* 332 352* 356* 357 377* 381* 382 453* 457 460* 472* 476* ec parameter fixed bin(35,0) dcl 1000 in procedure "add_opt" set ref 970 1012* 1015* ec 000616 automatic fixed bin(35,0) dcl 1061 in procedure "validate_opts" set ref 1092* 1098* 1101* ec parameter fixed bin(35,0) dcl 509 in procedure "expand_le_path" set ref 487 524* 525 536* 537 542* 543 549* 552 552 557* 565* 566 571* 572 578* 584* 591* 594 609* 611* 616 616 623* ec parameter fixed bin(35,0) dcl 1126 in procedure "abort" set ref 1110 1129* ec parameter fixed bin(35,0) dcl 913 in procedure "add_ep" set ref 889 936* 937 946* 947 956* 958* ec parameter fixed bin(35,0) dcl 661 in procedure "expand_le_archive_star" set ref 635 676* 677 682* 683 699* 700 712* 713 720* 721 731* 732 738* 739 746* en 000232 automatic char(32) packed unaligned dcl 517 set ref 524* 542* 545* 557* 565* 571* 578* 590* 601* 603 603 603 609* 611* 623* ename 000103 automatic char(32) packed unaligned dcl 790 in procedure "expand_le_star" set ref 830* 833 833 833 846* 863* 866* 867* ename parameter char packed unaligned dcl 658 in procedure "expand_le_archive_star" set ref 635 676* 685* 719* entry 65 based char(32) level 4 packed packed unaligned dcl 98 set ref 170* 310* entrypoint 000334 automatic char(168) packed unaligned dcl 917 set ref 923* 925* 951* 956* 958* 960 ep_name parameter char packed unaligned dcl 910 ref 889 923 925 925 931 932 error_table_$bad_conversion 000064 external static fixed bin(35,0) dcl 82 set ref 332* 357* 382* error_table_$badopt 000066 external static fixed bin(35,0) dcl 84 set ref 337* 362* 387* 435* error_table_$dirseg 000070 external static fixed bin(35,0) dcl 85 ref 572 error_table_$msf 000072 external static fixed bin(35,0) dcl 86 ref 584 error_table_$noarg 000074 external static fixed bin(35,0) dcl 87 set ref 214* 299* 321* 346* 371* 1075* error_table_$nomatch 000076 external static fixed bin(35,0) dcl 88 ref 746 expand_pathname_ 000024 constant entry external dcl 53 ref 310 expand_pathname_$component 000026 constant entry external dcl 55 ref 524 false 000122 constant bit(1) initial packed unaligned dcl 37 set ref 182 183 184 237* 252* 258* 269* 284* 290* 396 402 408 413 414 420 426 432 602 688 718 730 832 1082 1098* 1101* flags 12 based structure level 3 in structure "lei" dcl 98 in procedure "le" set ref 178* flags parameter bit packed unaligned dcl 998 in procedure "add_opt" ref 970 1023 flags 206(18) based structure array level 3 in structure "lei" packed packed unaligned dcl 98 in procedure "le" flags 206(18) based structure array level 3 in structure "lei" packed packed unaligned dcl 1004 in procedure "add_opt" set ref 1023* force 12(01) based bit(1) level 4 packed packed unaligned dcl 98 set ref 393* 396* found 000621 automatic bit(1) packed unaligned dcl 1064 set ref 1082* 1084 1088* 1092 get_system_free_area_ 000030 constant entry external dcl 58 ref 796 get_temp_segment_ 000032 constant entry external dcl 59 ref 163 get_wdir_ 000034 constant entry external dcl 60 ref 169 has_delete 000106 automatic bit(1) packed unaligned dcl 108 set ref 184* 265* 1098 has_global 000107 automatic bit(1) packed unaligned dcl 109 set ref 182* 960* 1098 has_retain 000110 automatic bit(1) packed unaligned dcl 110 set ref 183* 233* 1098 hcs_$star_dir_list_ 000036 constant entry external dcl 61 ref 814 hcs_$status_minf 000040 constant entry external dcl 63 ref 578 header based structure level 2 in structure "lei" dcl 98 in procedure "le" header based structure level 2 in structure "lei" dcl 1004 in procedure "add_opt" header based structure level 2 in structure "lei" dcl 1055 in procedure "validate_opts" header based structure level 2 in structure "le_input" dcl 2-114 in procedure "le" i 000111 automatic fixed bin(17,0) dcl 111 set ref 471* 472 472 472 472* 852* 855* index builtin function dcl 128 ref 197 250 282 925 inhibit parameter bit(1) packed unaligned dcl 911 ref 889 956 initiate_file_ 000042 constant entry external dcl 65 ref 571 676 863 initiate_file_$component 000044 constant entry external dcl 67 ref 542 ioa_ 000046 constant entry external dcl 70 ref 448 459 last 000113 automatic fixed bin(17,0) dcl 791 set ref 845* 852 le_ 000050 constant entry external dcl 71 ref 453 le_data_$version_string 000100 external static varying char(64) dcl 89 set ref 448* le_et_$too_many_options 000102 external static fixed bin(35,0) dcl 90 ref 1012 le_input based structure level 1 dcl 2-114 le_input_version_1 000002 constant char(8) initial packed unaligned dcl 2-153 ref 167 le_option based structure level 1 dcl 2-140 ref 1010 lei based structure level 1 dcl 98 in procedure "le" lei based structure level 1 dcl 1055 in procedure "validate_opts" lei based structure level 1 dcl 1004 in procedure "add_opt" set ref 1010 leip parameter pointer dcl 999 in procedure "add_opt" ref 970 1010 1019 1019 1020 1020 1021 1021 1022 1022 1023 1023 1024 1024 1025 1025 leip parameter pointer dcl 912 in procedure "add_ep" set ref 889 956* 958* leip parameter pointer dcl 508 in procedure "expand_le_path" set ref 487 549* 557* 591* 609* 611* 623* leip parameter pointer dcl 778 in procedure "expand_le_star" set ref 756 846* 867* leip parameter pointer dcl 660 in procedure "expand_le_archive_star" set ref 635 720* 731* leip parameter pointer dcl 1051 in procedure "validate_opts" set ref 1034 1070 1071 1084 1088 1088 1088 1092* 1098* 1101* leip 000112 automatic pointer dcl 112 in procedure "le" set ref 144* 148 148* 163* 167 168 169 170 171 172 173 174 175 176 178 179 202* 225* 237* 252* 258* 269* 284* 290* 310 310 331 337 337 356 362 362 381 387 387 393 396 401 402 407 408 413 414 423 426 429 432 444* 453* 465 471 472 472 472 472 476* 477* 845 852 855 870 870 length builtin function dcl 129 ref 603 603 603 603 603 833 833 833 833 833 link 206(18) based bit(1) array level 4 packed packed unaligned dcl 98 set ref 855* 870* linkage_editor_severity_ 000106 external static fixed bin(35,0) dcl 92 set ref 455* list 12(03) based bit(1) level 4 packed packed unaligned dcl 98 set ref 401* 408* 414* map 12(04) based bit(1) level 4 packed packed unaligned dcl 98 set ref 402* 407* 413* match_star_name_ 000052 constant entry external dcl 72 ref 712 msg parameter char packed unaligned dcl 1127 set ref 1110 1129* n_opts 115 based fixed bin(17,0) level 3 in structure "lei" dcl 1004 in procedure "add_opt" set ref 1010 1019* 1019 1020 1021 1022 1023 1024 1025 n_opts 115 based fixed bin(17,0) level 3 in structure "lei" dcl 1055 in procedure "validate_opts" ref 1070 1084 n_opts 115 based fixed bin(17,0) level 3 in structure "lei" dcl 98 in procedure "le" ref 471 845 852 870 name 2 based char(32) level 3 in structure "lei" dcl 98 in procedure "le" set ref 168* name 100 based char(32) level 4 in structure "lei" dcl 98 in procedure "le" set ref 174* name parameter char packed unaligned dcl 994 in procedure "add_opt" ref 970 1021 name 116 based char(32) array level 3 in structure "lei" packed packed unaligned dcl 1004 in procedure "add_opt" set ref 1021* nargs 000114 automatic fixed bin(17,0) dcl 113 set ref 154* 160 189 214 237 269 299 321 346 371 nindex 0(18) based fixed bin(18,0) array level 2 in structure "star_dir_list_branch" packed packed unsigned unaligned dcl 3-59 in procedure "le" ref 830 nindex 0(18) based fixed bin(18,0) array level 2 in structure "star_links" packed packed unsigned unaligned dcl 3-76 in procedure "le" ref 805 878 nnames 0(02) based fixed bin(16,0) array level 2 packed packed unsigned unaligned dcl 3-76 ref 805 878 no_match 000120 automatic bit(1) packed unaligned dcl 671 set ref 695* 718* 730* 746 null builtin function dcl 130 ref 144 148 465 477 692 705 798 799 805 807 956 956 958 958 o 000617 automatic fixed bin(17,0) dcl 1062 set ref 1070* 1071* 1084* 1088 1088 1088* offsetname 000507 automatic varying char(256) dcl 919 set ref 932* 943 943* 946 947* 951 opt 116 based structure array level 2 in structure "lei" dcl 98 in procedure "le" opt 116 based structure array level 2 in structure "lei" dcl 1004 in procedure "add_opt" opt 116 based structure array level 2 in structure "lei" dcl 1055 in procedure "validate_opts" optp parameter pointer dcl 997 in procedure "add_opt" ref 970 1025 optp 210 based pointer array level 3 in structure "lei" dcl 1004 in procedure "add_opt" set ref 1025* optp 210 based pointer array level 3 in structure "lei" dcl 98 in procedure "le" set ref 472* output_file 13 based structure level 3 packed packed unaligned dcl 98 path parameter char packed unaligned dcl 995 in procedure "add_opt" ref 970 1022 path parameter char packed unaligned dcl 507 in procedure "expand_le_path" set ref 487 524* path_count 000620 automatic fixed bin(17,0) dcl 1063 set ref 1066* 1071* 1071 1075 path_or_ep 126 based char(194) array level 3 in structure "lei" packed packed unaligned dcl 1004 in procedure "add_opt" set ref 1022* path_or_ep 126 based char(194) array level 3 in structure "lei" packed packed unaligned dcl 1055 in procedure "validate_opts" ref 1088 pathname 000121 automatic char(194) packed unaligned dcl 672 in procedure "expand_le_archive_star" set ref 685* 719* 720* 731* pathname 000114 automatic char(168) packed unaligned dcl 792 in procedure "expand_le_star" set ref 866* 867* pathname 000242 automatic char(194) packed unaligned dcl 518 in procedure "expand_le_path" set ref 545* 549* 601* 611* pathname_ 000054 constant entry external dcl 73 ref 590 601 685 866 pathname_$component 000056 constant entry external dcl 74 ref 545 719 pathname_len 3 based fixed bin(18,0) array level 2 packed packed unsigned unaligned dcl 3-76 ref 805 878 release_temp_segment_ 000060 constant entry external dcl 76 ref 148 476 rtrim builtin function dcl 131 ref 603 603 833 833 segname 000406 automatic varying char(256) dcl 918 set ref 931* 936 937* 951 segp 000324 automatic pointer dcl 519 in procedure "expand_le_path" set ref 542* 549* 571* 611* segp 000166 automatic pointer dcl 793 in procedure "expand_le_star" set ref 863* 867* severity 000115 automatic fixed bin(17,0) dcl 114 set ref 453* 455 459* size builtin function dcl 132 ref 1010 sname parameter char packed unaligned dcl 659 in procedure "expand_le_archive_star" set ref 635 682* 712* sname parameter char packed unaligned dcl 777 in procedure "expand_le_star" set ref 756 814* star_ALL_ENTRIES constant fixed bin(2,0) initial dcl 3-111 ref 813 star_DIRECTORY constant fixed bin(2,0) initial unsigned dcl 3-121 ref 826 star_LINK constant fixed bin(2,0) initial unsigned dcl 3-119 ref 805 852 870 878 star_LINKS_ONLY_WITH_LINK_PATHS constant fixed bin(3,0) initial dcl 3-112 ref 805 878 star_branch_count 000126 automatic fixed bin(17,0) dcl 3-13 set ref 805 805 805 805 807 814* 822 878 878 878 878 880 star_dir_list_branch based structure array level 1 dcl 3-59 ref 807 880 star_link_count 000132 automatic fixed bin(17,0) dcl 3-17 set ref 805 805 805 805 807 814* 822 878 878 878 878 880 star_links based structure array level 1 dcl 3-76 star_list_branch_ptr 000130 automatic pointer dcl 3-16 set ref 798* 805 805 805 805 807 807 814* 826 830 852 870 878 878 878 878 880 star_list_names based char(32) array packed unaligned dcl 3-92 ref 805 830 878 star_list_names_ptr 000134 automatic pointer dcl 3-20 set ref 799* 805 805 814* 830 878 star_select_sw 000136 automatic fixed bin(3,0) dcl 3-21 set ref 805 813* 814* 878 string builtin function dcl 133 set ref 178* substr builtin function dcl 134 ref 603 833 sys_area based area(1024) dcl 783 ref 805 807 878 880 sys_areap 000170 automatic pointer dcl 794 set ref 796* 805 807 814* 878 880 sys_info$max_seg_size 000104 external static fixed bin(35,0) dcl 91 ref 1010 terminate_file_ 000062 constant entry external dcl 77 ref 472 true 000006 constant bit(1) initial packed unaligned dcl 36 set ref 179 181 233 265 393 401 407 417 423 429 603 686 695 833 855 870 960 1092* type parameter fixed bin(17,0) dcl 506 in procedure "expand_le_path" set ref 487 549* 557* 591* 609* 611* 623* type parameter fixed bin(17,0) dcl 775 in procedure "expand_le_star" set ref 756 846* 867* type based fixed bin(2,0) array level 2 in structure "star_dir_list_branch" packed packed unsigned unaligned dcl 3-59 in procedure "le" ref 826 852 870 type parameter fixed bin(17,0) dcl 993 in procedure "add_opt" ref 970 1020 type 206(27) based fixed bin(8,0) array level 3 in structure "lei" packed packed unaligned dcl 98 in procedure "le" ref 472 472 type parameter fixed bin(17,0) dcl 656 in procedure "expand_le_archive_star" set ref 635 720* 731* type 206(27) based fixed bin(8,0) array level 3 in structure "lei" packed packed unaligned dcl 1055 in procedure "validate_opts" ref 1071 1088 1088 type 206(27) based fixed bin(8,0) array level 3 in structure "lei" packed packed unaligned dcl 1004 in procedure "add_opt" set ref 1020* type parameter fixed bin(17,0) dcl 909 in procedure "add_ep" set ref 889 956* 958* type based fixed bin(2,0) array level 2 in structure "star_links" packed packed unsigned unaligned dcl 3-76 in procedure "le" ref 805 878 unspec builtin function dcl 135 set ref 1023* version based char(8) level 3 dcl 98 set ref 167* version_flag 000116 automatic bit(1) packed unaligned dcl 115 set ref 181* 417* 420* 448 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ADDNAME internal static fixed bin(17,0) initial dcl 2-160 A_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-33 E_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 M_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 NO_LINK internal static fixed bin(17,0) initial dcl 2-164 NO_TABLE internal static fixed bin(17,0) initial dcl 2-166 N_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 REW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 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 packed 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 packed unaligned dcl 1-30 SMA_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SYNONYM internal static fixed bin(17,0) initial dcl 2-161 S_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 TABLE internal static fixed bin(17,0) initial dcl 2-165 TERM_FILE_BC internal static bit(2) initial packed unaligned dcl 4-12 TERM_FILE_DELETE internal static bit(5) initial packed unaligned dcl 4-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial packed unaligned dcl 4-16 TERM_FILE_TRUNC internal static bit(1) initial packed unaligned dcl 4-11 TERM_FILE_TRUNC_BC internal static bit(2) initial packed unaligned dcl 4-13 TERM_FILE_TRUNC_BC_TERM internal static bit(3) initial packed unaligned dcl 4-15 W_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 3-114 star_BRANCHES_ONLY internal static fixed bin(2,0) initial dcl 3-110 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 3-109 star_SEGMENT internal static fixed bin(2,0) initial unsigned dcl 3-120 star_entries based structure array level 1 dcl 3-27 star_entry_count automatic fixed bin(17,0) dcl 3-14 star_entry_ptr automatic pointer dcl 3-15 star_link_pathname based char packed unaligned dcl 3-102 star_linkx automatic fixed bin(17,0) dcl 3-18 star_list_branch based structure array level 1 dcl 3-41 star_names based char(32) array packed unaligned dcl 3-37 star_names_ptr automatic pointer dcl 3-19 terminate_file_switches based structure level 1 packed packed unaligned dcl 4-4 NAMES DECLARED BY EXPLICIT CONTEXT. ABORT 002431 constant label dcl 465 ref 1130 abort 005723 constant entry internal dcl 1110 ref 155 160 203 214 226 299 312 321 332 337 346 357 362 371 382 387 435 460 1075 add_ep 004746 constant entry internal dcl 889 ref 237 252 258 269 284 290 1092 1098 1101 add_opt 005353 constant entry internal dcl 970 ref 549 611 720 731 867 956 958 expand_le_archive_star 003454 constant entry internal dcl 635 ref 557 609 846 expand_le_path 002542 constant entry internal dcl 487 ref 202 225 expand_le_star 004140 constant entry internal dcl 756 ref 591 623 free_and_return 004676 constant label dcl 878 ref 864 868 le 000316 constant entry external dcl 19 linkage_editor 000325 constant entry external dcl 19 validate_opts 005455 constant entry internal dcl 1034 ref 444 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6516 6626 6055 6526 Length 7166 6055 110 323 441 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME le 732 external procedure is an external procedure. on unit on line 146 80 on unit expand_le_path internal procedure shares stack frame of external procedure le. expand_le_archive_star 202 internal procedure is called by several nonquick procedures. expand_le_star 177 internal procedure enables or reverts conditions. on unit on line 803 67 on unit add_ep internal procedure shares stack frame of external procedure le. add_opt 68 internal procedure is called by several nonquick procedures. validate_opts internal procedure shares stack frame of external procedure le. abort 84 internal procedure is called during a stack extension. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME expand_le_archive_star 000100 archive_bc expand_le_archive_star 000102 archivep expand_le_archive_star 000104 c_bc expand_le_archive_star 000105 complete_archive expand_le_archive_star 000106 cname expand_le_archive_star 000116 cp expand_le_archive_star 000120 no_match expand_le_archive_star 000121 pathname expand_le_archive_star expand_le_star 000100 archive expand_le_star 000101 bc expand_le_star 000102 compx expand_le_star 000103 ename expand_le_star 000113 last expand_le_star 000114 pathname expand_le_star 000166 segp expand_le_star 000170 sys_areap expand_le_star le 000100 argl le 000102 argp le 000104 argx le 000105 ec le 000106 has_delete le 000107 has_global le 000110 has_retain le 000111 i le 000112 leip le 000114 nargs le 000115 severity le 000116 version_flag le 000126 star_branch_count le 000130 star_list_branch_ptr le 000132 star_link_count le 000134 star_list_names_ptr le 000136 star_select_sw le 000146 archive expand_le_path 000147 bc expand_le_path 000150 cn expand_le_path 000160 dn expand_le_path 000232 en expand_le_path 000242 pathname expand_le_path 000324 segp expand_le_path 000334 entrypoint add_ep 000406 segname add_ep 000507 offsetname add_ep 000616 ec validate_opts 000617 o validate_opts 000620 path_count validate_opts 000621 found validate_opts THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ge_a alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this_desc call_int_other_desc return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry int_entry_desc op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. archive_$next_component check_star_name_$entry com_err_ cu_$arg_count cu_$arg_ptr cv_dec_check_ expand_pathname_ expand_pathname_$component get_system_free_area_ get_temp_segment_ get_wdir_ hcs_$star_dir_list_ hcs_$status_minf initiate_file_ initiate_file_$component ioa_ le_ match_star_name_ pathname_ pathname_$component release_temp_segment_ terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_conversion error_table_$badopt error_table_$dirseg error_table_$msf error_table_$noarg error_table_$nomatch le_data_$version_string le_et_$too_many_options linkage_editor_severity_ sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 19 000315 144 000332 146 000334 148 000350 150 000377 154 000400 155 000411 160 000427 163 000451 167 000474 168 000500 169 000503 170 000512 171 000516 172 000520 173 000521 174 000523 175 000526 176 000530 178 000531 179 000532 181 000534 182 000536 183 000537 184 000540 188 000541 189 000543 193 000547 197 000564 202 000600 203 000627 205 000650 209 000651 214 000661 220 000704 221 000705 225 000722 226 000751 228 000772 230 000773 233 001003 237 001005 243 001014 244 001015 250 001032 252 001046 253 001051 254 001053 258 001054 260 001107 262 001110 265 001120 269 001122 275 001131 276 001132 282 001147 284 001163 285 001166 286 001170 290 001171 292 001224 294 001225 299 001235 305 001260 306 001261 310 001276 312 001327 314 001350 316 001351 321 001361 326 001404 327 001405 331 001422 332 001450 337 001472 339 001533 341 001535 346 001545 351 001570 352 001571 356 001606 357 001634 362 001656 364 001717 366 001721 371 001731 376 001754 377 001755 381 001772 382 002020 387 002042 389 002103 393 002105 396 002121 399 002135 401 002145 402 002150 403 002152 405 002153 407 002157 408 002162 409 002164 411 002165 413 002175 414 002200 415 002202 417 002203 420 002216 423 002230 426 002244 429 002260 432 002274 435 002310 437 002330 439 002331 444 002332 448 002334 453 002356 455 002371 457 002374 459 002376 460 002415 465 002431 471 002435 472 002445 475 002512 476 002514 477 002537 480 002541 487 002542 524 002553 525 002605 531 002611 536 002615 537 002632 542 002635 543 002675 545 002701 549 002725 550 002771 552 002772 557 002776 558 003031 560 003032 565 003033 566 003050 571 003053 572 003110 578 003115 579 003153 584 003155 585 003161 590 003162 591 003202 592 003235 594 003236 601 003240 602 003262 603 003263 609 003305 611 003347 612 003413 614 003414 616 003415 623 003421 624 003451 626 003452 635 003453 676 003501 677 003536 682 003541 683 003557 685 003563 686 003610 687 003612 688 003613 692 003614 693 003616 694 003617 695 003622 699 003624 700 003660 705 003663 706 003670 712 003672 713 003715 718 003720 719 003721 720 003747 721 004014 724 004017 730 004020 731 004021 732 004066 738 004071 739 004124 741 004127 746 004130 749 004136 756 004137 796 004160 798 004166 799 004171 803 004172 805 004206 807 004254 809 004267 813 004270 814 004273 817 004343 822 004346 826 004357 830 004370 832 004401 833 004402 839 004424 845 004426 846 004431 852 004472 855 004514 856 004520 857 004522 863 004523 864 004562 866 004565 867 004607 868 004654 870 004657 874 004674 878 004676 880 004737 882 004745 889 004746 923 004757 925 004771 927 005020 931 005021 932 005036 936 005060 937 005105 943 005116 946 005130 947 005155 951 005166 952 005216 956 005217 958 005275 960 005343 963 005351 970 005352 1010 005400 1012 005410 1013 005412 1015 005413 1019 005414 1020 005415 1021 005423 1022 005431 1023 005437 1024 005447 1025 005451 1027 005454 1034 005455 1066 005457 1070 005460 1071 005471 1073 005504 1075 005506 1082 005530 1084 005531 1088 005545 1090 005571 1092 005573 1098 005630 1101 005670 1103 005721 1110 005722 1129 005736 1130 005763 ----------------------------------------------------------- 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