COMPILATION LISTING OF SEGMENT convert_characters Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/04/82 1816.4 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 convert_characters: cvc: proc; 12 13 /* procedure to convert a predefined set of characters in a segment to a different set */ 14 15 /* Originally coded by E. Franklin 16* Recode for SSS by R. Mullen */ 17 18 dcl unique_chars_ entry (bit (*)) returns (char (15)); /* to make tempname */ 19 dcl establish_cleanup_proc_ entry (entry); /* remember to cleanup */ 20 dcl ioa_ ext entry options (variable); /* input output ascii */ 21 dcl com_err_ ext entry options (variable); 22 dcl cu_$arg_count ext entry (fixed bin); 23 dcl cu_$arg_ptr ext entry (fixed bin, ptr, fixed bin, fixed bin (35)); 24 dcl expand_path_ ext entry (ptr, fixed bin, ptr, ptr, fixed bin (35)); 25 dcl hcs_$terminate_noname ext entry (ptr, fixed bin (35)); 26 dcl hcs_$initiate_count ext entry (char (*) aligned, char (*) aligned, char (*) aligned, fixed bin (24), 27 fixed bin (12), ptr, fixed bin (35)); 28 dcl hcs_$make_seg entry (char (*) aligned, char (*) aligned, char (*) aligned, fixed bin, ptr, fixed bin (35)); 29 dcl hcs_$fs_move_seg entry (ptr, ptr, fixed bin (1), fixed bin (35)); 30 dcl hcs_$delentry_seg entry (ptr, fixed bin (35)); 31 dcl hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)); 32 33 dcl (inptr, tempptr, outptr) ptr init (null); /* point to segs to be dealt with */ 34 dcl fs_flag bit (1) aligned init ("0"b); /* 1 => setting from_string */ 35 dcl string char (charnum) based; 36 dcl (bcd_flag, dart_flag, uc_flag, lc_flag, mult_flag, sp_flag) bit (1) unaligned init ("0"b); 37 dcl ts_flag bit (1) aligned init ("0"b); /* 1 => setting to_string */ 38 dcl procname char (18) aligned init ("convert_characters"); 39 dcl tempname char (24) aligned; /* name of seg in process dir */ 40 dcl max_nargs fixed bin init (3); /* will be set to two for some entrys */ 41 42 dcl (from_string, to_string) char (128) varying aligned init (""); /* define the conversion */ 43 dcl (static_from_string, static_to_string) char (128) varying aligned /* define the default conversion */ 44 internal static init (""); 45 46 dcl (code, bcode) fixed bin (35); /* status codes */ 47 dcl (error_table_$action_not_performed, /* to make sure user knows */ 48 error_table_$noarg, 49 error_table_$too_many_args) 50 fixed bin (35) external static; 51 52 dcl argptr pointer; /* will point to last arg picked up */ 53 dcl (arglen, nargs) fixed bin (17); 54 55 dcl aa char (4) aligned; /* aligned arg */ 56 dcl argbuf char (arglen) based (argptr); /* the last arg picked up */ 57 58 dcl dir char (168) aligned; /* dirname for last patharg picked up */ 59 dcl entry char (32) aligned; /* ename for same */ 60 dcl btcnt fixed bin (24); /* bit count */ 61 62 dcl (i, j) fixed bin (24); 63 dcl charnum fixed bin (24); /* num of chars in seg being converted */ 64 65 66 dcl (addr, addrel, divide, length, min, null, ptr, substr, translate) builtin; /* pawns */ 67 68 69 /* This entry converts from one user specified string to another */ 70 71 call cu_$arg_count (nargs); 72 call cu_$arg_ptr (1, argptr, arglen, code); 73 if code ^= 0 then go to error; 74 aa = argbuf; 75 if aa = "sp" then go to special; 76 else if aa = "bcd" then go to convert_bcd; 77 else if aa = "dart" then go to convert_dartmouth; 78 else if aa = "mp" then go to convert_multics_pl1; 79 else if aa = "uc" then go to convert_upper_case; 80 else if aa = "lc" then go to convert_lower_case; 81 else if aa = "to" then go to convert_to; 82 else if aa = "from" then go to convert_from; 83 else do; 84 call com_err_ (0, procname, "Unrecognized key - ^a", argptr -> argbuf); 85 return; 86 end; 87 special: 88 sp_flag = "1"b; 89 from_string = static_from_string; /* it uses internal static strings */ 90 to_string = static_to_string; /* to define the conversion */ 91 if nargs = 1 then go to print_strings; /* no problem even if int static strings were not set */ 92 if static_from_string = "" then if static_to_string = "" then do; /* complain */ 93 code = error_table_$action_not_performed; 94 call com_err_ (code, procname, "^/First use convert_from and convert_to to specify conversion."); 95 return; 96 end; 97 go to got_nargs; /* if one string is "" then the strings will be unequal below */ 98 99 /* This entry converts bcd special characters to corresponding ascii/ebcdic ones */ 100 101 convert_bcd: 102 bcd_flag = "1"b; 103 from_string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ%<#&"; 104 to_string = "abcdefghijklmnopqrstuvwxyz()=+"; 105 go to start; 106 107 108 convert_dartmouth: 109 dart_flag = "1"b; 110 from_string = "^_>+='{""?"; 111 to_string = "'=""<>:+?!"; 112 go to start; 113 114 /* This entry converts all lower case letters to upper case */ 115 116 convert_upper_case: 117 uc_flag = "1"b; 118 from_string = "abcdefghijklmnopqrstuvwxyz"; 119 to_string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 120 go to start; 121 122 /* This entry converts all upper case letters to lower case. */ 123 124 convert_lower_case: 125 lc_flag = "1"b; 126 from_string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 127 to_string = "abcdefghijklmnopqrstuvwxyz"; 128 go to start; 129 130 /* This entry converts from multics pl1 format to 360 pl1 format */ 131 132 convert_multics_pl1: 133 mult_flag = "1"b; 134 from_string = "abcdefghijklmnopqrstuvwxyz """; 135 to_string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ '"; 136 go to start; 137 138 139 /* The above entries all have max_nargs set to 3. 140* If no nore args are given the appropriate from_string and to_string will be printed. 141* If one or two more args are given the first is the pathname of the segment to be converted. 142* If one more arg is given the converted copy will replace the original. 143* If two more args are given then the converted copy will be placed in arg2. 144* 145* The entries below set max_nargs to 2. 146* Only one more arg may be given, either the from_string or the to_string. 147* */ 148 149 /* This entry causes from string to be reset */ 150 151 convert_from: 152 fs_flag = "1"b; 153 max_nargs = 2;go to start; 154 155 /* This entry causes to string to be reset */ 156 157 convert_to: 158 ts_flag = "1"b; 159 max_nargs = 2;go to start; 160 161 /* The body of the command starts here. */ 162 start: /* all keys come here except "sp" */ 163 if nargs = 1 then do; 164 if max_nargs = 3 then go to print_strings; /* automatic copies have been set */ 165 else do; /* should have gotten a string to set */ 166 code = error_table_$noarg; /* set up status code */ 167 error: call com_err_ (code, procname); /* come here if nothing to say besides code */ 168 go to RETURN; /* go through cleanup */ 169 end; 170 end; 171 172 got_nargs: if nargs > max_nargs then do; /* here if nargs ^= 0 */ 173 code = error_table_$too_many_args; /* set status code */ 174 go to error; /* and print a simple message */ 175 end; 176 177 call cu_$arg_ptr (2, argptr, arglen, code); /* get ptr to arg we know is there */ 178 if code ^= 0 then go to error; /* suprise */ 179 180 if max_nargs = 2 then do; /* setting a string */ 181 if arglen > 128 then do; /* cmust not be too long */ 182 call com_err_ (0, procname, "The string length (^d) exceeds 128 characters.", arglen); 183 return; /* nothing to clean up */ 184 end; 185 if fs_flag then static_from_string = argbuf; /* copy arg to proper */ 186 else if ts_flag then static_to_string = argbuf; /* internal static string */ 187 return; /* and just return */ 188 end; 189 190 if sp_flag & length (from_string) ^= length (to_string) then do; /* be sensible */ 191 code = error_table_$action_not_performed; /* let user know nothing happened */ 192 call com_err_ (code, procname, "^/Length of from_string (^d) is not equal to length of to_string (^d).", 193 length (from_string), length (to_string)); /* give useful information */ 194 return; /* and give up */ 195 end; 196 call expand_path_ (argptr, arglen, addr (dir), addr (entry), code); /* get absolute pathname */ 197 if code ^= 0 then do; /* can't */ 198 error_tell_arg: call com_err_ (code, procname, argptr -> argbuf); /* here to tell user which arg loses */ 199 go to RETURN; /* go through cleanup */ 200 end; 201 202 call establish_cleanup_proc_ (cleanup); /* dont leave a mess in any case */ 203 204 call hcs_$initiate_count (dir, entry, "", btcnt, 1, inptr, code); /* get ptr to seg to be converted */ 205 if inptr = null then do; /* could not initiate if */ 206 error_tell_dirent: call com_err_ (code, procname, "^a>^a", dir, entry); /* here to tell losing pathname */ 207 go to RETURN; /* go though cleanup */ 208 end; 209 charnum = divide (btcnt+8, 9, 24, 0); /* compute number of characters */ 210 211 tempname = "cvc_temp." || unique_chars_ ("0"b); /* name for temp seg is reasonable & unique */ 212 call hcs_$make_seg ("", tempname, "", 1011b, tempptr, code); /* create a temporary seg */ 213 if tempptr = null then do; /* could not create it */ 214 call com_err_ (code, procname, /* tell user what happened */ 215 "Unable to create ^a in process directory.", tempname); /* and why */ 216 go to RETURN; /* go through cleanup */ 217 end; 218 219 if nargs = 3 then do; /* don't write back into original seg */ 220 call cu_$arg_ptr (3, argptr, arglen, code); /* get name of output seg */ 221 if code ^= 0 then go to error; /* give simple message and return */ 222 call expand_path_ (argptr, arglen, addr (dir), addr (entry), code); /* convert arg to abs path */ 223 if code ^= 0 then go to error_tell_arg; /* print errmessage, which arg lost, and return */ 224 call hcs_$make_seg (dir, entry, "", 1011b, outptr, code); /* create output seg if does not exist */ 225 if outptr = null then go to error_tell_dirent; /* tell dir and entry since we know which */ 226 end; 227 else outptr = inptr; /* modify original seg */ 228 229 /* Here we do conversion. to take advantage of EIS we convert large 230*blocks at a time. To take advantage of the MVT instruction we must 231*use constants in the translate builtin. */ 232 do j = 1 to charnum by 16384; 233 i = min (16384, charnum-j+1); 234 235 if bcd_flag then 236 substr (tempptr -> string, 1, i) = translate 237 (substr (inptr -> string, 1, i), "abcdefghijklmnopqrstuvwxyz()=+", "ABCDEFGHIJKLMNOPQRSTUVWXYZ%<#&"); 238 else if dart_flag then 239 substr (tempptr -> string, 1, i) = translate 240 (substr (inptr -> string, 1, i), "^_>+='{""?", "'=""<>:+?!"); 241 else if lc_flag then 242 substr (tempptr -> string, 1, i) = translate 243 (substr (inptr -> string, 1, i), "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); 244 else if uc_flag then 245 substr (tempptr -> string, 1, i) = translate 246 (substr (inptr -> string, 1, i), "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz"); 247 else if mult_flag then 248 substr (tempptr -> string, 1, i) = translate 249 (substr (inptr -> string, 1, i), "abcdefghijklmnopqrstuvwxyz """, "ABCDEFGHIJKLMNOPQRSTUVWXYZ '"); 250 else if sp_flag then 251 substr (tempptr -> string, 1, i) = translate 252 (substr (inptr -> string, 1, i), to_string, from_string); 253 tempptr = addrel (tempptr, 4096); 254 inptr = addrel (inptr, 4096); 255 end; 256 call hcs_$set_bc_seg (tempptr, 9*charnum, bcode); /* in case of trouble later */ 257 258 tempptr = ptr (tempptr, 0); 259 call hcs_$fs_move_seg (tempptr, outptr, 1, code); /* truncate out seg, copy temp, trunc temp */ 260 if code ^= 0 then do; /* somehow failed */ 261 tempptr = null; /* so we won't delete temp */ 262 call com_err_ (code, procname, "^/Converted copy ^a is in process directory.", tempname); /* tell user all is not lost */ 263 if bcode ^= 0 then call com_err_ (bcode, procname, tempname); /* warn if bcnt not set on temp */ 264 go to RETURN; /* cleanup and leave */ 265 end; 266 267 if outptr ^= inptr then do; /* if same following steps not needed */ 268 call hcs_$set_bc_seg (outptr, 9*charnum, code); /* set btcnt on output seg */ 269 if code ^= 0 then go to error_tell_dirent; /* could not set btcnt, tell user the segments name */ 270 end; 271 272 RETURN: /* come here to exit if anything to cleanup */ 273 call cleanup; /* use handy internal proc */ 274 275 return; /* now we can return */ 276 print_strings: /* here to print strings */ 277 call ioa_ ("From string = ""^a""", from_string); /* first one */ 278 call ioa_ (" To string = ""^a""^/", to_string); /* then other */ 279 return; /* and all is done */ 280 281 /* --------------------------------------------------------------------------- */ 282 283 cleanup: proc; 284 if tempptr ^= null then call hcs_$delentry_seg (tempptr, code); /* delete temp seg */ 285 if outptr ^= null then if inptr ^= outptr then call hcs_$terminate_noname (outptr, code); 286 if inptr ^= null then call hcs_$terminate_noname (inptr, code); /* & terminate others */ 287 end cleanup; 288 end convert_characters; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/82 1627.6 convert_characters.pl1 >dumps>old>recomp>convert_characters.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. aa 000242 automatic char(4) dcl 55 set ref 74* 75 76 77 78 79 80 81 82 addr builtin function dcl 66 ref 196 196 196 196 222 222 222 222 addrel builtin function dcl 66 ref 253 254 argbuf based char unaligned dcl 56 set ref 74 84* 185 186 198* arglen 000240 automatic fixed bin(17,0) dcl 53 set ref 72* 74 84 84 177* 181 182* 185 186 196* 198 198 220* 222* argptr 000236 automatic pointer dcl 52 set ref 72* 74 84 177* 185 186 196* 198 220* 222* bcd_flag 000107 automatic bit(1) initial unaligned dcl 36 set ref 36* 101* 235 bcode 000235 automatic fixed bin(35,0) dcl 46 set ref 256* 263 263* btcnt 000325 automatic fixed bin(24,0) dcl 60 set ref 204* 209 charnum 000330 automatic fixed bin(24,0) dcl 63 set ref 209* 232 233 235 235 238 238 241 241 244 244 247 247 250 250 256 268 code 000234 automatic fixed bin(35,0) dcl 46 set ref 72* 73 93* 94* 166* 167* 173* 177* 178 191* 192* 196* 197 198* 204* 206* 212* 214* 220* 221 222* 223 224* 259* 260 262* 268* 269 284* 285* 286* com_err_ 000120 constant entry external dcl 21 ref 84 94 167 182 192 198 206 214 262 263 cu_$arg_count 000122 constant entry external dcl 22 ref 71 cu_$arg_ptr 000124 constant entry external dcl 23 ref 72 177 220 dart_flag 000110 automatic bit(1) initial unaligned dcl 36 set ref 36* 108* 238 dir 000243 automatic char(168) dcl 58 set ref 196 196 204* 206* 222 222 224* divide builtin function dcl 66 ref 209 entry 000315 automatic char(32) dcl 59 set ref 196 196 204* 206* 222 222 224* error_table_$action_not_performed 000144 external static fixed bin(35,0) dcl 47 ref 93 191 error_table_$noarg 000146 external static fixed bin(35,0) dcl 47 ref 166 error_table_$too_many_args 000150 external static fixed bin(35,0) dcl 47 ref 173 establish_cleanup_proc_ 000114 constant entry external dcl 19 ref 202 expand_path_ 000126 constant entry external dcl 24 ref 196 222 from_string 000132 automatic varying char(128) initial dcl 42 set ref 42* 89* 103* 110* 118* 126* 134* 190 192 192 250 276* fs_flag 000106 automatic bit(1) initial dcl 34 set ref 34* 151* 185 hcs_$delentry_seg 000140 constant entry external dcl 30 ref 284 hcs_$fs_move_seg 000136 constant entry external dcl 29 ref 259 hcs_$initiate_count 000132 constant entry external dcl 26 ref 204 hcs_$make_seg 000134 constant entry external dcl 28 ref 212 224 hcs_$set_bc_seg 000142 constant entry external dcl 31 ref 256 268 hcs_$terminate_noname 000130 constant entry external dcl 25 ref 285 286 i 000326 automatic fixed bin(24,0) dcl 62 set ref 233* 235 235 238 238 241 241 244 244 247 247 250 250 inptr 000100 automatic pointer initial dcl 33 set ref 33* 204* 205 227 235 238 241 244 247 250 254* 254 267 285 286 286* ioa_ 000116 constant entry external dcl 20 ref 276 278 j 000327 automatic fixed bin(24,0) dcl 62 set ref 232* 233* lc_flag 000112 automatic bit(1) initial unaligned dcl 36 set ref 36* 124* 241 length builtin function dcl 66 ref 190 190 192 192 192 192 max_nargs 000131 automatic fixed bin(17,0) initial dcl 40 set ref 40* 153* 159* 164 172 180 min builtin function dcl 66 ref 233 mult_flag 000113 automatic bit(1) initial unaligned dcl 36 set ref 36* 132* 247 nargs 000241 automatic fixed bin(17,0) dcl 53 set ref 71* 91 162 172 219 null builtin function dcl 66 ref 33 33 33 205 213 225 261 284 285 286 outptr 000104 automatic pointer initial dcl 33 set ref 33* 224* 225 227* 259* 267 268* 285 285 285* procname 000116 automatic char(18) initial dcl 38 set ref 38* 84* 94* 167* 182* 192* 198* 206* 214* 262* 263* ptr builtin function dcl 66 ref 258 sp_flag 000114 automatic bit(1) initial unaligned dcl 36 set ref 36* 87* 190 250 static_from_string 000010 internal static varying char(128) initial dcl 43 set ref 89 92 185* static_to_string 000051 internal static varying char(128) initial dcl 43 set ref 90 92 186* string based char unaligned dcl 35 set ref 235* 235 238* 238 241* 241 244* 244 247* 247 250* 250 substr builtin function dcl 66 set ref 235* 235 238* 238 241* 241 244* 244 247* 247 250* 250 tempname 000123 automatic char(24) dcl 39 set ref 211* 212* 214* 262* 263* tempptr 000102 automatic pointer initial dcl 33 set ref 33* 212* 213 235 238 241 244 247 250 253* 253 256* 258* 258 259* 261* 284 284* to_string 000173 automatic varying char(128) initial dcl 42 set ref 42* 90* 104* 111* 119* 127* 135* 190 192 192 250 278* translate builtin function dcl 66 ref 235 238 241 244 247 250 ts_flag 000115 automatic bit(1) initial dcl 37 set ref 37* 157* 186 uc_flag 000111 automatic bit(1) initial unaligned dcl 36 set ref 36* 116* 244 unique_chars_ 000112 constant entry external dcl 18 ref 211 NAMES DECLARED BY EXPLICIT CONTEXT. RETURN 002033 constant label dcl 272 ref 168 199 207 216 264 cleanup 002105 constant entry internal dcl 283 ref 202 202 272 convert_bcd 000541 constant label dcl 101 set ref 76 convert_characters 000314 constant entry external dcl 11 convert_dartmouth 000555 constant label dcl 108 ref 77 convert_from 000635 constant label dcl 151 ref 82 convert_lower_case 000605 constant label dcl 124 set ref 80 convert_multics_pl1 000621 constant label dcl 132 ref 78 convert_to 000642 constant label dcl 157 ref 81 convert_upper_case 000571 constant label dcl 116 ref 79 cvc 000304 constant entry external dcl 11 error 000660 constant label dcl 167 ref 73 174 178 221 error_tell_arg 001106 constant label dcl 198 ref 223 error_tell_dirent 001214 constant label dcl 206 ref 225 269 got_nargs 000676 constant label dcl 172 ref 97 print_strings 002040 constant label dcl 276 ref 91 164 special 000460 constant label dcl 87 ref 75 start 000647 constant label dcl 162 ref 105 112 120 128 136 153 159 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3610 3762 3370 3620 Length 4176 3370 152 177 220 102 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cvc 324 external procedure is an external procedure. cleanup 70 internal procedure is assigned to an entry variable. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 static_from_string cvc 000051 static_to_string cvc STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cvc 000100 inptr cvc 000102 tempptr cvc 000104 outptr cvc 000106 fs_flag cvc 000107 bcd_flag cvc 000110 dart_flag cvc 000111 uc_flag cvc 000112 lc_flag cvc 000113 mult_flag cvc 000114 sp_flag cvc 000115 ts_flag cvc 000116 procname cvc 000123 tempname cvc 000131 max_nargs cvc 000132 from_string cvc 000173 to_string cvc 000234 code cvc 000235 bcode cvc 000236 argptr cvc 000240 arglen cvc 000241 nargs cvc 000242 aa cvc 000243 dir cvc 000315 entry cvc 000325 btcnt cvc 000326 i cvc 000327 j cvc 000330 charnum cvc THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs call_ext_out_desc call_ext_out call_int_this return shorten_stack ext_entry int_entry set_cs_eis translate_3 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr establish_cleanup_proc_ expand_path_ hcs_$delentry_seg hcs_$fs_move_seg hcs_$initiate_count hcs_$make_seg hcs_$set_bc_seg hcs_$terminate_noname ioa_ unique_chars_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$noarg error_table_$too_many_args LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 33 000256 34 000262 36 000263 37 000271 38 000272 40 000275 42 000277 11 000303 71 000322 72 000331 73 000350 74 000352 75 000357 76 000364 77 000371 78 000374 79 000401 80 000406 81 000413 82 000420 84 000423 85 000457 87 000460 89 000462 90 000470 91 000475 92 000500 93 000512 94 000514 95 000537 97 000540 101 000541 103 000543 104 000550 105 000554 108 000555 110 000557 111 000564 112 000570 116 000571 118 000573 119 000600 120 000604 124 000605 126 000607 127 000614 128 000620 132 000621 134 000623 135 000630 136 000634 151 000635 153 000637 153 000641 157 000642 159 000644 159 000646 162 000647 164 000652 166 000655 167 000660 168 000675 172 000676 173 000701 174 000704 177 000705 178 000724 180 000726 181 000731 182 000734 183 000765 185 000766 186 001002 187 001015 190 001016 191 001023 192 001026 194 001060 196 001061 197 001104 198 001106 199 001132 202 001133 204 001145 205 001210 206 001214 207 001247 209 001250 211 001254 212 001301 213 001337 214 001343 216 001373 219 001374 220 001377 221 001416 222 001420 223 001443 224 001445 225 001504 226 001510 227 001511 232 001513 233 001522 235 001531 238 001546 241 001564 244 001602 247 001620 250 001636 253 001656 254 001662 255 001665 256 001670 258 001706 259 001710 260 001727 261 001731 262 001733 263 001763 264 002006 267 002007 268 002013 269 002031 272 002033 275 002037 276 002040 278 002060 279 002103 283 002104 284 002112 285 002127 286 002151 287 002167 ----------------------------------------------------------- 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