COMPILATION LISTING OF SEGMENT COBOL_SYNTAX_TRACE_ Compiled by: Multics PL/I Compiler, Release 31b, of April 24, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 05/24/89 1007.4 mst Wed Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 14 15 /****^ HISTORY COMMENTS: 16* 1) change(89-04-23,Zimmerman), approve(89-04-23,MCR8060), 17* audit(89-05-05,RWaters), install(89-05-24,MR12.3-1048): 18* MCR8060 COBOL_SYNTAX_TRACE_.pl1 Reformatted code to new Cobol standard. 19* END HISTORY COMMENTS */ 20 21 22 /* Modified on 01/31/80 by FCH, [4.2-2], rw phase added */ 23 /* Modified on 11/15/79 by MHD, [4.2-1], added comment entries to rls segments */ 24 /* Modified since Version 4.0 */ 25 26 27 /* format: style3 */ 28 COBOL_SYNTAX_TRACE_: 29 proc (arg_ptr, trace_mode); 30 31 /* perform a trace in the syntax interpreter */ 32 33 declare arg_ptr ptr, 34 trace_mode fixed bin (31); 35 36 declare ioa_ entry options (variable); 37 38 dcl tssi_$clean_up_segment 39 entry (ptr); 40 dcl tssi_$get_segment entry (char (*), char (*), ptr, ptr, fixed bin (35)); 41 dcl get_pdir_ entry returns (char (168)); 42 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 43 dcl hcs_$initiate_count entry (char (*), char (*), char (*), fixed bin (24), fixed bin (2), ptr, fixed bin (35)); 44 dcl com_err_ entry options (variable); 45 46 47 declare (mode, line_offset) static internal; 48 49 50 declare trace_on fixed bin static internal; 51 52 declare 1 trace static internal, 53 2 curr_first fixed bin (31) init (0), 54 2 curr_last fixed bin (31) init (0), 55 2 phase, 56 4 first (5) fixed bin (31) init (0, 0, 0, 0, 0), 57 4 last (5) fixed bin (31) init (0, 0, 0, 0, 0); 58 59 declare arc_name char (32); 60 declare NAME char (32); 61 declare line char (118); 62 declare dec char (16); 63 declare digs char (10) init ("0123456789"); 64 65 declare (i, curr_offset, curr_line, line_count) 66 fixed bin (31); 67 declare (siz, loc, tloc, POS) 68 fixed bin; 69 declare (first, last, val, pos, CL) 70 fixed bin (31); 71 declare off ptr; 72 declare phase_num fixed bin (31); 73 74 dcl (null, addr, substr, unspec, fixed, mod, index, divide) 75 builtin; 76 77 dcl code fixed bin (35); 78 dcl aclinfo_ptr ptr; 79 dcl bc fixed bin (24); 80 dcl cleanup condition; 81 dcl dn char (168), 82 en char (32); 83 84 declare 1 interp based (arg_ptr), 85 2 current_line fixed bin (31), 86 2 phase fixed bin (31), 87 2 addr_record ptr, 88 2 filler ptr, 89 2 dir_ptr ptr, 90 2 source_ptr ptr; 91 92 declare 1 header based (addr_record), 93 2 size fixed bin (31), 94 2 line fixed bin (31), 95 2 column fixed bin (31), 96 2 type fixed bin (31); 97 98 declare 1 rl_dir (10000) based (interp.dir_ptr), 99 2 offset ptr, 100 2 size fixed bin (31), 101 2 line fixed bin (31); 102 103 declare char_string char (100000) based (source_ptr); 104 105 declare char_array (100000) char (1) based (source_ptr); 106 declare bit_array (100000) bit (9) based (source_ptr); 107 108 declare arg char (32) based (arg_ptr); 109 110 reset_trace: 111 entry; 112 113 114 115 trace.curr_first = 0; 116 trace.curr_last = 0; 117 118 119 return; 120 121 trace: 122 entry (arg_ptr, trace_mode); 123 124 125 go to T (trace_on); 126 127 T (0): 128 if header.line = 0 129 then return; 130 else if header.line < trace.curr_first 131 then return; 132 else trace_on = 1; 133 134 go to T1; 135 136 T (1): 137 if trace.curr_last ^= 0 138 then do; 139 if header.line > trace.curr_last 140 then do; 141 trace_on = 2; 142 return; 143 end; 144 end; 145 146 go to T1; 147 148 T (2): 149 return; 150 151 T1: 152 if mode = 0 153 then do; 154 CL = current_line + line_offset; 155 line = " "; 156 siz = rl_dir.size (CL); 157 off = rl_dir.offset (CL); 158 159 dec = char (rl_dir.line (CL) * 10); 160 substr (line, 1, 5) = substr (dec, 12, 5); 161 162 substr (line, 41, siz) = substr (off -> char_string, 1, siz); 163 164 dec = char (header.line * 10); 165 substr (line, 13, 6) = substr (dec, 11, 6); 166 dec = char (header.column * 10); 167 substr (line, 20, 6) = substr (dec, 11, 6); 168 dec = char (header.type * 10); 169 substr (line, 27, 6) = substr (dec, 11, 6); 170 171 if (trace_mode = 1 | trace_mode = 4) 172 then substr (line, 33, 1) = "~"; 173 174 if trace_mode = 4 | trace_mode = 5 175 then substr (line, 7, 6) = ">>>>>>"; 176 177 if trace_mode = 3 178 then substr (line, 7, 6) = "<<<<<<"; 179 180 call ioa_ (line); 181 182 end; 183 184 return; 185 186 make_dir: 187 proc; 188 189 declare (loc, nb_loc) fixed bin; 190 declare ch char (1); 191 192 call tssi_$get_segment (get_pdir_ (), "RED_DIR_QJZW", interp.dir_ptr, aclinfo_ptr, code); 193 194 if code ^= 0 195 then go to error; 196 197 i, line_count, curr_offset, curr_line = 1; 198 199 do while (substr (char_string, i, 3) ^= "~~~"); 200 201 loc = index (substr (char_string, i, 256), " 202 "); 203 204 /*[4.2-1]*/ 205 if loc ^= 1 & char_array (i) ^= "~" 206 then do; 207 nb_loc = 1; 208 ch = substr (char_string, 1, 1); 209 210 do while (ch = " " | ch = " "); 211 212 nb_loc = nb_loc + 1; 213 ch = substr (char_string, nb_loc, 1); 214 215 end; 216 217 if nb_loc < loc 218 then do; 219 220 rl_dir.offset (curr_line) = addr (char_array (curr_offset)); 221 222 tloc = index (substr (char_string, i, loc), "~"); 223 224 if tloc = 0 225 then rl_dir.size (curr_line) = loc - 1; 226 else rl_dir.size (curr_line) = tloc - 1; 227 228 rl_dir.line (curr_line) = line_count; 229 230 curr_line = curr_line + 1; 231 232 end; 233 234 end; 235 236 i = i + loc; 237 curr_offset = i; 238 line_count = line_count + 1; 239 end; 240 241 if code ^= 0 242 then go to error; 243 244 end; 245 246 initialize: 247 entry (arg_ptr); 248 249 /*[4.2-2]*/ 250 POS = index ("id*dd*pd*db*rw*", substr (arg, 6, 2) || "*"); 251 252 /*[4.2-2]*/ 253 if POS = 0 254 then return; 255 256 /*[4.2-2]*/ 257 POS = divide (POS + 1, 2, 31, 0); 258 259 /*[4.2-2]*/ 260 call limits; 261 262 /*[4.2-2]*/ 263 trace.phase.first (POS) = first; /*[4.2-2]*/ 264 trace.phase.last (POS) = last; 265 266 return; 267 268 dec_to_bin: 269 proc; 270 271 declare (orig, size) fixed bin (31); 272 273 orig = i; 274 pos = index (digs, substr (arg, i, 1)); 275 276 do while (pos ^= 0); 277 i = i + 1; 278 pos = index (digs, substr (arg, i, 1)); 279 end; 280 281 size = i - orig; 282 283 if size ^= 0 284 then val = fixed (substr (arg, orig, size)); 285 else val = 0; 286 287 end; 288 289 arc_entry: 290 proc; 291 292 /* char(12) 014 012 012 012 */ 293 /* 017 012 011 011 */ 294 /* b b b b */ 295 296 /* char(32) component name(left justified , blank padding) */ 297 298 /* char(36) MM/DD/YYbb date */ 299 /* TTTT.T time */ 300 /* AAAA access mode */ 301 /* MM/DD/YYbb date */ 302 /* TTTT.T time */ 303 /* char(8) 017 017 017 017 */ 304 /* 012 012 012 012 */ 305 306 /* char(*) data (padded with 000 to half word boundry) */ 307 308 309 declare ent_ptr ptr; 310 declare size fixed bin (36); 311 312 declare 1 entry based (ent_ptr), 313 2 flag1 char (12), 314 2 name char (32), 315 2 desc char (36), 316 2 size char (12), 317 2 flag2 char (8), 318 2 data (100000) char (1); 319 320 ent_ptr = source_ptr; 321 322 do while ("1"b); 323 324 if NAME = entry.name 325 then do; 326 source_ptr = addr (entry.data (1)); 327 return; 328 end; 329 330 if unspec (substr (entry.flag1, 1, 1)) ^= "000001100"b 331 then do; 332 source_ptr = null (); 333 return; 334 end; 335 336 size = fixed (entry.size); 337 size = size / 9; 338 size = size + mod (-size, 4); 339 340 ent_ptr = addr (entry.data (size + 1)); 341 342 end; 343 344 end; 345 346 limits: 347 proc; 348 349 first = 0; 350 last = 0; 351 352 i = 8; 353 call dec_to_bin; 354 355 first = val; 356 if substr (arg, i, 1) ^= "," 357 then return; 358 359 i = i + 1; 360 call dec_to_bin; 361 362 last = val; 363 364 end; 365 366 error: 367 call com_err_ (code, "COBOL_SYNTAX_TRACE_"); 368 return; 369 370 cl: 371 proc; 372 373 call tssi_$clean_up_segment (aclinfo_ptr); 374 375 end; 376 377 initialize_phase: 378 entry (arg_ptr, phase_num); 379 380 line_offset = 0; 381 382 on cleanup call cl; 383 384 go to ph (phase_num); 385 386 ph (1): 387 NAME = "IDEDTABLE.reductions"; 388 arc_name = "IDEDTABLE.archive"; 389 go to pha; 390 391 ph (2): 392 NAME = "DDTABLE.reductions"; 393 arc_name = "DDTABLE.archive"; 394 go to pha; 395 396 ph (3): 397 NAME = "PDTABLE.reductions"; 398 arc_name = "PDTABLE.archive"; 399 go to pha; 400 401 ph (4): 402 NAME = "DB.reductions"; 403 arc_name = "DB.archive"; 404 go to pha; 405 406 /*[4.2-2]*/ 407 ph (5): /*[4.2-2]*/ 408 NAME = "RW.reductions"; 409 arc_name = "RW.archive"; /*[4.2-2]*/ 410 go to pha; 411 412 pha: 413 mode = 0; 414 415 call expand_pathname_ (NAME, dn, en, code); 416 417 if code ^= 0 418 then go to error; 419 420 call hcs_$initiate_count (dn, en, "", bc, 1, source_ptr, code); 421 422 if source_ptr = null () 423 then do; 424 call expand_pathname_ (arc_name, dn, en, code); 425 426 if code ^= 0 427 then go to error; 428 429 call hcs_$initiate_count (dn, en, "", bc, 1, source_ptr, code); 430 431 if source_ptr = null () 432 then mode = 1; 433 else do; 434 call arc_entry; 435 436 if source_ptr = null () 437 then go to error; 438 439 end; 440 end; 441 442 call make_dir; 443 444 trace.curr_first = trace.first (phase_num); 445 trace.curr_last = trace.last (phase_num); 446 447 trace_on = 0; 448 449 450 end COBOL_SYNTAX_TRACE_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/24/89 0834.2 COBOL_SYNTAX_TRACE_.pl1 >spec>install>MR12.3-1048>COBOL_SYNTAX_TRACE_.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. CL 000200 automatic fixed bin(31,0) dcl 69 set ref 154* 156 157 159 NAME 000110 automatic char(32) packed unaligned dcl 60 set ref 324 386* 391* 396* 401* 407* 415* POS 000173 automatic fixed bin(17,0) dcl 67 set ref 250* 253 257* 257 263 264 aclinfo_ptr 000206 automatic pointer dcl 78 set ref 192* 373* addr builtin function dcl 74 ref 220 326 340 addr_record 2 based pointer level 2 dcl 84 ref 127 130 139 164 166 168 arc_name 000100 automatic char(32) packed unaligned dcl 59 set ref 388* 393* 398* 403* 409* 424* arg based char(32) packed unaligned dcl 108 ref 250 274 278 283 356 arg_ptr parameter pointer dcl 33 ref 28 121 127 130 139 154 156 157 159 164 166 168 192 199 201 205 208 213 220 220 222 224 226 228 246 250 274 278 283 320 326 332 356 377 420 422 429 431 436 bc 000210 automatic fixed bin(24,0) dcl 79 set ref 420* 429* ch 000312 automatic char(1) packed unaligned dcl 190 set ref 208* 210 210 213* char_array based char(1) array packed unaligned dcl 105 set ref 205 220 char_string based char(100000) packed unaligned dcl 103 ref 162 199 201 208 213 222 cleanup 000212 stack reference condition dcl 80 ref 382 code 000204 automatic fixed bin(35,0) dcl 77 set ref 192* 194 241 366* 415* 417 420* 424* 426 429* column 2 based fixed bin(31,0) level 2 dcl 92 ref 166 com_err_ 000044 constant entry external dcl 44 ref 366 curr_first 000013 internal static fixed bin(31,0) initial level 2 dcl 52 set ref 115* 130 444* curr_last 1 000013 internal static fixed bin(31,0) initial level 2 dcl 52 set ref 116* 136 139 445* curr_line 000167 automatic fixed bin(31,0) dcl 65 set ref 197* 220 224 226 228 230* 230 curr_offset 000166 automatic fixed bin(31,0) dcl 65 set ref 197* 220 237* current_line based fixed bin(31,0) level 2 dcl 84 ref 154 data 31 based char(1) array level 2 packed packed unaligned dcl 312 set ref 326 340 dec 000156 automatic char(16) packed unaligned dcl 62 set ref 159* 160 164* 165 166* 167 168* 169 digs 000162 automatic char(10) initial packed unaligned dcl 63 set ref 63* 274 278 dir_ptr 6 based pointer level 2 dcl 84 set ref 156 157 159 192* 220 224 226 228 divide builtin function dcl 74 ref 257 dn 000220 automatic char(168) packed unaligned dcl 81 set ref 415* 420* 424* 429* en 000272 automatic char(32) packed unaligned dcl 81 set ref 415* 420* 424* 429* ent_ptr 000332 automatic pointer dcl 309 set ref 320* 324 326 330 336 340* 340 entry based structure level 1 packed packed unaligned dcl 312 expand_pathname_ 000040 constant entry external dcl 42 ref 415 424 first 2 000013 internal static fixed bin(31,0) initial array level 3 in structure "trace" dcl 52 in procedure "COBOL_SYNTAX_TRACE_" set ref 263* 444 first 000174 automatic fixed bin(31,0) dcl 69 in procedure "COBOL_SYNTAX_TRACE_" set ref 263 349* 355* fixed builtin function dcl 74 ref 283 336 flag1 based char(12) level 2 packed packed unaligned dcl 312 ref 330 get_pdir_ 000036 constant entry external dcl 41 ref 192 192 hcs_$initiate_count 000042 constant entry external dcl 43 ref 420 429 header based structure level 1 unaligned dcl 92 i 000165 automatic fixed bin(31,0) dcl 65 set ref 197* 199 201 205 222 236* 236 237 273 274 277* 277 278 281 352* 356 359* 359 index builtin function dcl 74 ref 201 222 250 274 278 interp based structure level 1 unaligned dcl 84 ioa_ 000030 constant entry external dcl 36 ref 180 last 000175 automatic fixed bin(31,0) dcl 69 in procedure "COBOL_SYNTAX_TRACE_" set ref 264 350* 362* last 7 000013 internal static fixed bin(31,0) initial array level 3 in structure "trace" dcl 52 in procedure "COBOL_SYNTAX_TRACE_" set ref 264* 445 line 000120 automatic char(118) packed unaligned dcl 61 in procedure "COBOL_SYNTAX_TRACE_" set ref 155* 160* 162* 165* 167* 169* 171* 174* 177* 180* line 1 based fixed bin(31,0) level 2 in structure "header" dcl 92 in procedure "COBOL_SYNTAX_TRACE_" ref 127 130 139 164 line 3 based fixed bin(31,0) array level 2 in structure "rl_dir" dcl 98 in procedure "COBOL_SYNTAX_TRACE_" set ref 159 228* line_count 000170 automatic fixed bin(31,0) dcl 65 set ref 197* 228 238* 238 line_offset 000011 internal static fixed bin(17,0) dcl 47 set ref 154 380* loc 000310 automatic fixed bin(17,0) dcl 189 set ref 201* 205 217 222 224 236 mod builtin function dcl 74 ref 338 mode 000010 internal static fixed bin(17,0) dcl 47 set ref 151 412* 431* name 3 based char(32) level 2 packed packed unaligned dcl 312 ref 324 nb_loc 000311 automatic fixed bin(17,0) dcl 189 set ref 207* 212* 212 213 217 null builtin function dcl 74 ref 332 422 431 436 off 000202 automatic pointer dcl 71 set ref 157* 162 offset based pointer array level 2 dcl 98 set ref 157 220* orig 000322 automatic fixed bin(31,0) dcl 271 set ref 273* 281 283 phase 2 000013 internal static structure level 2 unaligned dcl 52 phase_num parameter fixed bin(31,0) dcl 72 ref 377 384 444 445 pos 000177 automatic fixed bin(31,0) dcl 69 set ref 274* 276 278* rl_dir based structure array level 1 unaligned dcl 98 siz 000171 automatic fixed bin(17,0) dcl 67 set ref 156* 162 162 size 000334 automatic fixed bin(36,0) dcl 310 in procedure "arc_entry" set ref 336* 337* 337 338* 338 338 340 size 2 based fixed bin(31,0) array level 2 in structure "rl_dir" dcl 98 in procedure "COBOL_SYNTAX_TRACE_" set ref 156 224* 226* size 24 based char(12) level 2 in structure "entry" packed packed unaligned dcl 312 in procedure "arc_entry" ref 336 size 000323 automatic fixed bin(31,0) dcl 271 in procedure "dec_to_bin" set ref 281* 283 283 source_ptr 10 based pointer level 2 dcl 84 set ref 199 201 205 208 213 220 222 320 326* 332* 420* 422 429* 431 436 substr builtin function dcl 74 set ref 160* 160 162* 162 165* 165 167* 167 169* 169 171* 174* 177* 199 201 208 213 222 250 274 278 283 330 356 tloc 000172 automatic fixed bin(17,0) dcl 67 set ref 222* 224 226 trace 000013 internal static structure level 1 unaligned dcl 52 trace_mode parameter fixed bin(31,0) dcl 33 ref 28 121 171 171 174 174 177 trace_on 000012 internal static fixed bin(17,0) dcl 50 set ref 125 132* 141* 447* tssi_$clean_up_segment 000032 constant entry external dcl 38 ref 373 tssi_$get_segment 000034 constant entry external dcl 40 ref 192 type 3 based fixed bin(31,0) level 2 dcl 92 ref 168 unspec builtin function dcl 74 ref 330 val 000176 automatic fixed bin(31,0) dcl 69 set ref 283* 285* 355 362 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. bit_array based bit(9) array packed unaligned dcl 106 loc automatic fixed bin(17,0) dcl 67 NAMES DECLARED BY EXPLICIT CONTEXT. COBOL_SYNTAX_TRACE_ 000143 constant entry external dcl 28 T 000000 constant label array(0:2) dcl 127 ref 125 T1 000231 constant label dcl 151 ref 134 146 arc_entry 001366 constant entry internal dcl 289 ref 434 cl 001506 constant entry internal dcl 370 ref 382 dec_to_bin 001276 constant entry internal dcl 268 ref 353 360 error 000474 constant label dcl 366 ref 194 241 417 426 436 initialize 000432 constant entry external dcl 246 initialize_phase 000522 constant entry external dcl 377 limits 001460 constant entry internal dcl 346 ref 260 make_dir 001053 constant entry internal dcl 186 ref 442 ph 000003 constant label array(5) dcl 386 ref 384 pha 000616 constant label dcl 412 ref 389 394 399 404 410 reset_trace 000153 constant entry external dcl 110 trace 000167 constant entry external dcl 121 NAME DECLARED BY CONTEXT OR IMPLICATION. char builtin function ref 159 164 166 168 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1702 1750 1533 1712 Length 2150 1533 46 164 147 20 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME COBOL_SYNTAX_TRACE_ 724 external procedure is an external procedure. make_dir internal procedure shares stack frame of external procedure COBOL_SYNTAX_TRACE_. dec_to_bin internal procedure shares stack frame of external procedure COBOL_SYNTAX_TRACE_. arc_entry internal procedure shares stack frame of external procedure COBOL_SYNTAX_TRACE_. limits internal procedure shares stack frame of external procedure COBOL_SYNTAX_TRACE_. cl internal procedure shares stack frame of on unit on line 382. on unit on line 382 74 on unit STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 mode COBOL_SYNTAX_TRACE_ 000011 line_offset COBOL_SYNTAX_TRACE_ 000012 trace_on COBOL_SYNTAX_TRACE_ 000013 trace COBOL_SYNTAX_TRACE_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME COBOL_SYNTAX_TRACE_ 000100 arc_name COBOL_SYNTAX_TRACE_ 000110 NAME COBOL_SYNTAX_TRACE_ 000120 line COBOL_SYNTAX_TRACE_ 000156 dec COBOL_SYNTAX_TRACE_ 000162 digs COBOL_SYNTAX_TRACE_ 000165 i COBOL_SYNTAX_TRACE_ 000166 curr_offset COBOL_SYNTAX_TRACE_ 000167 curr_line COBOL_SYNTAX_TRACE_ 000170 line_count COBOL_SYNTAX_TRACE_ 000171 siz COBOL_SYNTAX_TRACE_ 000172 tloc COBOL_SYNTAX_TRACE_ 000173 POS COBOL_SYNTAX_TRACE_ 000174 first COBOL_SYNTAX_TRACE_ 000175 last COBOL_SYNTAX_TRACE_ 000176 val COBOL_SYNTAX_TRACE_ 000177 pos COBOL_SYNTAX_TRACE_ 000200 CL COBOL_SYNTAX_TRACE_ 000202 off COBOL_SYNTAX_TRACE_ 000204 code COBOL_SYNTAX_TRACE_ 000206 aclinfo_ptr COBOL_SYNTAX_TRACE_ 000210 bc COBOL_SYNTAX_TRACE_ 000220 dn COBOL_SYNTAX_TRACE_ 000272 en COBOL_SYNTAX_TRACE_ 000310 loc make_dir 000311 nb_loc make_dir 000312 ch make_dir 000322 orig dec_to_bin 000323 size dec_to_bin 000332 ent_ptr arc_entry 000334 size arc_entry THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out_desc call_ext_out return_mac mdfx3 enable_op ext_entry int_entry trunc_fx2 set_chars_eis index_chars_eis any_to_any_truncate_ divide_fx3 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ expand_pathname_ get_pdir_ hcs_$initiate_count ioa_ tssi_$clean_up_segment tssi_$get_segment NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 63 000130 28 000137 110 000151 115 000161 116 000163 119 000164 121 000165 125 000175 127 000200 130 000206 132 000211 134 000213 136 000214 139 000216 141 000224 142 000226 146 000227 148 000230 151 000231 154 000234 155 000241 156 000244 157 000252 159 000254 160 000272 162 000276 164 000302 165 000321 166 000325 167 000343 168 000346 169 000364 171 000367 174 000401 177 000410 180 000416 184 000426 246 000427 250 000440 253 000460 257 000461 260 000464 263 000465 264 000471 266 000473 366 000474 368 000517 377 000520 380 000530 382 000532 384 000550 386 000553 388 000556 389 000561 391 000562 393 000565 394 000570 396 000571 398 000574 399 000577 401 000600 403 000603 404 000606 407 000607 409 000612 410 000615 412 000616 415 000620 417 000643 420 000645 422 000713 424 000722 426 000746 429 000750 431 001016 434 001031 436 001032 442 001041 444 001042 445 001047 447 001051 450 001052 186 001053 192 001054 194 001122 197 001124 199 001131 201 001143 205 001154 207 001162 208 001164 210 001170 212 001175 213 001176 215 001207 217 001210 220 001213 222 001227 224 001246 226 001255 228 001261 230 001264 236 001265 237 001267 238 001271 239 001272 241 001273 244 001275 268 001276 273 001277 274 001301 276 001315 277 001320 278 001321 279 001336 281 001337 283 001342 285 001364 287 001365 289 001366 320 001367 324 001374 326 001401 327 001406 330 001407 332 001413 333 001420 336 001421 337 001434 338 001443 340 001452 342 001456 344 001457 346 001460 349 001461 350 001462 352 001463 353 001465 355 001466 356 001470 359 001501 360 001502 362 001503 364 001505 370 001506 373 001507 375 001517 ----------------------------------------------------------- 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