COMPILATION LISTING OF SEGMENT cv_ppscf Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/18/82 1648.1 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 (subrg, size): 12 cv_ppscf: proc (); 13 14 15 16 /* PARAMETERS */ 17 18 19 20 21 /* ENTRY CONSTANTS */ 22 23 24 dcl com_err_ entry options (variable); 25 dcl cu_$arg_count entry (fixed bin); 26 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 27 dcl cv_hex_check_ entry (char (*), fixed bin (35)) returns (fixed bin (35)); 28 dcl cv_ppscf$cv_ppscf ext; 29 dcl expand_pathname_$add_suffix entry (char (*), char (*), char (*), char (*), fixed bin (35)); 30 dcl get_pdir_ entry () returns (char (168)); 31 dcl ioa_ entry options (variable); 32 dcl ioa_$ioa_stream entry options (variable); 33 dcl ioa_$ioa_switch entry options (variable); 34 dcl iox_$attach_name entry (char (*), ptr, char (*), ptr, fixed bin (35)); 35 dcl iox_$close entry (ptr, fixed bin (35)); 36 dcl iox_$detach_iocb entry (ptr, fixed bin (35)); 37 dcl iox_$get_line entry (ptr, ptr, fixed bin (21), fixed bin (21), fixed bin (35)); 38 dcl iox_$open entry (ptr, fixed bin, bit (1) aligned, fixed bin (35)); 39 dcl iox_$put_chars entry (ptr, ptr, fixed bin (21), fixed bin (35)); 40 41 42 /* EXTERNAL DATA */ 43 44 45 dcl error_table_$badopt fixed bin (35) ext; 46 dcl error_table_$end_of_info fixed bin (35) ext; 47 dcl error_table_$long_record fixed bin (35) ext; 48 dcl error_table_$noarg fixed bin (35) ext; 49 50 51 /* BUILTIN FUNCTIONS & CONDITIONS */ 52 53 54 dcl addr builtin; 55 dcl fixed builtin; 56 dcl hbound builtin; 57 dcl length builtin; 58 dcl ltrim builtin; 59 dcl null builtin; 60 dcl rtrim builtin; 61 dcl search builtin; 62 dcl size builtin; 63 dcl substr builtin; 64 dcl unspec builtin; 65 dcl verify builtin; 66 67 dcl cleanup condition; 68 69 70 /* AUTOMATIC STORAGE */ 71 72 73 dcl X (20) fixed bin (8) unal; 74 dcl arg_len fixed bin; 75 dcl arg_ptr ptr; 76 dcl code fixed bin (35); 77 dcl default_char fixed bin; 78 dcl dname char (168); 79 dcl ename char (168); 80 dcl error_flag bit (1); 81 dcl hex_value fixed bin (35); 82 dcl i fixed bin; 83 dcl init bit (1) aligned; 84 dcl input file; 85 dcl input_i fixed bin; 86 dcl input_iocb_ptr ptr; 87 dcl input_l fixed bin; 88 dcl input_line char (128); 89 dcl j fixed bin; 90 dcl line_num fixed bin; 91 dcl list_flag bit (1); 92 dcl list_iocb_ptr ptr; 93 dcl listing output file; 94 dcl long_flag bit (1); 95 dcl me_ptr ptr; 96 dcl n_hits fixed bin; 97 dcl n_read fixed bin (21); 98 dcl nargs fixed bin; 99 dcl oc fixed bin (8) unal; 100 dcl output output file; 101 dcl output_iocb_ptr ptr; 102 dcl pps (0:255) fixed bin (8) unal; 103 dcl sort_iocb_ptr ptr; 104 dcl source_name char (32) var; 105 dcl source_path char (168) var; 106 dcl space_char fixed bin; 107 dcl sysprint print file; 108 dcl table (0:127-32, 0:255) fixed bin (8) unal; 109 dcl text_l fixed bin; 110 dcl text_ptr ptr; 111 dcl token_l fixed bin; 112 dcl token_ptr ptr; 113 dcl value fixed bin; 114 dcl word_ptr ptr; 115 dcl x fixed bin; 116 117 dcl 1 index_table, 118 2 default_char fixed bin (8) unal, 119 2 space_char fixed bin (8) unal, 120 2 tab (0:255), 121 3 ascii_char fixed bin (8) unal, 122 3 pps_char fixed bin (8) unal; 123 124 125 dcl 1 sort_rec, 126 2 key char (14) unal, 127 2 value fixed bin (8) unal, 128 2 nl char (1); 129 130 131 /* CONSTANTS */ 132 133 134 dcl BS char (1) static internal options (constant) init (""); 135 dcl ME char (8) static internal options (constant) init ("cv_ppscf"); 136 dcl NL char (1) static internal options (constant) init (" 137 "); 138 dcl WS char (4) static internal options (constant) init (" "); 139 140 dcl CODE_LINE (18) char (80) var static internal options (constant) init ( 141 " epp1 ap|2,* address of source string to pr1", 142 " epp3 ap|4,* address of target string to pr3", 143 " ldx3 0,du set x3 not to skip parent pointer if none", 144 " lxl2 ap|0 load argument list code value", 145 " canx2 =o000004,du check for code 4 - no parent pointer", 146 " tnz *+2 transfer if no parent pointer", 147 " ldx3 2,du parent pointer - set x3 to skip it", 148 " lda ap|6,x3* load source string descriptor", 149 " ldq ap|8,x3* load target string descriptor", 150 " ana mask drop all but string size bits", 151 " anq mask ditto", 152 " even", 153 " mvt (pr,rl),(pr,rl),fill(040) translate ascii to ebcdic", 154 " desc9a 1|0,al source string", 155 " desc9a 3|0,ql target string", 156 " arg mvtt", 157 " short_return ""exit", 158 "mask: oct 000077777777"); 159 160 161 /* INTERNAL STATIC */ 162 163 164 dcl db_sw bit (1) aligned static init ("0"b); 165 166 167 /* BASED VARIABLES */ 168 169 170 dcl arg char (arg_len) based (arg_ptr); 171 dcl input_array (128) char (1) unal based (addr (input_line)); 172 dcl text char (text_l) based (text_ptr); 173 dcl token char (token_l) based (token_ptr); 174 dcl word (6144) bit (36) aligned based (word_ptr); 175 176 me_ptr = addr (cv_ppscf$cv_ppscf); 177 178 179 call cu_$arg_count (nargs); 180 if nargs < 1 then do; 181 code = error_table_$noarg; 182 call com_err_ (code, ME, 183 "^/Usage is: cv_ppscf path {-list|-ls|-long|-lg}..."); 184 return; 185 end; 186 187 call cu_$arg_ptr (1, arg_ptr, arg_len, code); 188 if code ^= 0 then do; 189 call com_err_ (code, ME); 190 return; 191 end; 192 call expand_pathname_$add_suffix (arg, "ppscf", dname, ename, code); 193 if code ^= 0 then do; 194 call com_err_ (code, ME, "^a", arg); 195 return; 196 end; 197 source_name = substr (ename, 1, length (rtrim (ename))-6); 198 if dname = ">" then source_path = ""; 199 else source_path = rtrim (dname); 200 source_path = source_path || ">" || source_name; 201 202 203 list_flag = "0"b; 204 long_flag = "0"b; 205 do i = 2 to nargs; 206 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 207 if code ^= 0 then do; 208 call com_err_ (code, ME, "Referencing argument #^d.", i); 209 return; 210 end; 211 if arg = "-list" | arg = "-ls" then list_flag = "1"b; 212 else if arg = "-long" | arg = "-lg" then long_flag = "1"b; 213 else do; 214 code = error_table_$badopt; 215 call com_err_ (code, ME, "^a", arg); 216 return; 217 end; 218 end; 219 220 input_iocb_ptr = null (); 221 output_iocb_ptr = null (); 222 list_iocb_ptr = null (); 223 sort_iocb_ptr = null (); 224 225 on cleanup call CLEANUP (); 226 227 call iox_$attach_name ("input", input_iocb_ptr, "vfile_ " || source_path || ".ppscf ", me_ptr, code); 228 if code ^= 0 then do; 229 call com_err_ (code, ME, "Error attaching input stream.^/Attach description: ^a", 230 "vfile_ " || source_path || ".ppscf"); 231 return; 232 end; 233 call iox_$open (input_iocb_ptr, 1, "0"b, code); 234 if code ^= 0 then do; 235 call com_err_ (code, ME, "^a", "input"); 236 call CLEANUP (); 237 return; 238 end; 239 240 call iox_$attach_name ("output", output_iocb_ptr, "vfile_ " || source_path || ".alm", me_ptr, code); 241 if code ^= 0 then do; 242 call com_err_ (code, ME, "Error attaching output stream.^/Attach description: ^a", 243 "vfile_ " || source_path || ".alm"); 244 call CLEANUP (); 245 return; 246 end; 247 call iox_$open (output_iocb_ptr, 2, "0"b, code); 248 if code ^= 0 then do; 249 call com_err_ (code, ME, "^a", "output"); 250 call CLEANUP (); 251 return; 252 end; 253 254 if list_flag then do; 255 call iox_$attach_name ("listing", list_iocb_ptr, "vfile_ " || source_path || ".ppsctl", me_ptr, code); 256 if code ^= 0 then do; 257 call com_err_ (code, ME, "Error attaching listing switch.^/Attach description: ^a", 258 "vfile_ " || source_path || ".ppsctl"); 259 call CLEANUP (); 260 return; 261 end; 262 call iox_$open (list_iocb_ptr, 2, "0"b, code); 263 if code ^= 0 then do; 264 call com_err_ (code, ME, "^a", "listing"); 265 call CLEANUP (); 266 return; 267 end; 268 end; 269 270 call iox_$attach_name ("sort", sort_iocb_ptr, "vfile_ " || rtrim (get_pdir_ ()) || ">sort", me_ptr, code); 271 if code ^= 0 then do; 272 call com_err_ (code, ME, "Error attaching sort stream.^/Attach description: ^a", 273 "vfile_ " || rtrim (get_pdir_ ()) || ">sort"); 274 call CLEANUP (); 275 return; 276 end; 277 call iox_$open (sort_iocb_ptr, 2, "0"b, code); 278 if code ^= 0 then do; 279 call com_err_ (code, ME, "^a", "sort"); 280 call CLEANUP (); 281 return; 282 end; 283 284 error_flag = "0"b; 285 default_char = 0; 286 line_num = 1; 287 code = 0; 288 do while (code ^= error_table_$end_of_info); 289 input_line = ""; 290 call iox_$get_line (input_iocb_ptr, addr (input_line), length (input_line), n_read, code); 291 if code = error_table_$long_record then do; 292 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/The input line is too long.^/SOURCE: ^a^/", 293 line_num, input_line); 294 code = 0; 295 end; 296 else if code = 0 then do; 297 if substr (input_line, n_read, 1) = NL then 298 n_read = n_read -1; 299 if n_read > 0 then do; 300 call PROCESS_INPUT_LINE (); 301 if text_ptr ^= null () then 302 call WRITE_INPUT_LINE (); 303 end; 304 end; 305 else if code ^= error_table_$end_of_info then do; 306 call com_err_ (code, ME, "Error on line number ^d while reading input file.", line_num); 307 call CLEANUP (); 308 return; 309 end; 310 line_num = line_num+1; 311 end; 312 313 if error_flag then goto FATAL; 314 315 call SORT_INPUT (); 316 317 /* 318* 319* Initialize the tables involved. 320* 321**/ 322 323 324 do i = 0 to hbound (table, 1); 325 do j = 0 to hbound (table, 2); 326 table (i, j) = default_char; 327 end; 328 end; 329 330 do i = 0 to hbound (pps, 1); 331 pps (i) = default_char; 332 end; 333 334 index_table.default_char = default_char; 335 index_table.space_char = space_char; 336 do i = 0 to hbound (index_table.tab, 1); 337 index_table.tab (i).ascii_char = -1; 338 index_table.tab (i).pps_char = -1; 339 end; 340 341 line_num = 0; 342 n_hits = 0; 343 344 345 /* 346* 347* Now process the input file. 348* 349**/ 350 351 352 code = 0; 353 354 do while (code ^= error_table_$end_of_info); 355 356 call GET_A_LINE (); 357 358 if code ^= error_table_$end_of_info then 359 if x ^= 0 then 360 call PROCESS_A_LINE (); 361 362 end; 363 364 value = space_char; 365 if ^SET_PPS (0) then; 366 if ^SET_TABLE (0, (space_char)) then; 367 368 if list_flag then 369 call ioa_$ioa_switch (list_iocb_ptr, "^d out of ^d table entries used.", n_hits, size (table)*4); 370 if long_flag then 371 call ioa_ ("^d out of ^d table entries used.", n_hits, size (table)*4); 372 373 374 /* 375* 376* Now we have a completed table! Create a source segment. 377* 378**/ 379 380 381 call ioa_$ioa_switch (output_iocb_ptr, "^-segdef^-^a_move^/^a_move:", 382 source_name, source_name); 383 do i = 1 to hbound (CODE_LINE, 1); 384 call ioa_$ioa_switch (output_iocb_ptr, "^a", CODE_LINE (i)); 385 end; 386 call ioa_$ioa_switch (output_iocb_ptr, "^/^-segdef^-^a_table^/^a_table:", 387 source_name, source_name); 388 word_ptr = addr (table); 389 do i = 1 to size (table) by 4; 390 call ioa_$ioa_switch (output_iocb_ptr, "^-oct^-^w,^w,^w,^w", 391 word (i), word (i+1), word (i+2), word (i+3)); 392 end; 393 call ioa_$ioa_switch (output_iocb_ptr, "^|mvtt:^-null"); 394 word_ptr = addr (pps); 395 do i = 1 to size (pps) by 4; 396 call ioa_$ioa_switch (output_iocb_ptr, "^-oct^-^w,^w,^w,^w", 397 word (i), word (i+1), word (i+2), word (i+3)); 398 end; 399 call ioa_$ioa_switch (output_iocb_ptr, "^-end"); 400 401 402 if list_flag then 403 do i = 0 to hbound (index_table.tab, 1); 404 if index_table.tab (i).ascii_char = -1 then 405 call ioa_$ioa_switch (list_iocb_ptr, "^d", i); 406 else call ioa_$ioa_switch (list_iocb_ptr, "^d^2x^a", i, ASCII_STRING ((i))); 407 end; 408 409 410 FATAL: 411 412 call CLEANUP (); 413 414 415 return; 416 417 GET_A_LINE: proc (); 418 419 420 dcl i fixed bin; 421 dcl t_val bit (9) aligned; 422 423 424 x = 0; 425 call iox_$get_line (sort_iocb_ptr, addr (sort_rec), size (sort_rec)*4, n_read, code); 426 if code ^= 0 then do; 427 if code = error_table_$end_of_info then return; 428 call com_err_ (code, ME, "Error reading the sort file."); 429 goto FATAL; 430 end; 431 line_num = line_num+1; 432 if db_sw then 433 call ioa_ ("line number ^d = ""^a ^d""", line_num, ltrim (sort_rec.key, ""), sort_rec.value); 434 435 do i = 1 to length (sort_rec.key); 436 t_val = unspec (substr (sort_rec.key, i, 1)); 437 if t_val ^= "0"b then do; 438 x = x+1; 439 X (x) = fixed (t_val) - 32; 440 if db_sw then 441 call ioa_ ("X(^d)=^d", x, X (x)); 442 end; 443 end; 444 value = sort_rec.value; 445 446 return; 447 448 449 end GET_A_LINE; 450 451 PROCESS_A_LINE: proc (); 452 453 454 if x = 1 then do; 455 if ^SET_PPS (X (1)) then do; 456 call com_err_ (0, "create_table", 457 """^a"" character is already defined as ""^a"".", 458 ASCII_CHAR (X (1)), ASCII_CHAR (pps (X (1)))); 459 return; 460 end; 461 if ^SET_TABLE (X (1), pps (X (1)+32)) then do; 462 call com_err_ (0, "create_table", 463 "itself overstruck with itself is not unique.", 464 ASCII_CHAR (X (1))); 465 return; 466 end; 467 end; 468 else do i = 1 to x; 469 init = "0"b; 470 do j = 1 to x; 471 if i ^= j then do; 472 if ^init then do; 473 init = "1"b; 474 oc = pps (X (j)+32); 475 if oc = default_char then do; 476 call com_err_ (0, "create_table", 477 "PPS character representation for ""^a"" is not yet defined.", 478 ASCII_CHAR (X (j))); 479 return; 480 end; 481 end; 482 else do; 483 if table (X (j), oc) = default_char then do; 484 call com_err_ (0, "create_table", 485 """^a"" overstruck with ""^a"" is not yet defined.", 486 ASCII_STRING ((oc)), ASCII_CHAR (X (j))); 487 return; 488 end; 489 oc = table (X (j), oc); 490 end; 491 end; 492 end; 493 if ^SET_TABLE (X (i), oc) then do; 494 call com_err_ (0, "create_table", 495 """^a"" overstruck with ""^a"" is not unique.", 496 ASCII_STRING ((oc)), ASCII_CHAR (X (i))); 497 return; 498 end; 499 if ^SET_TABLE (X (i), (value)) then do; 500 call com_err_ (0, "create_table", 501 """^a"" overstruck with ""^a"" is not unique.", 502 ASCII_STRING ((value)), ASCII_CHAR (X (i))); 503 return; 504 end; 505 end; 506 507 return; 508 509 510 end PROCESS_A_LINE; 511 512 ASCII_CHAR: proc (c_val) returns (char (1)); 513 514 515 dcl c_val fixed bin (8) unal; 516 dcl collate builtin; 517 518 519 520 return (substr (collate (), (c_val+32+1), 1)); 521 522 end ASCII_CHAR; 523 524 ASCII_STRING: proc (pc) returns (char (*)); 525 526 527 dcl pc fixed bin (8) unal; 528 529 530 if index_table.tab (pc).pps_char = -1 then 531 return (ASCII_CHAR (index_table.tab (pc).ascii_char)); 532 else 533 return (ASCII_CHAR (index_table.tab (pc).ascii_char) || ASCII_STRING (index_table.tab (pc).pps_char)); 534 535 536 end ASCII_STRING; 537 538 SET_PPS: proc (ascii_char) returns (bit (1)); 539 540 541 dcl ascii_char fixed bin (8) unal; 542 543 544 if pps (ascii_char+32) ^= default_char then 545 if pps (ascii_char+32) = value then return ("1"b); 546 else return ("0"b); 547 548 if db_sw then call ioa_ ("pps(^d)=^d", ascii_char+32, value); 549 pps (ascii_char+32) = value; 550 if index_table.tab (value).ascii_char = -1 then 551 index_table.tab (value).ascii_char = ascii_char; 552 return ("1"b); 553 554 555 end SET_PPS; 556 557 SET_TABLE: proc (ascii_char, pps_char) returns (bit (1)); 558 559 560 dcl ascii_char fixed bin (8) unal; 561 dcl pps_char fixed bin (8) unal; 562 563 564 if table (ascii_char, pps_char) ^= default_char then 565 if table (ascii_char, pps_char) = value then return ("1"b); 566 else return ("0"b); 567 568 if db_sw then call ioa_ ("table(^d,^d)=^d", ascii_char, pps_char, value); 569 table (ascii_char, pps_char) = value; 570 n_hits = n_hits+1; 571 if index_table.tab (value).ascii_char = -1 then 572 if index_table.tab (value).pps_char ^= value then do; 573 index_table.tab (value).ascii_char = ascii_char; 574 index_table.tab (value).pps_char = pps_char; 575 end; 576 return ("1"b); 577 578 579 end SET_TABLE; 580 581 CLEANUP: proc (); 582 583 584 if input_iocb_ptr ^= null () then do; 585 call iox_$close (input_iocb_ptr, code); 586 call iox_$detach_iocb (input_iocb_ptr, code); 587 end; 588 589 if output_iocb_ptr ^= null () then do; 590 call iox_$close (output_iocb_ptr, code); 591 call iox_$detach_iocb (output_iocb_ptr, code); 592 end; 593 594 if list_iocb_ptr ^= null () then do; 595 call iox_$close (list_iocb_ptr, code); 596 call iox_$detach_iocb (list_iocb_ptr, code); 597 end; 598 599 if sort_iocb_ptr ^= null () then do; 600 call iox_$close (sort_iocb_ptr, code); 601 call iox_$detach_iocb (sort_iocb_ptr, code); 602 end; 603 604 return; 605 606 607 end CLEANUP; 608 609 PROCESS_INPUT_LINE: proc (); 610 611 612 input_i = 1; 613 input_l = n_read; 614 token_ptr, text_ptr = null (); 615 if line_num = 1 then do; 616 call GET_HEX (); 617 default_char = hex_value; 618 call GET_HEX (); 619 space_char = hex_value; 620 end; 621 else do; 622 call GET_HEX (); 623 if token_ptr = null () then return; 624 call GET_TEXT (); 625 if text_ptr = null () then return; 626 call SKIP_COMMENT (); 627 if input_l ^= 0 then 628 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Extra text in input line.^/Source: ^a", 629 line_num, input_line); 630 end; 631 632 return; 633 634 635 end PROCESS_INPUT_LINE; 636 637 GET_HEX: proc (); 638 639 call GET_TOKEN (); 640 if token_ptr = null () then do; 641 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Missing hexidecimal value.^/SOURCE: ^a", 642 line_num, input_line); 643 hex_value = 0; 644 return; 645 end; 646 hex_value = cv_hex_check_ (token, code); 647 if code ^= 0 then do; 648 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Illegal hexidecimal value.^/SOURCE: ^a", 649 line_num, input_line); 650 hex_value = 0; 651 end; 652 if hex_value > fixed ("ff"b4) then do; 653 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Hexidecimal value is too large.^/SOURCE: ^a", 654 line_num, input_line); 655 hex_value = 0; 656 end; 657 return; 658 659 end GET_HEX; 660 661 SKIP_WS: proc (); 662 663 dcl i fixed bin; 664 665 i = verify (substr (input_line, input_i, input_l), WS)-1; 666 if i < 0 then do; 667 input_i = input_l+1; 668 input_l = 0; 669 end; 670 else do; 671 input_i = input_i + i; 672 input_l = input_l - i; 673 end; 674 return; 675 676 end SKIP_WS; 677 678 GET_TOKEN: proc (); 679 680 if input_l > 0 then call SKIP_WS (); 681 if input_l <= 0 then do; 682 token_ptr = null (); 683 token_l = 0; 684 return; 685 end; 686 token_ptr = addr (input_array (input_i)); 687 token_l = search (substr (input_line, input_i, input_l), WS)-1; 688 if token_l < 0 then token_l = input_l; 689 input_i = input_i+token_l; 690 input_l = input_l - token_l; 691 return; 692 693 end GET_TOKEN; 694 695 GET_TEXT: proc (); 696 697 call GET_TOKEN (); 698 text_ptr = token_ptr; 699 text_l = token_l; 700 if text_ptr = null () then 701 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Missing text.^/SOURCE: ^a", 702 line_num, input_line); 703 return; 704 705 end GET_TEXT; 706 707 SKIP_COMMENT: proc (); 708 709 input_i = input_i+input_l+1; 710 input_l = 0; 711 return; 712 713 end SKIP_COMMENT; 714 715 WRITE_INPUT_LINE: proc (); 716 717 718 dcl i fixed bin; 719 dcl temp char (128) var; 720 721 722 unspec (sort_rec) = "0"b; 723 nl = " 724 "; 725 sort_rec.value = hex_value; 726 727 temp = ""; 728 do i = 1 to length (text); 729 if substr (text, i, 1) ^= BS then do; 730 if unspec (substr (text, i, 1)) < "040"b3 | 731 unspec (substr (text, i, 1)) > "177"b3 then 732 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Illegal text character. ""^a""^/SOURCE: ^a", 733 line_num, substr (text, i, 1), input_line); 734 else temp = temp || substr (text, i, 1); 735 end; 736 end; 737 if temp = "" then return; 738 739 if length (temp) > length (key) then 740 call ioa_$ioa_stream ("error_output", "ERROR ON LINE ^d^/Text is too long. Limit is ^d characters.^/SOURCE: ^a", 741 line_num, length (key), input_line); 742 substr (sort_rec.key, length (sort_rec.key)-length (temp)+1) = temp; 743 if db_sw then 744 call ioa_ ("keyline = ""^a ^d""", sort_rec.key, sort_rec.value); 745 call iox_$put_chars (sort_iocb_ptr, addr (sort_rec), size (sort_rec)*4, code); 746 if code ^= 0 then do; 747 call com_err_ (code, ME, "Error writing to sort file."); 748 goto FATAL; 749 end; 750 751 return; 752 753 754 end WRITE_INPUT_LINE; 755 756 SORT_INPUT: proc (); 757 758 759 call iox_$close (sort_iocb_ptr, code); 760 if code ^= 0 then do; 761 call com_err_ (code, ME, "Error closing sort file."); 762 goto FATAL; 763 end; 764 765 call sort_seg (rtrim (get_pdir_ ())||">sort"); 766 dcl sort_seg entry (char (*)); 767 768 call iox_$open (sort_iocb_ptr, 1, "0"b, code); 769 if code ^= 0 then do; 770 call com_err_ (code, ME, "Error reopening sort file."); 771 goto FATAL; 772 end; 773 774 return; 775 776 777 end SORT_INPUT; 778 779 debug: entry (); 780 781 782 db_sw = ^db_sw; 783 call ioa_ ("debug switch is ^[on^;off^].", db_sw); 784 return; 785 786 787 788 end cv_ppscf; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/18/82 1629.3 cv_ppscf.pl1 >dumps>old>recomp>cv_ppscf.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. BS 011371 constant char(1) initial unaligned dcl 134 ref 729 CODE_LINE 000000 constant varying char(80) initial array dcl 140 set ref 383 384* ME 000574 constant char(8) initial unaligned dcl 135 set ref 182* 189* 194* 208* 215* 229* 235* 242* 249* 257* 264* 272* 279* 306* 428* 747* 761* 770* NL 011370 constant char(1) initial unaligned dcl 136 ref 297 WS 000572 constant char(4) initial unaligned dcl 138 ref 665 687 X 000106 automatic fixed bin(8,0) array unaligned dcl 73 set ref 439* 440* 455* 456* 456* 456 456 461* 461 462* 462* 474 476* 476* 483 484* 484* 489 493* 494* 494* 499* 500* 500* addr builtin function dcl 54 ref 176 290 290 388 394 425 425 686 686 745 745 arg based char unaligned dcl 170 set ref 192* 194* 211 211 212 212 215* arg_len 000113 automatic fixed bin(17,0) dcl 74 set ref 187* 192 192 194 194 206* 211 211 212 212 215 215 arg_ptr 000114 automatic pointer dcl 75 set ref 187* 192 194 206* 211 211 212 212 215 ascii_char 0(18) 014537 automatic fixed bin(8,0) array level 3 in structure "index_table" packed unaligned dcl 117 in procedure "cv_ppscf" set ref 337* 404 530* 532* 550 550* 571 573* ascii_char parameter fixed bin(8,0) unaligned dcl 560 in procedure "SET_TABLE" set ref 557 564 564 568* 569 573 ascii_char parameter fixed bin(8,0) unaligned dcl 541 in procedure "SET_PPS" ref 538 544 544 548 549 550 c_val parameter fixed bin(8,0) unaligned dcl 515 ref 512 520 cleanup 000100 stack reference condition dcl 67 ref 225 code 000116 automatic fixed bin(35,0) dcl 76 set ref 181* 182* 187* 188 189* 192* 193 194* 206* 207 208* 214* 215* 227* 228 229* 233* 234 235* 240* 241 242* 247* 248 249* 255* 256 257* 262* 263 264* 270* 271 272* 277* 278 279* 287* 288 290* 291 294* 296 305 306* 352* 354 358 425* 426 427 428* 585* 586* 590* 591* 595* 596* 600* 601* 646* 647 745* 746 747* 759* 760 761* 768* 769 770* collate builtin function dcl 516 ref 520 com_err_ 000016 constant entry external dcl 24 ref 182 189 194 208 215 229 235 242 249 257 264 272 279 306 428 456 462 476 484 494 500 747 761 770 cu_$arg_count 000020 constant entry external dcl 25 ref 179 cu_$arg_ptr 000022 constant entry external dcl 26 ref 187 206 cv_hex_check_ 000024 constant entry external dcl 27 ref 646 cv_ppscf$cv_ppscf 000026 external static fixed bin(17,0) dcl 28 set ref 176 db_sw 000010 internal static bit(1) initial dcl 164 set ref 432 440 548 568 743 782* 782 783* default_char 000117 automatic fixed bin(17,0) dcl 77 in procedure "cv_ppscf" set ref 285* 326 331 334 475 483 544 564 617* default_char 014537 automatic fixed bin(8,0) level 2 in structure "index_table" packed unaligned dcl 117 in procedure "cv_ppscf" set ref 334* dname 000120 automatic char(168) unaligned dcl 78 set ref 192* 198 199 ename 000172 automatic char(168) unaligned dcl 79 set ref 192* 197 197 error_flag 000244 automatic bit(1) unaligned dcl 80 set ref 284* 313 error_table_$badopt 000056 external static fixed bin(35,0) dcl 45 ref 214 error_table_$end_of_info 000060 external static fixed bin(35,0) dcl 46 ref 288 305 354 358 427 error_table_$long_record 000062 external static fixed bin(35,0) dcl 47 ref 291 error_table_$noarg 000064 external static fixed bin(35,0) dcl 48 ref 181 expand_pathname_$add_suffix 000030 constant entry external dcl 29 ref 192 fixed builtin function dcl 55 ref 439 652 get_pdir_ 000032 constant entry external dcl 30 ref 270 272 765 hbound builtin function dcl 56 ref 324 325 330 336 383 402 hex_value 000245 automatic fixed bin(35,0) dcl 81 set ref 617 619 643* 646* 650* 652 655* 725 i 000246 automatic fixed bin(17,0) dcl 82 in procedure "cv_ppscf" set ref 205* 206* 208* 324* 326* 330* 331* 336* 337 338* 383* 384* 389* 390 390 390 390* 395* 396 396 396 396* 402* 404 404* 406* 406* 468* 471 493 494 494 499 500 500* i 014754 automatic fixed bin(17,0) dcl 420 in procedure "GET_A_LINE" set ref 435* 436* i 015056 automatic fixed bin(17,0) dcl 718 in procedure "WRITE_INPUT_LINE" set ref 728* 729 730 730 730 730 734* i 015024 automatic fixed bin(17,0) dcl 663 in procedure "SKIP_WS" set ref 665* 666 671 672 index_table 014537 automatic structure level 1 packed unaligned dcl 117 init 000247 automatic bit(1) dcl 83 set ref 469* 472 473* input 000066 constant file dcl 84 input_array based char(1) array unaligned dcl 171 set ref 686 input_i 000250 automatic fixed bin(17,0) dcl 85 set ref 612* 665 667* 671* 671 686 687 689* 689 709* 709 input_iocb_ptr 000252 automatic pointer dcl 86 set ref 220* 227* 233* 290* 584 585* 586* input_l 000254 automatic fixed bin(17,0) dcl 87 set ref 613* 627 665 667 668* 672* 672 680 681 687 688 690* 690 709 710* input_line 000255 automatic char(128) unaligned dcl 88 set ref 289* 290 290 290 290 292* 297 627* 641* 648* 653* 665 686 687 700* 730* 739* ioa_ 000034 constant entry external dcl 31 ref 370 432 440 548 568 743 783 ioa_$ioa_stream 000036 constant entry external dcl 32 ref 292 627 641 648 653 700 730 739 ioa_$ioa_switch 000040 constant entry external dcl 33 ref 368 381 384 386 390 393 396 399 404 406 iox_$attach_name 000042 constant entry external dcl 34 ref 227 240 255 270 iox_$close 000044 constant entry external dcl 35 ref 585 590 595 600 759 iox_$detach_iocb 000046 constant entry external dcl 36 ref 586 591 596 601 iox_$get_line 000050 constant entry external dcl 37 ref 290 425 iox_$open 000052 constant entry external dcl 38 ref 233 247 262 277 768 iox_$put_chars 000054 constant entry external dcl 39 ref 745 j 000315 automatic fixed bin(17,0) dcl 89 set ref 325* 326* 470* 471 474 476 476 483 484 484 489* key 014740 automatic char(14) level 2 packed unaligned dcl 125 set ref 432 432 435 436 739 739 739 742 742* 743* length builtin function dcl 57 ref 197 290 290 435 728 739 739 739 739 742 742 line_num 000316 automatic fixed bin(17,0) dcl 90 set ref 286* 292* 306* 310* 310 341* 431* 431 432* 615 627* 641* 648* 653* 700* 730* 739* list_flag 000317 automatic bit(1) unaligned dcl 91 set ref 203* 211* 254 368 402 list_iocb_ptr 000320 automatic pointer dcl 92 set ref 222* 255* 262* 368* 404* 406* 594 595* 596* listing 000070 constant file output dcl 93 long_flag 000322 automatic bit(1) unaligned dcl 94 set ref 204* 212* 370 ltrim builtin function dcl 58 ref 432 432 me_ptr 000324 automatic pointer dcl 95 set ref 176* 227* 240* 255* 270* n_hits 000326 automatic fixed bin(17,0) dcl 96 set ref 342* 368* 370* 570* 570 n_read 000327 automatic fixed bin(21,0) dcl 97 set ref 290* 297 297* 297 299 425* 613 nargs 000330 automatic fixed bin(17,0) dcl 98 set ref 179* 180 205 nl 3(27) 014740 automatic char(1) level 2 packed unaligned dcl 125 set ref 723* null builtin function dcl 59 ref 220 221 222 223 301 584 589 594 599 614 623 625 640 682 700 oc 000331 automatic fixed bin(8,0) unaligned dcl 99 set ref 474* 475 483 484 489* 489 493* 494 output 000072 constant file output dcl 100 output_iocb_ptr 000332 automatic pointer dcl 101 set ref 221* 240* 247* 381* 384* 386* 390* 393* 396* 399* 589 590* 591* pc parameter fixed bin(8,0) unaligned dcl 527 ref 524 530 530 532 532 pps 000334 automatic fixed bin(8,0) array unaligned dcl 102 set ref 330 331* 394 395 456* 456* 461* 474 544 544 549* pps_char 0(27) 014537 automatic fixed bin(8,0) array level 3 in structure "index_table" packed unaligned dcl 117 in procedure "cv_ppscf" set ref 338* 530 532* 571 574* pps_char parameter fixed bin(8,0) unaligned dcl 561 in procedure "SET_TABLE" set ref 557 564 564 568* 569 574 rtrim builtin function dcl 60 ref 197 199 270 272 765 search builtin function dcl 61 ref 687 size builtin function dcl 62 ref 368 370 389 395 425 745 sort_iocb_ptr 000434 automatic pointer dcl 103 set ref 223* 270* 277* 425* 599 600* 601* 745* 759* 768* sort_rec 014740 automatic structure level 1 packed unaligned dcl 125 set ref 425 425 425 722* 745 745 745 sort_seg 000106 constant entry external dcl 766 ref 765 source_name 000436 automatic varying char(32) dcl 104 set ref 197* 200 381* 381* 386* 386* source_path 000447 automatic varying char(168) dcl 105 set ref 198* 199* 200* 200 227 229 240 242 255 257 space_char 0(09) 014537 automatic fixed bin(8,0) level 2 in structure "index_table" packed unaligned dcl 117 in procedure "cv_ppscf" set ref 335* space_char 000522 automatic fixed bin(17,0) dcl 106 in procedure "cv_ppscf" set ref 335 364 366 619* substr builtin function dcl 63 set ref 197 297 436 520 665 687 729 730 730 730 730 734 742* sysprint 000074 constant file print dcl 107 t_val 014755 automatic bit(9) dcl 421 set ref 436* 437 439 tab 0(18) 014537 automatic structure array level 2 packed unaligned dcl 117 set ref 336 402 table 000523 automatic fixed bin(8,0) array unaligned dcl 108 set ref 324 325 326* 368 370 388 389 483 489 564 564 569* temp 015057 automatic varying char(128) dcl 719 set ref 727* 734* 734 737 739 742 742 text based char unaligned dcl 172 ref 728 729 730 730 730 730 734 text_l 014523 automatic fixed bin(17,0) dcl 109 set ref 699* 728 729 730 730 730 730 734 text_ptr 014524 automatic pointer dcl 110 set ref 301 614* 625 698* 700 728 729 730 730 730 730 734 token based char unaligned dcl 173 set ref 646* token_l 014526 automatic fixed bin(17,0) dcl 111 set ref 646 646 683* 687* 688 688* 689 690 699 token_ptr 014530 automatic pointer dcl 112 set ref 614* 623 640 646 682* 686* 698 unspec builtin function dcl 64 set ref 436 722* 730 730 value 3(18) 014740 automatic fixed bin(8,0) level 2 in structure "sort_rec" packed unaligned dcl 125 in procedure "cv_ppscf" set ref 432* 444 725* 743* value 014532 automatic fixed bin(17,0) dcl 113 in procedure "cv_ppscf" set ref 364* 444* 499 500 544 548* 549 550 550 564 568* 569 571 571 571 573 574 verify builtin function dcl 65 ref 665 word based bit(36) array dcl 174 set ref 390* 390* 390* 390* 396* 396* 396* 396* word_ptr 014534 automatic pointer dcl 114 set ref 388* 390 390 390 390 394* 396 396 396 396 x 014536 automatic fixed bin(17,0) dcl 115 set ref 358 424* 438* 438 439 440* 440 454 468 470 NAMES DECLARED BY EXPLICIT CONTEXT. ASCII_CHAR 006545 constant entry internal dcl 512 ref 456 456 456 456 462 462 476 476 484 484 494 494 500 500 530 532 ASCII_STRING 006567 constant entry internal dcl 524 ref 406 484 494 500 532 CLEANUP 007377 constant entry internal dcl 581 ref 225 236 244 250 259 265 274 280 307 410 FATAL 005117 constant label dcl 410 ref 313 429 748 762 771 GET_A_LINE 005160 constant entry internal dcl 417 ref 356 GET_HEX 007651 constant entry internal dcl 637 ref 616 618 622 GET_TEXT 010161 constant entry internal dcl 695 ref 624 GET_TOKEN 010103 constant entry internal dcl 678 ref 639 697 PROCESS_A_LINE 005443 constant entry internal dcl 451 ref 358 PROCESS_INPUT_LINE 007544 constant entry internal dcl 609 ref 300 SET_PPS 006751 constant entry internal dcl 538 ref 365 455 SET_TABLE 007134 constant entry internal dcl 557 ref 366 461 493 499 SKIP_COMMENT 010232 constant entry internal dcl 707 ref 626 SKIP_WS 010045 constant entry internal dcl 661 ref 680 SORT_INPUT 010566 constant entry internal dcl 756 ref 315 WRITE_INPUT_LINE 010243 constant entry internal dcl 715 ref 301 cv_ppscf 001706 constant entry external dcl 11 debug 005125 constant entry external dcl 779 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11750 12060 11375 11760 Length 12356 11375 110 262 353 6 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cv_ppscf 7280 external procedure is an external procedure. on unit on line 225 64 on unit GET_A_LINE internal procedure shares stack frame of external procedure cv_ppscf. PROCESS_A_LINE internal procedure shares stack frame of external procedure cv_ppscf. ASCII_CHAR 65 internal procedure is called during a stack extension. ASCII_STRING 90 internal procedure uses returns(char(*)) or returns(bit(*)). SET_PPS internal procedure shares stack frame of external procedure cv_ppscf. SET_TABLE internal procedure shares stack frame of external procedure cv_ppscf. CLEANUP 70 internal procedure is called by several nonquick procedures. PROCESS_INPUT_LINE internal procedure shares stack frame of external procedure cv_ppscf. GET_HEX internal procedure shares stack frame of external procedure cv_ppscf. SKIP_WS internal procedure shares stack frame of external procedure cv_ppscf. GET_TOKEN internal procedure shares stack frame of external procedure cv_ppscf. GET_TEXT internal procedure shares stack frame of external procedure cv_ppscf. SKIP_COMMENT internal procedure shares stack frame of external procedure cv_ppscf. WRITE_INPUT_LINE internal procedure shares stack frame of external procedure cv_ppscf. SORT_INPUT internal procedure shares stack frame of external procedure cv_ppscf. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 db_sw cv_ppscf STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cv_ppscf 000106 X cv_ppscf 000113 arg_len cv_ppscf 000114 arg_ptr cv_ppscf 000116 code cv_ppscf 000117 default_char cv_ppscf 000120 dname cv_ppscf 000172 ename cv_ppscf 000244 error_flag cv_ppscf 000245 hex_value cv_ppscf 000246 i cv_ppscf 000247 init cv_ppscf 000250 input_i cv_ppscf 000252 input_iocb_ptr cv_ppscf 000254 input_l cv_ppscf 000255 input_line cv_ppscf 000315 j cv_ppscf 000316 line_num cv_ppscf 000317 list_flag cv_ppscf 000320 list_iocb_ptr cv_ppscf 000322 long_flag cv_ppscf 000324 me_ptr cv_ppscf 000326 n_hits cv_ppscf 000327 n_read cv_ppscf 000330 nargs cv_ppscf 000331 oc cv_ppscf 000332 output_iocb_ptr cv_ppscf 000334 pps cv_ppscf 000434 sort_iocb_ptr cv_ppscf 000436 source_name cv_ppscf 000447 source_path cv_ppscf 000522 space_char cv_ppscf 000523 table cv_ppscf 014523 text_l cv_ppscf 014524 text_ptr cv_ppscf 014526 token_l cv_ppscf 014530 token_ptr cv_ppscf 014532 value cv_ppscf 014534 word_ptr cv_ppscf 014536 x cv_ppscf 014537 index_table cv_ppscf 014740 sort_rec cv_ppscf 014754 i GET_A_LINE 014755 t_val GET_A_LINE 015024 i SKIP_WS 015056 i WRITE_INPUT_LINE 015057 temp WRITE_INPUT_LINE THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return bound_check_signal enable shorten_stack ext_entry int_entry int_entry_desc size_check_fx1 size_check_fx2 return_chars_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr cv_hex_check_ expand_pathname_$add_suffix get_pdir_ ioa_ ioa_$ioa_stream ioa_$ioa_switch iox_$attach_name iox_$close iox_$detach_iocb iox_$get_line iox_$open iox_$put_chars sort_seg THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cv_ppscf$cv_ppscf error_table_$badopt error_table_$end_of_info error_table_$long_record error_table_$noarg input input.fsb listing listing.fsb output output.fsb sysprint sysprint.fsb LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 84 001622 93 001637 100 001653 107 001667 11 001705 176 001714 179 001717 180 001725 181 001730 182 001735 184 001760 187 001761 188 002002 189 002004 190 002021 192 002022 193 002057 194 002061 195 002113 197 002114 198 002135 199 002143 200 002163 203 002217 204 002221 205 002222 206 002234 207 002251 208 002253 209 002303 211 002304 212 002321 214 002334 215 002341 216 002372 218 002373 220 002401 221 002403 222 002404 223 002405 225 002406 227 002430 228 002507 229 002512 231 002567 233 002571 234 002614 235 002616 236 002647 237 002653 240 002654 241 002733 242 002736 244 003013 245 003020 247 003021 248 003044 249 003046 250 003077 251 003103 254 003104 255 003106 256 003165 257 003170 259 003245 260 003252 262 003253 263 003276 264 003300 265 003331 266 003335 270 003336 271 003435 272 003440 274 003535 275 003542 277 003543 278 003566 279 003570 280 003621 281 003625 284 003626 285 003627 286 003630 287 003634 288 003635 289 003641 290 003644 291 003670 292 003674 294 003727 295 003730 296 003731 297 003733 299 003745 300 003747 301 003750 304 003755 305 003756 306 003760 307 004007 308 004013 310 004014 311 004021 313 004022 315 004024 324 004025 325 004031 326 004035 327 004066 328 004074 330 004102 331 004106 332 004126 334 004134 335 004141 336 004145 337 004151 338 004163 339 004166 341 004174 342 004175 352 004176 354 004177 356 004203 358 004204 362 004213 364 004214 365 004220 366 004227 368 004243 370 004301 381 004333 383 004361 384 004370 385 004422 386 004430 388 004456 389 004460 390 004467 392 004574 393 004602 394 004625 395 004627 396 004636 398 004743 399 004751 402 004770 404 004776 406 005040 407 005110 410 005117 415 005123 779 005124 782 005133 783 005140 784 005157 417 005160 424 005161 425 005162 426 005207 427 005211 428 005215 429 005240 431 005241 432 005246 435 005324 436 005334 437 005341 438 005343 439 005350 440 005376 443 005426 444 005434 446 005442 451 005443 454 005444 455 005447 456 005473 459 005576 461 005577 462 005636 465 005707 467 005710 468 005711 469 005722 470 005723 471 005735 472 005737 473 005741 474 005743 475 005774 476 006000 479 006051 481 006052 483 006053 484 006124 487 006225 489 006227 492 006233 493 006241 494 006267 497 006370 499 006372 500 006427 503 006533 505 006535 507 006543 512 006544 520 006552 524 006566 530 006574 532 006650 538 006751 544 006753 546 007012 548 007017 549 007053 550 007104 552 007127 557 007134 564 007136 566 007214 568 007221 569 007257 570 007327 571 007334 573 007363 574 007366 576 007371 581 007376 584 007404 585 007411 586 007421 589 007433 590 007440 591 007451 594 007463 595 007470 596 007501 599 007513 600 007520 601 007531 604 007543 609 007544 612 007545 613 007551 614 007554 615 007557 616 007562 617 007563 618 007567 619 007570 620 007574 622 007575 623 007576 624 007603 625 007604 626 007611 627 007612 632 007650 637 007651 639 007652 640 007653 641 007657 643 007713 644 007714 646 007715 647 007744 648 007746 650 010002 652 010003 653 010007 655 010043 657 010044 661 010045 665 010046 666 010063 667 010065 668 010071 669 010072 671 010073 672 010076 674 010102 678 010103 680 010104 681 010107 682 010111 683 010113 684 010114 686 010115 687 010127 688 010144 689 010151 690 010154 691 010160 695 010161 697 010162 698 010163 699 010165 700 010171 703 010231 707 010232 709 010233 710 010241 711 010242 715 010243 722 010244 723 010247 725 010251 727 010256 728 010257 729 010271 730 010276 734 010356 736 010365 737 010373 739 010401 742 010450 743 010462 745 010513 746 010536 747 010540 748 010564 751 010565 756 010566 759 010567 760 010600 761 010602 762 010626 765 010627 768 010675 769 010721 770 010723 771 010747 774 010750 ----------------------------------------------------------- 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