COMPILATION LISTING OF SEGMENT fs_get_type_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 03/05/85 1059.3 mst Tue 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 /* fs_get_type_ -- for extended object support, determines type of object */ 11 /* BIM 830921 */ 12 /* format: style2,indcomtxt,idind30 */ 13 14 /*** * Modified 831022 BIM to return a link type instead of error_table_$link */ 15 /*** * Modified 831025 BIM to not chase links for delentry and chname. 16* Those entries call the $no_chase entrypoint here, as should 17* anything else that works on links. */ 18 /*** * Modified 840112 MAP for better member algorithm */ 19 /*** * Modified 840206 MAP to classify DM files when access to containing 20* dir is null. */ 21 22 fs_get_type_: 23 procedure (Dir_name, Entryname, Type, Code); 24 25 declare (Dir_name, Entryname, Type) char (*) parameter; 26 declare Code fixed bin (35) parameter; 27 28 declare suffix char (32) aligned; 29 declare (after, before, reverse) builtin; 30 31 /**** 32* First, check to see if the suffix is that of a reserved 33* "straight segment" or "straight directory". 34* 35* Then, try to find a suffix_XXX_$suffix_info for the suffix, 36* if any. 37* 38* Then, validate that. 39* 40* If it misses, classify as seg, dir, MSF, or DM file. */ 41 42 declare reserved_for_segments (60) char (32) aligned int static options (constant) init ( 43 /** */ 44 "absin", /** */ 45 "algol68", /** */ 46 "alm", /** */ 47 "apl", /** */ 48 "archive", /** */ 49 "basic", /** */ 50 "bcpl", /** */ 51 "bind", /** */ 52 "breaks", /** */ 53 "cds", /** */ 54 "cdt", /** */ 55 "chars", /** */ 56 "cmdb", /** */ 57 "cmdsm", /** */ 58 "cmf", /** */ 59 "cobol", /** */ 60 "code", /** */ 61 "dir_info", /** */ 62 "dsm", /** */ 63 "ec", /** */ 64 "fdocin", /** */ 65 "fdocout", /** */ 66 "fortran", /** */ 67 "gcos", /** */ 68 "gct", /** */ 69 "gdt", /** */ 70 "graphics", /** */ 71 "info", /** */ 72 "linus", /** */ 73 "lister", /** */ 74 "listform", /** */ 75 "listin", /** */ 76 "mail", /** */ 77 "map355", /** */ 78 "memo", /** */ 79 "pascal", /** */ 80 "pdt", /** */ 81 "pfd", /** */ 82 "pfl", /** */ 83 "pl1", /** */ 84 "pmf", /** */ 85 "probe", /** */ 86 "profile", /** */ 87 "qedx", /** */ 88 "rd", /** */ 89 "rdmec", /** */ 90 "rtdt", /** */ 91 "rtmf", /** */ 92 "runoff", /** */ 93 "runout", /** */ 94 "sat", /** */ 95 "sdmec", /** */ 96 "smf", /** */ 97 "symbols", /** */ 98 "table", /** */ 99 "ttf", /** */ 100 "ttt", /** */ 101 "value", /** */ 102 "volumes", /** */ 103 "wl" /** */ 104 ); 105 106 declare reserved_for_segments_and_msfs 107 (3) char (32) aligned int static options (constant) init ( 108 /** */ 109 "absout", /** */ 110 "compout", /** */ 111 "list" /** */ 112 ); 113 114 declare reserved_for_msfs (1) char (32) aligned int static options (constant) init ( 115 /** */ 116 "dict" /** */ 117 ); 118 119 declare reserved_for_directories (1) char (32) int aligned static options (constant) init ( 120 /** */ 121 "db" /** */ 122 ); 123 124 declare file_manager_$validate entry (char (*), char (*), fixed bin (35)); 125 declare hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), 126 fixed bin (35)); 127 declare status_minf_type fixed bin (2); 128 declare status_minf_bc fixed bin (24); 129 130 131 132 go to ENTRY_COMMON; 133 134 no_chase: 135 entry (Dir_name, Entryname, Type, Code); 136 137 call hcs_$status_minf (Dir_name, Entryname, (0), status_minf_type, (0), Code); 138 if Code ^= 0 139 then return; /* nothing else to say */ 140 if status_minf_type = 0 /** Link */ 141 then do; /* otherwise, fall through to ordinary stuff */ 142 Type = FS_OBJECT_TYPE_LINK; 143 Code = 0; 144 return; 145 end; 146 147 148 ENTRY_COMMON: 149 if index (Entryname, ".") > 0 150 then suffix = reverse (before (reverse (Entryname), ".")); 151 else suffix = ""; 152 Code = 0; 153 154 if suffix = "" 155 then call CLASSIFY_STANDARD_OBJECT; 156 else if member (suffix, reserved_for_segments) 157 then call CLASSIFY_AS_SEGMENT; 158 else if member (suffix, reserved_for_segments_and_msfs) 159 then call CLASSIFY_AS_SEGMENT_OR_MSF; 160 else if member (suffix, reserved_for_msfs) 161 then call CLASSIFY_AS_MSF; 162 else if member (suffix, reserved_for_directories) 163 then call CLASSIFY_AS_DIRECTORY; 164 else call CLASSIFY_HARD; 165 166 return; 167 168 169 170 CLASSIFY_STANDARD_OBJECT: 171 procedure; 172 declare error_table_$noentry fixed bin (35) ext static; 173 declare error_table_$incorrect_access fixed bin (35) ext static; 174 declare error_table_$no_info fixed bin (35) ext static; 175 declare t_code fixed bin (35); 176 177 call hcs_$status_minf (Dir_name, Entryname, (1 /* chase */), status_minf_type, status_minf_bc, Code); 178 179 if Code = error_table_$noentry 180 then do; /*** legitimize null links by turning off the chase switch */ 181 call hcs_$status_minf (Dir_name, Entryname, (0 /* no chase */), status_minf_type, status_minf_bc, 182 t_code); 183 if t_code = 0 184 then Code = 0; 185 end; 186 187 if Code = error_table_$incorrect_access | Code = error_table_$no_info 188 then do; 189 190 /**** This do group will be executed if the parent of an inner ring file 191* had null access for the caller; however, the inner ring file could 192* be a DM file and the caller could have access to it. Only file_manager_ 193* knows for sure... */ 194 195 call file_manager_$validate (Dir_name, Entryname, t_code); 196 if t_code = 0 197 then do; 198 Type = FS_OBJECT_TYPE_DM_FILE; 199 Code = 0; 200 return; 201 end; 202 end; 203 204 if Code ^= 0 205 then return; /* too bad */ 206 207 if status_minf_type = 0 /* null link. */ 208 then do; 209 Type = FS_OBJECT_TYPE_LINK; 210 return; 211 end; 212 213 /**** Segment or Dir/MSF */ 214 215 if status_minf_type = 1 /* seg */ 216 then do; 217 Type = FS_OBJECT_TYPE_SEGMENT; 218 return; 219 end; 220 221 /**** Dir or msf */ 222 223 if status_minf_bc = 0 224 then do; 225 Type = FS_OBJECT_TYPE_DIRECTORY; 226 return; 227 end; 228 229 call file_manager_$validate (Dir_name, Entryname, Code); 230 if Code = 0 231 then Type = FS_OBJECT_TYPE_DM_FILE; 232 else do; 233 Type = FS_OBJECT_TYPE_MSF; 234 Code = 0; 235 end; 236 return; 237 238 end CLASSIFY_STANDARD_OBJECT; 239 240 241 242 CLASSIFY_AS_SEGMENT: 243 procedure; 244 245 /**** This one has a suffix that should only be found on a segment. 246* If we were strict constructionists, we would only allow segments. 247* But we aren't, yet. */ 248 249 /**** Ditto for all of these. */ 250 251 CLASSIFY_AS_SEGMENT_OR_MSF: 252 CLASSIFY_AS_DIRECTORY: 253 CLASSIFY_AS_MSF: 254 entry; 255 256 call CLASSIFY_STANDARD_OBJECT; 257 return; 258 end CLASSIFY_AS_SEGMENT; 259 260 CLASSIFY_HARD: 261 procedure; 262 263 /**** Here for something with a suffix that was not filtered out. 264* We have no choice but to make_entry. */ 265 266 declare hcs_$make_entry entry (ptr, char (*), char (*), entry, fixed bin (35)); 267 declare si_entry_to_call entry (ptr) variable; 268 declare validate_entry_to_call entry (char (*), char (*), fixed bin (35)) variable; 269 declare code fixed bin (35); 270 declare 1 si aligned like suffix_info; 271 declare reference_name char (32); 272 273 reference_name = "suffix_" || rtrim (suffix) || "_"; 274 call hcs_$make_entry (codeptr (fs_get_type_), reference_name, "suffix_info", si_entry_to_call, code); 275 276 if code ^= 0 277 then do; 278 call CLASSIFY_STANDARD_OBJECT; /* nobody home */ 279 return; 280 end; 281 282 call hcs_$make_entry (codeptr (si_entry_to_call), reference_name, "validate", validate_entry_to_call, code); 283 if code = 0 284 then do; 285 call validate_entry_to_call (Dir_name, Entryname, code); 286 if code ^= 0 287 then do; 288 call CLASSIFY_STANDARD_OBJECT; 289 return; 290 end; 291 end; 292 293 294 /**** We found a suffix_info! */ 295 296 si.version = SUFFIX_INFO_VERSION_1; 297 call si_entry_to_call (addr (si)); 298 Type = si.type; 299 return; 300 end CLASSIFY_HARD; 301 302 303 304 member: 305 procedure (a_is_this_in, a_list) returns (bit (1) aligned); 306 307 declare a_is_this_in char (32) aligned; 308 declare a_list (*) char (32) aligned; 309 declare hx fixed bin unsigned; 310 declare is_this_in char (32) aligned; 311 declare lx fixed bin unsigned; 312 declare mx fixed bin unsigned; 313 declare list_size fixed bin; 314 declare listp ptr; 315 declare list (list_size) char (32) aligned based (listp); 316 declare hbound builtin; 317 318 list_size = dim (a_list, 1); 319 listp = addr (a_list); 320 is_this_in = a_is_this_in; 321 322 lx = lbound (list, 1); 323 hx = hbound (list, 1); 324 do while (lx <= hx); 325 mx = divide (lx + hx, 2, 17, 0); 326 if is_this_in = list (mx) 327 then return ("1"b); 328 else if is_this_in < list (mx) 329 then hx = mx - 1; 330 else lx = mx + 1; 331 end; 332 return ("0"b); 333 334 end member; 335 1 1 /* BEGIN INCLUDE FILE: suffix_info.incl.pl1 */ 1 2 /* format: style3,indcomtxt,idind30 */ 1 3 /**** Jay Pattin 2/13/83 1 4* M. Pandolf 1984.11.30 to set FS_OBJECT_TYPE_MSF to -multisegment_file 1 5* 1 6* The include file copy_flags.incl.pl1 must be included in any program using this include file. 1 7* 1 8* This structure is returned by the suffix_XXX_$suffix_info subroutines */ 1 9 1 10 declare suffix_info_ptr ptr; 1 11 1 12 declare 1 suffix_info aligned based (suffix_info_ptr), 1 13 2 version char (8), 1 14 2 type char (32) unaligned, 1 15 2 type_name char (32) unaligned, /* Singular name of the object type, e.g. "mailbox" */ 1 16 2 plural_name char (32) unaligned, /* Plural of above, e.g. "mailboxes" */ 1 17 2 flags unaligned, 1 18 3 standard_object bit (1) unaligned, /* ON if not an extended object (no suffix_XXX_) */ 1 19 3 extended_acl bit (1) unaligned, /* ON if uses extended ACLs, off if regular ACLs */ 1 20 3 has_switches bit (1) unaligned, /* ON if supports switches for objects */ 1 21 3 mbz1 bit (33) unaligned, 1 22 2 modes char (36), /* correspondence between bits and chars for extended modes */ 1 23 2 max_mode_len fixed bin, /* maximum number of modes on an object */ 1 24 2 num_ring_brackets fixed bin, /* number of ring brackets on object */ 1 25 2 copy_flags like copy_flags, /* See copy_flags.incl.pl1 */ 1 26 2 info_pathname char (168) unaligned; 1 27 /* pathname of info segment containing more info */ 1 28 1 29 declare SUFFIX_INFO_VERSION_1 char (8) static options (constant) init ("SUFFIX01"); 1 30 1 31 /* This information is returned by the suffix_XXX_$list_switches subroutines */ 1 32 1 33 declare switch_list_ptr ptr, 1 34 alloc_switch_count fixed bin, 1 35 alloc_switch_name_count fixed bin; 1 36 1 37 declare 1 switch_list aligned based (switch_list_ptr), 1 38 2 version char (8), /* SWITCH_LIST_VERSION_1 */ 1 39 2 switch_count fixed bin, /* total number of switches */ 1 40 2 switch_name_count fixed bin, /* total number of names */ 1 41 2 switches (alloc_switch_count refer (switch_list.switch_count)), 1 42 3 name_index fixed bin, /* index of first name for this switch */ 1 43 3 name_count fixed bin, /* number of names for this switch */ 1 44 3 default_value bit (1) aligned, /* default setting for this switch */ 1 45 3 mbz1 bit (36) aligned, /* reserved for future use */ 1 46 2 names (alloc_switch_name_count refer (switch_list.switch_name_count)) char (32); 1 47 1 48 declare SWITCH_LIST_VERSION_1 char (8) static options (constant) init ("SWLIST01"); 1 49 1 50 declare ( 1 51 FS_OBJECT_TYPE_SEGMENT init ("-segment"), 1 52 FS_OBJECT_TYPE_DIRECTORY init ("-directory"), 1 53 FS_OBJECT_TYPE_MSF init ("-multisegment_file"), 1 54 FS_OBJECT_TYPE_DM_FILE init ("-dm_file"), 1 55 FS_OBJECT_TYPE_LINK init ("-link") 1 56 ) char (32) unaligned int static options (constant); 1 57 1 58 /* END INCLUDE FILE: suffix_info.incl.pl1 */ 336 2 1 /* BEGIN INCLUDE FILE: copy_flags.incl.pl1 */ 2 2 2 3 /* Flags for attributes that should/may be copied by the copy_ subroutine. This include file is 2 4* required by suffix_info.incl.pl1 and copy_options.incl.pl1 2 5* 2 6* Jay Pattin 6/23/83 */ 2 7 2 8 declare 1 copy_flags aligned based, /* ON means that this attribute may be copied by copy_ */ 2 9 2 names bit (1) unaligned, 2 10 2 acl bit (1) unaligned, 2 11 2 ring_brackets bit (1) unaligned, 2 12 2 max_length bit (1) unaligned, 2 13 2 copy_switch bit (1) unaligned, 2 14 2 safety_switch bit (1) unaligned, 2 15 2 dumper_switches bit (1) unaligned, 2 16 2 entry_bound bit (1) unaligned, /* only for vanilla object segments */ 2 17 2 extend bit (1) unaligned, /* copy_ may append to end of existing object */ 2 18 2 update bit (1) unaligned, /* copy_ may replace contents of existing object */ 2 19 2 mbz bit (26) unaligned; 2 20 2 21 /* END INCLUDE FILE: copy_flags.incl.pl1 */ 337 338 end fs_get_type_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 03/05/85 1053.4 fs_get_type_.pl1 >special_ldd>online>6799>fs_get_type_.pl1 336 1 03/05/85 1050.6 suffix_info.incl.pl1 >special_ldd>online>6799>suffix_info.incl.pl1 337 2 10/14/83 1606.7 copy_flags.incl.pl1 >ldd>include>copy_flags.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. Code parameter fixed bin(35,0) dcl 26 set ref 22 134 137* 138 143* 152* 177* 179 183* 187 187 199* 204 229* 230 234* Dir_name parameter char unaligned dcl 25 set ref 22 134 137* 177* 181* 195* 229* 285* Entryname parameter char unaligned dcl 25 set ref 22 134 137* 148 148 177* 181* 195* 229* 285* FS_OBJECT_TYPE_DIRECTORY 000030 constant char(32) initial unaligned dcl 1-50 ref 225 FS_OBJECT_TYPE_DM_FILE 000010 constant char(32) initial unaligned dcl 1-50 ref 198 230 FS_OBJECT_TYPE_LINK 000000 constant char(32) initial unaligned dcl 1-50 ref 142 209 FS_OBJECT_TYPE_MSF 000020 constant char(32) initial unaligned dcl 1-50 ref 233 FS_OBJECT_TYPE_SEGMENT 000040 constant char(32) initial unaligned dcl 1-50 ref 217 SUFFIX_INFO_VERSION_1 000050 constant char(8) initial unaligned dcl 1-29 ref 296 Type parameter char unaligned dcl 25 set ref 22 134 142* 198* 209* 217* 225* 230* 233* 298* a_is_this_in parameter char(32) dcl 307 ref 304 320 a_list parameter char(32) array dcl 308 set ref 304 318 319 before builtin function dcl 29 ref 148 code 000146 automatic fixed bin(35,0) dcl 269 set ref 274* 276 282* 283 285* 286 copy_flags based structure level 1 dcl 2-8 error_table_$incorrect_access 000016 external static fixed bin(35,0) dcl 173 ref 187 error_table_$no_info 000020 external static fixed bin(35,0) dcl 174 ref 187 error_table_$noentry 000014 external static fixed bin(35,0) dcl 172 ref 179 file_manager_$validate 000010 constant entry external dcl 124 ref 195 229 hbound builtin function dcl 316 ref 323 hcs_$make_entry 000022 constant entry external dcl 266 ref 274 282 hcs_$status_minf 000012 constant entry external dcl 125 ref 137 177 181 hx 000306 automatic fixed bin(17,0) unsigned dcl 309 set ref 323* 324 325 328* is_this_in 000307 automatic char(32) dcl 310 set ref 320* 326 328 list based char(32) array dcl 315 ref 322 323 326 328 list_size 000321 automatic fixed bin(17,0) dcl 313 set ref 318* 323 listp 000322 automatic pointer dcl 314 set ref 319* 322 323 326 328 lx 000317 automatic fixed bin(17,0) unsigned dcl 311 set ref 322* 324 325 330* mx 000320 automatic fixed bin(17,0) unsigned dcl 312 set ref 325* 326 328 328 330 reference_name 000270 automatic char(32) unaligned dcl 271 set ref 273* 274* 282* reserved_for_directories 000052 constant char(32) initial array dcl 119 set ref 162* reserved_for_msfs 000062 constant char(32) initial array dcl 114 set ref 160* reserved_for_segments 000122 constant char(32) initial array dcl 42 set ref 156* reserved_for_segments_and_msfs 000072 constant char(32) initial array dcl 106 set ref 158* reverse builtin function dcl 29 ref 148 148 si 000147 automatic structure level 1 dcl 270 set ref 297 297 si_entry_to_call 000136 automatic entry variable dcl 267 set ref 274* 282 282 297 status_minf_bc 000111 automatic fixed bin(24,0) dcl 128 set ref 177* 181* 223 status_minf_type 000110 automatic fixed bin(2,0) dcl 127 set ref 137* 140 177* 181* 207 215 suffix 000100 automatic char(32) dcl 28 set ref 148* 151* 154 156* 158* 160* 162* 273 suffix_info based structure level 1 dcl 1-12 t_code 000120 automatic fixed bin(35,0) dcl 175 set ref 181* 183 195* 196 type 2 000147 automatic char(32) level 2 packed unaligned dcl 270 set ref 298 validate_entry_to_call 000142 automatic entry variable dcl 268 set ref 282* 285 version 000147 automatic char(8) level 2 dcl 270 set ref 296* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. SWITCH_LIST_VERSION_1 internal static char(8) initial unaligned dcl 1-48 after builtin function dcl 29 alloc_switch_count automatic fixed bin(17,0) dcl 1-33 alloc_switch_name_count automatic fixed bin(17,0) dcl 1-33 suffix_info_ptr automatic pointer dcl 1-10 switch_list based structure level 1 dcl 1-37 switch_list_ptr automatic pointer dcl 1-33 NAMES DECLARED BY EXPLICIT CONTEXT. CLASSIFY_AS_DIRECTORY 001656 constant entry internal dcl 251 ref 162 CLASSIFY_AS_MSF 001654 constant entry internal dcl 251 ref 160 CLASSIFY_AS_SEGMENT 001652 constant entry internal dcl 242 ref 156 CLASSIFY_AS_SEGMENT_OR_MSF 001660 constant entry internal dcl 251 ref 158 CLASSIFY_HARD 001663 constant entry internal dcl 260 ref 164 CLASSIFY_STANDARD_OBJECT 001401 constant entry internal dcl 170 ref 154 256 278 288 ENTRY_COMMON 001264 constant label dcl 148 ref 132 fs_get_type_ 001132 constant entry external dcl 22 ref 274 274 member 002076 constant entry internal dcl 304 ref 156 158 160 162 no_chase 001162 constant entry external dcl 134 NAMES DECLARED BY CONTEXT OR IMPLICATION. addr builtin function ref 297 297 319 codeptr builtin function ref 274 274 282 282 dim builtin function ref 318 divide builtin function ref 325 index builtin function ref 148 lbound builtin function ref 322 rtrim builtin function ref 273 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2364 2410 2253 2374 Length 2630 2253 24 204 111 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fs_get_type_ 307 external procedure is an external procedure. CLASSIFY_STANDARD_OBJECT internal procedure shares stack frame of external procedure fs_get_type_. CLASSIFY_AS_SEGMENT internal procedure shares stack frame of external procedure fs_get_type_. CLASSIFY_HARD internal procedure shares stack frame of external procedure fs_get_type_. member internal procedure shares stack frame of external procedure fs_get_type_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME fs_get_type_ 000100 suffix fs_get_type_ 000110 status_minf_type fs_get_type_ 000111 status_minf_bc fs_get_type_ 000120 t_code CLASSIFY_STANDARD_OBJECT 000136 si_entry_to_call CLASSIFY_HARD 000142 validate_entry_to_call CLASSIFY_HARD 000146 code CLASSIFY_HARD 000147 si CLASSIFY_HARD 000270 reference_name CLASSIFY_HARD 000306 hx member 000307 is_this_in member 000317 lx member 000320 mx member 000321 list_size member 000322 listp member THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_var_desc call_var call_ext_out_desc return shorten_stack ext_entry_desc reverse_cs set_cs_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. file_manager_$validate hcs_$make_entry hcs_$status_minf THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$incorrect_access error_table_$no_info error_table_$noentry LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 22 001125 132 001157 134 001160 137 001207 138 001250 140 001253 142 001255 143 001262 144 001263 148 001264 151 001324 152 001330 154 001331 156 001337 158 001347 160 001357 162 001367 164 001377 166 001400 170 001401 177 001402 179 001443 181 001450 183 001506 187 001512 195 001521 196 001542 198 001544 199 001552 200 001553 204 001554 207 001560 209 001562 210 001567 215 001570 217 001572 218 001577 223 001600 225 001602 226 001607 229 001610 230 001632 233 001643 234 001650 236 001651 242 001652 251 001653 256 001661 257 001662 260 001663 273 001664 274 001723 276 001763 278 001765 279 001766 282 001767 283 002024 285 002026 286 002050 288 002052 289 002053 296 002054 297 002057 298 002067 299 002075 304 002076 318 002102 319 002111 320 002114 322 002120 323 002122 324 002124 325 002127 326 002132 328 002146 330 002153 331 002156 332 002157 ----------------------------------------------------------- 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