COMPILATION LISTING OF SEGMENT compare_entry_names Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/12/82 1244.5 mst Fri Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 compare_entry_names: cen: proc; 12 13 /* Modified 02/05/79: P. B. Kelley - to fix uninitialized pointer bug */ 14 15 dcl area area based (Parea); 16 dcl cleanup condition; 17 dcl code fixed bin (35); 18 dcl (Larg, N1, N2, j, k) fixed bin; 19 dcl (Parg, Parea int static init (null), Pn1, Pn2) ptr; 20 dcl (head_sw, ok_switch) bit (1) aligned; 21 dcl (addr, null, ptr) builtin; 22 dcl com_err_ ext entry options (variable); 23 dcl expand_path_ entry (ptr, fixed bin, ptr, ptr, fixed bin (35)); 24 dcl get_equal_name_ entry (char (*) aligned, char (*) aligned, char (*) aligned, fixed bin (35)); 25 dcl get_system_free_area_ entry returns (ptr); 26 dcl ioa_ entry options (variable); 27 dcl hcs_$status_long ext entry (char (*) aligned, char (*) aligned, fixed bin (1), ptr, ptr, fixed bin (35)); 28 dcl cu_$arg_ptr ext entry (fixed bin, ptr, fixed bin, fixed bin (35)); 29 dcl 1 branch1 aligned, /* for old segment status */ 30 (2 type bit (2), 31 2 nnames bit (16), 32 2 nrp bit (18), 33 2 padding bit (288), 34 2 uid bit (36)) unaligned; /* need uid to make sure segs are different */ 35 dcl 1 branch2 aligned, /* for new segment status */ 36 (2 type bit (2), 37 2 nnames bit (16), 38 2 nrp bit (18), 39 2 padding bit (288), 40 2 uid bit (36)) unaligned; /* need uid to make sure segs are different */ 41 dcl names1 (N1) char (32) aligned based (Pn1); 42 dcl names2 (N2) char (32) aligned based (Pn2); 43 dcl 1 over_names2 (N2) aligned based (Pn2), /* overlay for names2. */ 44 2 value2 fixed bin (35), 45 2 pad (7) fixed bin (35); 46 dcl arg char (Larg) based (Parg); 47 dcl (error_table_$sameseg, error_table_$noalloc) ext static fixed bin (35); 48 dcl (dname1, dname2) char (168) aligned; 49 dcl (ename1, ename2) char (32) aligned; 50 51 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 52 /* */ 53 /* make sure we have an allocation area, and establish a cleanup on-unit. */ 54 /* */ 55 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 56 57 Pn1 = null; /* set to null to begin with */ 58 Pn2 = null; /* "" */ 59 60 if Parea = null then 61 Parea = get_system_free_area_ (); /* get an allocation area. */ 62 on cleanup call cleaner; 63 64 call cu_$arg_ptr (1, Parg, Larg, code); /* pick up first arg */ 65 if code ^= 0 then goto common_error; 66 67 call expand_path_ (Parg, Larg, addr (dname1), addr (ename1), code); 68 if code ^= 0 then goto common_error; 69 70 71 call cu_$arg_ptr (2, Parg, Larg, code); /* pick up second arg */ 72 if code ^= 0 then goto common_error; 73 74 call expand_path_ (Parg, Larg, addr (dname2), addr (ename2), code); 75 if code ^= 0 then goto common_error; 76 77 call get_equal_name_ (ename1, ename2, ename2, code); 78 if code ^= 0 then goto common_error; 79 80 call hcs_$status_long (dname1, ename1, 1b, addr (branch1), Parea, code); /* pick up entrynames for old seg */ 81 if code ^= 0 then do; 82 call com_err_ (code, "compare_entry_names", "^a>^a", dname1, ename1); 83 return; 84 end; 85 Pn1 = ptr (Parea, branch1.nrp); 86 N1 = fixed (branch1.nnames); 87 88 call hcs_$status_long (dname2, ename2, 1b, addr (branch2), Parea, code); /* pick up entry names for new seg */ 89 if code ^= 0 then do; 90 call com_err_ (code, "compare_entry_names", "^a>^a", dname2, ename2); 91 call cleaner; 92 return; 93 end; 94 Pn2 = ptr (Parea, branch2.nrp); 95 N2 = fixed (branch2.nnames); 96 97 if branch1.uid = branch2.uid then do; /* the segments are the same... */ 98 code = error_table_$sameseg; /* complain */ 99 call cleaner; 100 goto common_error; 101 end; 102 103 ok_switch = "0"b; 104 head_sw = "1"b; 105 do j = 1 to N1; /* find any names deleted from old segment */ 106 do k = 1 to N2; 107 if value2 (k) = -1 then; /* if 2nd name matches one in 1st array, skip it. */ 108 else if names1 (j) = names2 (k) then do; 109 value2 (k) = -1; /* mark the name in the 2nd array as non-unique */ 110 go to next_name1; 111 end; 112 end; 113 114 if head_sw then do; /* let user know which segment */ 115 call ioa_ ("^/Names unique to ^a>^a", dname1, ename1); 116 head_sw = "0"b; 117 ok_switch = "1"b; 118 end; 119 120 call ioa_ ("^2x^a", names1 (j)); /* print names deleted from old segment */ 121 122 next_name1: end; 123 124 head_sw = "1"b; 125 do k = 1 to N2; /* find any names added to new segment */ 126 if value2 (k) = -1 then /* name matches one in 1st name array. */ 127 go to next_name2; 128 if head_sw then do; /* let user know which segment */ 129 call ioa_ ("^/Names unique to ^a>^a", dname2, ename2); 130 head_sw = "0"b; 131 ok_switch = "1"b; 132 end; 133 134 call ioa_ ("^2x^a", names2 (k)); /* print unique names on new segment */ 135 136 next_name2: end; 137 138 if ok_switch then 139 call ioa_ ("^/Comparison finished.^/"); 140 else 141 call ioa_ ("Entry names are identical.^/"); 142 call cleaner; 143 return; 144 145 146 common_error: call com_err_ (code, "compare_entry_names"); /* for error in external calls */ 147 return; 148 149 150 cleaner: procedure; 151 152 if Pn1 ^= null then free names1 in (area); 153 if Pn2 ^= null then free names2 in (area); 154 155 end cleaner; 156 157 158 end compare_entry_names; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/12/82 1111.9 compare_entry_names.pl1 >spec>on>11/12/82>compare_entry_names.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. Larg 000107 automatic fixed bin(17,0) dcl 18 set ref 64* 67* 71* 74* N1 000110 automatic fixed bin(17,0) dcl 18 set ref 86* 105 152 N2 000111 automatic fixed bin(17,0) dcl 18 set ref 95* 106 125 153 Parea 000010 internal static pointer initial dcl 19 set ref 60 60* 80* 85 88* 94 152 153 Parg 000114 automatic pointer dcl 19 set ref 64* 67* 71* 74* Pn1 000116 automatic pointer dcl 19 set ref 57* 85* 108 120 152 152 Pn2 000120 automatic pointer dcl 19 set ref 58* 94* 107 108 109 126 134 153 153 addr builtin function dcl 21 ref 67 67 67 67 74 74 74 74 80 80 88 88 area based area(1024) dcl 15 ref 152 153 branch1 000124 automatic structure level 1 dcl 29 set ref 80 80 branch2 000136 automatic structure level 1 dcl 35 set ref 88 88 cleanup 000100 stack reference condition dcl 16 ref 62 code 000106 automatic fixed bin(35,0) dcl 17 set ref 64* 65 67* 68 71* 72 74* 75 77* 78 80* 81 82* 88* 89 90* 98* 146* com_err_ 000012 constant entry external dcl 22 ref 82 90 146 cu_$arg_ptr 000026 constant entry external dcl 28 ref 64 71 dname1 000150 automatic char(168) dcl 48 set ref 67 67 80* 82* 115* dname2 000222 automatic char(168) dcl 48 set ref 74 74 88* 90* 129* ename1 000274 automatic char(32) dcl 49 set ref 67 67 77* 80* 82* 115* ename2 000304 automatic char(32) dcl 49 set ref 74 74 77* 77* 88* 90* 129* error_table_$sameseg 000030 external static fixed bin(35,0) dcl 47 ref 98 expand_path_ 000014 constant entry external dcl 23 ref 67 74 get_equal_name_ 000016 constant entry external dcl 24 ref 77 get_system_free_area_ 000020 constant entry external dcl 25 ref 60 hcs_$status_long 000024 constant entry external dcl 27 ref 80 88 head_sw 000122 automatic bit(1) dcl 20 set ref 104* 114 116* 124* 128 130* ioa_ 000022 constant entry external dcl 26 ref 115 120 129 134 138 140 j 000112 automatic fixed bin(17,0) dcl 18 set ref 105* 108 120* k 000113 automatic fixed bin(17,0) dcl 18 set ref 106* 107 108 109* 125* 126 134* names1 based char(32) array dcl 41 set ref 108 120* 152 names2 based char(32) array dcl 42 set ref 108 134* 153 nnames 0(02) 000136 automatic bit(16) level 2 in structure "branch2" packed unaligned dcl 35 in procedure "cen" set ref 95 nnames 0(02) 000124 automatic bit(16) level 2 in structure "branch1" packed unaligned dcl 29 in procedure "cen" set ref 86 nrp 0(18) 000124 automatic bit(18) level 2 in structure "branch1" packed unaligned dcl 29 in procedure "cen" set ref 85 nrp 0(18) 000136 automatic bit(18) level 2 in structure "branch2" packed unaligned dcl 35 in procedure "cen" set ref 94 null builtin function dcl 21 ref 57 58 60 152 153 ok_switch 000123 automatic bit(1) dcl 20 set ref 103* 117* 131* 138 over_names2 based structure array level 1 dcl 43 ptr builtin function dcl 21 ref 85 94 uid 11 000124 automatic bit(36) level 2 in structure "branch1" packed unaligned dcl 29 in procedure "cen" set ref 97 uid 11 000136 automatic bit(36) level 2 in structure "branch2" packed unaligned dcl 35 in procedure "cen" set ref 97 value2 based fixed bin(35,0) array level 2 dcl 43 set ref 107 109* 126 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. arg based char unaligned dcl 46 error_table_$noalloc external static fixed bin(35,0) dcl 47 NAMES DECLARED BY EXPLICIT CONTEXT. cen 000053 constant entry external dcl 11 cleaner 001046 constant entry internal dcl 150 ref 62 91 99 142 common_error 001021 constant label dcl 146 ref 65 68 72 75 78 100 compare_entry_names 000062 constant entry external dcl 11 next_name1 000662 constant label dcl 122 ref 110 next_name2 000757 constant label dcl 136 ref 126 NAME DECLARED BY CONTEXT OR IMPLICATION. fixed builtin function ref 86 95 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1236 1270 1077 1246 Length 1466 1077 32 161 136 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cen 282 external procedure is an external procedure. on unit on line 62 64 on unit cleaner 64 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 Parea cen STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cen 000106 code cen 000107 Larg cen 000110 N1 cen 000111 N2 cen 000112 j cen 000113 k cen 000114 Parg cen 000116 Pn1 cen 000120 Pn2 cen 000122 head_sw cen 000123 ok_switch cen 000124 branch1 cen 000136 branch2 cen 000150 dname1 cen 000222 dname2 cen 000274 ename1 cen 000304 ename2 cen THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this call_int_other return enable ext_entry int_entry free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_ptr expand_path_ get_equal_name_ get_system_free_area_ hcs_$status_long ioa_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$sameseg LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000052 57 000067 58 000071 60 000072 62 000103 64 000125 65 000144 67 000146 68 000171 71 000173 72 000212 74 000214 75 000237 77 000241 78 000263 80 000265 81 000325 82 000327 83 000370 85 000371 86 000377 88 000403 89 000442 90 000444 91 000505 92 000511 94 000512 95 000520 97 000524 98 000527 99 000531 100 000535 103 000536 104 000537 105 000541 106 000550 107 000557 108 000566 109 000600 110 000602 112 000603 114 000605 115 000607 116 000633 117 000634 120 000636 122 000662 124 000664 125 000666 126 000675 128 000702 129 000704 130 000730 131 000731 134 000733 136 000757 138 000761 140 001000 142 001014 143 001020 146 001021 147 001044 150 001045 152 001053 153 001064 155 001075 ----------------------------------------------------------- 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