COMPILATION LISTING OF SEGMENT copy_names Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 03/21/84 1043.0 mst Wed Options: optimize map 1 /* ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1983 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* ************************************************************** */ 8 9 10 11 12 /* format: style2,idind30,indcomtxt */ 13 14 15 copy_names: 16 procedure options (variable); 17 18 /**** * The commands copy_names and move_names copy and move all 19* the additional names from one designated segment to another. 20* copy_names also copies the designated name. Name duplication 21* within a directory is handled in the accepted manner. 22* Any number of pairs of arguments is allowed and the = convention 23* is followed in the second argument of a pair. */ 24 25 /* Karolyn Martin 5/30/69 */ 26 /* modified by M. Weaver 9 April 1970 6:35 PM -- recoded into PL/I */ 27 /* last modified by M. Weaver 31 December 1970 */ 28 /* modified 6/3/75 by S. Herbst: command names changed to copy_names and move_names */ 29 /* TR7429 Changed to reject starnames 10/30/80 S. Herbst */ 30 /* Housecleaned, but not entirely, J Pattin and BIM 83-(8, 9, 10) */ 31 /* Allow star names in first argument. C Spitzer 12/20/83 */ 32 33 dcl arg char (lng) based (ap); 34 35 dcl (copy, errsw) bit (1) aligned; 36 dcl (i, j, n) fixed bin (17); 37 dcl lng fixed bin (21); 38 dcl areap ptr; 39 dcl myarea area based (areap); 40 dcl bitcnt fixed bin (24); 41 dcl code fixed bin (35); 42 dcl (dir1, dir2) char (168); 43 dcl (en1, en2, qent) char (32); 44 dcl cleanup condition; 45 dcl (null, sum) builtin; 46 dcl stars bit (1) aligned; 47 dcl ap ptr; 48 dcl whoami char (32); 49 dcl type fixed bin (2); 50 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 51 dcl check_star_name_$entry entry (character (*), fixed binary (35)); 52 dcl expand_pathname_ entry (character (*), character (*), character (*), fixed binary (35)); 53 dcl ( 54 com_err_, 55 com_err_$suppress_name 56 ) ext entry options (variable); 57 dcl error_table_$namedup external fixed bin (35); 58 dcl error_table_$segnamedup external fixed bin (35); 59 dcl get_wdir_ ext entry returns (char (168)); 60 dcl hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, 61 fixed bin (35)); 62 dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), 63 fixed bin (35)); 64 dcl copy_names_ entry (character (*), character (*), character (*), character (*), 65 character (*), bit (1) aligned, fixed binary (35)); 66 dcl move_names_ entry (character (*), character (*), character (*), character (*), 67 character (*), bit (1) aligned, fixed binary (35)); 68 dcl get_equal_name_ entry (character (*), character (*), character (32), fixed binary (35)); 69 dcl cu_$arg_count ext entry (fixed bin, fixed bin (35)); 70 dcl pathname_ entry (character (*), character (*)) returns (character (168)); 71 dcl get_system_free_area_ entry() returns(ptr); 72 73 /* The additional names are to be left on the original segment. */ 74 75 copy = "1"b; 76 whoami = "copy_names"; 77 go to work; 78 79 move_names: 80 entry options (variable); 81 82 /* The additional names are to be removed from the original segment. */ 83 84 copy = "0"b; 85 whoami = "move_names"; 86 87 work: 88 call cu_$arg_count (n, code); 89 if code ^= 0 90 then do; 91 call com_err_ (code, whoami); 92 return; 93 end; 94 if n = 0 95 then do; 96 call com_err_$suppress_name (0, whoami, "Usage: ^a from1 to1 ... fromj toj", whoami); 97 return; 98 end; 99 100 areap = get_system_free_area_ (); 101 star_entry_ptr, star_names_ptr = null; 102 on cleanup call cleaner; 103 104 /* The following master loop processes each pair of arguments completely 105* unless some error code is returned by the file system. */ 106 107 do i = 1 to n by 2; 108 109 /* get first arg */ 110 call cu_$arg_ptr (i, ap, lng, code); 111 call expand_pathname_ (arg, dir1, en1, code); 112 if code ^= 0 113 then do; 114 call com_err_ (code, whoami, "^a", arg); 115 return; 116 end; 117 call check_star_name_$entry (en1, code); 118 if code ^= 0 119 then do; 120 if code = 1 | code = 2 121 then stars = "1"b; 122 else do; 123 call com_err_ (code, whoami, "^a", en1); 124 return; 125 end; 126 end; 127 128 /* get second arg */ 129 if i = n 130 then do; 131 qent = en1; /* have odd no. of args */ 132 dir2 = get_wdir_ (); 133 call doit; 134 end; 135 else do; 136 call cu_$arg_ptr (i + 1, ap, lng, code); 137 call expand_pathname_ (arg, dir2, qent, code); 138 if code ^= 0 139 then do; 140 call com_err_ (code, whoami, "^a", arg); 141 return; 142 end; 143 if stars 144 then do; 145 call hcs_$star_ (dir1, en1, 3, areap, star_entry_count, star_entry_ptr, star_names_ptr, 146 code); 147 if code ^= 0 148 then do; 149 errseg1: 150 call com_err_ (code, whoami, "^a", pathname_ (dir1, en1)); 151 goto next_arg; 152 end; 153 do j = 1 to star_entry_count; 154 en1 = star_names (star_entries (j).nindex); 155 call doit; 156 end; 157 call cleaner; /* get rid of current star structures */ 158 end; 159 else call doit; 160 end; 161 next_arg: 162 end; 163 164 165 doit: 166 proc; 167 168 call get_equal_name_ (en1, qent, en2, code); 169 if code ^= 0 170 then do; 171 call com_err_ (code, whoami, "^a for ^a", qent, en1); 172 return; 173 end; 174 175 /* Does target segment exist?? */ 176 177 call hcs_$status_minf (dir2, en2, 0, type, bitcnt, code); 178 if code ^= 0 179 then go to errseg2; 180 181 /* If so, then move the names. */ 182 183 if copy 184 then call copy_names_ (dir1, en1, dir2, en2, whoami, errsw, code); 185 else call move_names_ (dir1, en1, dir2, en2, whoami, errsw, code); 186 187 if code ^= 0 & code ^= error_table_$namedup & code ^= error_table_$segnamedup 188 then if errsw 189 then 190 errseg2: 191 call com_err_ (code, whoami, "^a", pathname_ (dir2, en2)); 192 else call com_err_ (code, whoami, "^a", pathname_ (dir1, en1)); 193 194 end doit; 195 196 cleaner: 197 proc; 198 199 if star_names_ptr ^= null 200 then do; 201 free star_names in (myarea); 202 star_names_ptr = null; 203 end; 204 if star_entry_ptr ^= null 205 then do; 206 free star_entries in (myarea); 207 star_entry_ptr = null; 208 end; 209 210 return; 211 end cleaner; 212 213 1 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 1 2 1 3 /* This include file contains structures for the hcs_$star_, 1 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 1 5* 1 6* Written 23 October 1978 by Monte Davidoff. 1 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 1 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 1 9**/ 1 10 1 11 /* automatic */ 1 12 1 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 1 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 1 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 1 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 1 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 1 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 1 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 1 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 1 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 1 22 1 23 /* based */ 1 24 1 25 /* hcs_$star_ entry structure */ 1 26 1 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 1 28 2 type fixed binary (2) unsigned unaligned, 1 29 /* storage system type */ 1 30 2 nnames fixed binary (16) unsigned unaligned, 1 31 /* number of names of entry that match star_name */ 1 32 2 nindex fixed binary (18) unsigned unaligned; 1 33 /* index of first name in star_names */ 1 34 1 35 /* hcs_$star_ name structure */ 1 36 1 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 1 38 1 39 /* hcs_$star_list_ branch structure */ 1 40 1 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 42 2 type fixed binary (2) unsigned unaligned, 1 43 /* storage system type */ 1 44 2 nnames fixed binary (16) unsigned unaligned, 1 45 /* number of names of entry that match star_name */ 1 46 2 nindex fixed binary (18) unsigned unaligned, 1 47 /* index of first name in star_list_names */ 1 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 1 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 1 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 1 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 1 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 1 53 2 pad bit (7) unaligned, 1 54 2 records fixed binary (18) unsigned unaligned; 1 55 /* records used by branch */ 1 56 1 57 /* hcs_$star_dir_list_ branch structure */ 1 58 1 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 60 2 type fixed binary (2) unsigned unaligned, 1 61 /* storage system type */ 1 62 2 nnames fixed binary (16) unsigned unaligned, 1 63 /* number of names of entry that match star_name */ 1 64 2 nindex fixed binary (18) unsigned unaligned, 1 65 /* index of first name in star_list_names */ 1 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 1 67 2 pad bit (36) unaligned, 1 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 1 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 1 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 1 71 2 bit_count fixed binary (24) unaligned; 1 72 /* bit count of the branch */ 1 73 1 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 1 75 1 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 77 2 type fixed binary (2) unsigned unaligned, 1 78 /* storage system type */ 1 79 2 nnames fixed binary (16) unsigned unaligned, 1 80 /* number of names of entry that match star_name */ 1 81 2 nindex fixed binary (18) unsigned unaligned, 1 82 /* index of first name in star_list_names */ 1 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 1 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 1 85 2 pathname_len fixed binary (18) unsigned unaligned, 1 86 /* length of the pathname of the link */ 1 87 2 pathname_index fixed binary (18) unsigned unaligned; 1 88 /* index of start of pathname in star_list_names */ 1 89 1 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 1 91 1 92 declare star_list_names char (32) based (star_list_names_ptr) 1 93 dimension (star_links (star_branch_count + star_link_count).nindex 1 94 + star_links (star_branch_count + star_link_count).nnames 1 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 1 96 * binary ( 1 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 1 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 1 99 1 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 1 101 1 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 1 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 1 104 1 105 /* internal static */ 1 106 1 107 /* star_select_sw values */ 1 108 1 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 1 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 1 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 1 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 1 113 fixed binary (3) internal static options (constant) initial (5); 1 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 1 115 fixed binary (3) internal static options (constant) initial (7); 1 116 1 117 /* storage system types */ 1 118 1 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 1 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 1 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 1 122 1 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 214 215 216 end copy_names; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 03/21/84 1043.0 copy_names.pl1 >spec>on>6664>6664.pbf>copy_names.pl1 214 1 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. ap 000276 automatic pointer dcl 47 set ref 110* 111 114 136* 137 140 areap 000106 automatic pointer dcl 38 set ref 100* 145* 201 206 arg based char unaligned dcl 33 set ref 111* 114* 137* 140* bitcnt 000110 automatic fixed bin(24,0) dcl 40 set ref 177* check_star_name_$entry 000012 constant entry external dcl 51 ref 117 cleanup 000266 stack reference condition dcl 44 ref 102 code 000111 automatic fixed bin(35,0) dcl 41 set ref 87* 89 91* 110* 111* 112 114* 117* 118 120 120 123* 136* 137* 138 140* 145* 147 149* 168* 169 171* 177* 178 183* 185* 187 187 187 187* 192* com_err_ 000016 constant entry external dcl 53 ref 91 114 123 140 149 171 187 192 com_err_$suppress_name 000020 constant entry external dcl 53 ref 96 copy 000100 automatic bit(1) dcl 35 set ref 75* 84* 183 copy_names_ 000034 constant entry external dcl 64 ref 183 cu_$arg_count 000042 constant entry external dcl 69 ref 87 cu_$arg_ptr 000010 constant entry external dcl 50 ref 110 136 dir1 000112 automatic char(168) unaligned dcl 42 set ref 111* 145* 149* 149* 183* 185* 192* 192* dir2 000164 automatic char(168) unaligned dcl 42 set ref 132* 137* 177* 183* 185* 187* 187* en1 000236 automatic char(32) unaligned dcl 43 set ref 111* 117* 123* 131 145* 149* 149* 154* 168* 171* 183* 185* 192* 192* en2 000246 automatic char(32) unaligned dcl 43 set ref 168* 177* 183* 185* 187* 187* error_table_$namedup 000022 external static fixed bin(35,0) dcl 57 ref 187 error_table_$segnamedup 000024 external static fixed bin(35,0) dcl 58 ref 187 errsw 000101 automatic bit(1) dcl 35 set ref 183* 185* 187 expand_pathname_ 000014 constant entry external dcl 52 ref 111 137 get_equal_name_ 000040 constant entry external dcl 68 ref 168 get_system_free_area_ 000046 constant entry external dcl 71 ref 100 get_wdir_ 000026 constant entry external dcl 59 ref 132 hcs_$star_ 000030 constant entry external dcl 60 ref 145 hcs_$status_minf 000032 constant entry external dcl 62 ref 177 i 000102 automatic fixed bin(17,0) dcl 36 set ref 107* 110* 129 136* j 000103 automatic fixed bin(17,0) dcl 36 set ref 153* 154* lng 000105 automatic fixed bin(21,0) dcl 37 set ref 110* 111 111 114 114 136* 137 137 140 140 move_names_ 000036 constant entry external dcl 66 ref 185 myarea based area(1024) dcl 39 ref 201 206 n 000104 automatic fixed bin(17,0) dcl 36 set ref 87* 94 107 129 nindex 0(18) based fixed bin(18,0) array level 2 packed unsigned unaligned dcl 1-27 ref 154 nnames 0(02) based fixed bin(16,0) array level 2 packed unsigned unaligned dcl 1-27 ref 201 null builtin function dcl 45 ref 101 199 202 204 207 pathname_ 000044 constant entry external dcl 70 ref 149 149 187 187 192 192 qent 000256 automatic char(32) unaligned dcl 43 set ref 131* 137* 168* 171* star_entries based structure array level 1 dcl 1-27 ref 206 star_entry_count 000311 automatic fixed bin(17,0) dcl 1-14 set ref 145* 153 201 206 star_entry_ptr 000312 automatic pointer dcl 1-15 set ref 101* 145* 154 201 204 206 207* star_names based char(32) array unaligned dcl 1-37 ref 154 201 star_names_ptr 000314 automatic pointer dcl 1-19 set ref 101* 145* 154 199 201 202* stars 000274 automatic bit(1) dcl 46 set ref 120* 143 sum builtin function dcl 45 ref 201 type 000310 automatic fixed bin(2,0) dcl 49 set ref 177* whoami 000300 automatic char(32) unaligned dcl 48 set ref 76* 85* 91* 96* 96* 114* 123* 140* 149* 171* 183* 185* 187* 192* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. star_ALL_ENTRIES internal static fixed bin(2,0) initial dcl 1-111 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 1-114 star_BRANCHES_ONLY internal static fixed bin(2,0) initial dcl 1-110 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 1-121 star_LINK internal static fixed bin(2,0) initial unsigned dcl 1-119 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 1-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 1-112 star_SEGMENT internal static fixed bin(2,0) initial unsigned dcl 1-120 star_branch_count automatic fixed bin(17,0) dcl 1-13 star_dir_list_branch based structure array level 1 dcl 1-59 star_link_count automatic fixed bin(17,0) dcl 1-17 star_link_pathname based char unaligned dcl 1-102 star_links based structure array level 1 dcl 1-76 star_linkx automatic fixed bin(17,0) dcl 1-18 star_list_branch based structure array level 1 dcl 1-41 star_list_branch_ptr automatic pointer dcl 1-16 star_list_names based char(32) array unaligned dcl 1-92 star_list_names_ptr automatic pointer dcl 1-20 star_select_sw automatic fixed bin(3,0) dcl 1-21 NAMES DECLARED BY EXPLICIT CONTEXT. cleaner 001260 constant entry internal dcl 196 ref 102 157 copy_names 000051 constant entry external dcl 15 doit 000705 constant entry internal dcl 165 ref 133 155 159 errseg1 000600 constant label dcl 149 errseg2 001140 constant label dcl 187 ref 178 move_names 000065 constant entry external dcl 79 next_arg 000701 constant label dcl 161 ref 151 work 000076 constant label dcl 87 ref 77 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1562 1632 1336 1572 Length 2052 1336 50 204 224 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME copy_names 472 external procedure is an external procedure. on unit on line 102 64 on unit doit internal procedure shares stack frame of external procedure copy_names. cleaner 64 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME copy_names 000100 copy copy_names 000101 errsw copy_names 000102 i copy_names 000103 j copy_names 000104 n copy_names 000105 lng copy_names 000106 areap copy_names 000110 bitcnt copy_names 000111 code copy_names 000112 dir1 copy_names 000164 dir2 copy_names 000236 en1 copy_names 000246 en2 copy_names 000256 qent copy_names 000274 stars copy_names 000276 ap copy_names 000300 whoami copy_names 000310 type copy_names 000311 star_entry_count copy_names 000312 star_entry_ptr copy_names 000314 star_names_ptr copy_names THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this call_int_other return mpfx2 enable ext_entry int_entry free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. check_star_name_$entry com_err_ com_err_$suppress_name copy_names_ cu_$arg_count cu_$arg_ptr expand_pathname_ get_equal_name_ get_system_free_area_ get_wdir_ hcs_$star_ hcs_$status_minf move_names_ pathname_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$namedup error_table_$segnamedup LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 15 000050 75 000056 76 000060 77 000063 79 000064 84 000072 85 000073 87 000076 89 000107 91 000111 92 000126 94 000127 96 000131 97 000161 100 000162 101 000171 102 000174 107 000216 110 000225 111 000242 112 000272 114 000274 115 000326 117 000327 118 000344 120 000346 123 000355 124 000403 129 000404 131 000407 132 000412 133 000421 134 000422 136 000423 137 000442 138 000472 140 000474 141 000526 143 000527 145 000531 147 000576 149 000600 151 000647 153 000650 154 000657 155 000670 156 000671 157 000673 158 000677 159 000700 161 000701 216 000704 165 000705 168 000706 169 000731 171 000733 172 000766 177 000767 178 001025 183 001027 185 001070 187 001126 192 001210 194 001256 196 001257 199 001265 201 001272 202 001321 204 001324 206 001330 207 001332 210 001335 ----------------------------------------------------------- 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