COMPILATION LISTING OF SEGMENT calcomp_915_dim_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/18/82 1631.8 mst Thu Options: optimize map 1 /* *********************************************************** 2* * * 3* * * 4* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 5* * * 6* * * 7* *********************************************************** */ 8 9 /* ****************************************************** 10* * * 11* * * 12* * Copyright (c) 1972 by Massachusetts Institute of * 13* * Technology and Honeywell Information Systems, Inc. * 14* * * 15* * * 16* ****************************************************** */ 17 18 calcomp_915_dim_attach: proc (iocb_ptr, option_array, com_err_sw, code); 19 20 /* This code is a tape dim for the CalComp 915 (and similar) plotter 21* controller. The 915 hacks its characters in this format: 22* 23* The tape can be either 7- or 9-track, and ALWAYS uses 6-bit characters 24* (despite what the lying documentation says). The records are specified to 25* be 480 to 512 chars long; we use up to 510 chars/record. The first record 26* is a dummy record. It's supposed to contain the ID of the system it was 27* created on (a CalComp protective mechanism) but nothing looks at it. We 28* just put out "I am a plot record - stop plot." All significant records must 29* start with an octal 37 31 31 37, meaning "I am a plot record." Each record 30* must end with the octal code 17, meaning "stop plot" (so it doesn't try to 31* plot inter-record gaps - they're wild stuff.) 32* 33* The input to this routine is exactly the codes which are to go to the 915. 34* The dim has to know about the lengths of commands, because it seems you 35* can't split commands across record boundaries. You also can't put search 36* address in mid-record -- the plotter will find them when plotting, but not 37* when searching. The commands are packed in a Multics 9-bit ASCII character 38* instead of being in 6-bit. The conversion from 9-bit to 6-bit is done in 39* this DIM. 40* 41* Written 5/3/74 by C. D. Tavares */ 42 /* Modified 03/20/75 by CDT to make 9-track tapes possible. */ 43 /* Modified 03/31/75 by CDT to convert to IOX-style module */ 44 /* Modified 04/30/81 by CDT to clean up attach table on attach errors */ 45 /* Last modified 05/19/81 by CDT to remove unused and buggy changemode entry */ 46 47 dcl iocb_ptr pointer parameter, 48 option_array (*) char (*) varying parameter, 49 com_err_sw bit (1) aligned parameter, 50 code fixed bin (35) parameter; 51 52 dcl com_err_ ext entry options (variable), 53 explanation char (64); 54 55 dcl iox_$attach_ioname ext entry (char (*), pointer, char (*), fixed bin (35)), 56 iox_$open ext entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)); 57 58 dcl sys_area_p pointer static initial (null), 59 sys_area area based (sys_area_p), 60 get_system_free_area_ ext entry returns (pointer); 61 1 1 1 2 dcl 1 iocb aligned based (iocb_ptr), 1 3 /* I/O control block. */ 1 4 2 iocb_version fixed init (1), /* Version number of structure. */ 1 5 2 name char (32), /* I/O name of this block. */ 1 6 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 1 7 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 1 8 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 1 9 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 1 10 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 1 11 2 reserved bit (72), /* Reserved for future use. */ 1 12 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 1 13 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 1 14 /* open(p,mode,not_used,s) */ 1 15 2 close entry (ptr, fixed (35)),/* close(p,s) */ 1 16 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 1 17 /* get_line(p,bufptr,buflen,actlen,s) */ 1 18 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 1 19 /* get_chars(p,bufptr,buflen,actlen,s) */ 1 20 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 1 21 /* put_chars(p,bufptr,buflen,s) */ 1 22 2 modes entry (ptr, char (*), char (*), fixed (35)), 1 23 /* modes(p,newmode,oldmode,s) */ 1 24 2 position entry (ptr, fixed, fixed (21), fixed (35)), 1 25 /* position(p,u1,u2,s) */ 1 26 2 control entry (ptr, char (*), ptr, fixed (35)), 1 27 /* control(p,order,infptr,s) */ 1 28 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 1 29 /* read_record(p,bufptr,buflen,actlen,s) */ 1 30 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 1 31 /* write_record(p,bufptr,buflen,s) */ 1 32 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 1 33 /* rewrite_record(p,bufptr,buflen,s) */ 1 34 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 1 35 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 1 36 /* seek_key(p,key,len,s) */ 1 37 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 1 38 /* read_key(p,key,len,s) */ 1 39 2 read_length entry (ptr, fixed (21), fixed (35)); 1 40 /* read_length(p,len,s) */ 1 41 62 63 64 dcl 1 switch_data_block aligned based (iocb.attach_descrip_ptr), 65 2 attach_description char (64) varying, 66 2 open_description char (64) varying, 67 2 target_switch pointer, 68 2 outdx fixed bin, 69 2 buffer bit (buffer_size_in_bits) aligned; 70 71 dcl buffer_size_in_bits fixed bin (24) static initial (3060), /* 510 * 6 */ 72 buffer_size_in_chars fixed bin (21) static initial (340); /* 510 * 6 / 9 */ 73 74 dcl Start_plot bit (24) initial ("011111011001011001011111"b) static, 75 Stop_plot bit (6) initial ("001111"b) static; 76 77 78 dcl (error_table_$not_attached, 79 error_table_$not_detached, 80 error_table_$multiple_io_attachment) ext fixed bin (35); 81 82 dcl (null, substr, index) builtin; 83 84 85 if iocb.attach_descrip_ptr ^= null then do; 86 code = error_table_$not_detached; 87 explanation = ""; 88 goto attach_error; 89 end; 90 91 if sys_area_p = null then sys_area_p = get_system_free_area_ (); 92 93 allocate switch_data_block in (sys_area) set (iocb.attach_descrip_ptr); /* make an SDB */ 94 95 switch_data_block.attach_description = "calcomp_915_dim_ " || option_array (1); 96 97 iocb.open = calcomp_915_open; 98 iocb.detach_iocb = calcomp_915_detach; 99 100 switch_data_block.outdx = 0; 101 102 call iox_$attach_ioname ((option_array (1)), target_switch, 103 "ntape_ " || option_array (1) || " -raw -write", code); 104 if code ^= 0 then do; 105 explanation = "Attempting to attach tape."; 106 goto attach_error; 107 end; 108 109 code = 0; 110 111 call iox_$propagate (iocb_ptr); 112 113 return; 114 115 attach_error: 116 if com_err_sw then 117 call com_err_ (code, "calcomp_915_dim_", explanation); 118 119 if iocb.attach_descrip_ptr ^= null then do; 120 free iocb.attach_descrip_ptr -> switch_data_block in (sys_area); 121 iocb.attach_descrip_ptr = null; 122 end; 123 124 return; 125 126 calcomp_915_open: entry (iocb_ptr, mode, append, code); 127 128 dcl mode fixed bin parameter, 129 append bit (1) aligned parameter; 130 2 1 /* Begin include file ..... iox_modes.incl.pl1 */ 2 2 2 3 /* Written by C. D. Tavares, 03/17/75 */ 2 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 2 5 2 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 2 7 ("stream_input", "stream_output", "stream_input_output", 2 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 2 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 2 10 "direct_input", "direct_output", "direct_update"); 2 11 2 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 2 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 2 14 2 15 dcl (Stream_input initial (1), 2 16 Stream_output initial (2), 2 17 Stream_input_output initial (3), 2 18 Sequential_input initial (4), 2 19 Sequential_output initial (5), 2 20 Sequential_input_output initial (6), 2 21 Sequential_update initial (7), 2 22 Keyed_sequential_input initial (8), 2 23 Keyed_sequential_output initial (9), 2 24 Keyed_sequential_update initial (10), 2 25 Direct_input initial (11), 2 26 Direct_output initial (12), 2 27 Direct_update initial (13)) fixed bin int static options (constant); 2 28 2 29 /* End include file ..... iox_modes.incl.pl1 */ 131 132 133 dcl iox_$propagate ext entry (pointer); 134 135 call iox_$open (target_switch, Sequential_output, ""b, code); 136 if code ^= 0 then return; 137 138 outdx = 0; 139 buffer = Start_plot || Stop_plot; /* 37 31 31 37 17 - "I am a plot record - stop plot" */ 140 /* The calcomp wants a dummy record to begin with. */ 141 call iox_$write_record (target_switch, addr (buffer), buffer_size_in_chars, code); /* put it out there */ 142 if code ^= 0 then return; /* Hm! */ 143 144 actual_iocb_ptr -> iocb.put_chars = calcomp_915_write; 145 146 open_description = "stream_output"; 147 iocb.open_descrip_ptr = addr (open_description); 148 149 iocb.close = calcomp_915_close; 150 151 call iox_$propagate (actual_iocb_ptr); 152 153 return; /* You got it. */ 154 155 calcomp_915_close: entry (iocb_ptr, code); 156 157 dcl iox_$detach_iocb ext entry (pointer, fixed bin (35)), 158 iox_$close ext entry (pointer, fixed bin (35)); 159 160 call put_out; /* flush last bufferful */ 161 162 call iox_$close (target_switch, code); 163 if code ^= 0 then return; 164 165 actual_iocb_ptr -> iocb.open = calcomp_915_open; 166 actual_iocb_ptr -> iocb.detach_iocb = calcomp_915_detach; 167 actual_iocb_ptr -> iocb.open_descrip_ptr = null; 168 169 call iox_$propagate (actual_iocb_ptr); 170 171 return; 172 173 calcomp_915_detach: entry (iocb_ptr, code); 174 175 call iox_$detach_iocb (target_switch, code); /* Whirr! */ 176 if code ^= 0 then return; 177 178 free iocb.attach_descrip_ptr -> switch_data_block in (sys_area); 179 iocb.attach_descrip_ptr = null; 180 181 call iox_$propagate (actual_iocb_ptr); 182 return; 183 184 calcomp_915_write: entry (iocb_ptr, wksp, nelem, code); 185 186 dcl nelem fixed bin (21); 187 188 dcl instring bit (inlen) based (wksp), 189 (i, j, n_chars) fixed bin, 190 wksp pointer, 191 indx fixed bin (24); 192 193 dcl inlen fixed bin (24), 194 divide builtin, 195 before builtin, 196 addr builtin, 197 error_table_$negative_nelem fixed bin (35) external; 198 199 dcl iox_$write_record ext entry (pointer, pointer, fixed bin (21), fixed bin (35)); 200 201 dcl text fixed bin static initial (2), 202 search_address fixed bin static initial (1), 203 lookup_table (0 : 31) fixed bin static initial 204 (1, 4, 1, 1, 2, (11) -1, 205 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7); 206 207 dcl nelemt fixed bin (21); 208 209 if nelem < 0 then do; /* there's always a joker. */ 210 code = error_table_$negative_nelem; /* slap his wrists */ 211 return; 212 end; 213 214 nelemt = 0; 215 216 code = 0; 217 if nelem = 0 then return; /* write nothing - that's easy. */ 218 219 inlen = nelem * 9; /* inlen is in bits */ 220 indx = 4; /* first bit we are interested in is fourth. */ 221 222 if outdx = 0 then call start_record; /* we are beginning a tape record */ 223 224 another_element: 225 if fixed (substr (instring, indx - 1, 3)) = text then do; 226 i = fixed (substr (instring, indx + 2, 2)); 227 j = fixed (substr (instring, indx + 4, 2)); 228 n_chars = fixed (substr (instring, indx + i * 9 + j * 9 + 6, 9)) + i + j + 2; 229 end; 230 231 else do; 232 i = fixed (substr (instring, indx - 1, 7)); 233 if i = search_address then if outdx ^= length (Start_plot) + 1 then call put_out; 234 n_chars = lookup_table (i); 235 end; 236 237 if outdx + n_chars * 6 >= buffer_size_in_bits - 6 then call put_out; 238 239 do i = 1 to n_chars; 240 substr (buffer, outdx, 6) = substr (instring, indx, 6); 241 outdx = outdx + 6; 242 indx = indx + 9; 243 end; 244 245 246 nelemt = nelemt + n_chars; 247 if nelemt < nelem then goto another_element; 248 249 return; 250 251 put_out: proc; /* procedure to append "stop plot", write, and reinitialize buffer */ 252 253 substr (buffer, outdx, 6) = Stop_plot; /* stop plot. */ 254 call iox_$write_record (target_switch, addr (buffer), buffer_size_in_chars, code); 255 /* put out the buffer on one record */ 256 if code ^= 0 then goto returner; /* tape dim barfed */ 257 258 start_record: entry; /* entry to reinitialize buffer without writing it out */ 259 260 buffer = Start_plot; /* 37 31 31 37 - "I am a plot record" */ 261 outdx = length (Start_plot) + 1; /* note that many used */ 262 return; 263 end put_out; 264 265 returner: return; 266 267 end calcomp_915_dim_attach; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/18/82 1625.2 calcomp_915_dim_.pl1 >dumps>old>recomp>calcomp_915_dim_.pl1 62 1 07/02/81 1905.0 iocbv.incl.pl1 >ldd>include>iocbv.incl.pl1 131 2 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.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. Sequential_output 000041 constant fixed bin(17,0) initial dcl 2-15 set ref 135* Start_plot 000040 constant bit(24) initial unaligned dcl 74 ref 139 233 260 261 Stop_plot 001220 constant bit(6) initial unaligned dcl 74 ref 139 253 actual_iocb_ptr 12 based pointer level 2 dcl 1-2 set ref 144 151* 165 166 167 169* 181* addr builtin function dcl 193 ref 141 141 147 254 254 append parameter bit(1) dcl 128 ref 126 attach_descrip_ptr 14 based pointer level 2 dcl 1-2 set ref 85 93* 95 100 102 119 120 121* 135 138 139 141 141 141 146 147 162 175 178 179* 222 233 237 240 240 241 241 253 253 254 254 254 260 261 attach_description based varying char(64) level 2 dcl 64 set ref 95* buffer 45 based bit level 2 dcl 64 set ref 139* 141 141 240* 253* 254 254 260* buffer_size_in_bits constant fixed bin(24,0) initial dcl 71 ref 93 120 139 141 141 178 237 240 253 254 254 260 buffer_size_in_chars 000012 internal static fixed bin(21,0) initial dcl 71 set ref 141* 254* close 36 based entry variable level 2 dcl 1-2 set ref 149* code parameter fixed bin(35,0) dcl 47 set ref 18 86* 102* 104 109* 115* 126 135* 136 141* 142 155 162* 163 173 175* 176 184 210* 216* 254* 256 com_err_ 000014 constant entry external dcl 52 ref 115 com_err_sw parameter bit(1) dcl 47 ref 18 115 detach_iocb 26 based entry variable level 2 dcl 1-2 set ref 98* 166* error_table_$negative_nelem 000034 external static fixed bin(35,0) dcl 193 ref 210 error_table_$not_detached 000024 external static fixed bin(35,0) dcl 78 ref 86 explanation 000100 automatic char(64) unaligned dcl 52 set ref 87* 105* 115* get_system_free_area_ 000022 constant entry external dcl 58 ref 91 i 000120 automatic fixed bin(17,0) dcl 188 set ref 226* 228 228 232* 233 234 239* indx 000123 automatic fixed bin(24,0) dcl 188 set ref 220* 224 226 227 228 232 240 242* 242 inlen 000124 automatic fixed bin(24,0) dcl 193 set ref 219* 224 226 227 228 232 240 instring based bit unaligned dcl 188 ref 224 226 227 228 232 240 iocb based structure level 1 dcl 1-2 iocb_ptr parameter pointer dcl 47 set ref 18 85 93 95 97 98 100 102 111* 119 120 121 126 135 138 139 141 141 141 144 146 147 147 149 151 155 162 165 166 167 169 173 175 178 179 181 184 222 233 237 240 240 241 241 253 253 254 254 254 260 261 iox_$attach_ioname 000016 constant entry external dcl 55 ref 102 iox_$close 000032 constant entry external dcl 157 ref 162 iox_$detach_iocb 000030 constant entry external dcl 157 ref 175 iox_$open 000020 constant entry external dcl 55 ref 135 iox_$propagate 000026 constant entry external dcl 133 ref 111 151 169 181 iox_$write_record 000036 constant entry external dcl 199 ref 141 254 j 000121 automatic fixed bin(17,0) dcl 188 set ref 227* 228 228 lookup_table 000000 constant fixed bin(17,0) initial array dcl 201 ref 234 mode parameter fixed bin(17,0) dcl 128 ref 126 n_chars 000122 automatic fixed bin(17,0) dcl 188 set ref 228* 234* 237 239 246 nelem parameter fixed bin(21,0) dcl 186 ref 184 209 217 219 247 nelemt 000125 automatic fixed bin(21,0) dcl 207 set ref 214* 246* 246 247 null builtin function dcl 82 ref 85 91 119 121 167 179 open 32 based entry variable level 2 dcl 1-2 set ref 97* 165* open_descrip_ptr 20 based pointer level 2 dcl 1-2 set ref 147* 167* open_description 21 based varying char(64) level 2 dcl 64 set ref 146* 147 option_array parameter varying char array dcl 47 ref 18 95 102 102 outdx 44 based fixed bin(17,0) level 2 dcl 64 set ref 100* 138* 222 233 237 240 241* 241 253 261* put_chars 52 based entry variable level 2 dcl 1-2 set ref 144* search_address constant fixed bin(17,0) initial dcl 201 ref 233 substr builtin function dcl 82 set ref 224 226 227 228 232 240* 240 253* switch_data_block based structure level 1 dcl 64 set ref 93 120 178 sys_area based area(1024) dcl 58 ref 93 120 178 sys_area_p 000010 internal static pointer initial dcl 58 set ref 91 91* 93 120 178 target_switch 42 based pointer level 2 dcl 64 set ref 102* 135* 141* 162* 175* 254* text constant fixed bin(17,0) initial dcl 201 ref 224 wksp parameter pointer dcl 188 ref 184 224 226 227 228 232 240 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Direct_input internal static fixed bin(17,0) initial dcl 2-15 Direct_output internal static fixed bin(17,0) initial dcl 2-15 Direct_update internal static fixed bin(17,0) initial dcl 2-15 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 2-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 2-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 2-15 Sequential_input internal static fixed bin(17,0) initial dcl 2-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 2-15 Sequential_update internal static fixed bin(17,0) initial dcl 2-15 Stream_input internal static fixed bin(17,0) initial dcl 2-15 Stream_input_output internal static fixed bin(17,0) initial dcl 2-15 Stream_output internal static fixed bin(17,0) initial dcl 2-15 before builtin function dcl 193 divide builtin function dcl 193 error_table_$multiple_io_attachment external static fixed bin(35,0) dcl 78 error_table_$not_attached external static fixed bin(35,0) dcl 78 index builtin function dcl 82 iox_modes internal static char(24) initial array dcl 2-6 short_iox_modes internal static char(4) initial array dcl 2-12 NAMES DECLARED BY EXPLICIT CONTEXT. another_element 000770 constant label dcl 224 ref 247 attach_error 000350 constant label dcl 115 ref 88 106 calcomp_915_close 000567 constant entry external dcl 155 ref 149 calcomp_915_detach 000650 constant entry external dcl 173 ref 98 166 calcomp_915_dim_attach 000112 constant entry external dcl 18 calcomp_915_open 000433 constant entry external dcl 126 ref 97 165 calcomp_915_write 000734 constant entry external dcl 184 ref 144 put_out 001146 constant entry internal dcl 251 ref 160 233 237 returner 001145 constant label dcl 265 ref 256 start_record 001201 constant entry internal dcl 258 ref 222 NAMES DECLARED BY CONTEXT OR IMPLICATION. fixed builtin function ref 224 226 227 228 232 length builtin function ref 233 261 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1424 1464 1221 1434 Length 1712 1221 40 211 203 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME calcomp_915_dim_attach 140 external procedure is an external procedure. put_out internal procedure shares stack frame of external procedure calcomp_915_dim_attach. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 sys_area_p calcomp_915_dim_attach 000012 buffer_size_in_chars calcomp_915_dim_attach STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME calcomp_915_dim_attach 000100 explanation calcomp_915_dim_attach 000120 i calcomp_915_dim_attach 000121 j calcomp_915_dim_attach 000122 n_chars calcomp_915_dim_attach 000123 indx calcomp_915_dim_attach 000124 inlen calcomp_915_dim_attach 000125 nelemt calcomp_915_dim_attach THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out return shorten_stack ext_entry ext_entry_desc alloc_based free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ get_system_free_area_ iox_$attach_ioname iox_$close iox_$detach_iocb iox_$open iox_$propagate iox_$write_record THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$negative_nelem error_table_$not_detached LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000105 85 000130 86 000136 87 000140 88 000143 91 000144 93 000156 95 000172 97 000230 98 000237 100 000242 102 000243 104 000327 105 000332 106 000335 109 000336 111 000337 113 000347 115 000350 119 000403 120 000412 121 000420 124 000425 126 000426 135 000443 136 000466 138 000470 139 000475 141 000504 142 000523 144 000525 146 000535 147 000543 149 000545 151 000553 153 000562 155 000563 160 000577 162 000600 163 000615 165 000617 166 000627 167 000632 169 000634 171 000645 173 000646 175 000660 176 000675 178 000677 179 000710 181 000715 182 000726 184 000727 209 000744 210 000747 211 000752 214 000753 216 000754 217 000755 219 000756 220 000760 222 000762 224 000770 226 001006 227 001016 228 001026 229 001046 232 001047 233 001056 234 001067 237 001072 239 001106 240 001115 241 001130 242 001132 243 001134 246 001136 247 001140 249 001144 265 001145 251 001146 253 001147 254 001157 256 001176 258 001200 260 001202 261 001212 262 001214 ----------------------------------------------------------- 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