COMPILATION LISTING OF SEGMENT cobol_imp_word 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 1009.6 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_imp_word.pl1 Reformatted code to new Cobol standard. 19* END HISTORY COMMENTS */ 20 21 22 /* Modified on 07/17/80 by FCH, TEMPORARY was not recognized, [4.3-1], phx06605d(BUG439) */ 23 /* Modified on 10/11/79 by MHD, [4.1-1], added CHECKPOINT-FILE for RERUN */ 24 /* Modified on 06/14/79 by FCH, [4.0-1], run time debug switch */ 25 /* Modified since Version 4.0 */ 26 27 /* format: style3 */ 28 cobol_imp_word: 29 proc (word_ptr) returns (fixed bin); 30 31 /* 32* switch_name 1(308) switch-1 33* 2(309) switch-2 34* 3(310) switch-3 35* 4(311) switch-4 36* 5(312) switch-5 37* 6(313) switch-6 38* 7(314) switch-7 39* 8(315) switch-8 40* 9 switch-9 used for run-time switch by DEBUGGING 41* 42* device_name 9(281) sysin 43* 10(294) sysout 44* 11(197) console 45* 46* alphabet_name 20(505) ascii 47* 21(273) ebcdic 48* 22(418) gbcd 49* 23(274) hbcd 50* 24(275) ibcd 51* 25(276) jis 52* 53* device_appendage 30(199) card-punch 54* 31(217) msd 55* 32(261) preattached 56* 33(198) printer 57* 34(283) virtual 58* 35(200) card-reader 59* 60* computer_name 40(303) multics 61* 41(299) gcos 62* 42(103) level-61-ascii 63* 43(436) level-66-ascii 64* 44(289) level-62 65* 45(429) level-66 66* 46(303) level-68 67* 47(300) level-64 68* 48(297) his-series-60 69* 49 level-6 70* 71* label_name 60(296) file-id 72* 61(430) retention 73* 62(331) catalog-name 74* 62(331) catalogue-name 75* 76* comp_type 80(106) comp computational 77* 81(212) comp-1 computational-1 78* 82(213) comp-2 computational-2 79* 83(211) comp-3 computational-3 80* 84(209) comp-4 computational-4 81* 85(210) comp-5 computational-5 82* 86(292) comp-6 computational-6 83* 87(290) comp-7 computational-7 84* 88(610) comp-8 computational-8 85* 86* disp_type 130(42) disp display 87* 131(317) disp-1 display-1 88* 132(318) disp-2 display-2 89* 133(319) disp-3 display-3 90* 134(320) disp-4 display-4 91* 92* io_technique 90 additional 93* 91 address-format 94* 92(412) attach-options 95* 93(282) banner 96* 94 density 97* 95(405) detach 98* 96 device 99* 97 force 100* 98 modification 101* 99 output-mode 102* 100(410) permanent 103* 101 protect 104* 102 retain 105* 103 tape-options 106* 104(409) temporary 107* 105 generation 108* 106 replacement 109* 110* file_org 110(422) complementary 111* 111(439) ext 112* 112(431) secondary 113* 113(285) h-2000 114* 114(337) his 115* 115(298) ibm-dos 116* 116(330) ibm_os 117* 117(419) gfrc 118* 118 uff 119* 119(136) ansi 120* 121* forign_label_name 140 id 122* 123* language_name 200(191) cobol 124* 201 pl/i 125* 202 alm 126* 203 fortran 127* 204 apl 128* 205 basic 129* printer_control 210 hof 130* 211 channel-1 131* ... ... 132* 226 channel-16 133* 134* misc 1000 temp 135* 1001 maximum 136* 1002 supervisor 137* 1003 descriptors 138* 1004 aggregate 139* 1005 scalar 140* 1006 substitution 141* 1007 bits 142* 1008 multiply 143*[4.1-1] 1009 checkpoint-file 144* 145**/ 146 147 148 declare word_ptr ptr, 149 word_size fixed bin; 150 declare (addr, substr, index) 151 builtin; 152 153 declare (Wptr, Kptr) ptr, 154 loc fixed bin; 155 declare key fixed bin; 156 157 declare wd char (32) varying; 158 159 declare word char (32) based (word_ptr); 160 declare chars char (1000) based (Wptr); 161 declare K (1000) fixed bin based (Kptr); 162 163 declare W2 (1) char (2) static internal init ("id"); 164 165 declare K2 (1) fixed bin static internal, 166 init (140); 167 168 declare W3 (8) char (3) static internal init ("jis", "uff", "his", "hof", "msd", "alm", "apl", "ext"); 169 170 declare K3 (8) fixed bin static internal init (25, 118, 114, 210, 31, 202, 204, 111); 171 172 declare W4 (11) char (4) static internal 173 init ("gcos", "gbcd", "hbcd", "ibcd", "ansi", "temp", "comp", "disp", "pl/i", "bits", 174 "gfrc"); 175 176 declare K4 (11) fixed bin static internal init (41, 22, 23, 24, 119, 1000, 80, 130, 201, 1007, 117); 177 178 declare W5 (5) char (5) static internal init ("sysin", "ascii", "cobol", "basic", "force"); 179 180 declare K5 (5) fixed bin static internal init (9, 20, 200, 205, 97); 181 182 declare W6 (21) char (6) static internal 183 init ("sysout", "comp-1", "comp-2", "comp-3", "comp-4", "comp-5", "comp-6", "comp-7", 184 "comp-8", "disp-1", "disp-2", "disp-3", "disp-4", "ebcdic", "ibm-os", "h-2000", "detach", 185 "device", "banner", "scalar", "retain"); 186 187 declare K6 (21) fixed bin static internal 188 init (10, 81, 82, 83, 84, 85, 86, 87, 88, 131, 132, 133, 134, 21, 116, 113, 95, 96, 93, 189 1005, 102); 190 191 declare W7 (11) char (7) static internal 192 init ("console", "multics", "ibm-dos", "density", "file-id", "printer", "virtual", 193 "maximum", "fortran", "level-6", "protect"); 194 195 declare K7 (11) fixed bin static internal init (11, 40, 115, 94, 60, 33, 34, 1001, 203, 49, 101); 196 197 declare W8 (14) char (8) static internal /* [4.0-1] */ 198 init ("switch-1", "switch-2", "switch-3", "switch-4", "switch-5", "switch-6", "switch-7", 199 "switch-8", "switch-9", /* [4.0-1] */ 200 "multiply", "level-62", "level-66", "level-68", "level-64"); 201 202 declare K8 (14) fixed bin static internal /* [4.0-1] */ init (1, 2, 3, 4, 5, 6, 7, 8, 9, 203 /* [4.0-1] */ 204 1008, 44, 45, 46, 47); 205 206 declare W9 (14) char (9) static internal 207 init ("secondary", "temporary", "permanent", "channel-1", "channel-2", "channel-3", 208 "channel-4", "channel-5", "channel-6", "channel-7", "channel-8", "channel-9", "aggregate", 209 "retention"); 210 211 declare K9 (14) fixed bin static internal 212 init (112, 104, 100, 211, 212, 213, 214, 215, 216, 217, 218, 219, 1004, 61); 213 214 declare W10 (11) char (10) static internal 215 init ("additional", "generation", "supervisor", "channel-10", "channel-11", "channel-12", 216 "channel-13", "channel-14", "channel-15", "channel-16", "card-punch"); 217 218 declare K10 (11) fixed bin static internal init (90, 105, 1002, 220, 221, 222, 223, 224, 225, 226, 30); 219 220 declare W11 (5) char (11) static internal 221 init ("output-mode", "card-reader", "replacement", "descriptors", "preattached"); 222 223 declare K11 (5) fixed bin static internal init (99, 35, 106, 1003, 32); 224 225 declare W12 (4) char (12) static internal 226 init ("tape-options", "catalog-name", "substitution", "modification"); 227 228 declare K12 (4) fixed bin static internal init (103, 62, 1006, 98); 229 230 declare W13 (2) char (13) static internal init ("complementary", "his-series-60"); 231 232 declare K13 (2) fixed bin static internal init (110, 48); 233 234 declare W14 (5) char (14) static internal 235 init ("level-61-ascii", "level-66-ascii", "address-format", "catalogue-name", 236 "attach-options"); 237 238 declare K14 (5) fixed bin static internal init (42, 43, 91, 62, 92); 239 240 declare W15 (8) char (15) static internal 241 init ("computational-1", "computational-2", "computational-3", "computational-4", 242 "computational-5", "computational-6", "computational-7", 243 /*[4.1-1]*/ 244 "checkpoint-file"); 245 246 declare K15 (8) fixed bin static internal init (81, 82, 83, 84, 85, 86, 87, 247 /*[4.1-1]*/ 248 1009); 249 250 251 252 find_word: 253 proc; 254 255 if user_word.type ^= 8 | user_word.length > 15 256 then go to ret_0; 257 wd = substr (user_word.word, 1, user_word.length); 258 word_size = user_word.length; 259 260 go to S (word_size); 261 262 S (0): 263 loc = 0; 264 return; 265 266 S (1): 267 Wptr = addr (W2 (1)); 268 Kptr = addr (K2 (1)); 269 go to SS; 270 271 S (2): 272 Wptr = addr (W2 (1)); 273 Kptr = addr (K2 (1)); 274 go to SS; 275 276 S (3): 277 Wptr = addr (W3 (1)); 278 Kptr = addr (K3 (1)); 279 go to SS; 280 281 S (4): 282 Wptr = addr (W4 (1)); 283 Kptr = addr (K4 (1)); 284 go to SS; 285 286 S (5): 287 Wptr = addr (W5 (1)); 288 Kptr = addr (K5 (1)); 289 go to SS; 290 291 S (6): 292 Wptr = addr (W6 (1)); 293 Kptr = addr (K6 (1)); 294 go to SS; 295 296 S (7): 297 Wptr = addr (W7 (1)); 298 Kptr = addr (K7 (1)); 299 go to SS; 300 301 S (8): 302 Wptr = addr (W8 (1)); 303 Kptr = addr (K8 (1)); 304 go to SS; 305 306 S (9): 307 Wptr = addr (W9 (1)); 308 Kptr = addr (K9 (1)); 309 go to SS; 310 311 S (10): 312 Wptr = addr (W10 (1)); 313 Kptr = addr (K10 (1)); 314 go to SS; 315 316 S (11): 317 Wptr = addr (W11 (1)); 318 Kptr = addr (K11 (1)); 319 go to SS; 320 321 S (12): 322 Wptr = addr (W12 (1)); 323 Kptr = addr (K12 (1)); 324 go to SS; 325 326 S (13): 327 Wptr = addr (W13 (1)); 328 Kptr = addr (K13 (1)); 329 go to SS; 330 331 S (14): 332 Wptr = addr (W14 (1)); 333 Kptr = addr (K14 (1)); 334 go to SS; 335 336 S (15): 337 Wptr = addr (W15 (1)); 338 Kptr = addr (K15 (1)); 339 go to SS; 340 341 SS: 342 if Wptr = null () | Kptr = null () 343 then do; 344 loc = 0; 345 return; 346 end; 347 348 loc = index (chars, wd); 349 350 if loc = 0 351 then return; 352 353 loc = K ((loc - 1) / word_size + 1); 354 355 end; 356 357 ret_0: 358 return (0); 359 360 imp_word: 361 entry (word_ptr) returns (fixed bin); 362 363 call find_word; 364 365 return (loc); 366 367 lang_name: 368 entry (word_ptr) returns (fixed bin); 369 370 if reserved_word.type = 1 371 then do; 372 if reserved_word.key = 191 373 then return (1); 374 else return (0); 375 end; 376 377 call find_word; 378 379 if loc >= 200 & loc <= 205 380 then return (loc - 199); 381 else return (0); 382 383 switch_name: 384 entry (word_ptr) returns (fixed bin); 385 386 if reserved_word.type = 1 387 then do; 388 key = reserved_word.key; 389 390 if key >= 308 & key <= 315 391 then return (key - 307); 392 else return (0); 393 end; 394 395 call find_word; 396 397 if loc >= 1 & loc < 8 398 then return (loc); 399 else return (0); 400 401 printer_control: 402 entry (word_ptr) returns (fixed bin); 403 404 if loc >= 210 & loc < 230 405 then return (loc - 209); 406 else return (0); 407 408 device_name: 409 entry (word_ptr) returns (fixed bin); 410 411 if reserved_word.key = 1 412 then do; 413 key = reserved_word.key; 414 415 if key = 281 416 then return (1); 417 else if key = 294 418 then return (2); 419 else if key = 197 420 then return (3); 421 else return (0); 422 end; 423 424 call find_word; 425 426 if loc >= 9 & loc < 20 427 then return (loc - 8); 428 else return (0); 429 430 alphabet_name: 431 entry (word_ptr) returns (fixed bin); 432 433 if reserved_word.type = 1 434 then do; 435 key = reserved_word.key; 436 if key = 505 437 then return (1); 438 else if key = 273 439 then return (2); 440 else if key = 418 441 then return (3); 442 else if key = 274 443 then return (4); 444 else if key = 275 445 then return (5); 446 else if key = 276 447 then return (6); 448 else return (0); 449 end; 450 451 call find_word; 452 453 if loc >= 20 & loc < 30 454 then return (loc - 19); 455 else return (0); 456 457 device_appendage: 458 entry (word_ptr) returns (fixed bin); 459 460 if reserved_word.type = 1 461 then do; 462 key = reserved_word.key; 463 464 if key = 199 465 then return (1); 466 else if key = 217 467 then return (2); 468 else if key = 198 469 then return (4); 470 else if key = 283 471 then return (5); 472 else if key = 200 473 then return (6); 474 else return (0); 475 end; 476 477 call find_word; 478 479 if loc >= 30 & loc < 40 480 then return (loc - 29); 481 else return (0); 482 483 computer_name: 484 entry (word_ptr) returns (fixed bin); 485 486 if reserved_word.type = 1 487 then do; 488 key = reserved_word.key; 489 490 if key = 303 491 then return (1); 492 else if key = 299 493 then return (2); 494 else if key = 103 495 then return (3); 496 else if key = 436 497 then return (4); 498 else if key = 289 499 then return (5); 500 else if key = 429 501 then return (6); 502 else if key = 303 503 then return (7); 504 else if key = 300 505 then return (8); 506 else if key = 297 507 then return (9); 508 else return (0); 509 end; 510 511 call find_word; 512 513 if loc >= 40 & loc < 60 514 then return (loc - 39); 515 else return (0); 516 517 label_name: 518 entry (word_ptr) returns (fixed bin); 519 520 if reserved_word.type = 1 521 then do; 522 key = reserved_word.key; 523 524 if key = 331 525 then return (3); 526 else return (0); 527 end; 528 529 call find_word; 530 531 if loc >= 60 & loc < 80 532 then return (loc - 59); 533 else return (0); 534 535 forign_label_name: 536 entry (word_ptr) returns (fixed bin); 537 538 call find_word; 539 540 if loc = 140 541 then return (loc - 139); 542 else return (0); 543 544 comp_type: 545 entry (word_ptr) returns (fixed bin); 546 547 if reserved_word.type = 1 548 then do; 549 key = reserved_word.key; 550 551 if key = 106 552 then return (1); 553 else if key = 212 554 then return (2); 555 else if key = 213 556 then return (3); 557 else if key = 211 558 then return (4); 559 else if key = 209 560 then return (5); 561 else if key = 210 562 then return (6); 563 else if key = 292 564 then return (7); 565 else if key = 290 566 then return (8); 567 else if key = 610 568 then return (9); 569 else return (0); 570 end; 571 572 call find_word; 573 574 if loc >= 80 & loc < 90 575 then return (loc - 79); 576 else return (0); 577 578 disp_type: 579 entry (word_ptr) returns (fixed bin); 580 581 if reserved_word.type = 1 582 then do; 583 key = reserved_word.key; 584 585 if key = 42 586 then return (1); 587 else if key = 317 588 then return (2); 589 else if key = 318 590 then return (3); 591 else if key = 319 592 then return (4); 593 else if key = 320 594 then return (5); 595 else return (0); 596 597 end; 598 599 call find_word; 600 601 if loc >= 130 & loc < 140 602 then return (loc - 129); 603 else return (0); 604 605 io_technique: 606 entry (word_ptr) returns (fixed bin); 607 608 if reserved_word.type = 1 609 then do; 610 key = reserved_word.key; 611 612 if key = 412 613 then return (3); 614 else if key = 282 615 then return (4); 616 else if key = 95 617 then return (6); 618 else if key = 410 619 then return (11); /*[4.3-1]*/ 620 else if key = 409 621 then return (15); 622 else return (0); 623 end; 624 625 call find_word; 626 627 if loc >= 90 & loc < 110 628 then return (loc - 89); 629 else return (0); 630 631 file_org: 632 entry (word_ptr) returns (fixed bin); 633 634 if reserved_word.type = 1 635 then do; 636 key = reserved_word.key; 637 638 if key = 422 639 then return (1); 640 else if key = 439 641 then return (2); 642 else if key = 431 643 then return (3); 644 else if key = 285 645 then return (4); 646 else if key = 337 647 then return (5); 648 else if key = 298 649 then return (6); 650 else if key = 330 651 then return (7); 652 else if key = 419 653 then return (8); 654 else if key = 136 655 then return (9); 656 else return (0); 657 end; 658 call find_word; 659 660 if loc >= 110 & loc < 120 661 then return (loc - 109); 662 else return (0); 663 664 declare 1 reserved_word based (word_ptr), 1 1 1 2 /* begin include file ... cobol_TYPE1.incl.pl1 */ 1 3 /* Last modified on 11/17/76 by ORN */ 1 4 /* Last modified on 12/28/76 by FCH */ 1 5 /* Last modified on 12/16/80 by FCH */ 1 6 1 7 /* header */ 1 8 2 size fixed bin, 1 9 2 line fixed bin, 1 10 2 column fixed bin, 1 11 2 type fixed bin, 1 12 /* body */ 1 13 2 key fixed bin, 1 14 /* procedure division class bits */ 1 15 2 verb bit (1), 1 16 2 arith_op bit (1), 1 17 2 figcon bit (1), 1 18 2 terminator bit (1), 1 19 2 end_dec bit (1), 1 20 2 rel_op bit (1), 1 21 2 imper_verb bit (1), 1 22 2 end_cobol bit (1), 1 23 /* data division class bits */ 1 24 2 section_header bit (1), 1 25 2 fs_ind bit (1), 1 26 2 fd_clause bit (1), 1 27 2 dd_clause bit (1), 1 28 2 cd_input bit (1), 1 29 2 cd_output bit (1), 1 30 2 cset_name bit (1), 1 31 2 ss_division bit (1), 1 32 2 repl_jump_ind bit (4), 1 33 2 ided_recovery bit (1), 1 34 2 report_writer bit (5), 1 35 2 ss_desc_entry bit (1), 1 36 2 jump_index fixed bin, 1 37 2 length fixed bin, 1 38 2 name char(0 refer(reserved_word.length)); 1 39 1 40 1 41 1 42 /* end include file ... cobol_TYPE1.incl.pl1 */ 1 43 665 666 667 declare 1 user_word based (word_ptr), 2 1 2 2 /* begin include file ... cobol_TYPE.incl.pl1 */ 2 3 /* Last modified on 11/17/76 by ORN */ 2 4 2 5 /* header */ 2 6 2 size fixed bin, 2 7 2 line fixed bin, 2 8 2 column fixed bin, 2 9 2 type fixed bin, 2 10 /* body */ 2 11 2 info bit (8), 2 12 2 length fixed bin, 2 13 2 word char (0 refer(user_word.length)); 2 14 2 15 /* end include file ... cobol_TYPE8.incl.pl1 */ 2 16 668 669 670 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/24/89 0835.1 cobol_imp_word.pl1 >spec>install>MR12.3-1048>cobol_imp_word.pl1 665 1 11/11/82 1712.8 cobol_TYPE1.incl.pl1 >ldd>include>cobol_TYPE1.incl.pl1 668 2 03/27/82 0439.6 cobol_TYPE8.incl.pl1 >ldd>include>cobol_TYPE8.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. K based fixed bin(17,0) array dcl 161 ref 353 K10 000402 internal static fixed bin(17,0) initial array dcl 218 set ref 313 K11 000433 internal static fixed bin(17,0) initial array dcl 223 set ref 318 K12 000454 internal static fixed bin(17,0) initial array dcl 228 set ref 323 K13 000470 internal static fixed bin(17,0) initial array dcl 232 set ref 328 K14 000514 internal static fixed bin(17,0) initial array dcl 238 set ref 333 K15 000557 internal static fixed bin(17,0) initial array dcl 246 set ref 338 K2 000011 internal static fixed bin(17,0) array dcl 165 set ref 268 273 K3 000020 internal static fixed bin(17,0) initial array dcl 170 set ref 278 K4 000043 internal static fixed bin(17,0) initial array dcl 176 set ref 283 K5 000065 internal static fixed bin(17,0) initial array dcl 180 set ref 288 K6 000132 internal static fixed bin(17,0) initial array dcl 187 set ref 293 K7 000203 internal static fixed bin(17,0) initial array dcl 195 set ref 298 K8 000252 internal static fixed bin(17,0) initial array dcl 202 set ref 303 K9 000330 internal static fixed bin(17,0) initial array dcl 211 set ref 308 Kptr 000104 automatic pointer dcl 153 set ref 268* 273* 278* 283* 288* 293* 298* 303* 308* 313* 318* 323* 328* 333* 338* 341 353 W10 000346 internal static char(10) initial array packed unaligned dcl 214 set ref 311 W11 000415 internal static char(11) initial array packed unaligned dcl 220 set ref 316 W12 000440 internal static char(12) initial array packed unaligned dcl 225 set ref 321 W13 000460 internal static char(13) initial array packed unaligned dcl 230 set ref 326 W14 000472 internal static char(14) initial array packed unaligned dcl 234 set ref 331 W15 000521 internal static char(15) initial array packed unaligned dcl 240 set ref 336 W2 000010 internal static char(2) initial array packed unaligned dcl 163 set ref 266 271 W3 000012 internal static char(3) initial array packed unaligned dcl 168 set ref 276 W4 000030 internal static char(4) initial array packed unaligned dcl 172 set ref 281 W5 000056 internal static char(5) initial array packed unaligned dcl 178 set ref 286 W6 000072 internal static char(6) initial array packed unaligned dcl 182 set ref 291 W7 000157 internal static char(7) initial array packed unaligned dcl 191 set ref 296 W8 000216 internal static char(8) initial array packed unaligned dcl 197 set ref 301 W9 000270 internal static char(9) initial array packed unaligned dcl 206 set ref 306 Wptr 000102 automatic pointer dcl 153 set ref 266* 271* 276* 281* 286* 291* 296* 301* 306* 311* 316* 321* 326* 331* 336* 341 348 addr builtin function dcl 150 ref 266 268 271 273 276 278 281 283 286 288 291 293 296 298 301 303 306 308 311 313 316 318 321 323 326 328 331 333 336 338 chars based char(1000) packed unaligned dcl 160 ref 348 index builtin function dcl 150 ref 348 key 4 based fixed bin(17,0) level 2 in structure "reserved_word" dcl 664 in procedure "cobol_imp_word" ref 372 388 411 413 435 462 488 522 549 583 610 636 key 000107 automatic fixed bin(17,0) dcl 155 in procedure "cobol_imp_word" set ref 388* 390 390 390 413* 415 417 419 435* 436 438 440 442 444 446 462* 464 466 468 470 472 488* 490 492 494 496 498 500 502 504 506 522* 524 549* 551 553 555 557 559 561 563 565 567 583* 585 587 589 591 593 610* 612 614 616 618 620 636* 638 640 642 644 646 648 650 652 654 length 5 based fixed bin(17,0) level 2 dcl 667 ref 255 257 257 258 loc 000106 automatic fixed bin(17,0) dcl 153 set ref 262* 344* 348* 350 353* 353 365 379 379 379 397 397 397 404 404 404 426 426 426 453 453 453 479 479 479 513 513 513 531 531 531 540 540 574 574 574 601 601 601 627 627 627 660 660 660 reserved_word based structure level 1 unaligned dcl 664 substr builtin function dcl 150 ref 257 type 3 based fixed bin(17,0) level 2 in structure "user_word" dcl 667 in procedure "cobol_imp_word" ref 255 type 3 based fixed bin(17,0) level 2 in structure "reserved_word" dcl 664 in procedure "cobol_imp_word" ref 370 386 433 460 486 520 547 581 608 634 user_word based structure level 1 unaligned dcl 667 wd 000110 automatic varying char(32) dcl 157 set ref 257* 348 word 6 based char level 2 packed packed unaligned dcl 667 ref 257 word_ptr parameter pointer dcl 148 ref 28 255 255 257 257 258 360 367 370 372 383 386 388 401 408 411 413 430 433 435 457 460 462 483 486 488 517 520 522 535 544 547 549 578 581 583 605 608 610 631 634 636 word_size 000100 automatic fixed bin(17,0) dcl 148 set ref 258* 260 353 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. init automatic fixed bin(17,0) array dcl 165 word based char(32) packed unaligned dcl 159 NAMES DECLARED BY EXPLICIT CONTEXT. S 000000 constant label array(0:15) dcl 262 ref 260 SS 001430 constant label dcl 341 ref 269 274 279 284 289 294 299 304 309 314 319 324 329 334 339 alphabet_name 000263 constant entry external dcl 430 cobol_imp_word 000030 constant entry external dcl 28 comp_type 000646 constant entry external dcl 544 computer_name 000446 constant entry external dcl 483 device_appendage 000357 constant entry external dcl 457 device_name 000207 constant entry external dcl 408 disp_type 000761 constant entry external dcl 578 file_org 001137 constant entry external dcl 631 find_word 001250 constant entry internal dcl 252 ref 363 377 395 424 451 477 511 529 538 572 599 625 658 forign_label_name 000624 constant entry external dcl 535 imp_word 000042 constant entry external dcl 360 io_technique 001050 constant entry external dcl 605 label_name 000561 constant entry external dcl 517 lang_name 000056 constant entry external dcl 367 printer_control 000164 constant entry external dcl 401 ret_0 000035 constant label dcl 357 set ref 255 switch_name 000120 constant entry external dcl 383 NAME DECLARED BY CONTEXT OR IMPLICATION. null builtin function ref 341 341 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1652 2442 1471 1662 Length 2676 1471 570 220 161 560 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cobol_imp_word 92 external procedure is an external procedure. find_word internal procedure shares stack frame of external procedure cobol_imp_word. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 W2 cobol_imp_word 000011 K2 cobol_imp_word 000012 W3 cobol_imp_word 000020 K3 cobol_imp_word 000030 W4 cobol_imp_word 000043 K4 cobol_imp_word 000056 W5 cobol_imp_word 000065 K5 cobol_imp_word 000072 W6 cobol_imp_word 000132 K6 cobol_imp_word 000157 W7 cobol_imp_word 000203 K7 cobol_imp_word 000216 W8 cobol_imp_word 000252 K8 cobol_imp_word 000270 W9 cobol_imp_word 000330 K9 cobol_imp_word 000346 W10 cobol_imp_word 000402 K10 cobol_imp_word 000415 W11 cobol_imp_word 000433 K11 cobol_imp_word 000440 W12 cobol_imp_word 000454 K12 cobol_imp_word 000460 W13 cobol_imp_word 000470 K13 cobol_imp_word 000472 W14 cobol_imp_word 000514 K14 cobol_imp_word 000521 W15 cobol_imp_word 000557 K15 cobol_imp_word STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cobol_imp_word 000100 word_size cobol_imp_word 000102 Wptr cobol_imp_word 000104 Kptr cobol_imp_word 000106 loc cobol_imp_word 000107 key cobol_imp_word 000110 wd cobol_imp_word THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. return_mac ext_entry trunc_fx2 set_chars_eis index_chars_eis divide_fx1 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 28 000024 357 000035 360 000040 363 000047 365 000050 367 000054 370 000063 372 000071 374 000077 377 000101 379 000102 381 000113 383 000116 386 000125 388 000133 390 000135 392 000144 395 000146 397 000147 399 000157 401 000162 404 000171 406 000202 408 000205 411 000214 413 000222 415 000223 417 000230 419 000235 421 000242 424 000244 426 000245 428 000256 430 000261 433 000270 435 000276 436 000300 438 000305 440 000312 442 000317 444 000324 446 000331 448 000336 451 000340 453 000341 455 000352 457 000355 460 000364 462 000372 464 000374 466 000401 468 000406 470 000413 472 000420 474 000425 477 000427 479 000430 481 000441 483 000444 486 000453 488 000461 490 000463 492 000470 494 000475 496 000502 498 000507 500 000514 502 000521 504 000526 506 000533 508 000540 511 000542 513 000543 515 000554 517 000557 520 000566 522 000574 524 000576 526 000603 529 000605 531 000606 533 000617 535 000622 538 000631 540 000632 542 000641 544 000644 547 000653 549 000661 551 000663 553 000670 555 000675 557 000702 559 000707 561 000714 563 000721 565 000726 567 000733 569 000740 572 000742 574 000743 576 000754 578 000757 581 000766 583 000774 585 000776 587 001003 589 001010 591 001015 593 001022 595 001027 599 001031 601 001032 603 001043 605 001046 608 001055 610 001063 612 001065 614 001072 616 001077 618 001104 620 001111 622 001116 625 001120 627 001121 629 001132 631 001135 634 001144 636 001152 638 001154 640 001161 642 001166 644 001173 646 001200 648 001205 650 001212 652 001217 654 001224 656 001231 658 001233 660 001234 662 001245 252 001250 255 001251 257 001262 258 001271 260 001273 262 001274 264 001275 266 001276 268 001301 269 001303 271 001304 273 001307 274 001311 276 001312 278 001315 279 001317 281 001320 283 001323 284 001325 286 001326 288 001331 289 001333 291 001334 293 001337 294 001341 296 001342 298 001345 299 001347 301 001350 303 001353 304 001355 306 001356 308 001361 309 001363 311 001364 313 001367 314 001371 316 001372 318 001375 319 001377 321 001400 323 001403 324 001405 326 001406 328 001411 329 001413 331 001414 333 001417 334 001421 336 001422 338 001425 339 001427 341 001430 344 001440 345 001441 348 001442 350 001451 353 001453 355 001470 ----------------------------------------------------------- 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