COMPILATION LISTING OF SEGMENT get_seg_ptr_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/05/86 1048.0 mst Wed 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 /* This procedure was initially coded by Richard H. Gumpertz on 1/7/71 12* Procedure last modified: 13* 04/10/71 at 1536 by RHG to rename get_seg_ptr_$** to get_seg_ptr_** 14* to use the already installed copy of stack_frame.incl.pl1 15* 03/31/71 at 1428 by RHG to add entry point get_seg_ptr_arg_ 16* 03/24/71 at 1758 by RHG to clear return_code in $search 17* 03/24/71 at 1714 by RHG to make things a bit neater 18* 03/22/71 at 0357 by RHG to rename open_seg_ to get_seg_ptr_ 19* to combine get_seg_ptr_ and release_seg_ptr_ 20* to add the entry point $search 21* to change wanted_access from fixed bin(5) to bit(6) aligned 22* 01/20/71 at 1820 by RHG to supress hcs_$initiate_count errors such as "segknown" 23* 01/18/71 at 1104 by RHG to reformat the source 24* 01/17/71 at 1951 by RHG to speed up open_seg_$path 25* 01/17/71 at 1251 by RHG for initial implementation 26* 11/14/73 by Kobziar to not check append access 27* 11/30/77 by David Levin to zero unused part of last word. 28* */ 29 /* This procedure opens a segment for reading or writing, returning a pointer and a bit_count. 30* If the segment does not exist and "create" access was specified in the call then an attempt is 31* made to create the segment. A non-null pointer is returned if the segment is initiated. 32* An error code will be returned in return_code if the access to the 33* segment is not at least that specified in wanted_access. Otherwise any error return will have 34* the return_ptr null. 35* 36* The entry point get_seg_ptr_arg_ is identical to the main entry except that 37* the pathname is fetched out of the caller's argument list. 38* 39* The entry point get_seg_ptr_full_path_ is identical to the main entry except that 40* a directory name and an entry name are taken rather than a relative path name. 41* 42* The entry point get_seg_ptr_search_ initiates the segment via search rules but 43* initiates the segment with a null reference name. If it creates a segment 44* it creates it in the process directory. 45* 46* The entry point release_seg_ptr_ terminates a segment. It also truncates 47* the segment and sets its bit count if a nonnegative bit count is given. 48* */ 49 /* */ 50 get_seg_ptr_: procedure (path_name, wanted_access, bit_count, return_ptr, return_code); 51 call expand_pathname_ (path_name, directory_name, entry_name, error_code); 52 if error_code ^= 0 then goto error_return; 53 goto common; 54 55 get_seg_ptr_arg_: entry (arg_number, wanted_access, bit_count, return_ptr, return_code); 56 call cu_$arg_ptr_rel (arg_number, temp_ptr, len, error_code, 57 cu_$stack_frame_ptr () -> prev_sp -> arg_ptr); 58 if error_code ^= 0 then goto error_return; 59 call expand_pathname_ (path_name_arg, directory_name, entry_name, error_code); 60 if error_code ^= 0 then goto error_return; 61 goto common; 62 63 get_seg_ptr_full_path_: entry (d_name, e_name, wanted_access, bit_count, return_ptr, return_code); 64 directory_name = d_name; 65 entry_name = e_name; 66 goto common; 67 68 get_seg_ptr_search_: entry (ref_name, wanted_access, bit_count, return_ptr, return_code); 69 call hcs_$fs_get_seg_ptr (ref_name, temp_ptr, error_code); 70 if temp_ptr ^= null then /* temp_ptr = null if seg not known */ 71 do; 72 call hcs_$fs_get_path_name (temp_ptr, directory_name, len, entry_name, error_code); 73 /* get the path name of the segment */ 74 if error_code ^= 0 then goto error_return; 75 goto common; 76 end; 77 call hcs_$make_ptr (null_string, ref_name, null_string, temp_ptr, error_code); 78 /* search for the segment */ 79 if temp_ptr = null then /* temp_ptr = null if seg doesn't exist */ 80 do; 81 if substr (wanted_access, 6, 1) = "0"b then goto error_return; 82 /* return if "create" bit not on */ 83 directory_name = get_pdir_ (); /* else create the segment in the process dir */ 84 entry_name = ref_name; 85 return_code = 0; 86 goto create; 87 end; 88 call hcs_$fs_get_path_name (temp_ptr, directory_name, len, entry_name, error_code); 89 /* get the path name of the seg */ 90 if error_code ^= 0 then goto error_return; 91 call hcs_$terminate_name (ref_name, error_code); /* terminate the name we just made known */ 92 if error_code ^= 0 then goto error_return; 93 goto common; 94 95 release_seg_ptr_: entry (seg_ptr, bit_count, return_code); 96 return_code = 0; 97 goto release; 98 /* */ 99 dcl path_name char (*), 100 path_name_arg char (len) based (temp_ptr), 101 arg_number fixed bin, 102 ref_name char (*), 103 d_name char (*), 104 e_name char (*), 105 seg_ptr ptr, 106 wanted_access bit (6) aligned, 107 bit_count fixed bin (24), 108 word_count fixed bin (24), 109 word_mask (0:3) bit (36) aligned int static options (constant) 110 init ("777777777777"b3, "777000000000"b3, "777777000000"b3, "777777777000"b3), 111 segment (262144) bit (36) aligned based, 112 return_ptr ptr, 113 return_code fixed bin (35); 114 115 dcl (addr, 116 divide, 117 fixed, 118 length, 119 mod, 120 null, 121 substr) builtin; 122 123 dcl (error_table_$moderr, 124 error_table_$noentry) fixed bin (35) external; 125 126 dcl expand_pathname_ external entry (char (*), char (*) aligned, char (*) aligned, fixed bin (35)), 127 cu_$stack_frame_ptr external entry () returns (ptr), 128 cu_$arg_ptr_rel external entry (fixed bin, ptr, fixed bin, fixed bin (35), ptr), 129 get_pdir_ external entry () returns (char (168) aligned), 130 hcs_$status_ external entry (char (*) aligned, char (*) aligned, fixed bin, ptr, ptr, fixed bin (35)), 131 hcs_$initiate_count external entry (char (*) aligned, char (*) aligned, char (*) aligned, 132 fixed bin (24), fixed bin, ptr, fixed bin (35)), 133 hcs_$append_branch external entry (char (*) aligned, char (*) aligned, fixed bin (5), fixed bin (35)), 134 hcs_$fs_get_path_name external entry (ptr, char (*) aligned, fixed bin, char (*) aligned, fixed bin (35)), 135 hcs_$fs_get_seg_ptr external entry (char (*), ptr, fixed bin (35)), 136 hcs_$make_ptr external entry (char (*) aligned, char (*), char (*) aligned, ptr, fixed bin (35)), 137 hcs_$terminate_name external entry (char (*), fixed bin (35)), 138 hcs_$set_bc external entry (char (*) aligned, char (*) aligned, fixed bin (24), fixed bin (35)), 139 hcs_$truncate_seg external entry (ptr, fixed bin (24), fixed bin (35)), 140 hcs_$terminate_noname external entry (ptr, fixed bin (35)); 141 1 1 /* BEGIN INCLUDE FILE status_info_branch.incl.pl1 */ 1 2 dcl 1 status_info_branch, /* structure returned for branch */ 1 3 2 type bit(2), /* 0=link, 1=seg, 2=dir */ 1 4 2 nnames bit(16), /* number of names for this entry */ 1 5 2 nrp bit(18), /* ??????? */ 1 6 2 dtm bit(36), /* date and time last modified */ 1 7 2 dtu bit(36), /* date and time last used */ 1 8 2 mode bit(5), /* user's access mode */ 1 9 2 pad bit(13), 1 10 2 records bit(18); /* number of records used */ 1 11 /* END INCLUDE FILE status_info_branch.incl.pl1 */ 142 2 1 /* BEGIN INCLUDE FILE ... stack_frame.incl.pl1 ... */ 2 2 2 3 /* format: off */ 2 4 2 5 /* Modified: 16 Dec 1977, D. Levin - to add fio_ps_ptr and pl1_ps_ptr */ 2 6 /* Modified: 3 Feb 1978, P. Krupp - to add run_unit_manager bit & main_proc bit */ 2 7 /* Modified: 21 March 1978, D. Levin - change fio_ps_ptr to support_ptr */ 2 8 /* Modified: 03/01/84, S. Herbst - Added RETURN_PTR_MASK */ 2 9 2 10 2 11 /****^ HISTORY COMMENTS: 2 12* 1) change(86-09-15,Kissel), approve(86-09-15,MCR7473), 2 13* audit(86-10-01,Fawcett), install(86-11-03,MR12.0-1206): 2 14* Modified to add constants for the translator_id field in the stack_frame 2 15* structure. 2 16* END HISTORY COMMENTS */ 2 17 2 18 2 19 dcl RETURN_PTR_MASK bit (72) int static options (constant) /* mask to be AND'd with stack_frame.return_ptr */ 2 20 init ("777777777777777777000000"b3); /* when copying, to ignore bits that a call fills */ 2 21 /* with indicators (nonzero for Fortran hexfp caller) */ 2 22 /* say: unspec(ptr) = unspec(stack_frame.return_ptr) & RETURN_PTR_MASK; */ 2 23 2 24 dcl TRANSLATOR_ID_PL1V2 bit (18) internal static options (constant) init ("000000"b3); 2 25 dcl TRANSLATOR_ID_ALM bit (18) internal static options (constant) init ("000001"b3); 2 26 dcl TRANSLATOR_ID_PL1V1 bit (18) internal static options (constant) init ("000002"b3); 2 27 dcl TRANSLATOR_ID_SIGNAL_CALLER bit (18) internal static options (constant) init ("000003"b3); 2 28 dcl TRANSLATOR_ID_SIGNALLER bit (18) internal static options (constant) init ("000004"b3); 2 29 2 30 2 31 dcl sp pointer; /* pointer to beginning of stack frame */ 2 32 2 33 dcl stack_frame_min_length fixed bin static init(48); 2 34 2 35 2 36 dcl 1 stack_frame based(sp) aligned, 2 37 2 pointer_registers(0 : 7) ptr, 2 38 2 prev_sp pointer, 2 39 2 next_sp pointer, 2 40 2 return_ptr pointer, 2 41 2 entry_ptr pointer, 2 42 2 operator_and_lp_ptr ptr, /* serves as both */ 2 43 2 arg_ptr pointer, 2 44 2 static_ptr ptr unaligned, 2 45 2 support_ptr ptr unal, /* only used by fortran I/O */ 2 46 2 on_unit_relp1 bit(18) unaligned, 2 47 2 on_unit_relp2 bit(18) unaligned, 2 48 2 translator_id bit(18) unaligned, /* Translator ID (see constants above) 2 49* 0 => PL/I version II 2 50* 1 => ALM 2 51* 2 => PL/I version I 2 52* 3 => signal caller frame 2 53* 4 => signaller frame */ 2 54 2 operator_return_offset bit(18) unaligned, 2 55 2 x(0: 7) bit(18) unaligned, /* index registers */ 2 56 2 a bit(36), /* accumulator */ 2 57 2 q bit(36), /* q-register */ 2 58 2 e bit(36), /* exponent */ 2 59 2 timer bit(27) unaligned, /* timer */ 2 60 2 pad bit(6) unaligned, 2 61 2 ring_alarm_reg bit(3) unaligned; 2 62 2 63 2 64 dcl 1 stack_frame_flags based(sp) aligned, 2 65 2 pad(0 : 7) bit(72), /* skip over prs */ 2 66 2 xx0 bit(22) unal, 2 67 2 main_proc bit(1) unal, /* on if frame belongs to a main procedure */ 2 68 2 run_unit_manager bit(1) unal, /* on if frame belongs to run unit manager */ 2 69 2 signal bit(1) unal, /* on if frame belongs to logical signal_ */ 2 70 2 crawl_out bit(1) unal, /* on if this is a signal caller frame */ 2 71 2 signaller bit(1) unal, /* on if next frame is signaller's */ 2 72 2 link_trap bit(1) unal, /* on if this frame was made by the linker */ 2 73 2 support bit(1) unal, /* on if frame belongs to a support proc */ 2 74 2 condition bit(1) unal, /* on if condition established in this frame */ 2 75 2 xx0a bit(6) unal, 2 76 2 xx1 fixed bin, 2 77 2 xx2 fixed bin, 2 78 2 xx3 bit(25) unal, 2 79 2 old_crawl_out bit (1) unal, /* on if this is a signal caller frame */ 2 80 2 old_signaller bit(1) unal, /* on if next frame is signaller's */ 2 81 2 xx3a bit(9) unaligned, 2 82 2 xx4(9) bit(72) aligned, 2 83 2 v2_pl1_op_ret_base ptr, /* When a V2 PL/I program calls an operator the 2 84* * operator puts a pointer to the base of 2 85* * the calling procedure here. (text base ptr) */ 2 86 2 xx5 bit(72) aligned, 2 87 2 pl1_ps_ptr ptr; /* ptr to ps for this frame; also used by fio. */ 2 88 2 89 /* format: on */ 2 90 2 91 /* END INCLUDE FILE ... stack_frame.incl.pl1 */ 143 144 145 dcl error_code fixed bin (35), 146 directory_name char (168) aligned, 147 entry_name char (32) aligned, 148 temp_ptr ptr, 149 len fixed bin; 150 151 dcl null_string char (0) aligned internal static initial (""); 152 /* */ 153 common: return_code = 0; /* initialize */ 154 155 call hcs_$status_ (directory_name, entry_name, 1, addr (status_info_branch), null, error_code); 156 /* find out if the seg exists and the access we have to it */ 157 if error_code ^= 0 then goto create_seg; /* if error, seg probably didn't exist */ 158 if substr (wanted_access, 1, 4) & ^mode then return_code = error_table_$moderr; 159 /* make sure he has at least the access requested */ 160 161 initiate_seg: 162 call hcs_$initiate_count (directory_name, entry_name, null_string, bit_count, 1, return_ptr, error_code); 163 /* initiate the segment with null reference name */ 164 if return_ptr = null then goto error_return; /* check return_ptr not error_code to avoid "segknown" etc. */ 165 return; 166 167 create_seg: 168 if error_code ^= error_table_$noentry then goto error_return; 169 /* make sure the problem really was that seg didn't exist */ 170 if substr (wanted_access, 6, 1) = "0"b then goto error_return; 171 /* don't create the seg unless "create" access specified */ 172 create: call hcs_$append_branch (directory_name, entry_name, fixed (substr (wanted_access, 1, 5), 5, 0), error_code); 173 /* create the segment */ 174 if error_code = 0 then goto initiate_seg; /* if OK then go initiate the segment */ 175 /* else we have an error */ 176 177 178 179 error_return: /* we get here if we have an error return */ 180 bit_count = 0; 181 return_ptr = null; 182 error_return_2: 183 return_code = error_code; 184 return; 185 /* */ 186 release: 187 if bit_count >= 0 then /* set length only if bit count non-negative */ 188 set_length: do; 189 /* get the pathname so we can set bit count */ 190 call hcs_$fs_get_path_name (seg_ptr, directory_name, len, entry_name, error_code); 191 if error_code ^= 0 then goto error_return_2; 192 193 /* set the bit count */ 194 call hcs_$set_bc (directory_name, entry_name, bit_count, error_code); 195 if error_code ^= 0 then return_code = error_code; 196 197 /* truncate any unused pages */ 198 word_count = divide (bit_count+35, 36, 24, 0); 199 call hcs_$truncate_seg (seg_ptr, word_count, error_code); 200 if error_code ^= 0 then return_code = error_code; 201 if mod (bit_count, 36) ^= 0 then 202 seg_ptr -> segment (word_count) = seg_ptr -> segment (word_count) 203 & word_mask (mod (divide (bit_count+8, 9, 24, 0), 4)); 204 205 end set_length; 206 207 208 209 210 211 call hcs_$terminate_noname (seg_ptr, error_code); /* terminate the segment */ 212 if error_code ^= 0 then goto error_return_2; 213 /* */ 214 end get_seg_ptr_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/86 1042.7 get_seg_ptr_.pl1 >special_ldd>install>MR12.0-1206>get_seg_ptr_.pl1 142 1 05/06/74 1751.6 status_info_branch.incl.pl1 >ldd>include>status_info_branch.incl.pl1 143 2 11/03/86 1114.7 stack_frame.incl.pl1 >special_ldd>install>MR12.0-1206>stack_frame.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. addr builtin function dcl 115 ref 155 155 arg_number parameter fixed bin(17,0) dcl 99 set ref 55 56* arg_ptr 32 based pointer level 2 dcl 2-36 set ref 56* bit_count parameter fixed bin(24,0) dcl 99 set ref 50 55 63 68 95 161* 179* 186 194* 198 201 201 cu_$arg_ptr_rel 000020 constant entry external dcl 126 ref 56 cu_$stack_frame_ptr 000016 constant entry external dcl 126 ref 56 d_name parameter char unaligned dcl 99 ref 63 64 directory_name 000106 automatic char(168) dcl 145 set ref 51* 59* 64* 72* 83* 88* 155* 161* 172* 190* 194* divide builtin function dcl 115 ref 198 201 e_name parameter char unaligned dcl 99 ref 63 65 entry_name 000160 automatic char(32) dcl 145 set ref 51* 59* 65* 72* 84* 88* 155* 161* 172* 190* 194* error_code 000105 automatic fixed bin(35,0) dcl 145 set ref 51* 52 56* 58 59* 60 69* 72* 74 77* 88* 90 91* 92 155* 157 161* 167 172* 174 182 190* 191 194* 195 195 199* 200 200 211* 212 error_table_$moderr 000010 external static fixed bin(35,0) dcl 123 ref 158 error_table_$noentry 000012 external static fixed bin(35,0) dcl 123 ref 167 expand_pathname_ 000014 constant entry external dcl 126 ref 51 59 fixed builtin function dcl 115 ref 172 172 get_pdir_ 000022 constant entry external dcl 126 ref 83 hcs_$append_branch 000030 constant entry external dcl 126 ref 172 hcs_$fs_get_path_name 000032 constant entry external dcl 126 ref 72 88 190 hcs_$fs_get_seg_ptr 000034 constant entry external dcl 126 ref 69 hcs_$initiate_count 000026 constant entry external dcl 126 ref 161 hcs_$make_ptr 000036 constant entry external dcl 126 ref 77 hcs_$set_bc 000042 constant entry external dcl 126 ref 194 hcs_$status_ 000024 constant entry external dcl 126 ref 155 hcs_$terminate_name 000040 constant entry external dcl 126 ref 91 hcs_$terminate_noname 000046 constant entry external dcl 126 ref 211 hcs_$truncate_seg 000044 constant entry external dcl 126 ref 199 len 000172 automatic fixed bin(17,0) dcl 145 set ref 56* 59 59 72* 88* 190* mod builtin function dcl 115 ref 201 201 mode 3 000101 automatic bit(5) level 2 packed unaligned dcl 1-2 set ref 158 null builtin function dcl 115 ref 70 79 155 155 164 181 null_string 000010 internal static char initial dcl 151 set ref 77* 77* 161* path_name parameter char unaligned dcl 99 set ref 50 51* path_name_arg based char unaligned dcl 99 set ref 59* prev_sp 20 based pointer level 2 dcl 2-36 ref 56 ref_name parameter char unaligned dcl 99 set ref 68 69* 77* 84 91* return_code parameter fixed bin(35,0) dcl 99 set ref 50 55 63 68 85* 95 96* 153* 158* 182* 195* 200* return_ptr parameter pointer dcl 99 set ref 50 55 63 68 161* 164 181* seg_ptr parameter pointer dcl 99 set ref 95 190* 199* 201 201 211* segment based bit(36) array dcl 99 set ref 201* 201 stack_frame based structure level 1 dcl 2-36 status_info_branch 000101 automatic structure level 1 packed unaligned dcl 1-2 set ref 155 155 substr builtin function dcl 115 ref 81 158 170 172 172 temp_ptr 000170 automatic pointer dcl 145 set ref 56* 59 69* 70 72* 77* 79 88* wanted_access parameter bit(6) dcl 99 ref 50 55 63 68 81 158 170 172 172 word_count 000100 automatic fixed bin(24,0) dcl 99 set ref 198* 199* 201 201 word_mask 000000 constant bit(36) initial array dcl 99 ref 201 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. RETURN_PTR_MASK internal static bit(72) initial unaligned dcl 2-19 TRANSLATOR_ID_ALM internal static bit(18) initial unaligned dcl 2-25 TRANSLATOR_ID_PL1V1 internal static bit(18) initial unaligned dcl 2-26 TRANSLATOR_ID_PL1V2 internal static bit(18) initial unaligned dcl 2-24 TRANSLATOR_ID_SIGNALLER internal static bit(18) initial unaligned dcl 2-28 TRANSLATOR_ID_SIGNAL_CALLER internal static bit(18) initial unaligned dcl 2-27 length builtin function dcl 115 sp automatic pointer dcl 2-31 stack_frame_flags based structure level 1 dcl 2-64 stack_frame_min_length internal static fixed bin(17,0) initial dcl 2-33 NAMES DECLARED BY EXPLICIT CONTEXT. common 000555 constant label dcl 153 ref 53 61 66 75 93 create 000713 constant label dcl 172 ref 86 create_seg 000705 constant label dcl 167 ref 157 error_return 000745 constant label dcl 179 ref 52 58 60 74 81 90 92 164 167 170 error_return_2 000750 constant label dcl 182 ref 191 212 get_seg_ptr_ 000027 constant entry external dcl 50 get_seg_ptr_arg_ 000110 constant entry external dcl 55 get_seg_ptr_full_path_ 000222 constant entry external dcl 63 get_seg_ptr_search_ 000271 constant entry external dcl 68 initiate_seg 000635 constant label dcl 161 ref 174 release 000753 constant label dcl 186 ref 97 release_seg_ptr_ 000541 constant entry external dcl 95 set_length 000755 constant label dcl 186 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1370 1440 1123 1400 Length 1712 1123 50 235 245 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME get_seg_ptr_ 236 external procedure is an external procedure. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 null_string get_seg_ptr_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME get_seg_ptr_ 000100 word_count get_seg_ptr_ 000101 status_info_branch get_seg_ptr_ 000105 error_code get_seg_ptr_ 000106 directory_name get_seg_ptr_ 000160 entry_name get_seg_ptr_ 000170 temp_ptr get_seg_ptr_ 000172 len get_seg_ptr_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return_mac mdfx1 ext_entry ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cu_$arg_ptr_rel cu_$stack_frame_ptr expand_pathname_ get_pdir_ hcs_$append_branch hcs_$fs_get_path_name hcs_$fs_get_seg_ptr hcs_$initiate_count hcs_$make_ptr hcs_$set_bc hcs_$status_ hcs_$terminate_name hcs_$terminate_noname hcs_$truncate_seg THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$moderr error_table_$noentry LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 50 000022 51 000053 52 000100 53 000102 55 000103 56 000126 58 000157 59 000161 60 000211 61 000213 63 000214 64 000253 65 000261 66 000266 68 000267 69 000315 70 000340 72 000344 74 000375 75 000377 77 000400 79 000432 81 000436 83 000441 84 000450 85 000456 86 000457 88 000460 90 000511 91 000513 92 000532 93 000534 95 000535 96 000553 97 000554 153 000555 155 000556 157 000620 158 000622 161 000635 164 000700 165 000704 167 000705 170 000710 172 000713 174 000743 179 000745 181 000746 182 000750 184 000752 186 000753 190 000755 191 001007 194 001011 195 001036 198 001041 199 001045 200 001061 201 001064 211 001104 212 001116 214 001120 ----------------------------------------------------------- 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