COMPILATION LISTING OF SEGMENT get_temp_seg_ 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.1 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 12 13 /****^ HISTORY COMMENTS: 14* 1) change(86-10-17,Margolin), approve(86-10-17,MCR7549), 15* audit(86-10-21,Lippard), install(86-10-30,MR12.0-1203): 16* Module moved to bound_teco_ without change, but the installation tools 17* demand a history comment. Better not to anger the gods. 18* END HISTORY COMMENTS */ 19 20 21 get_temp_seg_: procedure (a_id, a_acl, a_ptr, a_code); 22 23 /* This procedure manages scratch segments in the user's 24* process directory. It is absolutely immune to "quit"s 25* and other methods of getting unexpected recursion. That 26* is, one may quit out of get_temp_seg_, hold, and 27* then call get_temp_seg_ again without risk of using 28* the same segment twice. 29* */ 30 /* Last modified (Date and reason): 31* by RHG on 17 July 1971 to redefine calls to be more usable by recursive procedures 32* by Richard H. Gumpertz on 10 July 1971 for initial implementation 33* */ 34 /* */ 35 declare a_id bit (36) aligned, 36 a_acl bit (5) aligned, 37 a_ptr ptr, 38 a_code fixed bin (35); 39 40 declare name_buffer char (32) aligned, 41 name_len fixed bin, 42 name based (addr (name_buffer)) aligned char (name_len); 43 44 declare (i, j) fixed bin, 45 p pointer, 46 first_time bit (1) aligned init ("1"b) int static, 47 process_dir char (168) aligned int static, 48 error_code fixed bin(35), 49 error_code2 fixed bin(35), 50 id bit (36) aligned, 51 rings (3) fixed bin, 52 acl fixed bin (5); 53 54 declare (addr, bit, fixed, hbound, null, stac, substr, unspec) builtin; 55 56 declare temp_seg_list_ptr init (null) int static ptr, 57 1 temp_seg_list (0:4095) based (temp_seg_list_ptr) aligned, 58 2 temp_seg, 59 3 used bit (36) aligned, 60 3 acl fixed bin (5), 61 3 ptr ptr, 62 2 proc_id, 63 3 name char (32) aligned, 64 3 stack_ptr ptr, 65 3 count fixed bin, 66 3 used bit (36) aligned; 67 68 declare hcs_$make_seg entry (char(*) aligned, char(*) aligned, char(*) aligned, fixed bin (5), ptr, fixed bin(35)), 69 hcs_$add_acl_entries entry(char(*) aligned, char(*) aligned, ptr, fixed bin, fixed bin(35)), 70 hcs_$truncate_seg entry (ptr, fixed bin, fixed bin(35)), 71 cu_$level_get entry () returns (fixed bin), 72 cu_$stack_frame_ptr entry () returns (pointer), 73 get_group_id_$tag_star entry returns(char(32) aligned), 74 get_pdir_ entry () returns (char (168) aligned), 75 ioa_$rsnnl entry options (variable); 76 77 declare (error_table_$notalloc, error_table_$not_seg_type) external fixed bin(35); 78 79 declare 1 seg_acl aligned, 80 2 access_name char(32), 81 2 modes bit(36), 82 2 zero_pad bit(36), 83 2 error_code fixed bin(35); 84 /* */ 1 1 /* BEGIN INCLUDE FILE ... stack_frame.incl.pl1 ... */ 1 2 1 3 /* format: off */ 1 4 1 5 /* Modified: 16 Dec 1977, D. Levin - to add fio_ps_ptr and pl1_ps_ptr */ 1 6 /* Modified: 3 Feb 1978, P. Krupp - to add run_unit_manager bit & main_proc bit */ 1 7 /* Modified: 21 March 1978, D. Levin - change fio_ps_ptr to support_ptr */ 1 8 /* Modified: 03/01/84, S. Herbst - Added RETURN_PTR_MASK */ 1 9 1 10 1 11 /****^ HISTORY COMMENTS: 1 12* 1) change(86-09-15,Kissel), approve(86-09-15,MCR7473), 1 13* audit(86-10-01,Fawcett), install(86-11-03,MR12.0-1206): 1 14* Modified to add constants for the translator_id field in the stack_frame 1 15* structure. 1 16* END HISTORY COMMENTS */ 1 17 1 18 1 19 dcl RETURN_PTR_MASK bit (72) int static options (constant) /* mask to be AND'd with stack_frame.return_ptr */ 1 20 init ("777777777777777777000000"b3); /* when copying, to ignore bits that a call fills */ 1 21 /* with indicators (nonzero for Fortran hexfp caller) */ 1 22 /* say: unspec(ptr) = unspec(stack_frame.return_ptr) & RETURN_PTR_MASK; */ 1 23 1 24 dcl TRANSLATOR_ID_PL1V2 bit (18) internal static options (constant) init ("000000"b3); 1 25 dcl TRANSLATOR_ID_ALM bit (18) internal static options (constant) init ("000001"b3); 1 26 dcl TRANSLATOR_ID_PL1V1 bit (18) internal static options (constant) init ("000002"b3); 1 27 dcl TRANSLATOR_ID_SIGNAL_CALLER bit (18) internal static options (constant) init ("000003"b3); 1 28 dcl TRANSLATOR_ID_SIGNALLER bit (18) internal static options (constant) init ("000004"b3); 1 29 1 30 1 31 dcl sp pointer; /* pointer to beginning of stack frame */ 1 32 1 33 dcl stack_frame_min_length fixed bin static init(48); 1 34 1 35 1 36 dcl 1 stack_frame based(sp) aligned, 1 37 2 pointer_registers(0 : 7) ptr, 1 38 2 prev_sp pointer, 1 39 2 next_sp pointer, 1 40 2 return_ptr pointer, 1 41 2 entry_ptr pointer, 1 42 2 operator_and_lp_ptr ptr, /* serves as both */ 1 43 2 arg_ptr pointer, 1 44 2 static_ptr ptr unaligned, 1 45 2 support_ptr ptr unal, /* only used by fortran I/O */ 1 46 2 on_unit_relp1 bit(18) unaligned, 1 47 2 on_unit_relp2 bit(18) unaligned, 1 48 2 translator_id bit(18) unaligned, /* Translator ID (see constants above) 1 49* 0 => PL/I version II 1 50* 1 => ALM 1 51* 2 => PL/I version I 1 52* 3 => signal caller frame 1 53* 4 => signaller frame */ 1 54 2 operator_return_offset bit(18) unaligned, 1 55 2 x(0: 7) bit(18) unaligned, /* index registers */ 1 56 2 a bit(36), /* accumulator */ 1 57 2 q bit(36), /* q-register */ 1 58 2 e bit(36), /* exponent */ 1 59 2 timer bit(27) unaligned, /* timer */ 1 60 2 pad bit(6) unaligned, 1 61 2 ring_alarm_reg bit(3) unaligned; 1 62 1 63 1 64 dcl 1 stack_frame_flags based(sp) aligned, 1 65 2 pad(0 : 7) bit(72), /* skip over prs */ 1 66 2 xx0 bit(22) unal, 1 67 2 main_proc bit(1) unal, /* on if frame belongs to a main procedure */ 1 68 2 run_unit_manager bit(1) unal, /* on if frame belongs to run unit manager */ 1 69 2 signal bit(1) unal, /* on if frame belongs to logical signal_ */ 1 70 2 crawl_out bit(1) unal, /* on if this is a signal caller frame */ 1 71 2 signaller bit(1) unal, /* on if next frame is signaller's */ 1 72 2 link_trap bit(1) unal, /* on if this frame was made by the linker */ 1 73 2 support bit(1) unal, /* on if frame belongs to a support proc */ 1 74 2 condition bit(1) unal, /* on if condition established in this frame */ 1 75 2 xx0a bit(6) unal, 1 76 2 xx1 fixed bin, 1 77 2 xx2 fixed bin, 1 78 2 xx3 bit(25) unal, 1 79 2 old_crawl_out bit (1) unal, /* on if this is a signal caller frame */ 1 80 2 old_signaller bit(1) unal, /* on if next frame is signaller's */ 1 81 2 xx3a bit(9) unaligned, 1 82 2 xx4(9) bit(72) aligned, 1 83 2 v2_pl1_op_ret_base ptr, /* When a V2 PL/I program calls an operator the 1 84* * operator puts a pointer to the base of 1 85* * the calling procedure here. (text base ptr) */ 1 86 2 xx5 bit(72) aligned, 1 87 2 pl1_ps_ptr ptr; /* ptr to ps for this frame; also used by fio. */ 1 88 1 89 /* format: on */ 1 90 1 91 /* END INCLUDE FILE ... stack_frame.incl.pl1 */ 85 86 /* */ 87 /* get_temp_seg_: entry (a_id, a_acl, a_ptr, a_code); /* remember the proc statement above */ 88 acl = fixed (a_acl, 5); 89 id = a_id; 90 a_ptr = null; 91 92 if first_time then call init; 93 94 do i = 0 to hbound (temp_seg, 1); 95 check_new_seg: if i >= proc_id.count (0) then do; 96 proc_id.count (0) = proc_id.count (0) + 1; 97 goto check_new_seg; 98 end; 99 if stac (addr (temp_seg.used (i)), id) then do; 100 if unspec (temp_seg.ptr (i)) = ""b then /* get a segment if we don't already have one */ 101 do; 102 call ioa_$rsnnl ("temp_seg_.^d.^d", name_buffer, name_len, cu_$level_get(), (i)); 103 temp_seg.acl (i) = acl; 104 call hcs_$make_seg (process_dir, name, "", acl, p, error_code); 105 if p = null then goto error; 106 temp_seg.ptr (i) = p; 107 end; 108 else if acl ^= temp_seg.acl (i) then do; 109 call change_acl; 110 if error_code ^= 0 then goto error; 111 end; 112 a_ptr = temp_seg.ptr (i); 113 114 a_code = 0; 115 return; 116 end; 117 end; 118 119 a_code = error_table_$notalloc; 120 return; 121 /* */ 122 assign_temp_seg_id_: entry (a_proc_id, a_id, a_code); 123 124 declare a_proc_id char (*); 125 126 if first_time then call init; 127 128 do i = 1 to hbound (proc_id, 1); /* note that i = 0 is illegal */ 129 if stac (addr (proc_id.used (i)), "1"b) then 130 do; 131 proc_id.name (i) = a_proc_id; 132 proc_id.stack_ptr (i) = cu_$stack_frame_ptr () -> stack_frame.prev_sp; 133 a_id = bit (fixed (proc_id.count (i), 18), 18) || bit (fixed (i, 18)); 134 a_code = 0; 135 return; 136 end; 137 end; 138 139 a_code = error_table_$notalloc; 140 a_id = "1"b; /* just in case he uses it anyways */ 141 return; 142 /* */ 143 release_temp_seg_: entry (a_id, a_ptr, a_code); 144 145 if first_time then call init; 146 id = a_id; 147 if id = ""b then id = "1"b; 148 p = a_ptr; 149 150 do i = 0 to proc_id.count (0)+1; 151 if temp_seg.ptr (i) = p then /* release it if this is the one */ 152 do; 153 if temp_seg.used (i) = id then 154 do; 155 acl = 01011b; 156 if temp_seg.acl (i) ^= acl then do; 157 call change_acl; 158 if error_code ^= 0 then goto error; 159 end; 160 call hcs_$truncate_seg (p, 0, error_code); 161 if error_code ^= 0 then goto error; 162 temp_seg.used (i) = ""b; 163 end; 164 a_code = 0; 165 return; 166 end; 167 end; 168 169 a_code = error_table_$not_seg_type; 170 return; 171 /* */ 172 release_temp_segs_all_: entry (a_id, a_code); 173 174 a_code = 0; 175 id = a_id; 176 j = fixed (substr (id, 19, 18), 18); 177 if j = 0 then return; 178 if first_time then call init; 179 180 do i = 0 to proc_id.count (0)+1; 181 if temp_seg.used (i) = id then 182 do; 183 error_code, error_code2 = 0; 184 if unspec (temp_seg.ptr (i)) then do; 185 acl = 01011b; 186 if temp_seg.acl (i) ^= acl then call change_acl; 187 if error_code ^= 0 then a_code = error_code; 188 call hcs_$truncate_seg (temp_seg.ptr (i), 0, error_code2); 189 if error_code2 ^= 0 then if error_code = 0 then a_code = error_code2; 190 end; 191 if error_code = 0 then if error_code2 = 0 then temp_seg.used (i) = ""b; 192 end; 193 if a_code = 0 then if fixed (substr (id, 1, 18), 18) = proc_id.count (j) then do; 194 proc_id.count (j) = proc_id.count (j) + 1; 195 proc_id.used (j) = ""b; 196 end; 197 end; 198 return; 199 /* */ 200 list_temporary_segments: list_temp_segs: lts: entry; 201 202 declare none_used bit (1) aligned, 203 ioa_ external entry options (variable); 204 205 if first_time then call init; 206 207 none_used = "1"b; 208 do i = 0 to proc_id.count (0)+1; 209 if temp_seg.used (i) then /* print it only if it is in use */ 210 do; 211 if none_used then /* print the header the first time only */ 212 do; 213 call ioa_ ("name seg_ptr proc_id stack proc_name"); 214 none_used = "0"b; 215 end; 216 j = fixed (substr (temp_seg.used (i), 19, 18), 18); 217 call ioa_ ("temp_seg_.^d.^d ^p ^w ^p ^a", 218 cu_$level_get(), (i), temp_seg.ptr (i), temp_seg.used (i), 219 proc_id.stack_ptr (j), proc_id.name (j)); 220 end; 221 end; 222 223 if none_used then call ioa_ ("no temporary segments in use"); 224 return; 225 /* */ 226 init: proc; 227 process_dir = get_pdir_ (); 228 call ioa_$rsnnl ("temp_seg_.^d.list", name_buffer, name_len, cu_$level_get()); 229 call hcs_$make_seg (process_dir, name, "", 1011b, temp_seg_list_ptr, error_code); 230 if temp_seg_list_ptr = null then goto error; 231 proc_id.name (0) = "****no name given***"; 232 proc_id.stack_ptr (0) = null; 233 first_time = ""b; 234 end init; 235 236 237 238 239 240 change_acl: proc; 241 rings (1), rings (2), rings (3) = cu_$level_get (); 242 call ioa_$rsnnl ("temp_seg_.^d.^d", name_buffer, name_len, cu_$level_get(), (i)); 243 temp_seg.acl (i) = -1; /* just in case we get quit out of */ 244 seg_acl.access_name = get_group_id_$tag_star(); 245 seg_acl.modes = substr(bit(acl,5), 2, 3); 246 seg_acl.zero_pad = "0"b; 247 call hcs_$add_acl_entries(process_dir, name, addr(seg_acl), 1, error_code); 248 if error_code = 0 then temp_seg.acl (i) = acl; 249 end; 250 251 252 253 254 255 error: a_code = error_code; 256 return; 257 /* */ 258 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/86 1042.7 get_temp_seg_.pl1 >special_ldd>install>MR12.0-1206>get_temp_seg_.pl1 85 1 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. a_acl parameter bit(5) dcl 35 ref 21 88 a_code parameter fixed bin(35,0) dcl 35 set ref 21 114* 119* 122 134* 139* 143 164* 169* 172 174* 187* 189* 193 255* a_id parameter bit(36) dcl 35 set ref 21 89 122 133* 140* 143 146 172 175 a_proc_id parameter char unaligned dcl 124 ref 122 131 a_ptr parameter pointer dcl 35 set ref 21 90* 112* 143 148 access_name 000125 automatic char(32) level 2 dcl 79 set ref 244* acl 000124 automatic fixed bin(5,0) dcl 44 in procedure "get_temp_seg_" set ref 88* 103 104* 108 155* 156 185* 186 245 248 acl 1 based fixed bin(5,0) array level 3 in structure "temp_seg_list" dcl 56 in procedure "get_temp_seg_" set ref 103* 108 156 186 243* 248* addr builtin function dcl 54 ref 99 104 129 229 247 247 247 bit builtin function dcl 54 ref 133 133 245 count 16 based fixed bin(17,0) array level 3 dcl 56 set ref 95 96* 96 133 150 180 193 194* 194 208 cu_$level_get 000074 constant entry external dcl 68 ref 102 102 217 217 228 228 241 242 242 cu_$stack_frame_ptr 000076 constant entry external dcl 68 ref 132 error_code 000116 automatic fixed bin(35,0) dcl 44 set ref 104* 110 158 160* 161 183* 187 187 189 191 229* 247* 248 255 error_code2 000117 automatic fixed bin(35,0) dcl 44 set ref 183* 188* 189 189 191 error_table_$not_seg_type 000110 external static fixed bin(35,0) dcl 77 ref 169 error_table_$notalloc 000106 external static fixed bin(35,0) dcl 77 ref 119 139 first_time 000010 internal static bit(1) initial dcl 44 set ref 92 126 145 178 205 233* fixed builtin function dcl 54 ref 88 133 133 176 193 216 get_group_id_$tag_star 000100 constant entry external dcl 68 ref 244 get_pdir_ 000102 constant entry external dcl 68 ref 227 hbound builtin function dcl 54 ref 94 128 hcs_$add_acl_entries 000070 constant entry external dcl 68 ref 247 hcs_$make_seg 000066 constant entry external dcl 68 ref 104 229 hcs_$truncate_seg 000072 constant entry external dcl 68 ref 160 188 i 000111 automatic fixed bin(17,0) dcl 44 set ref 94* 95 99 100 102 103 106 108 112* 128* 129 131 132 133 133* 150* 151 153 156 162* 180* 181 184 186 188 191* 208* 209 216 217 217 217* 242 243 248 id 000120 automatic bit(36) dcl 44 set ref 89* 99 146* 147 147* 153 175* 176 181 193 ioa_ 000112 constant entry external dcl 202 ref 213 217 223 ioa_$rsnnl 000104 constant entry external dcl 68 ref 102 228 242 j 000112 automatic fixed bin(17,0) dcl 44 set ref 176* 177 193 194 194 195 216* 217 217 modes 10 000125 automatic bit(36) level 2 dcl 79 set ref 245* name 4 based char(32) array level 3 in structure "temp_seg_list" dcl 56 in procedure "get_temp_seg_" set ref 131* 217* 231* name based char dcl 40 in procedure "get_temp_seg_" set ref 104* 229* 247* name_buffer 000100 automatic char(32) dcl 40 set ref 102* 104 228* 229 242* 247 name_len 000110 automatic fixed bin(17,0) dcl 40 set ref 102* 104 104 228* 229 229 242* 247 247 none_used 000140 automatic bit(1) dcl 202 set ref 207* 211 214* 223 null builtin function dcl 54 ref 90 105 230 232 p 000114 automatic pointer dcl 44 set ref 104* 105 106 148* 151 160* prev_sp 20 based pointer level 2 dcl 1-36 ref 132 proc_id 4 based structure array level 2 dcl 56 set ref 128 process_dir 000011 internal static char(168) dcl 44 set ref 104* 227* 229* 247* ptr 2 based pointer array level 3 dcl 56 set ref 100 106* 112 151 184 188* 217* rings 000121 automatic fixed bin(17,0) array dcl 44 set ref 241* 241* 241* seg_acl 000125 automatic structure level 1 dcl 79 set ref 247 247 stac builtin function dcl 54 ref 99 129 stack_frame based structure level 1 dcl 1-36 stack_ptr 14 based pointer array level 3 dcl 56 set ref 132* 217* 232* substr builtin function dcl 54 ref 176 193 216 245 temp_seg based structure array level 2 dcl 56 set ref 94 temp_seg_list based structure array level 1 dcl 56 temp_seg_list_ptr 000064 internal static pointer initial dcl 56 set ref 94 95 96 96 99 100 103 106 108 112 128 129 131 132 133 150 151 153 156 162 180 181 184 186 188 191 193 194 194 195 208 209 216 217 217 217 217 229* 230 231 232 243 248 unspec builtin function dcl 54 ref 100 184 used based bit(36) array level 3 in structure "temp_seg_list" dcl 56 in procedure "get_temp_seg_" set ref 99 153 162* 181 191* 209 216 217* used 17 based bit(36) array level 3 in structure "temp_seg_list" dcl 56 in procedure "get_temp_seg_" set ref 129 195* zero_pad 11 000125 automatic bit(36) level 2 dcl 79 set ref 246* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. RETURN_PTR_MASK internal static bit(72) initial unaligned dcl 1-19 TRANSLATOR_ID_ALM internal static bit(18) initial unaligned dcl 1-25 TRANSLATOR_ID_PL1V1 internal static bit(18) initial unaligned dcl 1-26 TRANSLATOR_ID_PL1V2 internal static bit(18) initial unaligned dcl 1-24 TRANSLATOR_ID_SIGNALLER internal static bit(18) initial unaligned dcl 1-28 TRANSLATOR_ID_SIGNAL_CALLER internal static bit(18) initial unaligned dcl 1-27 sp automatic pointer dcl 1-31 stack_frame_flags based structure level 1 dcl 1-64 stack_frame_min_length internal static fixed bin(17,0) initial dcl 1-33 NAMES DECLARED BY EXPLICIT CONTEXT. assign_temp_seg_id_ 000325 constant entry external dcl 122 change_acl 001260 constant entry internal dcl 240 ref 109 157 186 check_new_seg 000127 constant label dcl 95 ref 97 error 001130 constant label dcl 255 ref 105 110 158 161 230 get_temp_seg_ 000075 constant entry external dcl 21 init 001133 constant entry internal dcl 226 ref 92 126 145 178 205 list_temp_segs 000745 constant entry external dcl 200 list_temporary_segments 000754 constant entry external dcl 200 lts 000736 constant entry external dcl 200 release_temp_seg_ 000450 constant entry external dcl 143 release_temp_segs_all_ 000572 constant entry external dcl 172 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1660 1774 1437 1670 Length 2246 1437 114 236 221 56 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME get_temp_seg_ 309 external procedure is an external procedure. init internal procedure shares stack frame of external procedure get_temp_seg_. change_acl internal procedure shares stack frame of external procedure get_temp_seg_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 first_time get_temp_seg_ 000011 process_dir get_temp_seg_ 000064 temp_seg_list_ptr get_temp_seg_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME get_temp_seg_ 000100 name_buffer get_temp_seg_ 000110 name_len get_temp_seg_ 000111 i get_temp_seg_ 000112 j get_temp_seg_ 000114 p get_temp_seg_ 000116 error_code get_temp_seg_ 000117 error_code2 get_temp_seg_ 000120 id get_temp_seg_ 000121 rings get_temp_seg_ 000124 acl get_temp_seg_ 000125 seg_acl get_temp_seg_ 000140 none_used get_temp_seg_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return_mac stac_mac ext_entry ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cu_$level_get cu_$stack_frame_ptr get_group_id_$tag_star get_pdir_ hcs_$add_acl_entries hcs_$make_seg hcs_$truncate_seg ioa_ ioa_$rsnnl THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$not_seg_type error_table_$notalloc LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 21 000070 88 000111 89 000114 90 000116 92 000120 94 000123 95 000127 96 000134 97 000135 99 000136 100 000146 102 000154 103 000217 104 000224 105 000263 106 000267 107 000274 108 000275 109 000300 110 000301 112 000303 114 000311 115 000312 117 000313 119 000315 120 000320 122 000321 126 000345 128 000351 129 000357 131 000371 132 000402 133 000416 134 000432 135 000433 137 000434 139 000436 140 000441 141 000443 143 000444 145 000464 146 000470 147 000472 148 000475 150 000500 151 000511 153 000521 155 000525 156 000527 157 000531 158 000532 160 000534 161 000550 162 000552 164 000556 165 000557 167 000560 169 000562 170 000565 172 000566 174 000604 175 000605 176 000607 177 000612 178 000614 180 000620 181 000631 183 000636 184 000640 185 000646 186 000650 187 000654 188 000657 189 000676 191 000704 193 000714 194 000730 195 000731 197 000732 198 000734 200 000735 205 000761 207 000765 208 000767 209 001001 211 001006 213 001010 214 001023 216 001024 217 001031 221 001107 223 001111 224 001127 255 001130 256 001132 226 001133 227 001134 228 001143 229 001201 230 001243 231 001250 232 001254 233 001256 234 001257 240 001260 241 001261 242 001274 243 001340 244 001347 245 001356 246 001366 247 001367 248 001427 249 001436 ----------------------------------------------------------- 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