COMPILATION LISTING OF SEGMENT et_test Compiled by: Multics PL/I Compiler, Release 27b, of September 15, 1981 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 06/03/82 1024.2 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 et_test: procedure (script_ptr, script_len, arg_et_data_ptr, finished_flag, code); 12 13 14 /* Modified Aug, 1980 to add capability to run the new ets scripts. 15* * Accomplished by changing declaration of most fixed bin variables to 16* * fixed bin (35). 17**/ 18 19 20 21 /* This procedure will parse the input data for one instruction. The data 22* * for each instruction consists of statements. There are four types of 23* * statements: inst, desc, data, and page. The first statement of each 24* * instruction must be an "inst" statement. 25* * The format of a statement is as follows: 26* * 27* * name required_field -option . . . -option . . .; 28* * 29* * 1. The first field in all statements MUST be its 4 character statement 30* * name: "inst", "desc", "data", or "page". 31* * 32* * 2. In some statements (all but page) the second field in the statement 33* * MUST be some required information. 34* * 35* * 3. The other fields in the statement represent optional data which may or 36* * may not be given. Each option field MUST begin with a "-". 37* * 38* * 4. All statements must end with a ";". 39* * 40* * 5. There may be any number of blanks, tabs, and new line characters between 41* * any fields in the statement, including before the name field. 42* * 43* * 6. Wherever blanks are permitted (see 5. above) there may also be comment 44* * fields. Comments MUST begin with the characters "/*" and end with 45* * the characters "*/". 46* * 47* * Initial code on 10/24/72 by Bill Silver. 48**/ 49 50 51 52 /* The following data items are used as arguments in the call to et_test. */ 53 54 dcl script_ptr ptr, /* Pointer to the input data file. */ 55 56 script_len fixed bin (35), /* The length in characters of the 57* * input data file. */ 58 59 arg_et_data_ptr ptr, /* Pointer to the et_data area. */ 60 61 finished_flag fixed bin, /* Indicates when all of the instructions 62* * have been tested. */ 63 64 code fixed bin (35); /* Error code. */ 65 66 67 68 69 /* This is an overlay of the input script file. */ 70 71 dcl 1 script based (script_ptr), /* Used to access the input data segment 72* * as a stream of characters. */ 73 74 2 offset char (start), /* The part of the segment which we have 75* * allready processed. */ 76 77 2 window char (size); /* The part of the segment which we are 78* * currently accessing. */ 79 80 81 dcl start fixed bin (35), /* The number of script characters allready 82* * processed. The next character is the start 83* * of the window. */ 84 85 size fixed bin (35); /* The current size (in characters) of the window 86* * on the script segment. */ 87 88 89 90 /* These are some temporary variables. */ 91 92 dcl i fixed bin (35), /* Work index variables. */ 93 94 len fixed bin (35), /* Temporary. */ 95 96 next_statement_x fixed bin (35), /* The number of the last character in the 97* * current statement. */ 98 99 save fixed bin (35), /* Temporary. */ 100 101 test_x fixed bin; /* Used to hold the test_x field from this 102* * instruction's entry in the et_instr_data 103* * table. */ 104 105 106 107 /* An overlay of an mf field. */ 108 109 dcl 1 mf_map based unaligned, 110 2 ar bit (1), 111 2 rl bit (1), 112 2 id bit (1), 113 2 reg bit (4); 114 115 116 dcl stringrange_label label internal static; 117 118 119 120 121 dcl com_err_ entry options (variable), 122 123 condition_ entry (char (*), entry), 124 125 et_inst entry (char (*), ptr, fixed bin (35)), 126 et_desc entry (char (*), ptr, fixed bin (35)), 127 et_data entry (char (*), ptr, fixed bin (35)), 128 et_page entry (char (*), ptr, fixed bin (35)), 129 130 et_util$get_next entry (ptr, fixed bin (35), fixed bin (35), char (*), fixed bin (35)), 131 et_util$skip entry (ptr, fixed bin (35), fixed bin (35)); 132 133 134 dcl substr builtin; 135 /* */ 1 1 /* BEGIN INCLUDE FILE ... et_instr_data_map.incl.pl1 1 2** 1 3** Created Jan, 73 by Bill Silver. 1 4** 1 5** 1 6** Below is a map of the data found in et_instr_data.alm. 1 7** This is a table of "eis" multi-word instructions. 1 8**/ 1 9 1 10 1 11 1 12 dcl et_instr_data$num_instructions fixed bin external; 1 13 1 14 1 15 dcl 1 et_instr_data$instructions( 0:1 ) aligned external, 1 16 1 17 (2 mnemonic char(4), /* Instruction's assembler name. */ 1 18 1 19 2 opcode bit(10), /* Opcode, rightmost bit always ON. */ 1 20 1 21 2 instr_typex fixed bin(7), /* 1 => alphanumeric, 2 => numeric, 1 22* * 3 => bit string 4 => conversion. */ 1 23 1 24 2 char_sizex (3) fixed bin(2), /* Defines the character size for each descriptor. 1 25* * 0 => 1, 1 => 4, 1 26* * 2 => 36, 3 => -1, 1 27* * -1 => no descriptor */ 1 28 1 29 2 mf2_flag bit(1), /* 1 => instruction word has "mf2" field. 1 30* * 0 => descriptor word has "mf2" field. */ 1 31 1 32 2 mf3_flag bit(1), /* 1 => instruction word has "mf3" field. 1 33* * 0 => descriptor word has "mf3" field. */ 1 34 1 35 2 desc_3_flag bit(1), /* 0 => instruction has 2 descriptors. 1 36* * 1 => instruction has 3 descriptors. */ 1 37 1 38 2 test_x fixed bin(2), /* The number of the data statement used 1 39* * to input the test data. */ 1 40 1 41 2 result_x fixed bin(2)) /* The number of the descriptor which 1 42* * references the result data. */ 1 43 1 44 unaligned; 1 45 1 46 1 47 /* END of INCLUDE FILE ... et_instr_data_map.incl.pl1 */ 136 137 /* */ 2 1 /* BEGINNING OF INCLUDE FILE ... et_setup_data.incl.pl1 2 2* * 2 3* * Created Jan, 73 by Bill Silver. 2 4* * 2 5* * 2 6* * This include file defines the data that is needed to set up a test of an eis 2 7* * instruction. The area where this data actually resides is in "et". 2 8**/ 2 9 2 10 2 11 dcl et_data_ptr ptr; /* Pointer to the et_data area. */ 2 12 2 13 2 14 dcl 1 et_setup_data based (et_data_ptr) aligned, 2 15 2 16 2 next_instruction_x fixed bin, /* Index in script file of where the next 2 17* * instruction test begins. */ 2 18 2 19 2 name char (6), /* Mnemonic name of the instruction 2 20* * being tested. */ 2 21 2 22 2 test_count fixed bin, /* The number of the current test. */ 2 23 2 24 2 note char (64), /* A NOTE containing a description of the test. */ 2 25 2 26 2 loop_count fixed bin, /* Number of times to execute the same 2 27* * variation of an instruction. */ 2 28 2 29 2 instr_offset fixed bin, /* Indicates the position of the eis 2 30* * instruction within the instruction 2 31* * area in etx. */ 2 32 2 33 2 instr_num fixed bin, /* The index of the current instruction's 2 34* * entry in the et_instr_data$instruction 2 35* * array. */ 2 36 2 37 2 instr_type fixed bin, /* 1 = alphanumeric 2 = numeric 2 38* * 3 = bit string 4 = conversion */ 2 39 2 40 2 instr_word bit (36), /* The instruction word of the eis 2 41* * instruction to be tested. */ 2 42 2 43 2 descriptors (3) bit (36), /* The three possible descriptor words 2 44* * of the eis instruction. */ 2 45 2 46 2 ind_words (3) bit (36), /* The three possible indirect words that 2 47* * may follow the eis instruction. */ 2 48 2 49 2 desc_ptrs (3) ptr, /* An array of pointers to where any 2 50* * indirect descriptors must be placed. */ 2 51 2 52 2 mf_ptrs (3) ptr, /* Pointers to the mf fields for each descriptor. 2 53* * If an entry is null then there is no descriptor 2 54* * associated with this entry. */ 2 55 2 56 2 num_chars (3) fixed bin, /* For each descriptor a code indicating what 2 57* * type of "ta" or "tn" field it may have. It 2 58* * implies the number of characters in a word. 2 59* * 1 - descriptor must reference word boundary. 2 60* * 4 - any legal "ta" or "tn" field. 2 61* * Implies 9 bit characters as default. 2 62* * 36 - descriptor may reference bits. 2 63* * -1 - must use "ta" field of descriptor 1 2 64* * 0 - no descriptor. */ 2 65 2 66 2 data_ptrs (5) ptr, /* An array of pointers to where 2 67* * the data for the corresponding 2 68* * descriptor will go. It points to 2 69* * the first word of the data. 2 70* * Entry (4) is for the test data. 2 71* * Entry (5) is for the result data. */ 2 72 2 73 2 data_lens (5) fixed bin, /* An array of lengths of the data fields. 2 74* * They will always be in units of chars. */ 2 75 2 76 2 data_offsets (5) fixed bin, /* An array of character offsets. They specify 2 77* * the character position of the string in 2 78* * the first word of the string. */ 2 79 2 80 2 page_faults (14) bit (1) unal, /* A table of flags which indicate pages 2 81* * which should take a page fault during 2 82* * execution of the eis instruction. */ 2 83 2 84 2 page_ptrs (14) ptr, /* A pointer to each page that is used 2 85* * by the instruction. Pages not used will 2 86* * have null entries. */ 2 87 2 88 2 truncation_flag fixed bin, /* Indicates whether or not the instruction is 2 89* * going to take a truncation fault. 2 90* * 1 => yes, 0 => no. */ 2 91 2 92 2 pointers (0:7) ptr, /* The values of the pointer registers 2 93* * before the execution of the eis instr. */ 2 94 2 95 2 regs, /* Index, A, and Q registers. */ 2 96 3 x (0:7) fixed bin (17) unaligned, 2 97 3 A fixed bin (35), 2 98 3 Q fixed bin (35), 2 99 3 pad (2) bit (36), 2 100 2 101 2 ir_word bit (36); /* The settings of the indicator 2 102* * registers after the eis instruction 2 103* * has been executed. */ 2 104 2 105 2 106 2 107 /* END of INCLUDE FILE ... et_setup_data.incl.pl1 */ 138 139 /* */ 140 /* Establish a window onto the data segment which will look at all of the data 141* * of this one instruction. */ 142 143 et_data_ptr = arg_et_data_ptr; /* Copy this argument so we can reference 144* * common data directly. */ 145 146 start = next_instruction_x; /* Start the window at the beginning 147* * of the next instruction's data. */ 148 size = script_len - start; /* From there open the window on 149* * the rest of the file. */ 150 151 /* Move the window so that it starts at the beginning of the statement name 152* * of the next test statement. If len = 0 then none was found. */ 153 154 call et_util$get_next (script_ptr, start, size, "inst", len); 155 if len = 0 156 then do; 157 code = 100; 158 call com_err_ (0, "ET", "^d Script does not contain valid ""inst"" statement.", code); 159 finished_flag = 1; /* Set flag to end the whole */ 160 return; /* thing. End it now. */ 161 end; 162 163 164 /* We do have an instruction statement to start out test. We must set up a condition 165* * handler for the "stringrange" condition. We will also set up the label variable 166* * which the condition handler procedure can use to get back to this stack frame. 167**/ 168 169 call condition_ ("stringrange", stringrange_handler); 170 171 stringrange_label = stringrange_error; 172 173 save = start; /* Remember where the window is now at 174* * the beginning of this instruction. 175* * Right at the "inst" statement name. */ 176 177 start = start + 4; /* Move the window to after the "inst". */ 178 size = size - 4; 179 180 181 /* Find the beginning of the next instruction. */ 182 183 call et_util$get_next (script_ptr, start, size, "inst", len); 184 185 if len = 0 186 187 /* If no new instruction was found ( the current one is the last one ) then 188* * move the window back to the beginning of the current instruction and 189* * then set the size of the window to be the rest of the segment. Also set 190* * the finished_flag on to indicate that this is the last instruction to test. */ 191 192 then do; 193 start = save; 194 size = script_len - start; 195 next_instruction_x = script_len; 196 finished_flag = 1; 197 end; 198 199 /* If there is another instruction remember where it starts by saving its 200* * address (character number) in next_instruction_x. Then move the window 201* * back to the beginning of the current instruction. Set the size of the 202* * window so that it is open to just the data of the current instruction. */ 203 204 else do; 205 next_instruction_x = start; 206 start = save; 207 size = next_instruction_x - start; 208 end; 209 /* */ 210 /* Now look through the statements of this test. Each statement must 211* * end with a ";". First we must set up the next_statement_x to 212* * point to the beginning of the "inst" statement. 213* */ 214 next_statement_x = start; 215 216 217 218 statement_loop: 219 220 start = next_statement_x; /* Move the window to start at 221* * the beginning of the next state. */ 222 size = next_instruction_x - start; /* The window looks at the rest 223* * of the data for this instruction. */ 224 225 save = start; /* Save the start of the window at 226* * the beginning of the current statement. */ 227 228 /* Look for the ";" which denotes the end of the statement. */ 229 230 call et_util$get_next (script_ptr, start, size, ";", len); 231 if len = 0 /* If no ";" then there are no more */ 232 then goto end_statements; /* statements to parse for this test. */ 233 234 /* If there is a statement then remember where this statement ends and the next 235* * one begins. Move the window back to the beginning of the current statement 236* * and open it so that it just references the data for this statement. 237**/ 238 239 next_statement_x = start + 1; /* start references the character 240* * before the ";" so if we want to 241* * include the ";" in the window for 242* * this statement we must extend the 243* * window by one character. */ 244 start = save; 245 size = next_statement_x - start; 246 247 /* Now search for the statement name of this statement. Note that the first 248* * statement of each instruction must be an "inst" statement. It is processed 249* * in this generalized manner. All other statements do not have to be in any 250* * special order. The statement name does not have to be at the beginning 251* * of the statement line but it must be the first non skip field. 252**/ 253 call et_util$skip (script_ptr, start, size); 254 255 /* Now test to see if we have a valid statement name. If we do we will call 256* * the procedure which will parse this statement. If there is no valid 257* * statement name then we have to return with an error. 258* * Note, upon entry to any of the statement parsing procedures the data window 259* * will start at the first character of the statement name and end at either 260* * a ";" or the end of the data for this instruction. 261**/ 262 263 if substr (window, 1, 4) = "inst" 264 then call et_inst (window, et_data_ptr, code); 265 266 else if substr (window, 1, 4) = "desc" 267 then call et_desc (window, et_data_ptr, code); 268 269 else if substr (window, 1, 4) = "data" 270 then call et_data (window, et_data_ptr, code); 271 272 else if substr (window, 1, 4) = "page" 273 then call et_page (window, et_data_ptr, code); 274 275 else do; 276 call com_err_ (0, "ET", "^d Invalid statement name: ^a ", 277 code, substr (window, 1, 4)); 278 code = 102; 279 end; 280 281 282 /* If the statement just parsed contained an error we will skip the whole test. 283* * The index to the beginning of the next instruction will be saved in "next_instruction_x" 284* * and the next time "et_test" is entered it will start working on the the next 285* * instruction test. 286**/ 287 288 if code ^= 0 then return; /* Was there an error? */ 289 290 291 292 goto statement_loop; /* This is the end of the loop which 293* * processes the statements in an instruction 294* * test. Each iteration processes one 295* * statement. */ 296 297 298 299 /* Now we have parsed all of the statements in this instruction test. 300* * We must set up any index registers that are used in modification of a descriptor. 301* * This is based on the number of characters per word for this descriptor. 302**/ 303 304 end_statements: 305 306 if mf_ptrs (3) = null () 307 then len = 2; 308 else len = 3; 309 310 do i = 1 to len; 311 if mf_ptrs (i) -> mf_map.reg ^= "0"b 312 then if num_chars (i) ^= -1 313 then regs.x (i) = i * num_chars (i); 314 else regs.x (i) = i * num_chars (1); 315 end; 316 317 318 /* Now we must check that the appropriate data fields have been set up by input data. 319* * statements. We will check the following: 320* * 321* * 1. Every instruction must have data for descriptor 1. 322* * 2. If the statement is used to input test data is not a or data 2 statement 323* * then there must be data for descriptor 2. 324* * 3. If there is a third descriptor and the test data is NOT input via a data 3 325* * statement then there must be data for descriptor 3. 326* * 4. If there is supposed to be test data for this instruction then this data must 327* * be present. 328**/ 329 330 331 test_x = et_instr_data$instructions (instr_num).test_x; 332 333 334 if data_lens (1) = 0 335 336 then call error_missing_data (1); 337 338 339 if (test_x ^= 2) & (data_lens (2) = 0) 340 341 then call error_missing_data (2); 342 343 344 if (et_instr_data$instructions (instr_num).desc_3_flag) & 345 346 (test_x ^= 3) & (data_lens (3) = 0) 347 348 then call error_missing_data (3); 349 350 351 if (test_x ^= 0) & (data_lens (4) = 0) 352 353 then call error_missing_data (test_x); 354 355 356 357 return; 358 /* */ 359 /* We come here from the stringrange handler procedure. */ 360 361 362 stringrange_error: 363 364 code = 109; 365 366 call com_err_ (0, "ET", "^d Stringrange condition. Current window is: ^/^a", code, window); 367 368 return; 369 370 371 372 373 374 375 stringrange_handler: procedure; 376 377 goto stringrange_label; 378 379 end stringrange_handler; 380 /* */ 381 error_missing_data: procedure (data_num); 382 383 384 dcl data_num fixed bin; /* The number of the data statement that is missing. */ 385 386 387 code = 110 + data_num; 388 389 390 if data_num ^= test_x 391 392 then 393 call com_err_ (0, "ET", "^d data ^d statement missing or incomplete.", 394 code, data_num); 395 396 else 397 call com_err_ (0, "ET", "^d Test data ^d statement missing or incomplete.", 398 code, data_num); 399 400 401 end error_missing_data; 402 403 404 405 406 end et_test; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/03/82 1024.2 et_test.pl1 >spec>on>phx-dir>et_test.pl1 136 1 05/06/74 1741.2 et_instr_data_map.incl.pl1 >ldd>include>et_instr_data_map.incl.pl1 138 2 06/02/82 1246.3 et_setup_data.incl.pl1 >spec>on>phx-dir>et_setup_data.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. arg_et_data_ptr parameter pointer dcl 54 ref 11 143 code parameter fixed bin(35,0) dcl 54 set ref 11 157* 158* 263* 266* 269* 272* 276* 278* 288 362* 366* 387* 390* 396* com_err_ 000014 constant entry external dcl 121 ref 158 276 366 390 396 condition_ 000016 constant entry external dcl 121 ref 169 data_lens 72 based fixed bin(17,0) array level 2 dcl 2-14 ref 334 339 344 351 data_num parameter fixed bin(17,0) dcl 384 set ref 381 387 390 390* 396* desc_3_flag 1(29) 000034 external static bit(1) array level 2 packed unaligned dcl 1-15 ref 344 et_data 000024 constant entry external dcl 121 ref 269 et_data_ptr 000110 automatic pointer dcl 2-11 set ref 143* 146 195 205 207 222 263* 266* 269* 272* 304 311 311 311 311 314 314 331 334 339 344 344 351 et_desc 000022 constant entry external dcl 121 ref 266 et_inst 000020 constant entry external dcl 121 ref 263 et_instr_data$instructions 000034 external static structure array level 1 dcl 1-15 et_page 000026 constant entry external dcl 121 ref 272 et_setup_data based structure level 1 dcl 2-14 et_util$get_next 000030 constant entry external dcl 121 ref 154 183 230 et_util$skip 000032 constant entry external dcl 121 ref 253 finished_flag parameter fixed bin(17,0) dcl 54 set ref 11 159* 196* i 000102 automatic fixed bin(35,0) dcl 92 set ref 310* 311 311 311 311 311 314 314* instr_num 26 based fixed bin(17,0) level 2 dcl 2-14 ref 331 344 len 000103 automatic fixed bin(35,0) dcl 92 set ref 154* 155 183* 185 230* 231 304* 308* 310 mf_map based structure level 1 packed unaligned dcl 109 mf_ptrs 46 based pointer array level 2 dcl 2-14 ref 304 311 next_instruction_x based fixed bin(17,0) level 2 dcl 2-14 set ref 146 195* 205* 207 222 next_statement_x 000104 automatic fixed bin(35,0) dcl 92 set ref 214* 218 239* 245 num_chars 54 based fixed bin(17,0) array level 2 dcl 2-14 ref 311 311 314 reg 0(03) based bit(4) level 2 packed unaligned dcl 109 ref 311 regs 164 based structure level 2 dcl 2-14 save 000105 automatic fixed bin(35,0) dcl 92 set ref 173* 193 206 225* 244 script based structure level 1 packed unaligned dcl 71 script_len parameter fixed bin(35,0) dcl 54 ref 11 148 194 195 script_ptr parameter pointer dcl 54 set ref 11 154* 183* 230* 253* 263 263 266 266 269 269 272 272 276 276 366 size 000101 automatic fixed bin(35,0) dcl 81 set ref 148* 154* 178* 178 183* 194* 207* 222* 230* 245* 253* 263 263 263 266 266 266 269 269 269 272 272 272 276 276 366 366 start 000100 automatic fixed bin(35,0) dcl 81 set ref 146* 148 154* 173 177* 177 183* 193* 194 205 206* 207 214 218* 222 225 230* 239 244* 245 253* 263 263 266 266 269 269 272 272 276 276 366 stringrange_label 000010 internal static label variable dcl 116 set ref 171* 377 substr builtin function dcl 134 ref 263 266 269 272 276 276 test_x 1(30) 000034 external static fixed bin(2,0) array level 2 in structure "et_instr_data$instructions" packed unaligned dcl 1-15 in procedure "et_test" ref 331 test_x 000106 automatic fixed bin(17,0) dcl 92 in procedure "et_test" set ref 331* 339 344 351 351* 390 window based char level 2 packed unaligned dcl 71 set ref 263 263* 266 266* 269 269* 272 272* 276 276 366* x 164 based fixed bin(17,0) array level 3 packed unaligned dcl 2-14 set ref 311* 314* NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. et_instr_data$num_instructions external static fixed bin(17,0) dcl 1-12 NAMES DECLARED BY EXPLICIT CONTEXT. end_statements 000715 constant label dcl 304 ref 231 error_missing_data 001145 constant entry internal dcl 381 ref 334 339 344 351 et_test 000125 constant entry external dcl 11 statement_loop 000373 constant label dcl 218 set ref 292 stringrange_error 001064 constant label dcl 362 ref 171 stringrange_handler 001136 constant entry internal dcl 375 ref 169 169 NAME DECLARED BY CONTEXT OR IMPLICATION. null builtin function ref 304 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1414 1452 1271 1424 Length 1670 1271 36 202 123 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME et_test 194 external procedure is an external procedure. stringrange_handler 64 internal procedure is assigned to an entry variable. error_missing_data internal procedure shares stack frame of external procedure et_test. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 stringrange_label et_test STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME et_test 000100 start et_test 000101 size et_test 000102 i et_test 000103 len et_test 000104 next_statement_x et_test 000105 save et_test 000106 test_x et_test 000110 et_data_ptr et_test THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return tra_label_var ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ condition_ et_data et_desc et_inst et_page et_util$get_next et_util$skip THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. et_instr_data$instructions LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000120 143 000132 146 000136 148 000140 154 000146 155 000176 157 000200 158 000203 159 000236 160 000241 169 000242 171 000266 173 000272 177 000274 178 000300 183 000306 185 000337 193 000341 194 000343 195 000352 196 000354 197 000356 205 000357 206 000361 207 000363 214 000371 218 000373 222 000375 225 000403 230 000405 231 000437 239 000441 244 000445 245 000447 253 000455 263 000471 266 000532 269 000563 272 000614 276 000645 278 000706 288 000711 292 000714 304 000715 308 000725 310 000727 311 000735 314 000763 315 000775 331 001002 334 001013 339 001021 344 001033 351 001054 357 001063 362 001064 366 001067 368 001134 375 001135 377 001143 381 001145 387 001147 390 001153 396 001217 401 001257 ----------------------------------------------------------- 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