COMPILATION LISTING OF SEGMENT archive_sort Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 07/26/84 1215.5 mst Thu 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 /* ARCHIVE_SORT - Archive Segment Sorting Program. 12* 9/21/69 - Noel I. Morris 13* Recoded in PL/1 - 1/23/70 14* Checking for format errors, more rational treatment of other errors, 15* list-insertion code re-arranged, C Garman, 6 Mar 1972. 16* modified by E Stone Jan 1974 to call new version of update_handler_ 17* Modified to call newer update_handler_ 03/29/79 by Steve Herbst 18* Modified to check for error_table_$no_move from hcs_$fs_move_seg 05/16/84 S. Herbst 19* 20* */ 21 22 archive_sort: as: proc; 23 24 dcl whoami char(16) aligned static init("archive_sort"); 25 26 dcl argptr ptr, /* pointer to argument */ 27 arglen fixed bin (17), /* character length of argument */ 28 argument char (arglen) based (argptr), /* template for argument */ 29 argno fixed bin (17), /* number of argument */ 30 (code, udh_code) fixed bin(35), /* error code */ 31 dir char (168) aligned, /* directory path name */ 32 arc_name char(40) aligned, /* Used to build "xx.archive" */ 33 arc_temp_name char(32) aligned init("as_temp_.archive"), 34 comment char(40) aligned, /* Variable for errors during move */ 35 err_str char(8) aligned, /* For specifying type of format error */ 36 c0 char(0) aligned, /* Null string */ 37 bitcnt fixed bin (24), /* archive segment bit count */ 38 stop fixed bin (19), /* length (in words) of archive segment */ 39 inptr ptr, /* pointer to archive segment */ 40 outptr ptr static init(null), /* pointer to temporary segment */ 41 clean fixed bin static init(0), /* flag indicating state of temp seg */ 42 max_entries fixed bin static init(1000), /* Size of arrays below */ 43 (p_array ptr, /* array of archive sub-file pointers */ 44 n_array fixed bin(18)) (0:999), /* array of archive sub-file lengths */ 45 nwords fixed bin(18), /* word count of archive sub-file */ 46 (dirp, entryp) ptr, /* Pointers to character strings */ 47 (p1, p2) ptr, /* temporary sorting pointers */ 48 in_sort fixed bin, /* Abandon sort if unnecessary */ 49 retry fixed bin, /* Counter for re-try of move */ 50 (i, j) fixed bin; /* sorting indices */ 51 52 dcl move_array(nwords) fixed bin(35) based; /* for PL/I based-array move */ 53 54 dcl expand_path_ ext entry (ptr, fixed bin, ptr, ptr, fixed bin(35)), 55 cu_$arg_ptr ext entry (fixed bin, ptr, fixed bin, fixed bin(35)), 56 cv_dec_check_ entry(char(*) aligned, fixed bin(35), fixed bin(18)), 57 hcs_$initiate_count entry(char(*) aligned, char(*) aligned, char(*) aligned, 58 fixed bin(24), fixed bin, ptr, fixed bin(35)), 59 hcs_$make_seg entry(char(*) aligned, char(*) aligned, char(*) aligned, 60 fixed bin, ptr, fixed bin(35)), 61 hcs_$set_bc_seg entry(ptr, fixed bin(24), fixed bin(35)), 62 hcs_$chname_seg entry(ptr, char(*) aligned, char(*) aligned, fixed bin(35)), 63 hcs_$fs_move_seg entry(ptr, ptr, fixed bin, fixed bin(35)), 64 hcs_$truncate_seg ext entry (ptr, fixed bin, fixed bin(35)), 65 hcs_$terminate_noname ext entry (ptr, fixed bin(35)), 66 update_handler_ entry (char(*) aligned, char(*) aligned, char(*) aligned, bit(36),bit(36),fixed bin(35)), 67 update_handler_$reprotect entry (char(*) aligned, char(*) aligned, bit(36),bit(36),fixed bin(35)), 68 (com_err_, ioa_$rsnnl) entry options(variable); 69 70 dcl cleanup condition; 71 72 dcl (addr, addrel, bin, divide, fixed, index, null, rel, substr) builtin; 73 74 dcl access_switches bit (36), /* returned by update_handler_: 75* BIT saying whether access was forced 76* BIT saying there already was such an ACL term */ 77 old_mode bit (36); /* previous mode if any */ 78 79 dcl (error_table_$entlong, 80 error_table_$moderr, 81 error_table_$no_move, 82 error_table_$noarg, 83 error_table_$segknown) fixed bin (35) ext; 84 85 dcl (archive_data_$ident, /* Magic numbers to verify "archive-ness" */ 86 archive_data_$fence) char(8) ext aligned; /* .. */ 87 88 declare 1 arc_head based aligned, /* archive header declaration */ 89 2 ident1 char (8), 90 2 historical char(4), 91 2 name char (32), 92 2 dtm char(16), 93 2 mode char(4), 94 2 dtu char (20), 95 2 bitcnt char (8), 96 2 ident2 char (8); 97 98 /* 99* Create the temporary segment. */ 100 101 if outptr = null 102 then do; 103 104 call hcs_$make_seg (c0, arc_temp_name, c0, 1011b, outptr, code); 105 if outptr = null 106 then do; 107 108 error_3: call com_err_ (code, whoami, "^R^a^B (in process directory)", arc_temp_name); 109 110 return; 111 112 end; 113 114 if code = error_table_$segknown /* Did segment exist before? */ 115 then go to unclean; /* Left dirty, truncate it */ 116 117 end; 118 119 else if clean ^= 0 120 then do; 121 122 unclean: call hcs_$truncate_seg(outptr, 0, code); 123 if code ^= 0 124 then go to error_3; 125 126 end; 127 128 clean = 0; /* Clear flag always */ 129 130 on cleanup call trunc_temp; 131 132 dirp = addr(dir); 133 entryp = addr(arc_name); 134 135 /* Pick up arguments to program. */ 136 137 argno = 1; /* Initialize argument number. */ 138 139 argument_loop: 140 call cu_$arg_ptr (argno, argptr, arglen, code); /* Grab pointer to argument. */ 141 if code ^= 0 142 then do; 143 144 if code = error_table_$noarg 145 then if argno ^= 1 146 then go to finish; 147 148 call com_err_(code, whoami); 149 150 go to finish; 151 152 end; 153 154 if arglen = 0 then go to exit; /* .. */ 155 156 /* Expand the path name. */ 157 158 call expand_path_(argptr, arglen, dirp, entryp, code); 159 if code ^= 0 then do; /* Expand the name. */ 160 error: call com_err_ (code, whoami, argument); 161 go to exit; 162 end; 163 164 substr(arc_name, 33, 8) = (8)" "; /* Set blanks after expanded name */ 165 166 if index(arc_name, ".archive ") = 0 /* Check for ".archive" provided */ 167 then do; /* Not provided, add it, check length */ 168 169 call ioa_$rsnnl("^a.archive", arc_name, nwords, arc_name); 170 if nwords >= 33 171 then do; 172 173 code = error_table_$entlong; 174 go to error; 175 176 end; 177 178 end; 179 180 /* Initiate and get the length of the archive file. */ 181 182 call hcs_$initiate_count (dir, arc_name, c0, bitcnt, 1, inptr, code); 183 if inptr = null /* Attempt to initiate the segment. */ 184 then do; 185 186 call com_err_(code, whoami, "^R^a>^a^B", dir, arc_name); 187 go to exit; 188 189 end; 190 191 stop = divide (bitcnt + 35, 36, 19, 0); /* Compute word count of segment. */ 192 if stop = 0 193 then do; 194 195 call com_err_(0, whoami, "^R^a>^a^B is empty.", dir, arc_name); 196 197 go to exit_1; 198 199 end; 200 201 202 203 /* 204* Examine the archive file and perform sort. */ 205 206 p1 = inptr; /* Set archive pointer to beginning of segment. */ 207 in_sort = 0; /* Initialize flag for file-already-sorted */ 208 209 do i = 0 by 1 while(fixed(rel(p1), 18) < stop); /* Set loop */ 210 211 if i = max_entries /* Check for end of loop */ 212 then do; 213 214 call com_err_(0, whoami, "More than ^d components in ^R^a>^a^B, ^a", 215 (max_entries), dir, arc_name, 216 "Archive not sorted."); 217 218 go to exit_1; /* Terminate the input seg */ 219 220 end; 221 222 if p1 -> arc_head.ident1 ^= archive_data_$ident /* Verify "archive-ness" of header */ 223 then do; 224 225 err_str = "head "; 226 227 fmt_err: call com_err_(0, whoami, "Archive format error (^aer) in component ^d: ^R^a>^a^B", 228 err_str, i + 1, dir, arc_name); 229 230 go to exit_1; /* Terminate the segment */ 231 232 end; 233 234 if p1 -> arc_head.ident2 ^= archive_data_$fence /* Check trailer */ 235 then do; 236 237 err_str = "trail "; 238 239 go to fmt_err; 240 241 end; 242 243 call cv_dec_check_(p1 -> arc_head.bitcnt, code, nwords); 244 /* Convert bit-count in header to binary value. */ 245 if code ^= 0 246 then do; 247 248 call com_err_(0, whoami, 249 "Non-numeric characters in bit-count for component ^R^a^B^/ ^R^a>^a^B, ^a", 250 p1 -> arc_head.name, dir, arc_name, 251 "Archive not sorted."); 252 253 go to exit_1; 254 255 end; 256 257 /* Following inner loop compares name of this component 258* with names of previously encountered components 259* in order to find the proper slot for the component. 260* Items are entered into the list in order, 261* higher-sequence items being pushed up on the fly until 262* the appropriate spot is found. 263* 264* Note that first time the loop code will not be executed, since 265* the first item is simultaneously 266* at the beginning and end of the list. 267* 268* */ 269 270 do j = i to 1 by -1; /* Search list, from high to low. */ 271 p2 = p_array (j-1); /* Get sub-file pointer. */ 272 273 /* Compare names. Note that ">=" is used, not ">", so that identical 274* entries (which really shouldn't ever be encountered) 275* will not be interchanged; they will always remain in the same relative order. */ 276 277 if p1 -> arc_head.name >= p2 -> arc_head.name 278 then go to end_loop; /* Insert new info into array */ 279 280 p_array (j) = p2; /* Current name less than current entry in list, */ 281 n_array (j) = n_array (j-1); /* move this entry up one position */ 282 283 end; 284 285 /* If we fall out of loop, current info goes in position 0 of arrays */ 286 287 end_loop: /* Come here to enter info into proper slot */ 288 if j = i /* If new entry at end of list, ie already in sequence */ 289 then in_sort = in_sort + 1; /* Increment flag */ 290 291 p_array (j) = p1; /* Place sub-file pointer into correct slot. */ 292 293 nwords = divide(nwords + 35, 36, 18, 0) + 25; /* Compute number of words in sub-file. */ 294 n_array (j) = nwords; /* Set sub-file length array. */ 295 296 p1 = addrel (p1, nwords); /* Step to next sub-file. */ 297 298 end; 299 300 /* 301* End of per-archive loop, list now in order for creation of sorted temporary */ 302 303 if in_sort = i /* If all array entries made at top */ 304 then go to exit_1; /* A sordid case, terminate, no message */ 305 306 stop = bin(rel(p1), 18); /* Re-calculate word-count */ 307 bitcnt = stop * 36; /* and bit-count */ 308 309 /* Copy each of the archive sub-files in correct order into the temporary segment. */ 310 311 clean = clean + 1; /* Dirty, dirty, dirty! */ 312 313 p1 = outptr; /* Now set pointer into output segment. */ 314 do j = 0 by 1 while(j ^= i); /* Process all sub-files. */ 315 nwords = n_array (j); /* Extract the word count. */ 316 p1 -> move_array = p_array(j) -> move_array; /* Copy the sub-file into temporary. */ 317 p1 = addrel (p1, nwords); /* Step the output pointer. */ 318 end; 319 320 321 /* Move the temporary back into the archive file. */ 322 323 retry = 0; /* Clear counter */ 324 325 try_move: 326 call hcs_$fs_move_seg (outptr, inptr, 1b, code); /* Move the temporary after truncating the original */ 327 if code ^= 0 328 then do; 329 330 if code = error_table_$moderr | code = error_table_$no_move /* no write on target? */ 331 then if retry = 0 /* Have we been here before? */ 332 then do; /* OK, try to change mode */ 333 334 call update_handler_(dir, arc_name, whoami, access_switches, old_mode, udh_code); 335 336 if udh_code = 0 /* Successful? */ 337 then do; 338 339 retry = retry + 1; /* Update counter */ 340 go to try_move; /* See if it works this time */ 341 342 end; 343 344 else if udh_code = 1 /* He answered "no" */ 345 then code = 0; /* Suppress part of diagnostic */ 346 else code = udh_code; /* Something else, tell him */ 347 348 go to set_com; /* Print error message */ 349 350 end; 351 352 else /* ! */ 353 set_com: comment = ""; 354 355 else comment = " Original may have been truncated. "; 356 357 call hcs_$set_bc_seg(outptr, bitcnt, udh_code); /* Make temporary copiable */ 358 call hcs_$chname_seg(outptr, arc_temp_name, arc_name, udh_code); 359 if udh_code = 0 360 then arc_temp_name = arc_name; /* Successful rename */ 361 362 outptr = null; /* Re-call makeseg next time. */ 363 364 call com_err_(code, whoami, "^R^a>^a^B not updated. ^/ ^a ^a^a", dir, arc_name, 365 comment, "Sorted version temporarily preserved in [pd]>", arc_temp_name); 366 367 go to finish; 368 369 end; 370 371 clean = 0; /* Successful fs_move call yields truncated seg */ 372 373 /* Reset the bit-count on the branch (really shouldn't have changed) */ 374 375 call hcs_$set_bc_seg(inptr, bitcnt, code); 376 377 if code ^= 0 378 then call com_err_(code, whoami, "^R^a>^a^B", dir, arc_name); 379 380 if retry ^= 0 381 then call update_handler_$reprotect(dir, arc_name, access_switches, old_mode, code); 382 383 exit_1: 384 call hcs_$terminate_noname (inptr, code); /* Terminate null reference name. */ 385 if code ^= 0 then 386 call com_err_ (code, whoami, "^R^a>^a^B", dir, arc_name); 387 388 /* Go back for more. */ 389 390 exit: 391 argno = argno + 1; /* Increment the argument number. */ 392 go to argument_loop; /* Back for more. */ 393 394 trunc_temp: proc; /* Cleanup procedure */ 395 396 if clean ^= 0 397 then call hcs_$truncate_seg(outptr, 0, (0)); /* Ignore error code */ 398 399 clean = 0; /* Clear flag, indicates truncated seg */ 400 401 end trunc_temp; 402 403 finish: 404 end archive_sort; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/26/84 1140.9 archive_sort.pl1 >special_ldd>on>07/26/84>archive_sort.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. access_switches 006136 automatic bit(36) unaligned dcl 74 set ref 334* 380* addr builtin function dcl 72 ref 132 133 addrel builtin function dcl 72 ref 296 317 arc_head based structure level 1 dcl 88 arc_name 000160 automatic char(40) dcl 26 set ref 133 164* 166 169* 169* 182* 186* 195* 214* 227* 248* 334* 358* 359 364* 377* 380* 385* arc_temp_name 000172 automatic char(32) initial dcl 26 set ref 26* 104* 108* 358* 359* 364* archive_data_$fence 000070 external static char(8) dcl 85 ref 234 archive_data_$ident 000066 external static char(8) dcl 85 ref 222 arglen 000102 automatic fixed bin(17,0) dcl 26 set ref 139* 154 158* 160 160 argno 000103 automatic fixed bin(17,0) dcl 26 set ref 137* 139* 144 390* 390 argptr 000100 automatic pointer dcl 26 set ref 139* 158* 160 argument based char unaligned dcl 26 set ref 160* bin builtin function dcl 72 ref 306 bitcnt 000216 automatic fixed bin(24,0) dcl 26 in procedure "as" set ref 182* 191 307* 357* 375* bitcnt 25 based char(8) level 2 in structure "arc_head" dcl 88 in procedure "as" set ref 243* c0 000216 automatic char dcl 26 set ref 104* 104* 182* clean 000016 internal static fixed bin(17,0) initial dcl 26 set ref 119 128* 311* 311 371* 396 399* cleanup 006130 stack reference condition dcl 70 ref 130 code 000104 automatic fixed bin(35,0) dcl 26 set ref 104* 108* 114 122* 123 139* 141 144 148* 158* 159 160* 173* 182* 186* 243* 245 325* 327 330 330 344* 346* 364* 375* 377 377* 380* 383* 385 385* com_err_ 000050 constant entry external dcl 54 ref 108 148 160 186 195 214 227 248 364 377 385 comment 000202 automatic char(40) dcl 26 set ref 352* 355* 364* cu_$arg_ptr 000022 constant entry external dcl 54 ref 139 cv_dec_check_ 000024 constant entry external dcl 54 ref 243 dir 000106 automatic char(168) dcl 26 set ref 132 182* 186* 195* 214* 227* 248* 334* 364* 377* 380* 385* dirp 006114 automatic pointer dcl 26 set ref 132* 158* divide builtin function dcl 72 ref 191 293 entryp 006116 automatic pointer dcl 26 set ref 133* 158* err_str 000214 automatic char(8) dcl 26 set ref 225* 227* 237* error_table_$entlong 000054 external static fixed bin(35,0) dcl 79 ref 173 error_table_$moderr 000056 external static fixed bin(35,0) dcl 79 ref 330 error_table_$no_move 000060 external static fixed bin(35,0) dcl 79 ref 330 error_table_$noarg 000062 external static fixed bin(35,0) dcl 79 ref 144 error_table_$segknown 000064 external static fixed bin(35,0) dcl 79 ref 114 expand_path_ 000020 constant entry external dcl 54 ref 158 fixed builtin function dcl 72 ref 209 hcs_$chname_seg 000034 constant entry external dcl 54 ref 358 hcs_$fs_move_seg 000036 constant entry external dcl 54 ref 325 hcs_$initiate_count 000026 constant entry external dcl 54 ref 182 hcs_$make_seg 000030 constant entry external dcl 54 ref 104 hcs_$set_bc_seg 000032 constant entry external dcl 54 ref 357 375 hcs_$terminate_noname 000042 constant entry external dcl 54 ref 383 hcs_$truncate_seg 000040 constant entry external dcl 54 ref 122 396 i 006126 automatic fixed bin(17,0) dcl 26 set ref 209* 211 227 270 287* 303 314 ident1 based char(8) level 2 dcl 88 ref 222 ident2 27 based char(8) level 2 dcl 88 ref 234 in_sort 006124 automatic fixed bin(17,0) dcl 26 set ref 207* 287* 287 303 index builtin function dcl 72 ref 166 inptr 000220 automatic pointer dcl 26 set ref 182* 183 206 325* 375* 383* ioa_$rsnnl 000052 constant entry external dcl 54 ref 169 j 006127 automatic fixed bin(17,0) dcl 26 set ref 270* 271 280 281 281* 287 291 294 314* 314* 315 316* max_entries constant fixed bin(17,0) initial dcl 26 ref 211 214 move_array based fixed bin(35,0) array dcl 52 set ref 316* 316 n_array 004142 automatic fixed bin(18,0) array dcl 26 set ref 281* 281 294* 315 name 3 based char(32) level 2 dcl 88 set ref 248* 277 277 null builtin function dcl 72 ref 101 105 183 362 nwords 006112 automatic fixed bin(18,0) dcl 26 set ref 169* 170 243* 293* 293 294 296 315* 316 317 old_mode 006137 automatic bit(36) unaligned dcl 74 set ref 334* 380* outptr 000014 internal static pointer initial dcl 26 set ref 101 104* 105 122* 313 325* 357* 358* 362* 396* p1 006120 automatic pointer dcl 26 set ref 206* 209 222 234 243 248 277 291 296* 296 306 313* 316 317* 317 p2 006122 automatic pointer dcl 26 set ref 271* 277 280 p_array 000222 automatic pointer array dcl 26 set ref 271 280* 291* 316 rel builtin function dcl 72 ref 209 306 retry 006125 automatic fixed bin(17,0) dcl 26 set ref 323* 330 339* 339 380 stop 000217 automatic fixed bin(19,0) dcl 26 set ref 191* 192 209 306* 307 substr builtin function dcl 72 set ref 164* udh_code 000105 automatic fixed bin(35,0) dcl 26 set ref 334* 336 344 346 357* 358* 359 update_handler_ 000044 constant entry external dcl 54 ref 334 update_handler_$reprotect 000046 constant entry external dcl 54 ref 380 whoami 000010 internal static char(16) initial dcl 24 set ref 108* 148* 160* 186* 195* 214* 227* 248* 334* 364* 377* 385* NAMES DECLARED BY EXPLICIT CONTEXT. archive_sort 000227 constant entry external dcl 22 argument_loop 000406 constant label dcl 139 ref 392 as 000217 constant entry external dcl 22 end_loop 001250 constant label dcl 287 ref 277 error 000473 constant label dcl 160 ref 174 error_3 000304 constant label dcl 108 ref 123 exit 001736 constant label dcl 390 ref 154 161 187 exit_1 001666 constant label dcl 383 ref 197 218 230 253 303 finish 001740 constant label dcl 403 ref 144 150 367 fmt_err 001045 constant label dcl 227 ref 239 set_com 001430 constant label dcl 352 ref 348 trunc_temp 001741 constant entry internal dcl 394 ref 130 try_move 001333 constant label dcl 325 ref 340 unclean 000343 constant label dcl 122 ref 114 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2236 2330 1764 2246 Length 2560 1764 72 213 251 10 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME as 3280 external procedure is an external procedure. on unit on line 130 80 on unit trunc_temp internal procedure shares stack frame of on unit on line 130. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 whoami as 000014 outptr as 000016 clean as STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME as 000100 argptr as 000102 arglen as 000103 argno as 000104 code as 000105 udh_code as 000106 dir as 000160 arc_name as 000172 arc_temp_name as 000202 comment as 000214 err_str as 000216 c0 as 000216 bitcnt as 000217 stop as 000220 inptr as 000222 p_array as 004142 n_array as 006112 nwords as 006114 dirp as 006116 entryp as 006120 p1 as 006122 p2 as 006124 in_sort as 006125 retry as 006126 i as 006127 j as 006136 access_switches as 006137 old_mode as THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return enable ext_entry int_entry set_cs_eis index_cs_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_ptr cv_dec_check_ expand_path_ hcs_$chname_seg hcs_$fs_move_seg hcs_$initiate_count hcs_$make_seg hcs_$set_bc_seg hcs_$terminate_noname hcs_$truncate_seg ioa_$rsnnl update_handler_ update_handler_$reprotect THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. archive_data_$fence archive_data_$ident error_table_$entlong error_table_$moderr error_table_$no_move error_table_$noarg error_table_$segknown LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 26 000211 22 000216 101 000235 104 000242 105 000277 108 000304 110 000334 114 000335 117 000340 119 000341 122 000343 123 000356 128 000360 130 000362 132 000400 133 000402 137 000404 139 000406 141 000423 144 000425 148 000433 150 000447 154 000450 158 000452 159 000471 160 000473 161 000517 164 000520 166 000522 169 000531 170 000562 173 000565 174 000570 182 000571 183 000634 186 000640 187 000675 191 000676 192 000702 195 000703 197 000743 206 000744 207 000746 209 000747 211 000755 214 000760 218 001031 222 001032 225 001043 227 001045 230 001115 234 001116 237 001125 239 001127 243 001130 245 001150 248 001152 253 001223 270 001224 271 001231 277 001234 280 001241 281 001242 283 001245 287 001250 291 001254 293 001257 294 001264 296 001266 298 001270 303 001272 306 001275 307 001277 311 001301 313 001303 314 001305 315 001311 316 001313 317 001325 318 001330 323 001332 325 001333 327 001352 330 001354 334 001363 336 001416 339 001420 340 001421 344 001422 346 001426 348 001427 352 001430 355 001434 357 001437 358 001452 359 001477 362 001504 364 001507 367 001560 371 001561 375 001563 377 001575 380 001634 383 001666 385 001677 390 001736 392 001737 403 001740 394 001741 396 001742 399 001761 401 001763 ----------------------------------------------------------- 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