COMPILATION LISTING OF SEGMENT structure_ref_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/19/84 1117.2 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 structure_ref_: 7 procedure (); 8 9 /* * STRUCTURE_REF_ 10* * 11* * This procedure parses a reference to a PL/I variable; it is used 12* * by analyze_multics to implement the structure display facility. 13* * A subset of PL/I syntax is permitted: reference either to scalar 14* * variables or to structures, with subscripts. The subscripts must 15* * be decimal integers, and the ":" syntax may be used to indicate 16* * a cross-section. Either parentheses or braces may be used to 17* * indicate subscripts, to avoid command processor problems. 18* * 19* * The structure reference may be followed by one or more names, 20* * separated by slashes, which can be interpreted by the caller as 21* * as substrings on which to match to select elements of the structure. 22* * There must be a slash between the structure reference and the first 23* * match string, and a slash between each pair of match strings. An 24* * optional slash may be supplied at the end, for compatibility with 25* * qedx syntax. 26* * 27* * The results of the parse are a top level name, a fully qualified 28* * structure name (suitable for use with stu_), and a subscript 29* * array for use with display_data_. 30* * 31* * Examples: 32* * 33* * pvt pvt.array pvt.array{13} 34* * pvt/volmap/ pvt.array{1:4}/volmap/ 35* * 36* * 4 Jun 83, WOS: Initial coding 37* */ 38 39 declare P_reference char (*) parameter; /* Input: name to resolve */ 40 declare P_structure char (*) parameter; /* Output: Top level structure name */ 41 declare P_full_name char (*) parameter; /* Output: fully qualified name */ 42 declare P_subscripts (2, *) fixed bin parameter; /* Output: cross-section bounds */ 43 declare P_n_subscripts fixed bin parameter; /* Output: how many subscripts are valid */ 44 declare P_substrings (*) char (*) varying parameter; /* Output: substrings to match in reference */ 45 declare P_n_substrings fixed bin parameter; /* Output: how many substrings there are */ 46 declare P_code fixed bin (35) parameter; 47 48 declare code fixed bin (35); 49 50 declare reference char (256) varying; 51 declare top_name char (64) varying; 52 declare full_name char (256) varying; 53 declare subscript_idx fixed bin; 54 declare n_subscripts fixed bin; 55 declare n_substrings fixed bin; 56 57 declare n_tokens fixed bin; 58 declare n_reference_tokens fixed bin; 59 60 declare 1 token (-1 : 80), 61 2 type fixed bin, 62 2 start fixed bin, 63 2 lth fixed bin; 64 65 declare TOKEN_BLANK init (1) fixed bin internal static options (constant); 66 declare TOKEN_NUMBER init (2) fixed bin internal static options (constant); 67 declare TOKEN_NAME init (3) fixed bin internal static options (constant); 68 declare TOKEN_DOT init (4) fixed bin internal static options (constant); 69 declare TOKEN_COMMA init (5) fixed bin internal static options (constant); 70 declare TOKEN_COLON init (6) fixed bin internal static options (constant); 71 declare TOKEN_OPEN init (7) fixed bin internal static options (constant); 72 declare TOKEN_CLOSE init (8) fixed bin internal static options (constant); 73 declare TOKEN_SLASH init (9) fixed bin internal static options (constant); 74 75 declare LOWER fixed bin internal static options (constant) init (1); 76 declare UPPER fixed bin internal static options (constant) init (2); 77 78 declare (subscriptrange, stringsize, conversion) condition; 79 80 declare (addr, fixed, index, null, substr) builtin; 81 82 /* */ 83 84 structure_ref_$parse: 85 entry (P_reference, 86 P_structure, P_full_name, 87 P_subscripts, P_n_subscripts, P_substrings, P_n_substrings, P_code); 88 89 /* These catch all the cases of too mayy subscripts, too many names, etc. 90* It might be nice to give real error messages for these, but it's a lot 91* of trouble, and the syntax of structure references is pretty simple. 92* The conditions are selectively enabled for the statements where we want 93* to detect that they have been raised. */ 94 95 on condition (stringsize) goto SYNTAX_ERROR; 96 on condition (subscriptrange) goto SYNTAX_ERROR; 97 on condition (conversion) goto SYNTAX_ERROR; 98 99 P_structure = ""; 100 P_full_name = ""; 101 P_n_subscripts = 0; 102 P_n_substrings = 0; 103 104 reference = rtrim (P_reference); 105 106 call parse_reference (); 107 108 call parse_reference_tokens (); 109 110 call parse_substring_tokens (); 111 112 P_structure = top_name; 113 P_full_name = full_name; 114 P_n_subscripts = n_subscripts; 115 P_n_substrings = n_substrings; 116 P_code = 0; 117 118 return; 119 120 SYNTAX_ERROR: 121 P_code = code; 122 return; 123 124 /* */ 125 126 parse_reference: 127 procedure (); 128 129 declare char_idx fixed bin; 130 declare token_idx fixed bin; 131 declare state fixed bin; 132 declare action fixed bin; 133 declare this_type fixed bin; 134 declare this_char char (1) unaligned; 135 136 declare CHAR_WHITE init (1) fixed bin internal static options (constant); 137 declare CHAR_SPECIAL init (2) fixed bin internal static options (constant); 138 declare CHAR_DIGIT init (3) fixed bin internal static options (constant); 139 declare CHAR_ALPHA init (4) fixed bin internal static options (constant); 140 141 declare STATE_NONE init (1) fixed bin internal static options (constant); 142 declare STATE_NAME init (2) fixed bin internal static options (constant); 143 declare STATE_NUMBER init (3) fixed bin internal static options (constant); 144 145 declare ACTION_INVALID init (1) fixed bin internal static options (constant); 146 declare ACTION_DONE init (2) fixed bin internal static options (constant); 147 declare ACTION_ADD init (3) fixed bin internal static options (constant); 148 149 declare ACTION (3, 4) internal static options (constant) init 150 (3, 2, 2, 2, 151 2, 2, 3, 3, 152 2, 2, 3, 1); 153 154 declare STATE (3, 4) internal static options (constant) init 155 (1, 1, 3, 2, 156 1, 1, 2, 2, 157 1, 1, 3, 1); 158 159 /* */ 160 161 do token_idx = lbound (token, 1) to 1; /* Make spurious tokens for backward references */ 162 token.type (token_idx) = TOKEN_BLANK; 163 end; 164 165 state = STATE_NONE; 166 token_idx = 1; 167 do char_idx = 1 to length (reference); 168 this_char = substr (reference, char_idx, 1); 169 this_type = char_type (this_char); 170 action = ACTION (state, this_type); 171 state = STATE (state, this_type); 172 173 if (action = ACTION_INVALID) then do; 174 code = char_idx; 175 goto SYNTAX_ERROR; 176 end; 177 178 else if (action = ACTION_ADD) then do; 179 if (this_type ^= CHAR_WHITE) then 180 token.lth (token_idx) = token.lth (token_idx) + 1; 181 end; 182 183 else if (action = ACTION_DONE) then do; 184 if (token.type (token_idx) ^= TOKEN_BLANK) then 185 token_idx = token_idx + 1; 186 187 (subscriptrange): /* To catch too many tokens */ 188 token.lth (token_idx) = 1; 189 token.start (token_idx) = char_idx; 190 191 if (this_type = CHAR_WHITE) then 192 token.type (token_idx) = TOKEN_BLANK; 193 else if (this_type = CHAR_DIGIT) then 194 token.type (token_idx) = TOKEN_NUMBER; 195 else if (this_type) = CHAR_ALPHA then 196 token.type (token_idx) = TOKEN_NAME; 197 else if (this_char = ".") then 198 token.type (token_idx) = TOKEN_DOT; 199 else if (this_char = ",") then 200 token.type (token_idx) = TOKEN_COMMA; 201 else if (this_char = ":") then 202 token.type (token_idx) = TOKEN_COLON; 203 else if (this_char = "(") | (this_char = "{") then 204 token.type (token_idx) = TOKEN_OPEN; 205 else if (this_char = ")") | (this_char = "}") then 206 token.type (token_idx) = TOKEN_CLOSE; 207 else if (this_char = "/") then 208 token.type (token_idx) = TOKEN_SLASH; 209 else do; 210 code = char_idx; 211 goto SYNTAX_ERROR; 212 end; 213 end; 214 end; 215 216 if (token.type (token_idx) = TOKEN_BLANK) 217 then n_tokens = token_idx - 1; 218 else n_tokens = token_idx; 219 220 do token_idx = 1 to n_tokens while (token (token_idx).type ^= TOKEN_SLASH); 221 end; 222 223 if (token_idx > n_tokens) then 224 n_reference_tokens = n_tokens; 225 else n_reference_tokens = token_idx - 1; 226 227 return; 228 229 /* */ 230 231 char_type: 232 procedure (one_char) returns (fixed bin); 233 234 declare one_char char (1) unaligned parameter; 235 236 237 if (one_char = " ") then return (CHAR_WHITE); 238 if (index (".,:(){}/", one_char) ^= 0) then return (CHAR_SPECIAL); 239 if (index ("0123456789", one_char) ^= 0) then return (CHAR_DIGIT); 240 if (index ("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", one_char) ^= 0) then return (CHAR_ALPHA); 241 242 code = char_idx; 243 goto SYNTAX_ERROR; 244 245 end char_type; 246 247 end parse_reference; 248 249 /* */ 250 251 parse_reference_tokens: 252 procedure (); 253 254 declare token_idx fixed bin; 255 declare this_type fixed bin; 256 declare next_type fixed bin; 257 declare this_token char (64) varying; 258 259 260 if (token.type (1) ^= TOKEN_NAME) then do; 261 code = 1; 262 goto SYNTAX_ERROR; 263 end; 264 265 full_name = ""; 266 token_idx = 0; 267 n_subscripts = 0; 268 269 do while (token_idx < n_reference_tokens); 270 call next_reference_token (); 271 272 if (this_type = TOKEN_NAME) then do; 273 if (token_idx < n_reference_tokens) then 274 if (next_type ^= TOKEN_DOT) & (next_type ^= TOKEN_OPEN) then 275 call reference_token_error (); 276 277 if (length (full_name) ^= 0) then 278 full_name = full_name || "."; 279 else top_name = this_token; /* First time through, set the structure top level name */ 280 281 (stringsize): 282 full_name = full_name || this_token; 283 end; 284 285 else if (this_type = TOKEN_OPEN) | (this_type = TOKEN_COMMA) then do; 286 if (next_type ^= TOKEN_NUMBER) then call reference_token_error (); 287 call next_reference_token (); 288 289 if (next_type ^= TOKEN_CLOSE) & (next_type ^= TOKEN_COMMA) & (next_type ^= TOKEN_COLON) then 290 call reference_token_error (); 291 292 n_subscripts = n_subscripts + 1; 293 (conversion, subscriptrange): 294 P_subscripts (LOWER, n_subscripts) = fixed (this_token); 295 296 if (next_type ^= TOKEN_COLON) then 297 P_subscripts (UPPER, n_subscripts) = P_subscripts (LOWER, n_subscripts); 298 else do; 299 call next_reference_token (); /* Skip the colon */ 300 call next_reference_token (); /* and get the second subscript */ 301 302 if (this_type ^= TOKEN_NUMBER) then call reference_token_error (); 303 if (next_type ^= TOKEN_COMMA) & (next_type ^= TOKEN_CLOSE) then call reference_token_error (); 304 305 (conversion, subscriptrange): 306 P_subscripts (UPPER, n_subscripts) = fixed (this_token); 307 end; 308 end; /* Of subscript case */ 309 310 else if (this_type = TOKEN_CLOSE) then; /* run out of subscripts */ 311 312 else if (this_type = TOKEN_DOT) then do; 313 if (next_type ^= TOKEN_NAME) then 314 goto SYNTAX_ERROR; 315 end; 316 317 else call reference_token_error (); 318 end; 319 320 return; 321 322 /* */ 323 324 next_reference_token: 325 procedure (); 326 327 if (token_idx = n_reference_tokens) then call reference_token_error (); 328 329 token_idx = token_idx + 1; 330 331 this_type = token.type (token_idx); 332 next_type = token.type (token_idx + 1); 333 334 this_token = substr (reference, 335 token.start (token_idx), token.lth (token_idx)); 336 337 return; 338 end next_reference_token; 339 340 341 342 reference_token_error: 343 procedure (); 344 345 code = token.start (token_idx); 346 goto SYNTAX_ERROR; 347 348 end reference_token_error; 349 350 end parse_reference_tokens; 351 352 /* */ 353 354 parse_substring_tokens: 355 procedure (); 356 357 declare token_idx fixed bin; 358 declare first_token fixed bin; 359 declare last_token fixed bin; 360 361 362 n_substrings = 0; 363 364 first_token = n_reference_tokens + 1; /* First slash */ 365 if (first_token > n_tokens) then return; /* no substrings */ 366 367 if (token.type (n_tokens) = TOKEN_SLASH) then /* Allow a lone slash at the end of the reference */ 368 last_token = n_tokens - 1; /* but don't require it */ 369 else last_token = n_tokens; 370 371 do token_idx = first_token to last_token; 372 if (token.type (token_idx) ^= TOKEN_SLASH) then 373 goto SUBSTRING_ERROR; 374 if (token_idx = last_token) then /* Not enough */ 375 goto SUBSTRING_ERROR; 376 token_idx = token_idx + 1; /* Move to the name */ 377 if (token.type (token_idx) ^= TOKEN_NAME) then 378 goto SUBSTRING_ERROR; 379 380 n_substrings = n_substrings + 1; 381 (subscriptrange): 382 P_substrings (n_substrings) = substr (reference, token.start (token_idx), token.lth (token_idx)); 383 end; 384 385 return; 386 387 388 389 SUBSTRING_ERROR: 390 code = token_idx; 391 goto SYNTAX_ERROR; 392 393 end parse_substring_tokens; 394 395 end structure_ref_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/84 1440.1 structure_ref_.pl1 >special_ldd>online>6897-11/15/84>structure_ref_.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. ACTION 000014 constant fixed bin(17,0) initial array dcl 149 ref 170 ACTION_ADD constant fixed bin(17,0) initial dcl 147 ref 178 ACTION_DONE constant fixed bin(17,0) initial dcl 146 ref 183 ACTION_INVALID constant fixed bin(17,0) initial dcl 145 ref 173 CHAR_ALPHA constant fixed bin(17,0) initial dcl 139 ref 195 240 CHAR_DIGIT constant fixed bin(17,0) initial dcl 138 ref 193 239 CHAR_SPECIAL constant fixed bin(17,0) initial dcl 137 ref 238 CHAR_WHITE constant fixed bin(17,0) initial dcl 136 ref 179 191 237 LOWER constant fixed bin(17,0) initial dcl 75 ref 293 296 P_code parameter fixed bin(35,0) dcl 46 set ref 84 116* 120* P_full_name parameter char unaligned dcl 41 set ref 84 100* 113* P_n_subscripts parameter fixed bin(17,0) dcl 43 set ref 84 101* 114* P_n_substrings parameter fixed bin(17,0) dcl 45 set ref 84 102* 115* P_reference parameter char unaligned dcl 39 ref 84 104 P_structure parameter char unaligned dcl 40 set ref 84 99* 112* P_subscripts parameter fixed bin(17,0) array dcl 42 set ref 84 293* 296* 296 305* P_substrings parameter varying char array dcl 44 set ref 84 381* STATE 000000 constant fixed bin(17,0) initial array dcl 154 ref 171 STATE_NONE constant fixed bin(17,0) initial dcl 141 ref 165 TOKEN_BLANK constant fixed bin(17,0) initial dcl 65 ref 162 184 191 216 TOKEN_CLOSE constant fixed bin(17,0) initial dcl 72 ref 205 289 303 310 TOKEN_COLON constant fixed bin(17,0) initial dcl 70 ref 201 289 296 TOKEN_COMMA constant fixed bin(17,0) initial dcl 69 ref 199 285 289 303 TOKEN_DOT constant fixed bin(17,0) initial dcl 68 ref 197 273 312 TOKEN_NAME constant fixed bin(17,0) initial dcl 67 ref 195 260 272 313 377 TOKEN_NUMBER constant fixed bin(17,0) initial dcl 66 ref 193 286 302 TOKEN_OPEN constant fixed bin(17,0) initial dcl 71 ref 203 273 285 TOKEN_SLASH constant fixed bin(17,0) initial dcl 73 ref 207 220 367 372 UPPER constant fixed bin(17,0) initial dcl 76 ref 296 305 action 000751 automatic fixed bin(17,0) dcl 132 set ref 170* 173 178 183 char_idx 000746 automatic fixed bin(17,0) dcl 129 set ref 167* 168 174 189 210* 242 code 000100 automatic fixed bin(35,0) dcl 48 set ref 120 174* 210* 242* 261* 345* 389* conversion 000732 stack reference condition dcl 78 ref 97 first_token 001041 automatic fixed bin(17,0) dcl 358 set ref 364* 365 371 fixed builtin function dcl 80 ref 293 305 full_name 000223 automatic varying char(256) dcl 52 set ref 113 265* 277 277* 277 281* 281 index builtin function dcl 80 ref 238 239 240 last_token 001042 automatic fixed bin(17,0) dcl 359 set ref 367* 369* 371 374 lth 2 000330 automatic fixed bin(17,0) array level 2 dcl 60 set ref 179* 179 187* 334 381 n_reference_tokens 000327 automatic fixed bin(17,0) dcl 58 set ref 223* 225* 269 273 327 364 n_subscripts 000324 automatic fixed bin(17,0) dcl 54 set ref 114 267* 292* 292 293 296 296 305 n_substrings 000325 automatic fixed bin(17,0) dcl 55 set ref 115 362* 380* 380 381 n_tokens 000326 automatic fixed bin(17,0) dcl 57 set ref 216* 218* 220 223 223 365 367 367 369 next_type 000774 automatic fixed bin(17,0) dcl 256 set ref 273 273 286 289 289 289 296 303 303 313 332* one_char parameter char(1) unaligned dcl 234 ref 231 237 238 239 240 reference 000101 automatic varying char(256) dcl 50 set ref 104* 167 168 334 381 start 1 000330 automatic fixed bin(17,0) array level 2 dcl 60 set ref 189* 334 345 381 state 000750 automatic fixed bin(17,0) dcl 131 set ref 165* 170 171* 171 stringsize 000724 stack reference condition dcl 78 ref 95 subscriptrange 000716 stack reference condition dcl 78 ref 96 substr builtin function dcl 80 ref 168 334 381 this_char 000753 automatic char(1) unaligned dcl 134 set ref 168* 169* 197 199 201 203 203 205 205 207 this_token 000775 automatic varying char(64) dcl 257 set ref 279 281 293 305 334* this_type 000752 automatic fixed bin(17,0) dcl 133 in procedure "parse_reference" set ref 169* 170 171 179 191 193 195 this_type 000773 automatic fixed bin(17,0) dcl 255 in procedure "parse_reference_tokens" set ref 272 285 285 302 310 312 331* token 000330 automatic structure array level 1 unaligned dcl 60 set ref 161 token_idx 000747 automatic fixed bin(17,0) dcl 130 in procedure "parse_reference" set ref 161* 162* 166* 179 179 184 184* 184 187 189 191 193 195 197 199 201 203 205 207 216 216 218 220* 220* 223 225 token_idx 000772 automatic fixed bin(17,0) dcl 254 in procedure "parse_reference_tokens" set ref 266* 269 273 327 329* 329 331 332 334 334 345 token_idx 001040 automatic fixed bin(17,0) dcl 357 in procedure "parse_substring_tokens" set ref 371* 372 374 376* 376 377 381 381* 389 top_name 000202 automatic varying char(64) dcl 51 set ref 112 279* type 000330 automatic fixed bin(17,0) array level 2 dcl 60 set ref 162* 184 191* 193* 195* 197* 199* 201* 203* 205* 207* 216 220 260 331 332 367 372 377 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. STATE_NAME internal static fixed bin(17,0) initial dcl 142 STATE_NUMBER internal static fixed bin(17,0) initial dcl 143 addr builtin function dcl 80 null builtin function dcl 80 subscript_idx automatic fixed bin(17,0) dcl 53 NAMES DECLARED BY EXPLICIT CONTEXT. SUBSTRING_ERROR 001330 constant label dcl 389 ref 372 374 377 SYNTAX_ERROR 000316 constant label dcl 120 ref 95 96 97 175 211 243 262 313 346 391 char_type 000572 constant entry internal dcl 231 ref 169 next_reference_token 001157 constant entry internal dcl 324 ref 270 287 299 300 parse_reference 000322 constant entry internal dcl 126 ref 106 parse_reference_tokens 000655 constant entry internal dcl 251 ref 108 parse_substring_tokens 001214 constant entry internal dcl 354 ref 110 reference_token_error 001206 constant entry internal dcl 342 ref 273 286 289 302 303 317 327 structure_ref_ 000105 constant entry external dcl 6 structure_ref_$parse 000122 constant entry external dcl 84 NAMES DECLARED BY CONTEXT OR IMPLICATION. lbound builtin function ref 161 length builtin function ref 167 277 rtrim builtin function ref 104 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1436 1446 1344 1446 Length 1624 1344 10 141 71 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME structure_ref_ 735 external procedure is an external procedure. on unit on line 95 64 on unit on unit on line 96 64 on unit on unit on line 97 64 on unit parse_reference internal procedure shares stack frame of external procedure structure_ref_. char_type internal procedure shares stack frame of external procedure structure_ref_. parse_reference_tokens internal procedure shares stack frame of external procedure structure_ref_. next_reference_token internal procedure shares stack frame of external procedure structure_ref_. reference_token_error internal procedure shares stack frame of external procedure structure_ref_. parse_substring_tokens internal procedure shares stack frame of external procedure structure_ref_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME structure_ref_ 000100 code structure_ref_ 000101 reference structure_ref_ 000202 top_name structure_ref_ 000223 full_name structure_ref_ 000324 n_subscripts structure_ref_ 000325 n_substrings structure_ref_ 000326 n_tokens structure_ref_ 000327 n_reference_tokens structure_ref_ 000330 token structure_ref_ 000746 char_idx parse_reference 000747 token_idx parse_reference 000750 state parse_reference 000751 action parse_reference 000752 this_type parse_reference 000753 this_char parse_reference 000772 token_idx parse_reference_tokens 000773 this_type parse_reference_tokens 000774 next_type parse_reference_tokens 000775 this_token parse_reference_tokens 001040 token_idx parse_substring_tokens 001041 first_token parse_substring_tokens 001042 last_token parse_substring_tokens THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. return tra_ext bound_check_signal enable ext_entry ext_entry_desc int_entry stringsize any_to_any_tr NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 000104 84 000112 95 000154 96 000173 97 000212 99 000231 100 000237 101 000244 102 000245 104 000246 106 000270 108 000271 110 000272 112 000273 113 000302 114 000310 115 000312 116 000314 118 000315 120 000316 122 000321 126 000322 161 000323 162 000331 163 000335 165 000337 166 000341 167 000343 168 000353 169 000357 170 000361 171 000367 173 000371 174 000374 175 000376 178 000377 179 000401 181 000407 183 000410 184 000412 187 000420 189 000432 191 000437 193 000446 195 000453 197 000460 199 000467 201 000474 203 000501 205 000510 207 000517 210 000524 211 000526 214 000527 216 000531 218 000542 220 000544 221 000557 223 000561 225 000567 227 000571 231 000572 237 000574 238 000606 239 000622 240 000636 242 000652 243 000654 251 000655 260 000656 261 000661 262 000663 265 000664 266 000665 267 000666 269 000667 270 000673 272 000674 273 000677 277 000710 279 000722 281 000727 283 000743 285 000744 286 000750 287 000754 289 000755 292 000765 293 000766 296 001034 299 001060 300 001061 302 001062 303 001066 305 001074 308 001142 310 001143 312 001146 313 001150 315 001153 317 001154 318 001155 320 001156 324 001157 327 001160 329 001164 331 001165 332 001172 334 001174 337 001205 342 001206 345 001207 346 001213 354 001214 362 001215 364 001216 365 001221 367 001224 369 001235 371 001237 372 001245 374 001251 376 001254 377 001255 380 001262 381 001263 383 001325 385 001327 389 001330 391 001332 ----------------------------------------------------------- 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