COMPILATION LISTING OF SEGMENT basic_resequence_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 09/11/84 1244.4 mst Tue 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 /* format: style2 */ 11 12 basic_resequence_: 13 procedure (first_value, increment, tbl, txt, jt, highest, error_code); 14 15 16 /* A resequencer for line numbered files, for use with the basic_system editor. 17* J.M. Broughton -- April 1973 */ 18 19 /* Modified July 19, 1974 by J.M. Broughton to properly handle mixed case 20* letters in if, on, and goto statements */ 21 22 declare first_value fixed bin, /* value from which to start resequencing */ 23 increment fixed bin, /* each new line number will be upped by this amount */ 24 tbl pointer, /* points to table, corresponds to ntbl */ 25 txt pointer, /* points to txt area, corresponds to ntxt */ 26 jt fixed bin, /* offset of first free word in test */ 27 highest fixed bin, /* maximum line number */ 28 error_code fixed bin (35); /* standard error_code */ 29 30 declare hcs_$make_seg entry (char (*), char (*), char (*), 31 /* creates the temporary segment */ 32 fixed bin (5), ptr, fixed bin (35)), 33 hcs_$truncate_seg entry (ptr, fixed bin, fixed bin (35)), 34 /* shortens a segment */ 35 hcs_$terminate_noname entry (ptr, fixed bin (35)), 36 /* terminates null ref name */ 37 ioa_ entry options (variable); 38 /* output formatting routine */ 39 40 declare 1 segment based aligned, /* temporary segment */ 41 2 text (0:21503) fixed bin (35), 42 /* area to place new source */ 43 2 translation_table (0:99999), /* info from which to translate line numbers */ 44 1 line_translation_table 45 (0:99999) based (trtbl) aligned, 46 /* line number mappings */ 47 2 oldvalue fixed bin (17) unal, 48 /* old number from new */ 49 2 newvalue fixed bin (17) unal, 50 /* new number from old */ 51 1 table (0:99999) based aligned, 52 /* table of line information */ 53 2 indx fixed bin (17) unal, 54 /* offset from start of "txt" */ 55 2 chcount fixed bin (17) unal, 56 /* number of characters */ 57 line char (oldcount) based (oldline_ptr) aligned, 58 /* old line */ 59 oldcount fixed bin, 60 oldline_ptr pointer, 61 oldindex fixed bin, /* index of old line in original t text */ 62 nline char (132) based (nline_ptr) aligned, 63 /* new patched line */ 64 nline_ptr pointer, 65 tline char (256) varying,/* lower cased version of old line */ 66 1 string based aligned, /* psuedo string to be overlayed on lines */ 67 2 ch (0:262143) char (1) unaligned, 68 /* the characters */ 69 copy_overlay (count) fixed bin (35) based, 70 /* overlay to move text area */ 71 count fixed bin; /* number of words to move */ 72 73 declare trtbl pointer, /* pointer to translation table */ 74 ntbl pointer, /* pointer to table of resequenced source */ 75 ntxt pointer; /* pointer to temp. segment and resequenced text */ 76 77 declare new_max fixed bin, /* maximum line number of new program */ 78 linum fixed bin, /* number of line currently being created */ 79 jnt fixed bin initial (0), 80 /* offset from start of "ntxt" */ 81 nl char (1) static aligned initial (" 82 "), 83 tab char (1) static aligned initial (" "), 84 /* new line and tab characters */ 85 (loc, nloc) fixed bin, /* offsets from being of old/new line */ 86 numl fixed bin, /* length (in chars.) of line number */ 87 newline bit (1) aligned, /* indicates newline after line number */ 88 code fixed bin (35), /* standard error code */ 89 (i, j, k) fixed bin, /* often used temporaries */ 90 (addr, max, mod, null, divide, search, substr, verify, index) 91 builtin; 92 93 /*************************************************** Internal Subroutines *************************************************/ 94 95 96 get_number: 97 procedure (place) returns (fixed bin); 98 99 declare chr char (1) aligned, /* temporary */ 100 place, 101 d fixed bin (17), 102 error bit (1) initial ("1"b), 103 /* indicates if there are leading chars */ 104 line fixed bin; /* line number */ 105 106 line = 0; /* initialize line number */ 107 108 do numl = 0 by 1; /* scan line */ 109 chr = txt -> ch (place + numl); /* get current line */ 110 d = index ("0123456789", chr) - 1; /* compute the digit */ 111 if d < 0 /* test if really a digit */ 112 then do; 113 if error /* has a digit been found yet */ 114 then go to bad_char; /* number has not been started */ 115 else do; /* end of the line number */ 116 newline = (chr = nl); /* set newline indicator */ 117 return (line); /* finished */ 118 end; 119 end; 120 else do; 121 line = (line * 10) + d; /* compute line number */ 122 error = "0"b; /* a digit has been found */ 123 end; 124 end; /* of do group */ 125 126 end get_number; 127 128 129 130 write_number: 131 procedure (number, place); /* writes a number into source lines */ 132 133 declare number fixed bin, /* number to be converted */ 134 place fixed bin, /* offset in nline */ 135 temp_string char (5) aligned, /* holds number as it is built up */ 136 n fixed bin; /* temporary */ 137 138 numl = 0; /* initialize length of number in chars. */ 139 140 do while (number > 0); /* process the whole number */ 141 n = mod (number, 10); /* get low order digit */ 142 numl = numl + 1; /* add one to length */ 143 substr (temp_string, 6 - numl, 1) = substr ("0123456789", n + 1, 1); 144 /* move character into temp. string */ 145 number = divide (number, 10, 17, 0); /* try for another digit */ 146 end; 147 148 substr (nline, nloc, numl) = substr (temp_string, 6 - numl); 149 /* move number into source */ 150 place = place + numl; /* move pointer ahead by length of number */ 151 152 return; 153 154 end write_number; 155 156 /********************************************* Execution Begins Here **************************************************/ 157 158 159 160 call hcs_$make_seg ("", "basic_rseq_temp_1_", "", 01011b, ntxt, code); 161 /* create temp for new text, trans. table */ 162 if ntxt = null 163 then go to error; 164 call hcs_$truncate_seg (ntxt, 0, code); /* zero it out */ 165 if code ^= 0 166 then go to error; 167 call hcs_$make_seg ("", "basic_rseq_temp_2_", "", 01011b, ntbl, code); 168 /* create temporary for new table */ 169 if ntbl = null 170 then go to error; 171 call hcs_$truncate_seg (ntbl, 0, code); /* again zero it out */ 172 if code ^= 0 173 then go to error; 174 trtbl = addr (ntxt -> segment.translation_table); /* get pointer to translation table */ 175 error_code = 0; /* just to make sure */ 176 177 178 j = first_value; /* compute new line numbers */ 179 do i = 0 to highest; /* search all old numbers */ 180 if tbl -> table (i).chcount > 0 181 then do; /* test if valid line */ 182 newvalue (i) = j; /* set new value of old number */ 183 oldvalue (j) = i; /* remember old number too */ 184 j = j + increment; /* get new line number */ 185 if j > 99999 186 then do; /* this can't be allowed */ 187 call ioa_ ("Maximum line number too large."); 188 /* indicate error */ 189 return; /* and return immediately */ 190 end; 191 end; 192 end; 193 new_max = j - increment; /* compute new maximum line number */ 194 195 196 do linum = first_value by increment while (linum <= new_max); 197 /* step through each line patching source */ 198 199 j = oldvalue (linum); /* find old source line */ 200 oldindex = tbl -> table (j).indx; /* get the index */ 201 oldcount = tbl -> table (j).chcount; /* and character count */ 202 oldline_ptr = addr (txt -> ch (oldindex)); /* and now a pointer to it */ 203 204 tline = translate (line, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); 205 /* lower case the string */ 206 ntbl -> table (linum).indx = jnt; /* compute index of new line */ 207 nline_ptr = addr (ntxt -> ch (jnt)); /* and a pointer */ 208 209 loc, nloc = search (tline, "0123456789"); /* where is the line number */ 210 substr (nline, 1, loc) = substr (line, 1, loc); 211 /* move any leading white space to new source line */ 212 call write_number ((linum), nloc); /* write new line number into source */ 213 k = search (substr (tline, loc), " ") - 1; 214 /* set pointer in "line" past line number */ 215 216 if k < 0 217 then do; 218 219 /* statement contains only a line number */ 220 221 loc = oldcount; 222 goto next_line; 223 end; 224 225 loc = loc + k; 226 227 k = verify (substr (tline, loc), " ") - 1; 228 /* find the beginning of the statement */ 229 substr (nline, nloc, k) = substr (line, loc, k); 230 /* move preceding white space */ 231 nloc = nloc + k; 232 loc = loc + k; /* update pointers */ 233 234 k = index ("igo", substr (tline, loc, 1)); /* what type of statement is this */ 235 go to type (k); /* process it according to its type */ 236 237 type (1): /* if or input */ 238 if substr (tline, loc + 1, 1) = "n" /* ignore an input statement */ 239 then go to next_line; 240 k = index (substr (tline, loc), "th") + 3; /* line number follows "then" */ 241 if k > 3 242 then go to patch_line; /* found a then, patch_line will finish the job */ 243 go to type (2); /* otherwise look for a goto */ 244 245 type (3): /* on go(to sub) */ 246 k = index (substr (tline, loc), "go") - 1; /* find the "go" */ 247 if k < 0 248 then go to bad_statement; /* no go anything */ 249 substr (nline, nloc, k) = substr (line, loc, k); 250 /* move the first part of the statement */ 251 nloc = nloc + k; 252 loc = loc + k; 253 254 type (2): /* goto or gosub */ 255 k = index (substr (tline, loc), "to") + 1; /* look for a go "to" */ 256 if k = 1 257 then do; /* not a goto, try for gosub */ 258 k = index (substr (tline, loc), "sub") + 2; 259 /* look for it */ 260 if k = 2 261 then go to bad_statement; /* neither - something is in error */ 262 end; 263 264 patch_line: 265 substr (nline, nloc, k) = substr (line, loc, k); 266 /* move line up to line number */ 267 nloc = nloc + k; 268 loc = loc + k; 269 270 newline = "0"b; /* just to make sure */ 271 do while (^newline); /* process all line numbers */ 272 k = search (substr (tline, loc), "0123456789") - 1; 273 /* find where the line number begins */ 274 if k < 0 275 then goto next_line; /* skip if no more line numbers. 276* This check handles cases like 277* 10 goto 20 ' comment 278* which used to cause fault */ 279 substr (nline, nloc, k) = substr (line, loc, k); 280 /* move whatever preceeds the number */ 281 nloc = nloc + k; 282 loc = loc + k; 283 j = get_number (oldindex + loc - 1); /* get the line number to be changed */ 284 i = newvalue (j); /* get new equivalent */ 285 if i = 0 286 then go to bad_line; /* invalid line number */ 287 loc = loc + numl; /* update pointer by length of number */ 288 call write_number (i, nloc); 289 end; 290 291 next_line: 292 type (0): 293 i = oldcount - loc + 1; /* get length of string to end of line */ 294 substr (nline, nloc, i) = substr (line, loc, i); 295 /* move the remaining portion of the line */ 296 ntbl -> table (linum).chcount = nloc + i - 1;/* compute number of charcters in line */ 297 jnt = jnt + nloc + i + 2; /* align next line on word boundary */ 298 jnt = jnt - mod (jnt, 4); 299 300 end; /* go back for another line */ 301 302 /* Resequencing complete, update orignal */ 303 304 count = max (highest, new_max) + 1; /* use highest to zero out old elements of table */ 305 tbl -> copy_overlay = ntbl -> copy_overlay; /* move the "table" */ 306 highest = new_max; 307 jt = jnt; /* reset "jt" to new value */ 308 count = divide (jnt, 4, 17, 0); /* get number of words to move */ 309 txt -> copy_overlay = ntxt -> copy_overlay; /* copy count words of text */ 310 call hcs_$truncate_seg (ntxt, 0, error_code); /* cleanup */ 311 call hcs_$truncate_seg (ntbl, 0, error_code); 312 call hcs_$terminate_noname (ntbl, error_code); 313 call hcs_$terminate_noname (ntxt, error_code); 314 315 return; 316 317 318 /* Various Error Handlers */ 319 320 321 error: 322 error_code = code; /* indicate error */ 323 return; 324 325 bad_statement: /* invalid syntax */ 326 call ioa_ ("Invalid statement encountered on line ^d, old line ^d.", linum, oldvalue (linum)); 327 go to next_line; 328 329 bad_char: /* we found an invalid character on this line */ 330 call ioa_ ("Bad line number encountered on line ^d, old line ^d.", linum, oldvalue (linum)); 331 go to next_line; 332 333 bad_line: /* come here if wrong line number encountered */ 334 call ioa_ ("Bad line number ^d encountered on line ^d, old line ^d.", j, linum, oldvalue (linum)); 335 go to next_line; 336 337 338 end basic_resequence_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 09/11/84 1222.3 basic_resequence_.pl1 >spec>on>basic>basic_resequence_.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. addr builtin function dcl 77 ref 174 202 207 ch based char(1) array level 2 packed unaligned dcl 40 set ref 109 202 207 chcount 0(18) based fixed bin(17,0) array level 2 packed unaligned dcl 40 set ref 180 201 296* chr 000244 automatic char(1) dcl 99 set ref 109* 110 116 code 000227 automatic fixed bin(35,0) dcl 77 set ref 160* 164* 165 167* 171* 172 321 copy_overlay based fixed bin(35,0) array dcl 40 set ref 305* 305 309* 309 count 000211 automatic fixed bin(17,0) dcl 40 set ref 304* 305 308* 309 d 000245 automatic fixed bin(17,0) dcl 99 set ref 110* 111 121 divide builtin function dcl 77 ref 145 308 error 000246 automatic bit(1) initial unaligned dcl 99 set ref 99* 113 122* error_code parameter fixed bin(35,0) dcl 22 set ref 12 175* 310* 311* 312* 313* 321* first_value parameter fixed bin(17,0) dcl 22 ref 12 178 196 hcs_$make_seg 000010 constant entry external dcl 30 ref 160 167 hcs_$terminate_noname 000014 constant entry external dcl 30 ref 312 313 hcs_$truncate_seg 000012 constant entry external dcl 30 ref 164 171 310 311 highest parameter fixed bin(17,0) dcl 22 set ref 12 179 304 306* i 000230 automatic fixed bin(17,0) dcl 77 set ref 179* 180 182 183* 284* 285 288* 291* 294 294 296 297 increment parameter fixed bin(17,0) dcl 22 ref 12 184 193 196 index builtin function dcl 77 ref 110 234 240 245 254 258 indx based fixed bin(17,0) array level 2 packed unaligned dcl 40 set ref 200 206* ioa_ 000016 constant entry external dcl 30 ref 187 325 329 333 j 000231 automatic fixed bin(17,0) dcl 77 set ref 178* 182 183 184* 184 185 193 199* 200 201 283* 284 333* jnt 000222 automatic fixed bin(17,0) initial dcl 77 set ref 77* 206 207 297* 297 298* 298 298 307 308 jt parameter fixed bin(17,0) dcl 22 set ref 12 307* k 000232 automatic fixed bin(17,0) dcl 77 set ref 213* 216 225 227* 229 229 231 232 234* 235 240* 241 245* 247 249 249 251 252 254* 256 258* 260 264 264 267 268 272* 274 279 279 281 282 line based char dcl 40 in procedure "basic_resequence_" ref 204 210 229 249 264 279 294 line 000247 automatic fixed bin(17,0) dcl 99 in procedure "get_number" set ref 106* 117 121* 121 line_translation_table based structure array level 1 dcl 40 linum 000221 automatic fixed bin(17,0) dcl 77 set ref 196* 196* 199 206 212 296* 325* 325 329* 329 333* 333 loc 000223 automatic fixed bin(17,0) dcl 77 set ref 209* 210 210 213 221* 225* 225 227 229 232* 232 234 237 240 245 249 252* 252 254 258 264 268* 268 272 279 282* 282 283 287* 287 291 294 max builtin function dcl 77 ref 304 mod builtin function dcl 77 ref 141 298 n 000260 automatic fixed bin(17,0) dcl 133 set ref 141* 143 new_max 000220 automatic fixed bin(17,0) dcl 77 set ref 193* 196 304 306 newline 000226 automatic bit(1) dcl 77 set ref 116* 270* 271 newvalue 0(18) based fixed bin(17,0) array level 2 packed unaligned dcl 40 set ref 182* 284 nl constant char(1) initial dcl 77 ref 116 nline based char(132) dcl 40 set ref 148* 210* 229* 249* 264* 279* 294* nline_ptr 000106 automatic pointer dcl 40 set ref 148 207* 210 229 249 264 279 294 nloc 000224 automatic fixed bin(17,0) dcl 77 set ref 148 209* 212* 229 231* 231 249 251* 251 264 267* 267 279 281* 281 288* 294 296 297 ntbl 000214 automatic pointer dcl 73 set ref 167* 169 171* 206 296 305 311* 312* ntxt 000216 automatic pointer dcl 73 set ref 160* 162 164* 174 207 309 310* 313* null builtin function dcl 77 ref 162 169 number parameter fixed bin(17,0) dcl 133 set ref 130 140 141 145* 145 numl 000225 automatic fixed bin(17,0) dcl 77 set ref 108* 109* 138* 142* 142 143 148 148 150 287 oldcount 000100 automatic fixed bin(17,0) dcl 40 set ref 201* 204 210 221 229 249 264 279 291 294 oldindex 000104 automatic fixed bin(17,0) dcl 40 set ref 200* 202 283 oldline_ptr 000102 automatic pointer dcl 40 set ref 202* 204 210 229 249 264 279 294 oldvalue based fixed bin(17,0) array level 2 packed unaligned dcl 40 set ref 183* 199 325* 329* 333* place parameter fixed bin(17,0) dcl 133 in procedure "write_number" set ref 130 150* 150 place parameter fixed bin(17,0) dcl 99 in procedure "get_number" ref 96 109 search builtin function dcl 77 ref 209 213 272 segment based structure level 1 dcl 40 string based structure level 1 dcl 40 substr builtin function dcl 77 set ref 143* 143 148* 148 210* 210 213 227 229* 229 234 237 240 245 249* 249 254 258 264* 264 272 279* 279 294* 294 table based structure array level 1 dcl 40 tbl parameter pointer dcl 22 ref 12 180 200 201 305 temp_string 000256 automatic char(5) dcl 133 set ref 143* 148 tline 000110 automatic varying char(256) dcl 40 set ref 204* 209 213 227 234 237 240 245 254 258 272 translation_table 52000 based fixed bin(17,0) array level 2 dcl 40 set ref 174 trtbl 000212 automatic pointer dcl 73 set ref 174* 182 183 199 284 325 329 333 txt parameter pointer dcl 22 ref 12 109 202 309 verify builtin function dcl 77 ref 227 NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. tab internal static char(1) initial dcl 77 NAMES DECLARED BY EXPLICIT CONTEXT. bad_char 001203 constant label dcl 329 ref 113 bad_line 001231 constant label dcl 333 ref 285 bad_statement 001155 constant label dcl 325 ref 247 260 basic_resequence_ 000154 constant entry external dcl 12 error 001151 constant label dcl 321 set ref 162 165 169 172 get_number 001262 constant entry internal dcl 96 ref 283 next_line 001003 constant label dcl 291 ref 222 237 274 327 331 335 patch_line 000721 constant label dcl 264 ref 241 type 000000 constant label array(0:3) dcl 237 ref 235 243 write_number 001337 constant entry internal dcl 130 ref 212 288 NAME DECLARED BY CONTEXT OR IMPLICATION. translate builtin function ref 204 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2514 2534 2431 2524 Length 2712 2431 20 142 62 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME basic_resequence_ 234 external procedure is an external procedure. get_number internal procedure shares stack frame of external procedure basic_resequence_. write_number internal procedure shares stack frame of external procedure basic_resequence_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME basic_resequence_ 000100 oldcount basic_resequence_ 000102 oldline_ptr basic_resequence_ 000104 oldindex basic_resequence_ 000106 nline_ptr basic_resequence_ 000110 tline basic_resequence_ 000211 count basic_resequence_ 000212 trtbl basic_resequence_ 000214 ntbl basic_resequence_ 000216 ntxt basic_resequence_ 000220 new_max basic_resequence_ 000221 linum basic_resequence_ 000222 jnt basic_resequence_ 000223 loc basic_resequence_ 000224 nloc basic_resequence_ 000225 numl basic_resequence_ 000226 newline basic_resequence_ 000227 code basic_resequence_ 000230 i basic_resequence_ 000231 j basic_resequence_ 000232 k basic_resequence_ 000244 chr get_number 000245 d get_number 000246 error get_number 000247 line get_number 000256 temp_string write_number 000260 n write_number THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_cs call_ext_out_desc call_ext_out return mod_fx1 signal shorten_stack ext_entry set_cs_eis index_cs_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. hcs_$make_seg hcs_$terminate_noname hcs_$truncate_seg ioa_ NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000146 77 000161 160 000162 162 000225 164 000231 165 000245 167 000247 169 000310 171 000314 172 000330 174 000332 175 000336 178 000340 179 000342 180 000351 182 000357 183 000363 184 000370 185 000372 187 000375 189 000411 192 000412 193 000414 196 000420 199 000427 200 000432 201 000437 202 000444 204 000451 206 000466 207 000474 209 000500 210 000514 212 000520 213 000524 216 000543 221 000544 222 000546 225 000547 227 000550 229 000567 231 000575 232 000576 234 000577 235 000611 237 000612 240 000616 241 000634 243 000636 245 000637 247 000654 249 000655 251 000661 252 000662 254 000663 256 000703 258 000705 260 000717 264 000721 267 000725 268 000726 270 000727 271 000730 272 000732 274 000751 279 000752 281 000760 282 000761 283 000762 284 000770 285 000775 287 000776 288 001000 289 001002 291 001003 294 001007 296 001016 297 001023 298 001030 300 001035 304 001040 305 001047 306 001056 307 001060 308 001062 309 001064 310 001073 311 001107 312 001124 313 001136 315 001150 321 001151 323 001154 325 001155 327 001202 329 001203 331 001230 333 001231 335 001261 96 001262 99 001264 106 001266 108 001267 109 001270 110 001302 111 001312 113 001313 116 001315 117 001321 121 001324 122 001330 124 001331 126 001333 130 001337 138 001341 140 001342 141 001345 142 001350 143 001351 145 001357 146 001362 148 001363 150 001401 152 001403 ----------------------------------------------------------- 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