COMPILATION LISTING OF SEGMENT expression_semantics Compiled by: Multics PL/I Compiler, Release 32c, of June 16, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 07/31/89 1356.9 mst Mon 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 /* format: style3 */ 12 expression_semantics: 13 proc (blk, stmnt, input_tree, context) returns (ptr); 14 15 /* Modified 770520 by PG to get defaulting of constants to agree with ANSI standard */ 16 /* Modified 770701 by PG to fix 1609 (invalid initialization of automatic variables in prologue) */ 17 /* Modified 770708 by PG to fix 1641 (default statements shouldn't be applied to string constants) */ 18 /* Modified 780314 by PG to fix 1673 (don't default constants unless default statement explicitly touches constants) */ 19 /* Modified 780322 by RAB to diagnose non array_or_entry followed by parenthesized list */ 20 /* Modified Nov 1978 by DS to suppress redundant label and entry cross-references */ 21 /* Modified 26 Dec 1979 by PCK to implement by name assignment */ 22 /* Modified: 28 April 1980 by PCK to fix 1959 */ 23 24 /* parameters */ 25 26 dcl (blk, stmnt, input_tree) 27 ptr parameter; 28 29 /* automatic */ 30 31 dcl (tree, s, subs, d, p, q, b) 32 ptr; 33 dcl (i, n, t, asterisk_count) 34 fixed bin (15); 35 dcl opcode bit (9) aligned; 36 dcl (LHS_aggregate, pds, cross_section) 37 bit (1) aligned; 38 39 /* builtins */ 40 41 dcl (addr, index, null, string) 42 builtin; 43 44 /* external static */ 45 46 dcl pl1_stat_$LHS ptr ext static; 47 dcl pl1_stat_$LHS_ref ptr ext static; 48 dcl pl1_stat_$root ptr ext static; 49 dcl pl1_stat_$locator (128) ptr ext static; 50 dcl pl1_stat_$index fixed bin (15) ext static; 51 52 /* program */ 53 54 tree = input_tree; 55 56 subs = null; 57 cross_section, this_context = "0"b; 58 def_this_context.ignore_based = def_context.ignore_based; 59 def_this_context.suppress_cross_ref = def_context.suppress_cross_ref; 60 61 if tree = null 62 then goto ret; 63 64 if tree -> node.type = operator_node 65 then do; 66 if tree -> operator.processed 67 then goto ret; 68 69 opcode = tree -> operator.op_code; 70 71 if opcode < r_parn | opcode > lock_file 72 then goto not_io; 73 74 if ((opcode >= get_file) & (opcode <= locate_file) | (opcode >= rewrite_file) & (opcode <= lock_file)) 75 then do; 76 call io_semantics (blk, stmnt, tree); 77 if opcode ^= open_file & opcode ^= close_file 78 then tree = null; /* 7-18-72: all others handled 79* by recio or stream_prep */ 80 81 goto ret; 82 end; 83 84 if opcode >= r_parn & opcode <= bn_format 85 then do; 86 call io_data_list_semantics$format_list_semantics (blk, stmnt, tree); 87 tree -> operator.processed = "1"b; 88 goto ret; 89 end; 90 91 if opcode = put_data_trans 92 then do; 93 q = tree -> operand (2); 94 if q -> node.type = token_node 95 then do; 96 p = create_reference (q); 97 q, tree -> operand (2) = p; 98 end; 99 if q -> node.type = reference_node 100 then q -> reference.put_data_sw = "1"b; 101 end; 102 103 if opcode = get_list_trans | opcode = get_edit_trans 104 then def_this_context.left_side = "1"b; 105 106 not_io: 107 if opcode = assign_by_name 108 then do; 109 call expand_by_name (blk, stmnt, tree); 110 111 if stmnt -> statement.root = null 112 then go to ret; 113 else opcode = assign; 114 end; 115 116 if opcode = refer | opcode = bit_pointer 117 then if pl1_stat_$index > 0 118 then do; 119 p = pl1_stat_$locator (pl1_stat_$index) -> reference.qualifier; 120 121 if opcode = refer 122 then do; 123 tree = copy_expression (tree -> operand (2)); 124 if tree -> node.type = token_node 125 then tree = create_reference (tree); 126 127 tree -> reference.qualifier = share_expression (p); 128 tree = expression_semantics (blk, stmnt, tree, this_context); 129 130 goto ret; 131 end; 132 else do; 133 if p -> node.type = operator_node 134 then if p -> operator.op_code = assign 135 then if p -> operand (1) -> reference.symbol -> symbol.aligned 136 then p = p -> operand (2); 137 tree -> operand (2) = share_expression (p); 138 end; 139 end; 140 else do; 141 if opcode = bit_pointer 142 then call semantic_translator$abort (291, null); 143 144 tree = tree -> operand (1); 145 tree = expression_semantics (blk, stmnt, tree, this_context); 146 goto ret; 147 end; 148 149 150 if opcode = assign 151 then do; 152 def_this_context.left_side = "1"b; 153 154 if def_context.top 155 then def_this_context.by_name_assignment = stmnt -> statement.expanded_by_name; 156 157 tree -> operand (1) = expression_semantics (blk, stmnt, (tree -> operand (1)), this_context); 158 LHS_aggregate = def_this_context.aggregate; 159 160 if def_this_context.return_from_empty 161 then do; 162 tree = tree -> operand (1); 163 goto ret; 164 end; 165 166 do p = tree -> operand (1) repeat p -> operand (1) while (p -> node.type = operator_node); 167 end; 168 169 if p -> node.type ^= reference_node 170 then call print (145); 171 172 if def_context.top 173 then do; 174 pl1_stat_$LHS_ref = p; 175 pl1_stat_$LHS = p -> reference.symbol; 176 end; 177 178 if stmnt -> statement.expanded_by_name 179 then def_this_context.by_name_assignment = def_context.top | def_context.by_name_assignment; 180 181 def_this_context.aggregate, def_this_context.left_side = "0"b; 182 tree -> operand (2) = expression_semantics (blk, stmnt, (tree -> operand (2)), this_context); 183 def_context.RHS_aggregate = def_this_context.aggregate; 184 def_this_context.aggregate = def_this_context.aggregate | LHS_aggregate; 185 186 if def_this_context.return_from_empty 187 then do; 188 tree = tree -> operand (2); 189 190 goto ret; 191 end; 192 end; 193 else do; 194 def_this_context.by_name_assignment = def_context.by_name_assignment; 195 if opcode = do_fun 196 then do; 197 def_this_context.left_side = "1"b; 198 tree -> operand (2) = 199 expression_semantics (blk, stmnt, (tree -> operand (2)), this_context); 200 def_this_context.left_side = "0"b; 201 end; 202 203 if opcode = do_spec /* do loop while, repeat specs are only processed inside the loop */ 204 then do i = 1 to 3, 6; 205 if tree -> operand (i) ^= null 206 then tree -> operand (i) = 207 expression_semantics (blk, stmnt, (tree -> operand (i)), this_context); 208 end; 209 else do i = 1 to tree -> operator.number; 210 /* normal operator...process all operands */ 211 if tree -> operand (i) ^= null 212 then tree -> operand (i) = 213 expression_semantics (blk, stmnt, (tree -> operand (i)), this_context); 214 end; 215 end; 216 217 if opcode = return_value 218 then do; 219 tree = operator_semantics (blk, stmnt, tree, this_context); 220 221 if tree ^= null 222 then tree -> operator.processed = "1"b; 223 224 goto ret; 225 end; 226 227 if ^def_this_context.aggregate | opcode = allot_var | opcode = free_var | opcode = std_entry 228 then do; 229 tree = operator_semantics (blk, stmnt, tree, context); 230 231 if tree ^= null 232 then tree -> operator.processed = "1"b; 233 234 goto ret; 235 end; 236 237 /* Only aggregates will reach this point */ 238 if opcode = std_entry | opcode = join 239 then do; 240 tree -> operator.processed = "1"b; 241 goto ret; 242 end; 243 244 if opcode >= jump 245 then if opcode = prefix_plus | opcode = join | opcode >= get_list_trans & opcode <= put_data_trans 246 then ; 247 else call print (62); 248 249 if opcode = assign & (def_context.arg_list | def_context.top) 250 then do; 251 this_context = context; 252 253 if def_this_context.top 254 then def_this_context.by_name_assignment = stmnt -> statement.expanded_by_name; 255 256 tree = expand_assign (blk, stmnt, tree, this_context, null); 257 tree -> operator.processed = "1"b; 258 goto ret; 259 end; 260 261 def_context.aggregate = "1"b; 262 263 if opcode = copy_words 264 then do; 265 p = expand_primitive (blk, stmnt, (tree -> operand (1)), "0"b); 266 267 do q = p repeat q -> operand (1) while (q -> operand (1) -> node.type = operator_node); 268 end; 269 270 tree -> operand (1) = q -> operand (1); 271 q -> operand (1) = tree; 272 tree = p; 273 274 tree -> operator.processed = "1"b; 275 goto ret; 276 end; 277 278 if opcode = negate | opcode = not_bits | opcode = prefix_plus | opcode = put_field 279 | opcode = put_field_chk | (opcode >= get_list_trans & opcode <= put_data_trans) 280 then tree = expand_prefix (blk, stmnt, tree, context); 281 else tree = expand_infix (blk, stmnt, tree, context); 282 283 tree -> operator.processed = "1"b; 284 285 goto ret; 286 end; 287 288 if tree -> node.type = token_node 289 then do; 290 if tree -> token.type = identifier 291 then do; 292 293 if ^lookup (blk, stmnt, tree, s, this_context) 294 then do; 295 call semantic_translator$error (77, tree); 296 s = create_symbol ((pl1_stat_$root -> block.son), tree, by_implication); 297 call declare (s); 298 s -> symbol.allocate = "1"b; 299 300 d = create_cross_reference (); 301 d -> cross_reference.next = null; 302 s -> symbol.cross_references = d; 303 string (d -> cross_reference.source_id) = string (stmnt -> statement.source_id); 304 end; 305 306 if s -> node.type = label_node 307 then goto process_label; 308 309 q = s -> symbol.reference; 310 if q -> reference.offset = null & q -> reference.qualifier = null 311 & q -> reference.length = null & ^(s -> symbol.entry | s -> symbol.defined) 312 then tree = q; 313 else do; 314 tree = copy_expression ((q)); 315 tree -> reference.shared = "0"b; 316 tree -> reference.ref_count = 1; 317 tree -> reference.qualifier = null; 318 end; 319 go to process_reference; 320 end; 321 322 /* Default arithmetic constant tokens */ 323 324 if (tree -> token.type & is_arithmetic_constant) = is_arithmetic_constant 325 then do b = blk repeat b -> block.father while (b ^= null); 326 if b -> block.default ^= null 327 then do; 328 s = create_symbol (blk, null, by_compiler); 329 s -> symbol.constant = "1"b; 330 if tree -> token.loc ^= ""b 331 /* "p" flag ON */ 332 then go to ignore_default_attempt; 333 334 /* constant contains an "e" implies is_float_constant */ 335 if (tree -> token.type & is_float_constant) = is_float_constant 336 then s -> symbol.float = "1"b; 337 else if index (tree -> token.string, "f") ^= 0 338 then s -> symbol.fixed = "1"b; 339 340 /* constant contains an "i" implies is_imaginary_constant */ 341 if (tree -> token.type & is_imaginary_constant) = is_imaginary_constant 342 then s -> symbol.complex = "1"b; 343 else s -> symbol.real = "1"b; 344 345 call validate (s); /* now default the symbol */ 346 347 if ^s -> symbol.defaulted 348 /* were any defaults applied? */ 349 then go to ignore_default_attempt; 350 /* No */ 351 352 if ^s -> symbol.fixed & ^s -> symbol.float 353 /* complete the scale */ 354 then s -> symbol.fixed = "1"b; 355 356 if ^s -> symbol.binary & ^s -> symbol.decimal 357 /* complete the base */ 358 then if (tree -> token.type & is_decimal_constant) = is_decimal_constant 359 then s -> symbol.decimal = "1"b; 360 else s -> symbol.binary = "1"b; 361 362 /* validate and the above code has now supplied 363* the data type to coerce the literal constant to, 364* except possibly for the size (length or precision) */ 365 366 /* get a pointer to a reference to the converted constant */ 367 368 if s -> symbol.c_dcl_size = 0 & s -> symbol.dcl_size = null 369 then tree = convert (tree, string (s -> symbol.attributes)); 370 else tree = convert$to_target (tree, (s -> symbol.reference)); 371 372 ignore_default_attempt: 373 call free_node (s); 374 375 go to ret; 376 end; 377 end; /* control comes here if there were no default statements */ 378 go to ret; 379 end; 380 381 if tree -> node.type = label_node 382 then do; 383 s = tree; 384 go to process_label; 385 end; 386 387 if tree -> node.type ^= reference_node 388 then goto ret; 389 390 if tree -> reference.symbol -> node.type ^= token_node 391 then do; 392 s = tree -> reference.symbol; 393 if s -> node.type ^= symbol_node 394 then goto ret; /* could be subscripted reference_node for labels */ 395 if s -> symbol.param_desc /* the qualifier field should be fully processed */ 396 then do; 397 tree -> reference.processed = "1"b; 398 goto process_reference; 399 end; 400 401 if ^tree -> reference.symbol -> symbol.based /* for init allocated based structures */ 402 & ^tree -> reference.processed 403 then tree -> reference.qualifier = null;/* for auto-adj storage class */ 404 405 goto process_reference; 406 end; 407 408 subs = tree -> reference.offset; 409 tree -> reference.offset = null; /* lookup never sees the offset field */ 410 411 if ^lookup (blk, stmnt, tree, s, this_context) 412 then do; 413 q = tree -> reference.length; 414 if q ^= null 415 then do; 416 p = create_token (tree -> reference.symbol -> token.string || """ in """ 417 || q -> element (q -> list.number) -> token.string, identifier); 418 call semantic_translator$abort (102, p); 419 end; 420 421 if subs = null 422 then do; 423 pds = tree -> reference.put_data_sw; 424 425 call semantic_translator$error (77, tree); 426 s = create_symbol ((pl1_stat_$root -> block.son), (tree -> reference.symbol), by_implication); 427 call declare (s); 428 s -> symbol.allocate = "1"b; 429 430 d = create_cross_reference (); 431 d -> cross_reference.next = null; 432 s -> symbol.cross_references = d; 433 string (d -> cross_reference.source_id) = string (stmnt -> statement.source_id); 434 435 if pds 436 then do; 437 tree -> reference.put_data_sw = "1"b; 438 goto copy_ref; 439 end; 440 441 goto process_reference; 442 end; 443 444 do i = 1 to number_of_names; 445 if tree -> reference.symbol -> token.string = pl1_data$builtin_name (i).name 446 then do; 447 s = create_symbol ((pl1_stat_$root -> block.son), (tree -> reference.symbol), 448 by_implication); 449 450 d = create_cross_reference (); 451 d -> cross_reference.next = null; 452 s -> symbol.cross_references = d; 453 string (d -> cross_reference.source_id) = string (stmnt -> statement.source_id); 454 s -> symbol.builtin = "1"b; 455 s -> symbol.c_dcl_size = i; 456 457 tree -> reference.offset = null; 458 tree -> reference.symbol = s; 459 s -> symbol.reference = tree; 460 461 tree = builtin (blk, stmnt, tree, subs, s, context); 462 goto ret; 463 end; 464 end; 465 466 call semantic_translator$error (64, tree); 467 s = create_symbol ((pl1_stat_$root -> block.son), (tree -> reference.symbol), by_implication); 468 s -> symbol.entry = "1"b; 469 s -> symbol.variable_arg_list = "1"b; 470 call declare (s); 471 s -> symbol.allocate = "1"b; 472 tree = copy_expression (s -> symbol.reference); 473 end; 474 475 /* this name was found by lookup. */ 476 477 if s -> node.type = label_node 478 then go to process_label; 479 480 copy_ref: 481 p = s -> symbol.reference; 482 q = tree -> reference.qualifier; 483 pds = tree -> reference.put_data_sw; 484 485 if q = null & subs = null & p -> reference.offset = null & p -> reference.qualifier = null 486 & p -> reference.length = null & ^s -> symbol.entry & ^pds 487 then do; 488 call free_node (tree); 489 tree = p; 490 end; 491 else do; 492 tree -> reference = p -> reference; 493 tree -> reference.shared, tree -> reference.aggregate, tree -> reference.processed = "0"b; 494 tree -> reference.ref_count = 1; 495 tree -> reference.put_data_sw = pds; 496 497 if tree -> reference.offset ^= null 498 then tree -> reference.offset = copy_expression (/* p-> */ tree -> reference.offset); 499 500 if tree -> reference.length ^= null 501 then tree -> reference.length = copy_expression (/* p-> */ tree -> reference.length); 502 503 tree -> reference.qualifier = q; 504 end; 505 506 process_reference: 507 if def_context.left_side 508 then call propagate_bit (s, set_bit); 509 else if s -> symbol.auto | s -> symbol.defined 510 then if s -> symbol.dcl_type ^= by_compiler /* ck this because left_side bit not always set */ 511 then if s -> symbol.block_node ^= null 512 then if s -> symbol.block_node -> block.prologue_flag 513 /* are we processing prologue stmts? */ 514 then call print (295); /* invalid initialization of automatic variable */ 515 516 if tree -> reference.processed 517 then if tree -> reference.array_ref | s -> symbol.structure 518 then goto set_aggregate_bit; 519 else goto ret; 520 521 if s -> symbol.builtin 522 then do; 523 if s -> symbol.c_dcl_size = 0 524 then do; 525 do i = 1 to number_of_names; 526 if description (i).name = s -> symbol.token -> token.string 527 then do; 528 s -> symbol.c_dcl_size = i; 529 goto call_builtin; 530 end; 531 end; 532 533 call semantic_translator$abort (63, s); 534 end; 535 536 call_builtin: 537 tree = builtin (blk, stmnt, tree, subs, s, context); 538 539 goto ret; 540 end; 541 542 if s -> symbol.generic 543 then do; 544 tree = generic_selector (blk, stmnt, tree, subs, context); 545 goto ret; 546 end; 547 548 /* this is a variable or named constant. */ 549 /* processing the qualifier */ 550 551 if s -> symbol.based 552 then if tree -> reference.qualifier ^= null 553 then q = tree -> reference.qualifier; 554 else if s -> symbol.reference -> reference.qualifier = null 555 then if ^def_context.ignore_based 556 then call print (66); 557 else q = null; 558 else q = copy_expression (s -> symbol.reference -> reference.qualifier); 559 560 else if tree -> reference.qualifier ^= null 561 then call print (67); 562 else if ^s -> symbol.defined & s -> symbol.reference -> reference.qualifier ^= null 563 then do; 564 q = s -> symbol.reference -> reference.qualifier; 565 if q -> node.type ^= reference_node 566 then q = copy_expression ((q)); 567 end; 568 else q = null; 569 570 if q ^= null 571 then do; 572 if q -> node.type = symbol_node 573 then q = q -> symbol.reference; 574 575 if tree -> reference.qualifier = null 576 then p = s -> symbol.block_node; 577 else p = blk; 578 579 q = expression_semantics (p, stmnt, q, this_context); 580 581 if def_this_context.aggregate 582 then call print (68); 583 584 tree -> reference.qualifier, q = convert (q, pointer_type); 585 586 if q -> node.type = operator_node 587 then if q -> op_code = assign 588 then if q -> operand (2) -> reference.symbol -> symbol.offset 589 then do; 590 q -> operator.processed = "0"b; 591 /* offset -> .... */ 592 tree -> reference.qualifier, q = operator_semantics (blk, stmnt, q, "0"b); 593 q -> operator.processed = "1"b; 594 end; 595 596 pl1_stat_$index = pl1_stat_$index + 1; 597 if pl1_stat_$index > 128 598 then call print (70); 599 pl1_stat_$locator (pl1_stat_$index) = tree; 600 end; 601 602 /* processing the subscripts */ 603 /* calling subscripter or defined_reference */ 604 /* scalar, cross_section, or array(*,*,*) */ 605 606 if s -> symbol.dimensioned & subs ^= null 607 then do; 608 asterisk_count = 0; 609 610 do i = 1 to subs -> list.number; 611 if subs -> element (i) -> node.type = token_node 612 then if subs -> element (i) -> token.type = asterisk 613 then asterisk_count = asterisk_count + 1; 614 end; 615 616 if asterisk_count = subs -> list.number 617 then do; 618 subs = null; 619 tree -> reference.array_ref = "1"b; 620 621 cross_section = "0"b; 622 623 if def_context.arg_list & ^s -> symbol.defined 624 then goto process_ref_sons; 625 626 tree -> reference.offset = null; 627 628 if q ^= null 629 then pl1_stat_$index = pl1_stat_$index - 1; 630 631 goto set_aggregate_bit; 632 end; 633 else tree -> reference.array_ref, cross_section = asterisk_count ^= 0; 634 635 if cross_section & def_context.evaluate_offset 636 then if ^def_context.string_unspec 637 then call semantic_translator$abort (272, tree); 638 else do; 639 pl1_stat_$index = pl1_stat_$index - 1; 640 641 goto set_aggregate_bit; 642 end; 643 644 if def_context.arg_list 645 then do; 646 if cross_section 647 then do; 648 tree -> reference.offset = subs; 649 def_context.cross_section = "1"b; 650 651 if q ^= null 652 then pl1_stat_$index = pl1_stat_$index - 1; 653 654 goto ret; 655 end; 656 657 if s -> symbol.defined 658 then tree = defined_reference (blk, stmnt, tree, subs, s, context); 659 else tree = subscripter (blk, stmnt, tree, subs, s); 660 end; 661 662 else if ^(s -> symbol.structure | cross_section) | def_context.evaluate_offset 663 then if s -> symbol.defined 664 then tree = defined_reference (blk, stmnt, tree, subs, s, context); 665 else tree = subscripter (blk, stmnt, tree, subs, s); 666 667 if s -> symbol.entry & def_context.top & subs = null 668 then subs = create_list (0); 669 end; 670 671 else if subs ^= null & ^s -> symbol.entry 672 then call neither_array_nor_entry; 673 674 /* array_reference, or undimensioned scalar */ 675 else if s -> symbol.defined & ^s -> symbol.structure & ^tree -> reference.array_ref 676 then tree = defined_reference (blk, stmnt, tree, subs, s, context); 677 678 process_ref_sons: /* processing the offset */ 679 if tree -> reference.offset ^= null 680 then do; 681 tree -> reference.offset = 682 expression_semantics ((s -> symbol.block_node), stmnt, (tree -> reference.offset), "0"b); 683 tree -> reference.offset = convert$to_integer ((tree -> reference.offset), integer_type); 684 end; 685 686 /* processing the length */ 687 688 if tree -> reference.length ^= null 689 then do; 690 tree -> reference.length = 691 expression_semantics ((s -> symbol.block_node), stmnt, (tree -> reference.length), "0"b); 692 tree -> reference.length = convert$to_integer ((tree -> reference.length), integer_type); 693 end; 694 695 call simplify_offset (tree, context); 696 697 if def_this_context.aggregate 698 then call print (73); 699 700 if q ^= null 701 then pl1_stat_$index = pl1_stat_$index - 1; 702 703 /* calls function */ 704 705 if s -> symbol.entry 706 then if subs ^= null 707 then do; 708 if cross_section 709 then call print (72); 710 p = create_operator (std_arg_list, 3); 711 p -> operand (2) = subs; 712 q = create_operator (std_call, 3); 713 q -> operand (2) = tree; 714 q -> operand (3) = p; 715 tree = q; 716 717 tree = function (blk, stmnt, tree, s, context); 718 719 if tree -> node.type = operator_node 720 then tree -> operator.processed = "1"b; 721 else tree -> reference.processed = "1"b; 722 723 goto ret; 724 end; 725 726 set_aggregate_bit: /* turning on the aggregate bit */ 727 tree -> reference.array_ref = tree -> reference.array_ref | cross_section; 728 729 if subs ^= null 730 then do; 731 732 /* put back subs on the reference node for use by expand_primitive */ 733 734 tree -> reference.offset = subs; 735 736 /* undo work of simplify_offset to avoid DISASTER! */ 737 738 tree -> reference.c_offset = s -> symbol.reference -> reference.c_offset; 739 tree -> reference.units = s -> symbol.reference -> reference.units; 740 string (tree -> reference.info.other) = "0"b; 741 end; 742 743 if pl1_stat_$LHS ^= null & ^def_context.left_side & ^def_context.evaluate_offset 744 then stmnt -> statement.LHS_in_RHS = temp_needed (tree, cross_section); 745 746 if tree -> reference.array_ref & s -> symbol.defined & ^s -> symbol.overlayed 747 then def_context.cross_section = "1"b; 748 749 if s -> symbol.structure | tree -> reference.array_ref 750 then def_context.aggregate = "1"b; 751 752 if ^def_context.ignore_based 753 then tree -> reference.processed = "1"b; 754 755 goto ret; 756 757 /* this is a reference to a label constant. */ 758 759 process_label: 760 if s -> label.array 761 then do; 762 if subs ^= null 763 then do; 764 if subs -> list.number ^= 1 765 then call print (80); 766 p = subs -> element (1); 767 if p -> node.type = token_node 768 then if p -> token.type = asterisk 769 then cross_section = "1"b; 770 end; 771 772 if subs = null | cross_section 773 then do; 774 tree = create_reference (s); 775 tree -> reference.processed = "1"b; 776 tree -> reference.array_ref = "1"b; 777 def_context.aggregate = "1"b; 778 call increment_label_array_counts; 779 goto ret; 780 end; 781 782 tree = subscripter (blk, stmnt, tree, subs, s); 783 tree -> reference.offset = expression_semantics (blk, stmnt, (tree -> reference.offset), this_context); 784 call simplify_offset (tree, "0"b); 785 if def_this_context.aggregate 786 then call print (73); 787 tree -> reference.processed = "1"b; 788 789 if tree -> reference.offset = null 790 then do; 791 q = s -> label.statement -> list.element (tree -> reference.c_offset + 1); 792 if q ^= null 793 then q -> statement.reference_count = q -> statement.reference_count + 1; 794 else call print (494); 795 end; 796 else call increment_label_array_counts; 797 end; 798 else do; 799 if subs ^= null 800 then call neither_array_nor_entry; 801 802 if s -> label.statement ^= null 803 then s -> label.statement -> statement.reference_count = 804 s -> label.statement -> statement.reference_count + 1; 805 806 tree = s; 807 end; 808 809 ret: 810 return (tree); 811 812 /* Is a temporary needed because of RHS-LHS overlap */ 813 814 temp_needed: 815 procedure (RHS_ref, RHS_cross_section) returns (bit (1) aligned); 816 817 /* parameters */ 818 819 dcl RHS_ref ptr parameter; 820 dcl RHS_cross_section bit (1) aligned parameter; 821 822 /* external static */ 823 824 dcl ( 825 pl1_stat_$LHS, 826 pl1_stat_$LHS_ref 827 ) ptr ext static; 828 829 /* builtin */ 830 831 dcl (null, string) builtin; 832 833 /* automatic */ 834 835 dcl (LHS_ref, LHS_sym, RHS_sym) 836 ptr; 837 dcl t fixed bin; 838 839 LHS_ref = pl1_stat_$LHS_ref; 840 LHS_sym = pl1_stat_$LHS; 841 RHS_sym = RHS_ref -> reference.symbol; 842 843 if RHS_ref -> reference.array_ref 844 then do; 845 846 if defined_on (RHS_sym, LHS_sym) 847 then return ("1"b); 848 849 if defined_on (LHS_sym, RHS_sym) 850 then return ("1"b); 851 852 if cross_section_overlap () 853 then return ("1"b); 854 855 end; 856 857 if string_overlay_possible () 858 then return ("1"b); 859 860 return ("0"b); 861 862 /* Is s1 defined on s2? */ 863 864 defined_on: 865 procedure (s1, s2) returns (bit (1) aligned); 866 867 /* parameters */ 868 869 dcl (s1, s2) ptr; 870 871 /* automatic */ 872 873 dcl s1_defined_on_s2 bit (1) aligned; 874 875 if s1 -> symbol.defined & s1 -> symbol.equivalence ^= null 876 then if s1 -> symbol.equivalence -> node.type = token_node 877 then if s1 -> symbol.equivalence = s2 -> symbol.token 878 then s1_defined_on_s2 = "1"b; 879 else s1_defined_on_s2 = "0"b; 880 else if s1 -> symbol.equivalence -> reference.symbol = s2 881 then s1_defined_on_s2 = "1"b; 882 else s1_defined_on_s2 = "0"b; 883 else s1_defined_on_s2 = "0"b; 884 885 return (s1_defined_on_s2); 886 887 end /* defined_on */; 888 889 /* If the RHS reference is a possible reference to a cross-section, 890* determine if possible RHS-LHS overlap will require an aggregate temp */ 891 892 cross_section_overlap: 893 procedure () returns (bit (1) aligned); 894 895 /* The RHS reference is a possible cross-section reference if any of 896* the following conditions are satisfied: 897* 898* (1) An explicit cross-section reference was given (e.g. a(i,*)); 899* This would be indicated by RHS_cross_section. 900* 901* (2) A reference to a parameter with star extents was given. This 902* is the only valid way a parameter may be aliased to a cross-section. 903* 904* (3) A reference to a variable with the defined attribute was given. 905* If this is isub defining, the variable may be a cross-section of 906* an array. 907* 908* Note: These tests are rather crude; future implementations should attempt 909* to refine them or to substitute a more systematic approach. 910* */ 911 912 /* automatic */ 913 914 dcl (RHS_subs, LHS_subs) 915 ptr; 916 917 if (RHS_cross_section | (RHS_sym -> symbol.parameter & RHS_sym -> symbol.star_extents) | RHS_sym -> symbol.defined) 918 & (LHS_sym -> symbol.based | LHS_sym -> symbol.defined | LHS_sym -> symbol.parameter) 919 & LHS_sym -> symbol.dimensioned & string (LHS_sym -> symbol.data_type) = string (RHS_sym -> symbol.data_type) 920 then return ("1"b); 921 922 if LHS_sym = RHS_sym & RHS_cross_section 923 then do; 924 LHS_subs = LHS_ref -> reference.offset; 925 RHS_subs = RHS_ref -> reference.offset; 926 927 if LHS_subs = null | RHS_subs = null 928 then return ("1"b); 929 else if LHS_subs -> node.type ^= list_node | RHS_subs -> node.type ^= list_node 930 then return ("1"b); 931 else return (^stars_match ()); 932 933 end; 934 935 return ("0"b); 936 937 /* Determine if two unprocessed subscript lists have asterisks in 938* corresponding positions. E.g., (*,i) and (*,i+1) do, and (*,i) and (i+1,*) 939* don't. */ 940 941 stars_match: 942 procedure () returns (bit (1) aligned); 943 944 /* automatic */ 945 946 dcl i fixed bin; 947 948 do i = 1 to LHS_subs -> list.number; 949 if is_star ((LHS_subs -> list.element (i))) ^= is_star ((RHS_subs -> list.element (i))) 950 then return ("0"b); 951 end; 952 953 return ("1"b); 954 955 /* Determine if a subscript is an asterisk (denotes a cross-section) */ 956 957 is_star: 958 procedure (subscript) returns (bit (1) aligned); 959 960 /* parameter */ 961 962 dcl subscript ptr; 963 964 if subscript -> node.type ^= token_node 965 then return ("0"b); 966 967 if subscript -> token.type ^= asterisk 968 then return ("0"b); 969 970 return ("1"b); 971 972 end /* is_star */; 973 974 end /* stars_match */; 975 976 end /* cross_section_overlap */; 977 978 /* Check for a possible string overlay--one that is valid PL/I 979* If it is possible for both references to string overlay define one 980* other, excluding the case of references to the same generation of 981* storage, a temporary is needed */ 982 983 string_overlay_possible: 984 procedure () returns (bit (1) aligned); 985 986 t = 0; 987 988 if LHS_sym -> symbol.aliasable & RHS_sym -> symbol.aliasable & LHS_sym -> symbol.packed & RHS_sym -> symbol.packed 989 & ^compare_expression (LHS_ref, RHS_ref) & string_overlay (LHS_sym) & string_overlay (RHS_sym) 990 then do; 991 992 if RHS_sym -> symbol.father ^= null 993 then return ("1"b); 994 995 if RHS_sym -> symbol.based | RHS_sym -> symbol.defined | RHS_sym -> symbol.parameter 996 then return ("1"b); 997 998 end; 999 1000 return ("0"b); 1001 1002 end /* string_overlay_possible */; 1 1 /* subroutine to determine if a declaration can be string overlayed. */ 1 2 1 3 string_overlay: proc(s) returns(bit(1) aligned); 1 4 1 5 dcl (s,p) ptr; 1 6 1 7 if ^s->symbol.packed then go to fail; 1 8 if s->symbol.structure 1 9 then do; 1 10 p = s->symbol.son; 1 11 do while(p^=null); 1 12 if ^string_overlay(p) then go to fail; 1 13 p = p->symbol.brother; 1 14 end; 1 15 return("1"b); 1 16 end; 1 17 if ^(s->symbol.bit|s->symbol.char|s->symbol.picture) 1 18 then go to fail; 1 19 if t = 0 then if s->symbol.bit then t = bit_; 1 20 else t = character_; 1 21 else if s->symbol.bit 1 22 then if t = character_ then go to fail; 1 23 else; 1 24 else if t = bit_ then go to fail; 1 25 return("1"b); 1 26 1 27 fail: 1 28 return("0"b); 1 29 end string_overlay; 1003 1004 end /* temp_needed */; 1005 1006 /* increments reference counts of all statements pointed at by label array */ 1007 1008 increment_label_array_counts: 1009 proc; 1010 1011 dcl (q, vector) ptr; 1012 dcl i fixed bin; 1013 1014 vector = s -> label.statement; 1015 do i = 1 to vector -> list.number; 1016 q = vector -> list.element (i); 1017 if q ^= null 1018 then q -> statement.reference_count = q -> statement.reference_count + 1; 1019 end; 1020 1021 end; 1022 1023 1024 /* subroutine to print an error message */ 1025 1026 print: 1027 proc (m); 1028 1029 dcl m fixed bin (15); 1030 1031 if tree -> node.type = operator_node 1032 then p = null; 1033 else p = tree; 1034 1035 call semantic_translator$abort (m, p); 1036 1037 end; 1038 1039 /* prints appropriate error message */ 1040 1041 neither_array_nor_entry: 1042 proc; 1043 1044 dcl errno fixed bin (15); 1045 1046 if def_context.top & stmnt -> statement.statement_type = call_statement 1047 then errno = 224; /* used $ where entry value needed */ 1048 else errno = 370; /* $ was followed by parenthesized list & is neither array nor entry */ 1049 1050 call print (errno); 1051 1052 end; 1053 2 1 /* BEGIN INCLUDE FILE ... semant.incl.pl1 */ 2 2 2 3 /* Modified: 30 Aug 1979 by PCK to fix 1804 and 1823 */ 2 4 /* Modified: 26 Aug 1979 by PCK to implement by name assignment */ 2 5 2 6 2 7 declare alloc_semantics entry(pointer,pointer,pointer); 2 8 /* parameter 1: (input) block node pointer */ 2 9 /* parameter 2: (input) statement node pointer */ 2 10 /* parameter 3: (in/out) tree pointer */ 2 11 2 12 declare alloc_semantics$init_only entry(pointer,pointer,pointer); 2 13 /* parameter 1: (input) qualifier pointer */ 2 14 /* parameter 2: (input) statement node pointer */ 2 15 /* parameter 3: (input) symbol node pointer */ 2 16 2 17 declare builtin entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned) 2 18 returns(pointer); 2 19 /* parameter 1: (input) block node pointer */ 2 20 /* parameter 2: (input) statement node pointer */ 2 21 /* parameter 3: (input) tree pointer */ 2 22 /* parameter 4: (input) subscript pointer */ 2 23 /* parameter 5: (input) builtin symbol node pointer */ 2 24 /* parameter 6: (in/out) context */ 2 25 /* return: (output) tree pointer */ 2 26 2 27 declare check_star_extents entry(pointer,pointer); 2 28 /* parameter 1: (input) symbol node of procedure */ 2 29 /* parameter 2: (input) argument list pointer */ 2 30 2 31 declare compare_declaration entry(pointer,pointer,bit(1) aligned) reducible 2 32 returns(bit(1) aligned); 2 33 /* parameter 1: (input) reference or symbol node ptr */ 2 34 /* parameter 2: (input) symbol node ptr */ 2 35 /* parameter 3: (input) "1"b if aligned attribute ignored for string */ 2 36 /* return: (output) compare bit */ 2 37 2 38 declare context_processor entry(pointer,label); 2 39 /* parameter 1: (input) root block node pointer */ 2 40 2 41 declare declare entry(pointer); 2 42 /* parameter 1: (input) symbol node pointer */ 2 43 2 44 declare declare_structure entry(pointer); 2 45 /* parameter 1: (input) symbol node pointer */ 2 46 2 47 declare defined_reference entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned) 2 48 returns(pointer); 2 49 /* parameter 1: (input) block node pointer */ 2 50 /* parameter 2: (input) statement node pointer */ 2 51 /* parameter 3: (input) tree pointer */ 2 52 /* parameter 4: (input) subscript list pointer or null*/ 2 53 /* parameter 5: (input) symbol node pointer */ 2 54 /* parameter 6: (in/out) context */ 2 55 /* return: (output) tree pointer */ 2 56 2 57 declare do_semantics entry(pointer,pointer,pointer); 2 58 /* parameter 1: (input) block node pointer */ 2 59 /* parameter 2: (input) statement node pointer */ 2 60 /* parameter 3: (input) tree pointer */ 2 61 2 62 declare expand_assign entry(pointer,pointer,pointer,bit(36) aligned,pointer) 2 63 returns(pointer); 2 64 /* parameter 1: (input) block node pointer */ 2 65 /* parameter 2: (input) statement node pointer */ 2 66 /* parameter 3: (input) tree pointer */ 2 67 /* parameter 4: (in/out) context */ 2 68 /* parameter 5: (input) aggregate reference node ptr */ 2 69 /* return: (output) tree pointer */ 2 70 2 71 declare expand_by_name entry(pointer,pointer,pointer); 2 72 /* parameter 1: (input) block node pointer */ 2 73 /* parameter 2: (input) statement node pointer */ 2 74 /* parameter 3: (input/output) tree pointer */ 2 75 2 76 declare expand_infix entry(pointer,pointer,pointer,bit(36) aligned) 2 77 returns(pointer); 2 78 /* parameter 1: (input) block node pointer */ 2 79 /* parameter 2: (input) statement node pointer */ 2 80 /* parameter 3: (input) tree pointer */ 2 81 /* parameter 4: (in/out) context */ 2 82 /* return: (output) tree pointer */ 2 83 2 84 declare expand_initial entry(pointer,pointer,pointer); 2 85 /* parameter 1: (input) symbol node pointer */ 2 86 /* parameter 2: (input) statement node pointer */ 2 87 /* parameter 3: (input) locator */ 2 88 2 89 declare expand_prefix entry(pointer,pointer,pointer,bit(36) aligned) 2 90 returns(pointer); 2 91 /* parameter 1: (input) block node pointer */ 2 92 /* parameter 2: (input) statement node pointer */ 2 93 /* parameter 3: (input) tree pointer */ 2 94 /* parameter 4: (in/out) context */ 2 95 /* return: (output) tree pointer */ 2 96 2 97 declare expand_primitive entry(pointer,pointer,pointer,bit(36) aligned) 2 98 returns(pointer); 2 99 /* parameter 1: (input) block node pointer */ 2 100 /* parameter 2: (input) statement node pointer */ 2 101 /* parameter 3: (input) tree pointer */ 2 102 /* parameter 4: (input) context */ 2 103 /* return: (output) tree pointer */ 2 104 2 105 declare expression_semantics entry(pointer,pointer,pointer,bit(36) aligned) 2 106 returns(pointer); 2 107 /* parameter 1: (input) block node pointer */ 2 108 /* parameter 2: (input) statement node pointer */ 2 109 /* parameter 3: (input) tree pointer */ 2 110 /* parameter 4: (in/out) context */ 2 111 /* return: (output) tree pointer */ 2 112 2 113 declare fill_refer entry(pointer,pointer,bit(1) aligned) 2 114 returns(pointer); 2 115 /* parameter 1: (input) null,ref node,op node ptr */ 2 116 /* parameter 2: (input) null,ref node,op node ptr */ 2 117 /* parameter 3: (input) copy switch for param 2 */ 2 118 /* return: (output) ptr to processed tree */ 2 119 2 120 declare io_data_list_semantics$format_list_semantics entry(pointer,pointer,pointer); 2 121 /* parameter 1: (input) block node pointer */ 2 122 /* parameter 2: (input) statement node pointer */ 2 123 /* parameter 3: (in/out) tree pointer */ 2 124 2 125 declare function entry(pointer,pointer,pointer,pointer,bit(36) aligned) 2 126 returns(pointer); 2 127 /* parameter 1: (input) block node pointer */ 2 128 /* parameter 2: (input) statement node pointer */ 2 129 /* parameter 3: (input) tree pointer */ 2 130 /* parameter 4: (input) symbol node pointer */ 2 131 /* parameter 5: (in/out) context */ 2 132 /* return: (output) tree pointer */ 2 133 2 134 declare generic_selector entry(pointer,pointer,pointer,pointer,bit(36) aligned) 2 135 returns(pointer); 2 136 /* parameter 1: (input) block node pointer */ 2 137 /* parameter 2: (input) statement node pointer */ 2 138 /* parameter 3: (input) tree pointer */ 2 139 /* parameter 4: (input) pointer to argument list */ 2 140 /* parameter 5: (in/out) context */ 2 141 /* return: (output) tree pointer */ 2 142 2 143 declare io_data_list_semantics entry(pointer,pointer,pointer); 2 144 /* parameter 1: (input) block node pointer */ 2 145 /* parameter 2: (input) statement node pointer */ 2 146 /* parameter 3: (input) operator node pointer */ 2 147 2 148 declare io_semantics entry(pointer,pointer,pointer); 2 149 /* parameter 1: (input) block node pointer */ 2 150 /* parameter 2: (input) statement node pointer */ 2 151 /* parameter 3: (input) tree pointer */ 2 152 2 153 declare lookup entry(pointer,pointer,pointer,pointer,bit(36) aligned) 2 154 returns(bit(1) aligned); 2 155 /* parameter 1: (input) block node pointer */ 2 156 /* parameter 2: (input) stmnt|symbol node pointer */ 2 157 /* parameter 3: (input) token or reference node ptr */ 2 158 /* parameter 4: (output) symbol node pointer */ 2 159 /* parameter 5: (in/out) context */ 2 160 /* return: (output) symbol found bit */ 2 161 2 162 declare make_non_quick entry(pointer, bit (36) aligned); 2 163 /* parameter 1: (input) tree pointer */ 2 164 /* parameter 2: (input) reason why being made nonquick */ 2 165 2 166 declare match_arguments entry(pointer,pointer) reducible 2 167 returns(bit(1) aligned); 2 168 /* parameter 1: (input) reference or symbol node ptr */ 2 169 /* parameter 2: (input) reference or symbol node ptr */ 2 170 /* return: (output) compare bit */ 2 171 2 172 declare offset_adder entry(pointer,fixed binary(31),fixed binary(3),bit(1) aligned, 2 173 pointer,fixed binary(31),fixed binary(3),bit(1) aligned,bit(1)); 2 174 /* parameter 1: (in/out) tree pointer */ 2 175 /* parameter 2: (in/out) constant size */ 2 176 /* parameter 3: (in/out) units */ 2 177 /* parameter 4: (in/out) ON if units ^= word_, but tree in words */ 2 178 /* parameter 5: (input) tree pointer */ 2 179 /* parameter 6: (input) constant size */ 2 180 /* parameter 7: (input) units */ 2 181 /* parameter 8: (input) ON if units ^= word_, but tree in words */ 2 182 /* parameter 9: (input) ON if should not improve units */ 2 183 2 184 declare operator_semantics entry(pointer,pointer,pointer,bit(36) aligned) 2 185 returns(pointer); 2 186 /* parameter 1: (input) block node pointer */ 2 187 /* parameter 2: (input) statement node pointer */ 2 188 /* parameter 3: (input) tree pointer */ 2 189 /* parameter 4: (in/out) context */ 2 190 /* return: (output) tree pointer */ 2 191 2 192 declare propagate_bit entry(pointer,fixed binary(15)); 2 193 /* parameter 1: (input) symbol node pointer */ 2 194 /* parameter 2: (input) attribute number */ 2 195 2 196 declare semantic_translator$call_es entry(pointer,pointer,pointer,label,bit(1) aligned) 2 197 returns(pointer); 2 198 /* parameter 1: (input) block ptr */ 2 199 /* parameter 2: (input) statement ptr */ 2 200 /* parameter 3: (input) tree ptr */ 2 201 /* parameter 4: (input) failure label */ 2 202 /* parameter 5: (input) "1"b -- convert to integer */ 2 203 /* return: (output) tree ptr */ 2 204 2 205 declare simplify_expression entry(pointer,fixed bin,bit(1)aligned); 2 206 /* parameter 1: (in/out) tree pointer */ 2 207 /* parameter 2: (output) value of constant, if the entire tree 2 208* is simplified */ 2 209 /* parameter 3: (output) bit indicating if the tree has 2 210* been simplified */ 2 211 2 212 declare simplify_offset entry(pointer,bit(36) aligned); 2 213 /* parameter 1: (input) reference node pointer */ 2 214 /* parameter 2: (input) context */ 2 215 2 216 declare subscripter entry(pointer,pointer,pointer,pointer,pointer) 2 217 returns(pointer); 2 218 /* parameter 1: (input) block node pointer */ 2 219 /* parameter 2: (input) statement node pointer */ 2 220 /* parameter 3: (input) tree pointer */ 2 221 /* parameter 4: (in/out) subscript list pointer */ 2 222 /* parameter 5: (input) symbol node pointer */ 2 223 /* return: (output) reference node pointer */ 2 224 2 225 declare validate entry(pointer); 2 226 /* parameter 1: (input) symbol node pointer */ 2 227 3 1 /****^ ********************************************************* 3 2* * * 3 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 3 4* * * 3 5* ********************************************************* */ 3 6 3 7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */ 3 8 3 9 3 10 /****^ HISTORY COMMENTS: 3 11* 1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu), 3 12* install(89-07-31,MR12.3-1066): 3 13* Removed the obsolete parameter source_line from the dcl of error_(). 3 14* END HISTORY COMMENTS */ 3 15 3 16 /* Modified: 6 Jun 1979 by PG to add rank and byte 3 17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 3 18* */ 3 19 3 20 declare adjust_count entry(pointer); 3 21 /* parameter 1: (input) any node pointer */ 3 22 3 23 declare bindec entry(fixed bin(31)) reducible 3 24 returns(character(12) aligned); 3 25 /* parameter 1: (input) bin value */ 3 26 /* return: (output) character value with blanks */ 3 27 3 28 declare bindec$vs entry(fixed bin(31)) reducible 3 29 returns(character(12) aligned varying); 3 30 /* parameter 1: (input) binary value */ 3 31 /* return: (output) char value without blanks */ 3 32 3 33 declare binoct entry(fixed bin(31)) reducible 3 34 returns(char(12) aligned); 3 35 /* parameter 1: (input) binary value */ 3 36 /* return: (output) char value with blanks */ 3 37 3 38 declare binary_to_octal_string entry(fixed bin(31)) reducible 3 39 returns(char(12) aligned); 3 40 /* parameter 1: (input) binary value */ 3 41 /* return: (output) right-aligned char value */ 3 42 3 43 declare binary_to_octal_var_string entry(fixed bin(31)) reducible 3 44 returns(char(12) varying aligned); 3 45 /* parameter 1: (input) binary value */ 3 46 /* returns: (output) char value without blanks */ 3 47 3 48 declare compare_expression entry(pointer,pointer) reducible 3 49 returns(bit(1) aligned); 3 50 /* parameter 1: (input) any node pointer */ 3 51 /* parameter 2: (input) any node pointer */ 3 52 /* return: (output) compare bit */ 3 53 3 54 declare constant_length entry (pointer, fixed bin (71)) 3 55 returns (bit (1) aligned); 3 56 /* parameter 1: (input) reference node pointer */ 3 57 /* parameter 2: (input) value of constant length */ 3 58 /* return: (output) "1"b if constant length */ 3 59 3 60 declare convert entry(pointer,bit(36) aligned) 3 61 returns(pointer); 3 62 /* parameter 1: (input) any node pointer */ 3 63 /* parameter 2: (input) target type */ 3 64 /* return: (output) target value tree pointer */ 3 65 3 66 declare convert$to_integer entry(pointer,bit(36)aligned) 3 67 returns(pointer); 3 68 /* parameter 1: (input) any node pointer */ 3 69 /* parameter 2: (input) target type */ 3 70 /* return: (output) target value tree pointer */ 3 71 3 72 declare convert$from_builtin entry(pointer,bit(36) aligned) 3 73 returns(pointer); 3 74 /* parameter 1: (input) any node pointer */ 3 75 /* parameter 2: (input) target type */ 3 76 /* return: (output) target value tree pointer */ 3 77 3 78 declare convert$validate entry(pointer,pointer); 3 79 /* parameter 1: (input) source value tree pointer */ 3 80 /* parameter 2: (input) target reference node pointer */ 3 81 3 82 declare convert$to_target_fb entry(pointer,pointer) 3 83 returns(pointer); 3 84 /* parameter 1: (input) source value tree pointer */ 3 85 /* parameter 2: (input) target reference node pointer */ 3 86 /* return: (output) target value tree pointer */ 3 87 3 88 declare convert$to_target entry(pointer,pointer) 3 89 returns(pointer); 3 90 /* parameter 1: (input) source value tree pointer */ 3 91 /* parameter 2: (input) target reference node pointer */ 3 92 /* return: (output) target value tree pointer */ 3 93 3 94 declare copy_expression entry(pointer unaligned) 3 95 returns(pointer); 3 96 /* parameter 1: (input) any node pointer */ 3 97 /* return: (output) any node pointer */ 3 98 3 99 declare copy_expression$copy_sons entry(pointer,pointer); 3 100 /* parameter 1: (input) father symbol node pointer */ 3 101 /* parameter 2: (input) stepfather symbol node ptr */ 3 102 3 103 declare copy_unique_expression entry(pointer) 3 104 returns(pointer); 3 105 /* parameter 1: (input) any node pointer */ 3 106 /* return: (output) any node pointer */ 3 107 3 108 declare create_array entry() 3 109 returns(pointer); 3 110 /* return: (output) array node pointer */ 3 111 3 112 declare create_block entry(bit(9) aligned,pointer) 3 113 returns(pointer); 3 114 /* parameter 1: (input) block type */ 3 115 /* parameter 2: (input) father block node pointer */ 3 116 /* return: (output) block node pointer */ 3 117 3 118 declare create_bound entry() 3 119 returns(pointer); 3 120 /* return: (output) bound node pointer */ 3 121 3 122 declare create_context entry(pointer,pointer) 3 123 returns(pointer); 3 124 /* parameter 1: (input) block node pointer */ 3 125 /* parameter 2: (input) token pointer */ 3 126 /* return: (output) context node pointer */ 3 127 3 128 declare create_cross_reference entry() 3 129 returns(pointer); 3 130 /* return: (output) cross reference node pointer */ 3 131 3 132 declare create_default entry 3 133 returns(pointer); 3 134 /* return: (output) default node pointer */ 3 135 3 136 declare create_identifier entry() 3 137 returns(pointer); 3 138 /* return: (output) token node pointer */ 3 139 3 140 declare create_label entry(pointer,pointer,bit(3) aligned) 3 141 returns(pointer); 3 142 /* parameter 1: (input) block node pointer */ 3 143 /* parameter 2: (input) token node pointer */ 3 144 /* parameter 3: (input) declare type */ 3 145 /* return: (output) label node pointer */ 3 146 3 147 declare create_list entry(fixed bin(15)) 3 148 returns(pointer); 3 149 /* parameter 1: (input) number of list elements */ 3 150 /* return: (output) list node pointer */ 3 151 3 152 declare create_operator entry(bit(9) aligned,fixed bin(15)) 3 153 returns(pointer); 3 154 /* parameter 1: (input) operator type */ 3 155 /* parameter 2: (input) number of operands */ 3 156 /* return: (output) operator node pointer */ 3 157 3 158 declare create_reference entry(pointer) 3 159 returns(pointer); 3 160 /* parameter 1: (input) symbol node pointer */ 3 161 /* return: (output) reference node pointer */ 3 162 3 163 declare create_statement entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 3 164 returns(pointer); 3 165 /* parameter 1: (input) statement type */ 3 166 /* parameter 2: (input) block node pointer */ 3 167 /* parameter 3: (input) label node pointer */ 3 168 /* parameter 4: (input) conditions */ 3 169 /* return: (output) statement node pointer */ 3 170 3 171 declare create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 3 172 returns(pointer); 3 173 /* parameter 1: (input) statement type */ 3 174 /* parameter 2: (input) block node pointer */ 3 175 /* parameter 3: (input) label node pointer */ 3 176 /* parameter 4: (input) conditions */ 3 177 /* return: (output) statement node pointer */ 3 178 3 179 declare create_storage entry(fixed bin(15)) 3 180 returns(pointer); 3 181 /* parameter 1: (input) number of words */ 3 182 /* return: (output) storage block pointer */ 3 183 3 184 declare create_symbol entry(pointer,pointer,bit(3) aligned) 3 185 returns(pointer); 3 186 /* parameter 1: (input) block node pointer */ 3 187 /* parameter 2: (input) token node pointer */ 3 188 /* parameter 3: (input) declare type */ 3 189 /* return: (output) symbol node pointer */ 3 190 3 191 declare create_token entry (character (*), bit (9) aligned) 3 192 returns (ptr); 3 193 /* parameter 1: (input) token string */ 3 194 /* parameter 2: (input) token type */ 3 195 /* return: (output) token node ptr */ 3 196 3 197 declare create_token$init_hash_table entry (); 3 198 3 199 declare create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned) 3 200 returns (ptr); 3 201 /* parameter 1: (input) token string */ 3 202 /* parameter 2: (input) token type */ 3 203 /* parameter 3: (input) protected flag */ 3 204 /* return: (output) token node ptr */ 3 205 3 206 declare decbin entry(character(*) aligned) reducible 3 207 returns(fixed bin(31)); 3 208 /* parameter 1: (input) decimal character string */ 3 209 /* return: (output) binary value */ 3 210 3 211 declare declare_constant entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15)) 3 212 returns(pointer); 3 213 /* parameter 1: (input) value */ 3 214 /* parameter 2: (input) type */ 3 215 /* parameter 3: (input) size */ 3 216 /* parameter 4: (input) scale */ 3 217 /* return: (output) reference node pointer */ 3 218 3 219 declare declare_constant$bit entry(bit(*) aligned) 3 220 returns(pointer); 3 221 /* parameter 1: (input) bit */ 3 222 /* return: (output) reference node pointer */ 3 223 3 224 declare declare_constant$char entry(character(*) aligned) 3 225 returns(pointer); 3 226 /* parameter 1: (input) character */ 3 227 /* return: (output) reference node pointer */ 3 228 3 229 declare declare_constant$desc entry(bit(*) aligned) 3 230 returns(pointer); 3 231 /* parameter 1: (input) descriptor bit value */ 3 232 /* return: (output) reference node pointer */ 3 233 3 234 declare declare_constant$integer entry(fixed bin(31)) /* note...should really be fixed bin(24) */ 3 235 returns(pointer); 3 236 /* parameter 1: (input) integer */ 3 237 /* return: (output) reference node pointer */ 3 238 3 239 declare declare_descriptor entry(pointer,pointer,pointer,pointer,bit(2) aligned) 3 240 returns(pointer); 3 241 /* parameter 1: (input) block node pointer */ 3 242 /* parameter 2: (input) statement node pointer */ 3 243 /* parameter 3: (input) symbol node pointer */ 3 244 /* parameter 4: (input) loc pointer */ 3 245 /* parameter 5: (input) array descriptor bit 3 246* cross_section bit */ 3 247 /* return: (output) reference node pointer */ 3 248 3 249 declare declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned) 3 250 returns(pointer); 3 251 /* parameter 1: (input) block node pointer */ 3 252 /* parameter 2: (input) statement node pointer */ 3 253 /* parameter 3: (input) symbol node pointer */ 3 254 /* parameter 4: (input) loc pointer */ 3 255 /* parameter 5: (input) array descriptor bit 3 256* cross_section bit */ 3 257 /* return: (output) reference node pointer */ 3 258 3 259 declare declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned) 3 260 returns(pointer); 3 261 /* parameter 1: (input) block node pointer */ 3 262 /* parameter 2: (input) statement node pointer */ 3 263 /* parameter 3: (input) symbol node pointer */ 3 264 /* parameter 4: (input) loc pointer */ 3 265 /* parameter 5: (input) array descriptor bit 3 266* cross_section bit */ 3 267 /* return: (output) reference node pointer */ 3 268 3 269 declare declare_integer entry(pointer) 3 270 returns(pointer); 3 271 /* parameter 1: (input) block node pointer */ 3 272 /* return: (output) reference node pointer */ 3 273 3 274 declare declare_picture entry(char(*)aligned,pointer,fixed bin(15)); 3 275 /* parameter 1: (input) picture string */ 3 276 /* parameter 2: (input) symbol node pointer */ 3 277 /* parameter 3: (output) error code, if any */ 3 278 3 279 declare declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned) 3 280 returns(pointer); 3 281 /* parameter 1: (input) picture string */ 3 282 /* parameter 2: (input) scalefactor of picture */ 3 283 /* parameter 3: (input) ="1"b => complex picture */ 3 284 /* parameter 4: (input) ="1"b => unaligned temp */ 3 285 /* return: (output) reference node pointer */ 3 286 3 287 declare declare_pointer entry(pointer) 3 288 returns(pointer); 3 289 /* parameter 1: (input) block node pointer */ 3 290 /* return: (output) reference node pointer */ 3 291 3 292 declare declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer) 3 293 returns(pointer); 3 294 /* parameter 1: (input) type */ 3 295 /* parameter 2: (input) precision */ 3 296 /* parameter 3: (input) scale */ 3 297 /* parameter 4: (input) length */ 3 298 /* return: (output) reference node pointer */ 3 299 3 300 declare decode_node_id entry(pointer,bit(1) aligned) 3 301 returns(char(120) varying); 3 302 /* parameter 1: (input) node pointer */ 3 303 /* parameter 2: (input) ="1"b => capitals */ 3 304 /* return: (output) source line id */ 3 305 3 306 declare decode_source_id entry( 4 1 1 structure unaligned, 4 2 2 /* file_number */ bit(8), 4 3 2 /* line_number */ bit(14), 4 4 2 /* stmt_number */ bit(5), 3 307 3 308 bit(1) aligned) 3 309 returns(char(120) varying); 3 310 /* parameter 1: (input) source id */ 3 311 /* parameter 2: (input) ="1"b => capitals */ 3 312 /* return: (output) source line id */ 3 313 3 314 declare error entry(fixed bin(15),pointer,pointer); 3 315 /* parameter 1: (input) error number */ 3 316 /* parameter 2: (input) statement node pointer or null*/ 3 317 /* parameter 3: (input) token node pointer */ 3 318 3 319 declare error$omit_text entry(fixed bin(15),pointer,pointer); 3 320 /* parameter 1: (input) error number */ 3 321 /* parameter 2: (input) statement node pointer or null*/ 3 322 /* parameter 3: (input) token node pointer */ 3 323 3 324 declare error_ entry(fixed bin(15), 5 1 1 structure unaligned, 5 2 2 /* file_number */ bit(8), 5 3 2 /* line_number */ bit(14), 5 4 2 /* stmt_number */ bit(5), 3 325 3 326 pointer,fixed bin(8),fixed bin(23),fixed bin(11)); 3 327 /* parameter 1: (input) error number */ 3 328 /* parameter 2: (input) statement id */ 3 329 /* parameter 3: (input) any node pointer */ 3 330 /* parameter 4: (input) source segment */ 3 331 /* parameter 5: (input) source starting character */ 3 332 /* parameter 6: (input) source length */ 3 333 3 334 declare error_$no_text entry(fixed bin(15), 6 1 1 structure unaligned, 6 2 2 /* file_number */ bit(8), 6 3 2 /* line_number */ bit(14), 6 4 2 /* stmt_number */ bit(5), 3 335 3 336 pointer); 3 337 /* parameter 1: (input) error number */ 3 338 /* parameter 2: (input) statement id */ 3 339 /* parameter 3: (input) any node pointer */ 3 340 3 341 declare error_$initialize_error entry(); 3 342 3 343 declare error_$finish entry(); 3 344 3 345 declare free_node entry(pointer); 3 346 /* parameter 1: any node pointer */ 3 347 3 348 declare get_array_size entry(pointer,fixed bin(3)); 3 349 /* parameter 1: (input) symbol node pointer */ 3 350 /* parameter 2: (input) units */ 3 351 3 352 declare get_size entry(pointer); 3 353 /* parameter 1: (input) symbol node pointer */ 3 354 3 355 declare merge_attributes external entry(pointer,pointer) 3 356 returns(bit(1) aligned); 3 357 /* parameter 1: (input) target symbol node pointer */ 3 358 /* parameter 2: (input) source symbol node pointer */ 3 359 /* return: (output) "1"b if merge was unsuccessful */ 3 360 3 361 declare optimizer entry(pointer); 3 362 /* parameter 1: (input) root pointer */ 3 363 3 364 declare parse_error entry(fixed bin(15),pointer); 3 365 /* parameter 1: (input) error number */ 3 366 /* parameter 2: (input) any node pointer */ 3 367 3 368 declare parse_error$no_text entry(fixed bin(15),pointer); 3 369 /* parameter 1: (input) error number */ 3 370 /* parameter 2: (input) any node pointer */ 3 371 3 372 declare pl1_error_print$write_out 3 373 entry(fixed bin(15), 7 1 1 structure unaligned, 7 2 2 /* file_number */ bit(8), 7 3 2 /* line_number */ bit(14), 7 4 2 /* stmt_number */ bit(5), 3 374 3 375 pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15)); 3 376 /* parameter 1: (input) error number */ 3 377 /* parameter 2: (input) statement identification */ 3 378 /* parameter 3: (input) any node pointer */ 3 379 /* parameter 4: (input) source segment */ 3 380 /* parameter 5: (input) source character index */ 3 381 /* parameter 6: (input) source length */ 3 382 /* parameter 7: (input) source line */ 3 383 3 384 declare pl1_error_print$listing_segment 3 385 entry(fixed bin(15), 8 1 1 structure unaligned, 8 2 2 /* file_number */ bit(8), 8 3 2 /* line_number */ bit(14), 8 4 2 /* stmt_number */ bit(5), 3 386 3 387 pointer); 3 388 /* parameter 1: (input) error number */ 3 389 /* parameter 2: (input) statement identification */ 3 390 /* parameter 3: (input) token node pointer */ 3 391 3 392 declare pl1_print$varying entry(character(*) aligned varying); 3 393 /* parameter 1: (input) string */ 3 394 3 395 declare pl1_print$varying_nl entry(character(*) aligned varying); 3 396 /* parameter 1: (input) string */ 3 397 3 398 declare pl1_print$non_varying entry(character(*) aligned,fixed bin(31)); 3 399 /* parameter 1: (input) string */ 3 400 /* parameter 2: (input) string length or 0 */ 3 401 3 402 declare pl1_print$non_varying_nl entry(character(*) aligned,fixed bin(31)); 3 403 /* parameter 1: (input) string */ 3 404 /* parameter 2: (input) string length or 0 */ 3 405 3 406 declare pl1_print$string_pointer entry(pointer,fixed bin(31)); 3 407 /* parameter 1: (input) string pointer */ 3 408 /* parameter 2: (input) string size */ 3 409 3 410 declare pl1_print$string_pointer_nl entry(pointer,fixed bin(31)); 3 411 /* parameter 1: (input) string pointer */ 3 412 /* parameter 2: (input) string length or 0 */ 3 413 3 414 declare pl1_print$unaligned_nl entry(character(*) unaligned,fixed bin(31)); 3 415 /* parameter 1: (input) string */ 3 416 /* parameter 2: (input) length */ 3 417 3 418 declare pl1_print$for_lex entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned); 3 419 /* parameter 1: (input) ptr to base of source segment */ 3 420 /* parameter 2: (input) line number */ 3 421 /* parameter 3: (input) starting offset in source seg */ 3 422 /* parameter 4: (input) number of chars to copy */ 3 423 /* parameter 5: (input) ON iff shd print line number */ 3 424 /* parameter 6: (input) ON iff line begins in comment */ 3 425 3 426 declare refer_extent entry(pointer,pointer); 3 427 /* parameter 1: (input/output) null,ref node,op node pointer */ 3 428 /* parameter 2: (input) null,ref node,op node pointer */ 3 429 3 430 declare reserve$clear entry() 3 431 returns(pointer); 3 432 /* return: (output) pointer */ 3 433 3 434 declare reserve$declare_lib entry(fixed bin(15)) 3 435 returns(pointer); 3 436 /* parameter 1: (input) builtin function number */ 3 437 /* return: (output) pointer */ 3 438 3 439 declare reserve$read_lib entry(fixed bin(15)) 3 440 returns(pointer); 3 441 /* parameter 1: (input) builtin function number */ 3 442 /* return: (output) pointer */ 3 443 3 444 declare semantic_translator entry(); 3 445 3 446 declare semantic_translator$abort entry(fixed bin(15),pointer); 3 447 /* parameter 1: (input) error number */ 3 448 /* parameter 2: (input) any node pointer */ 3 449 3 450 declare semantic_translator$error entry(fixed bin(15),pointer); 3 451 /* parameter 1: (input) error number */ 3 452 /* parameter 2: (input) any node pointer */ 3 453 3 454 declare share_expression entry(ptr) 3 455 returns(ptr); 3 456 /* parameter 1: (input) usually operator node pointer */ 3 457 /* return: (output) tree pointer or null */ 3 458 3 459 declare token_to_binary entry(ptr) reducible 3 460 returns(fixed bin(31)); 3 461 /* parameter 1: (input) token node pointer */ 3 462 /* return: (output) converted binary value */ 3 463 3 464 /* END INCLUDE FILE ... language_utility.incl.pl1 */ 2 228 2 229 /* END INCLUDE FILE ... semant.incl.pl1 */ 1054 9 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 9 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 9 3 /* format: style3,idind30 */ 9 4 9 5 declare 1 block aligned based, 9 6 2 node_type bit (9) unaligned, 9 7 2 source_id structure unaligned, 9 8 3 file_number bit (8), 9 9 3 line_number bit (14), 9 10 3 statement_number bit (5), 9 11 2 father ptr unaligned, 9 12 2 brother ptr unaligned, 9 13 2 son ptr unaligned, 9 14 2 declaration ptr unaligned, 9 15 2 end_declaration ptr unaligned, 9 16 2 default ptr unaligned, 9 17 2 end_default ptr unaligned, 9 18 2 context ptr unaligned, 9 19 2 prologue ptr unaligned, 9 20 2 end_prologue ptr unaligned, 9 21 2 main ptr unaligned, 9 22 2 end_main ptr unaligned, 9 23 2 return_values ptr unaligned, 9 24 2 return_count ptr unaligned, 9 25 2 plio_ps ptr unaligned, 9 26 2 plio_fa ptr unaligned, 9 27 2 plio_ffsb ptr unaligned, 9 28 2 plio_ssl ptr unaligned, 9 29 2 plio_fab2 ptr unaligned, 9 30 2 block_type bit (9) unaligned, 9 31 2 prefix bit (12) unaligned, 9 32 2 like_attribute bit (1) unaligned, 9 33 2 no_stack bit (1) unaligned, 9 34 2 get_data bit (1) unaligned, 9 35 2 flush_at_call bit (1) unaligned, 9 36 2 processed bit (1) unaligned, 9 37 2 text_displayed bit (1) unaligned, 9 38 2 number fixed bin (9) unsigned unaligned, 9 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 9 40 2 temp_list ptr, 9 41 2 entry_list ptr, 9 42 2 o_and_s ptr, 9 43 2 why_nonquick aligned, 9 44 3 auto_adjustable_storage bit (1) unaligned, 9 45 3 returns_star_extents bit (1) unaligned, 9 46 3 stack_extended_by_args bit (1) unaligned, 9 47 3 invoked_by_format bit (1) unaligned, 9 48 3 format_statement bit (1) unaligned, 9 49 3 io_statements bit (1) unaligned, 9 50 3 assigned_to_entry_var bit (1) unaligned, 9 51 3 condition_statements bit (1) unaligned, 9 52 3 no_owner bit (1) unaligned, 9 53 3 recursive_call bit (1) unaligned, 9 54 3 options_non_quick bit (1) unaligned, 9 55 3 options_variable bit (1) unaligned, 9 56 3 never_referenced bit (1) unaligned, 9 57 3 pad_nonquick bit (5) unaligned, 9 58 2 prologue_flag bit (1) unaligned, 9 59 2 options_main bit (1) unaligned, 9 60 2 pad bit (16) unaligned, 9 61 2 number_of_entries fixed bin (17), 9 62 2 level fixed bin (17), 9 63 2 last_auto_loc fixed bin (17), 9 64 2 symbol_block fixed bin (17), 9 65 2 entry_info fixed bin (18), 9 66 2 enter structure unaligned, 9 67 3 start fixed bin (17), 9 68 3 end fixed bin (17), 9 69 2 leave structure unaligned, 9 70 3 start fixed bin (17), 9 71 3 end fixed bin (17), 9 72 2 owner ptr; 9 73 9 74 declare max_block_number fixed bin internal static options (constant) initial (511); 9 75 9 76 /* END INCLUDE FILE ... block.incl.pl1 */ 1055 10 1 dcl ( root_block initial("000000001"b), 10 2 external_procedure initial("000000010"b), 10 3 internal_procedure initial("000000011"b), 10 4 begin_block initial("000000100"b), 10 5 on_unit initial("000000101"b)) internal static bit(9) aligned options(constant); 1056 11 1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */ 11 2 11 3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */ 11 4 11 5 dcl ( bit_ init(1), 11 6 digit_ init(2), 11 7 character_ init(3), 11 8 half_ init(4), 11 9 word_ init(5), 11 10 mod2_ init(6), 11 11 mod4_ init(7)) fixed bin(3) int static options(constant); 11 12 11 13 /* END INCLUDE FILE ... boundary.incl.pl1 */ 1057 12 1 /****^ ********************************************************* 12 2* * * 12 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 12 4* * * 12 5* ********************************************************* */ 12 6 12 7 /* BEGIN INCLUDE FILE ... builtin_table.incl.pl1 */ 12 8 12 9 12 10 /****^ HISTORY COMMENTS: 12 11* 1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu), 12 12* install(89-07-31,MR12.3-1066): 12 13* Updated the number of builtin functions from 115 to 127. 12 14* END HISTORY COMMENTS */ 12 15 12 16 /* Modified: 13 Feb 1988 by RW increased "description" from 115 to 127 */ 12 17 12 18 /* format: style2,^indattr,ifthendo,ifthen,^indnoniterdo,^elsestmt,dclind9 */ 12 19 dcl 1 pl1_data$builtin_name ext static, 12 20 2 number_of_names fixed bin (15), 12 21 2 description (127), 12 22 3 name char (14), 12 23 3 aggregate_result bit (1), 12 24 3 nonstandard bit (1), 12 25 3 unused bit (7), 12 26 3 opcode bit (9), 12 27 3 reserve_list_number fixed bin (15), 12 28 3 jump_index fixed bin (15), 12 29 3 check_indicator fixed bin (15), 12 30 3 number1 fixed bin (15), 12 31 3 number2 fixed bin (15), 12 32 3 number_of_descriptions fixed bin (15), 12 33 3 descriptor (4), 12 34 4 check_code fixed bin (15), 12 35 4 type bit (36) aligned; 12 36 12 37 /* check_indicator resulting action: 12 38* 12 39* 1 number1 is required number of arguments 12 40* 2 number1 is minimum number of arguments 12 41* 3 number1 is minimum number of arguments, 12 42* number2 is maximum number of arguments. 12 43* 12 44* check_code resulting action: 12 45* 12 46* 1 argument must be of this type 12 47* 2 argument should be converted to this type 12 48* 3 argument should be converted to float binary 12 49* 4 argument should be converted to arithmetic type 12 50* 5 argument should be converted to integer type 12 51* 6 argument should be real decimal fixed constant 12 52* 7 argument should be converted to string type 12 53* 8 argument must either be a bit string or real fixed binary 12 54* 9 argument must be variable 12 55* 10 argument must be arithmetic or string 12 56* */ 12 57 12 58 /* END INCLUDE FILE ... builtin_table.incl.pl1 */ 1058 13 1 /* BEGIN INCLUDE FILE ... cross_reference.incl.pl1 */ 13 2 13 3 dcl 1 cross_reference based aligned, 13 4 2 node_type bit(9) unaligned, 13 5 2 source_id structure unaligned, 13 6 3 file_number bit(8), 13 7 3 line_number bit(14), 13 8 3 statement_number bit(5), 13 9 2 next ptr unaligned, 13 10 2 ref_type structure unaligned, 13 11 3 set_reference bit(1), 13 12 3 pad bit(35); 13 13 13 14 /* END INCLUDE FILE ... cross_reference.incl.pl1 */ 1059 14 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 14 2 14 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 14 4 14 5 dcl ( by_declare initial("001"b), 14 6 by_explicit_context initial("010"b), 14 7 by_context initial("011"b), 14 8 by_implication initial("100"b), 14 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 14 10 14 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 1060 15 1 dcl 1 label based aligned, 15 2 2 node_type bit(9) unaligned, 15 3 2 source_id structure unaligned, 15 4 3 file_number bit(8), 15 5 3 line_number bit(14), 15 6 3 statement_number bit(5), 15 7 2 location fixed(17) unaligned, 15 8 2 allocated bit(1) unaligned, 15 9 2 dcl_type bit(3) unaligned, 15 10 2 reserved bit(29) unaligned, 15 11 2 array bit(1) unaligned, 15 12 2 used_as_format bit(1) unaligned, 15 13 2 used_in_goto bit(1) unaligned, 15 14 2 symbol_table bit(18) unaligned, 15 15 2 low_bound fixed(17) unaligned, 15 16 2 high_bound fixed(17) unaligned, 15 17 2 block_node ptr unaligned, 15 18 2 token ptr unaligned, 15 19 2 next ptr unaligned, 15 20 2 multi_use ptr unaligned, 15 21 2 cross_reference ptr unaligned, 15 22 2 statement ptr unaligned; 1061 16 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 16 2 16 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 16 4 16 5 16 6 dcl 1 list based aligned, 16 7 2 node_type bit(9) unaligned, 16 8 2 reserved bit(12) unaligned, 16 9 2 number fixed(14) unaligned, 16 10 2 element dimension(n refer(list.number)) ptr unaligned; 16 11 16 12 dcl max_list_elements fixed bin(17) internal static options (constant) 16 13 init(16383); 16 14 16 15 /* END INCLUDE FILE ... list.incl.pl1 */ 1062 17 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 17 2 17 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 17 4 17 5 dcl ( block_node initial("000000001"b), 17 6 statement_node initial("000000010"b), 17 7 operator_node initial("000000011"b), 17 8 reference_node initial("000000100"b), 17 9 token_node initial("000000101"b), 17 10 symbol_node initial("000000110"b), 17 11 context_node initial("000000111"b), 17 12 array_node initial("000001000"b), 17 13 bound_node initial("000001001"b), 17 14 format_value_node initial("000001010"b), 17 15 list_node initial("000001011"b), 17 16 default_node initial("000001100"b), 17 17 machine_state_node initial("000001101"b), 17 18 source_node initial("000001110"b), 17 19 label_node initial("000001111"b), 17 20 cross_reference_node initial("000010000"b), 17 21 sf_par_node initial("000010001"b), 17 22 temporary_node initial("000010010"b), 17 23 label_array_element_node initial("000010011"b), 17 24 by_name_agg_node initial("000010100"b)) 17 25 bit(9) internal static aligned options(constant); 17 26 17 27 dcl 1 node based aligned, 17 28 2 type unal bit(9), 17 29 2 source_id unal structure, 17 30 3 file_number bit(8), 17 31 3 line_number bit(14), 17 32 3 statement_number bit(5); 17 33 17 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 1063 18 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 18 2 18 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 18 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 18 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 18 6 /* Modified: 26 July 82 BIM wordno, segno */ 18 7 18 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 18 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 18 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 18 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 18 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 18 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 18 14 18 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 18 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 18 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 18 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 18 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 18 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 18 21 18 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 18 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 18 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 18 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 18 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 18 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 18 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 18 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 18 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 18 31 18 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 18 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 18 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 18 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 18 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 18 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 18 38 18 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 18 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 18 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 18 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 18 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 18 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 18 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 18 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 18 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 18 48 18 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 18 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 18 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 18 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 18 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 18 54 return_string initial("001100110"b), /* return string opnd(1) */ 18 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 18 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 18 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 18 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 18 59 std_return initial("001101011"b), /* return -no arguments- */ 18 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 18 61 free_ctl initial("001101101"b), /* free opnd(1) */ 18 62 stop initial("001101110"b), /* stop - terminate run unit */ 18 63 18 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 18 65* opnd(2) <- opnd(3) / 36 */ 18 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 18 67* opnd(2) <- opnd(3) / 4 */ 18 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 18 69* opnd(2) <- opnd(3) / 2 */ 18 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 18 71 18 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 18 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 18 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 18 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 18 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 18 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 18 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 18 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 18 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 18 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 18 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 18 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 18 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 18 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 18 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 18 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 18 88 18 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 18 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 18 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 18 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 18 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 18 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 18 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 18 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 18 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 18 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 18 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 18 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 18 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 18 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 18 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 18 104 18 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 18 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 18 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 18 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 18 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 18 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 18 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 18 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 18 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 18 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 18 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 18 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 18 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 18 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 18 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 18 120 18 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 18 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 18 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 18 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 18 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 18 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 18 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 18 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 18 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 18 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 18 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 18 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 18 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 18 134 18 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 18 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 18 137 18 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 18 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 18 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 18 141* opnd(2) is the file name 18 142* opnd(3) is the block */ 18 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 18 144* opnd(2) is the file name */ 18 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 18 146* opnd(2) is the file name */ 18 147 18 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 18 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 18 150* opnd(3) is old value, (4) is new value. */ 18 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 18 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 18 153 18 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 18 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 18 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 18 157* opnd(5) is the list */ 18 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 18 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 18 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 18 161 18 162 r_parn initial("011110001"b), /* format op code */ 18 163 l_parn initial("011110010"b), 18 164 r_format initial("011110011"b), 18 165 c_format initial("011110100"b), 18 166 f_format initial("011110101"b), 18 167 e_format initial("011110110"b), 18 168 b_format initial("011110111"b), 18 169 a_format initial("011111000"b), 18 170 x_format initial("011111001"b), 18 171 skip_format initial("011111010"b), 18 172 column_format initial("011111011"b), 18 173 page_format initial("011111100"b), 18 174 line_format initial("011111101"b), 18 175 picture_format initial("011111110"b), 18 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 18 177 18 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 18 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 18 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 18 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 18 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 18 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 18 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 18 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 18 186 record_io initial("100001000"b), /* perform record io operation */ 18 187 fortran_read initial("100001001"b), /* A complete read statement */ 18 188 fortran_write initial("100001010"b), /* A complete write statement */ 18 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 18 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 18 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 18 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 18 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 18 194 18 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 18 196 /* They are processed by the semantic translator. */ 18 197 18 198 return_value initial("100010010"b), /* return(opnd(1)) */ 18 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 18 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 18 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 18 202 /* opnd(3) is skip, opnd(4) is list */ 18 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 18 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 18 205 /* opnd(3) is skip,opnd(4) is line */ 18 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 18 207 open_file initial("100011001"b), 18 208 close_file initial("100011010"b), 18 209 read_file initial("100011011"b), 18 210 write_file initial("100011100"b), 18 211 locate_file initial("100011101"b), 18 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 18 213 /* opnd(2) is control variable ref */ 18 214 /* opnd(3) is specification operator */ 18 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 18 216 /* repeat opnd(4) while opnd(5) */ 18 217 /* opnd(6) is next specification */ 18 218 18 219 rewrite_file initial("100100000"b), 18 220 delete_file initial("100100001"b), 18 221 unlock_file initial("100100010"b), 18 222 lock_file initial("100100011"b), 18 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 18 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 18 225 nop initial("100100111"b), /* no-op */ 18 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 18 227 18 228 /* These operators are produced by the semantic translator in processing the math 18 229* builtin functions and are used as input to the code generator */ 18 230 18 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 18 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 18 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 18 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 18 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 18 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 18 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 18 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 18 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 18 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 18 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 18 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 18 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 18 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 18 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 18 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 18 247 18 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 18 249 18 250 bit(9) aligned internal static options(constant); 18 251 18 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 1064 19 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 19 2 19 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 19 4 19 5 /* format: style3 */ 19 6 dcl 1 operator based aligned, 19 7 2 node_type bit (9) unaligned, 19 8 2 op_code bit (9) unaligned, 19 9 2 shared bit (1) unaligned, 19 10 2 processed bit (1) unaligned, 19 11 2 optimized bit (1) unaligned, 19 12 2 number fixed (14) unaligned, 19 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 19 14 19 15 dcl max_number_of_operands 19 16 fixed bin (15) int static options (constant) initial (32767); 19 17 19 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 1065 20 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 20 2 20 3 dcl 1 reference based aligned, 20 4 2 node_type bit(9) unaligned, 20 5 2 array_ref bit(1) unaligned, 20 6 2 varying_ref bit(1) unaligned, 20 7 2 shared bit(1) unaligned, 20 8 2 put_data_sw bit(1) unaligned, 20 9 2 processed bit(1) unaligned, 20 10 2 units fixed(3) unaligned, 20 11 2 ref_count fixed(17) unaligned, 20 12 2 c_offset fixed(24), 20 13 2 c_length fixed(24), 20 14 2 symbol ptr unaligned, 20 15 2 qualifier ptr unaligned, 20 16 2 offset ptr unaligned, 20 17 2 length ptr unaligned, 20 18 2 subscript_list ptr unaligned, 20 19 /* these fields are used by the 645 code generator */ 20 20 2 address structure unaligned, 20 21 3 base bit(3), 20 22 3 offset bit(15), 20 23 3 op bit(9), 20 24 3 no_address bit(1), 20 25 3 inhibit bit(1), 20 26 3 ext_base bit(1), 20 27 3 tag bit(6), 20 28 2 info structure unaligned, 20 29 3 address_in structure, 20 30 4 b dimension(0:7) bit(1), 20 31 4 storage bit(1), 20 32 3 value_in structure, 20 33 4 a bit(1), 20 34 4 q bit(1), 20 35 4 aq bit(1), 20 36 4 string_aq bit(1), 20 37 4 complex_aq bit(1), 20 38 4 decimal_aq bit(1), 20 39 4 b dimension(0:7) bit(1), 20 40 4 storage bit(1), 20 41 4 indicators bit(1), 20 42 4 x dimension(0:7) bit(1), 20 43 3 other structure, 20 44 4 big_offset bit(1), 20 45 4 big_length bit(1), 20 46 4 modword_in_offset bit(1), 20 47 2 data_type fixed(5) unaligned, 20 48 2 bits structure unaligned, 20 49 3 padded_ref bit(1), 20 50 3 aligned_ref bit(1), 20 51 3 long_ref bit(1), 20 52 3 forward_ref bit(1), 20 53 3 ic_ref bit(1), 20 54 3 temp_ref bit(1), 20 55 3 defined_ref bit(1), 20 56 3 evaluated bit(1), 20 57 3 allocate bit(1), 20 58 3 allocated bit(1), 20 59 3 aliasable bit(1), 20 60 3 even bit(1), 20 61 3 perm_address bit(1), 20 62 3 aggregate bit(1), 20 63 3 hit_zero bit(1), 20 64 3 dont_save bit(1), 20 65 3 fo_in_qual bit(1), 20 66 3 hard_to_load bit(1), 20 67 2 relocation bit(12) unaligned, 20 68 2 more_bits structure unaligned, 20 69 3 substr bit(1), 20 70 3 padded_for_store_ref bit(1), 20 71 3 aligned_for_store_ref bit(1), 20 72 3 mbz bit(15), 20 73 2 store_ins bit(18) unaligned; 20 74 20 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 1066 21 1 /* BEGIN INCLUDE FILE ... semantic_bits.incl.pl1 */ 21 2 21 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 21 4 21 5 dcl context aligned bit(36), 21 6 this_context aligned bit(36); 21 7 21 8 dcl 1 def_context aligned based(addr(context)), 21 9 2 aggregate unaligned bit(1), 21 10 2 arg_list unaligned bit(1), 21 11 2 left_side unaligned bit(1), 21 12 2 return unaligned bit(1), 21 13 2 evaluate_offset unaligned bit(1), 21 14 2 top unaligned bit(1), 21 15 2 RHS_aggregate unaligned bit(1), 21 16 2 return_from_empty unaligned bit(1), 21 17 2 ignore_based unaligned bit(1), 21 18 2 ext_param unaligned bit(1), 21 19 2 cross_section unaligned bit(1), 21 20 2 string_unspec unaligned bit(1), 21 21 2 f_offset_to_be_added unaligned bit(1), 21 22 2 suppress_cross_ref unaligned bit(1), 21 23 2 by_name_assignment unaligned bit(1), 21 24 2 by_name_lookup unaligned bit(1), 21 25 2 pad unaligned bit(20); 21 26 21 27 dcl 1 def_this_context aligned like def_context based(addr(this_context)); 21 28 21 29 /* END INCLUDE FILE ... semantic_bits.incl.pl1 */ 1067 22 1 /* *********************************************************** 22 2* * * 22 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 22 4* * * 22 5* *********************************************************** */ 22 6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */ 22 7 /* Internal interface of the PL/I compiler */ 22 8 22 9 dcl 1 statement based aligned, 22 10 2 node_type bit(9) unaligned, 22 11 2 source_id structure unaligned, 22 12 3 file_number bit(8), 22 13 3 line_number bit(14), 22 14 3 statement_number bit(5), 22 15 2 next ptr unaligned, 22 16 2 back ptr unaligned, 22 17 2 root ptr unaligned, 22 18 2 labels ptr unaligned, 22 19 2 reference_list ptr unaligned, 22 20 2 state_list ptr unaligned, 22 21 2 reference_count fixed(17) unaligned, 22 22 2 ref_count_copy fixed(17) unaligned, 22 23 2 object structure unaligned, 22 24 3 start fixed(17), 22 25 3 finish fixed(17), 22 26 2 source structure unaligned, 22 27 3 segment fixed(11), 22 28 3 start fixed(23), 22 29 3 length fixed(11), 22 30 2 prefix bit(12) unaligned, 22 31 2 optimized bit(1) unaligned, 22 32 2 free_temps bit(1) unaligned, 22 33 2 LHS_in_RHS bit(1) unaligned, 22 34 2 statement_type bit(9) unaligned, 22 35 2 bits structure unaligned, 22 36 3 processed bit(1) unaligned, 22 37 3 put_in_profile bit(1) unaligned, 22 38 3 generated bit(1) unaligned, 22 39 3 snap bit(1) unaligned, 22 40 3 system bit(1) unaligned, 22 41 3 irreducible bit(1) unaligned, 22 42 3 checked bit(1) unaligned, 22 43 3 save_temps bit(1) unaligned, 22 44 3 suppress_warnings bit(1) unaligned, 22 45 3 force_nonquick bit(1) unaligned, 22 46 3 expanded_by_name bit(1) unaligned, 22 47 3 begins_loop bit(1) unaligned, 22 48 3 pad bit(24) unaligned; 22 49 22 50 /* END INCLUDE FILE ... statement.incl.pl1 */ 1068 23 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 23 2 23 3 dcl 1 symbol based aligned, 23 4 2 node_type bit(9) unal, 23 5 2 source_id structure unal, 23 6 3 file_number bit(8), 23 7 3 line_number bit(14), 23 8 3 statement_number bit(5), 23 9 2 location fixed(18) unal unsigned, 23 10 2 allocated bit(1) unal, 23 11 2 dcl_type bit(3) unal, 23 12 2 reserved bit(6) unal, 23 13 2 pix unal, 23 14 3 pic_fixed bit(1) unal, 23 15 3 pic_float bit(1) unal, 23 16 3 pic_char bit(1) unal, 23 17 3 pic_scale fixed(7) unal, 23 18 3 pic_size fixed(7) unal, 23 19 2 level fixed(8) unal, 23 20 2 boundary fixed(3) unal, 23 21 2 size_units fixed(3) unal, 23 22 2 scale fixed(7) unal, 23 23 2 runtime bit(18) unal, 23 24 2 runtime_offset bit(18) unal, 23 25 2 block_node ptr unal, 23 26 2 token ptr unal, 23 27 2 next ptr unal, 23 28 2 multi_use ptr unal, 23 29 2 cross_references ptr unal, 23 30 2 initial ptr unal, 23 31 2 array ptr unal, 23 32 2 descriptor ptr unal, 23 33 2 equivalence ptr unal, 23 34 2 reference ptr unal, 23 35 2 general ptr unal, 23 36 2 father ptr unal, 23 37 2 brother ptr unal, 23 38 2 son ptr unal, 23 39 2 word_size ptr unal, 23 40 2 bit_size ptr unal, 23 41 2 dcl_size ptr unal, 23 42 2 symtab_size ptr unal, 23 43 2 c_word_size fixed(24), 23 44 2 c_bit_size fixed(24), 23 45 2 c_dcl_size fixed(24), 23 46 23 47 2 attributes structure aligned, 23 48 3 data_type structure unal, 23 49 4 structure bit(1) , 23 50 4 fixed bit(1), 23 51 4 float bit(1), 23 52 4 bit bit(1), 23 53 4 char bit(1), 23 54 4 ptr bit(1), 23 55 4 offset bit(1), 23 56 4 area bit(1), 23 57 4 label bit(1), 23 58 4 entry bit(1), 23 59 4 file bit(1), 23 60 4 arg_descriptor bit(1), 23 61 4 storage_block bit(1), 23 62 4 explicit_packed bit(1), /* options(packed) */ 23 63 4 condition bit(1), 23 64 4 format bit(1), 23 65 4 builtin bit(1), 23 66 4 generic bit(1), 23 67 4 picture bit(1), 23 68 23 69 3 misc_attributes structure unal, 23 70 4 dimensioned bit(1), 23 71 4 initialed bit(1), 23 72 4 aligned bit(1), 23 73 4 unaligned bit(1), 23 74 4 signed bit(1), 23 75 4 unsigned bit(1), 23 76 4 precision bit(1), 23 77 4 varying bit(1), 23 78 4 local bit(1), 23 79 4 decimal bit(1), 23 80 4 binary bit(1), 23 81 4 real bit(1), 23 82 4 complex bit(1), 23 83 4 variable bit(1), 23 84 4 reducible bit(1), 23 85 4 irreducible bit(1), 23 86 4 returns bit(1), 23 87 4 position bit(1), 23 88 4 internal bit(1), 23 89 4 external bit(1), 23 90 4 like bit(1), 23 91 4 member bit(1), 23 92 4 non_varying bit(1), 23 93 4 options bit(1), 23 94 4 variable_arg_list bit(1), /* options(variable) */ 23 95 4 alloc_in_text bit(1), /* options(constant) */ 23 96 23 97 3 storage_class structure unal, 23 98 4 auto bit(1), 23 99 4 based bit(1), 23 100 4 static bit(1), 23 101 4 controlled bit(1), 23 102 4 defined bit(1), 23 103 4 parameter bit(1), 23 104 4 param_desc bit(1), 23 105 4 constant bit(1), 23 106 4 temporary bit(1), 23 107 4 return_value bit(1), 23 108 23 109 3 file_attributes structure unal, 23 110 4 print bit(1), 23 111 4 input bit(1), 23 112 4 output bit(1), 23 113 4 update bit(1), 23 114 4 stream bit(1), 23 115 4 reserved_1 bit(1), 23 116 4 record bit(1), 23 117 4 sequential bit(1), 23 118 4 direct bit(1), 23 119 4 interactive bit(1), /* env(interactive) */ 23 120 4 reserved_2 bit(1), 23 121 4 reserved_3 bit(1), 23 122 4 stringvalue bit(1), /* env(stringvalue) */ 23 123 4 keyed bit(1), 23 124 4 reserved_4 bit(1), 23 125 4 environment bit(1), 23 126 23 127 3 compiler_developed structure unal, 23 128 4 aliasable bit(1), 23 129 4 packed bit(1), 23 130 4 passed_as_arg bit(1), 23 131 4 allocate bit(1), 23 132 4 set bit(1), 23 133 4 exp_extents bit(1), 23 134 4 refer_extents bit(1), 23 135 4 star_extents bit(1), 23 136 4 isub bit(1), 23 137 4 put_in_symtab bit(1), 23 138 4 contiguous bit(1), 23 139 4 put_data bit(1), 23 140 4 overlayed bit(1), 23 141 4 error bit(1), 23 142 4 symtab_processed bit(1), 23 143 4 overlayed_by_builtin bit(1), 23 144 4 defaulted bit(1), 23 145 4 connected bit(1); 23 146 23 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 1069 24 1 /* BEGIN INCLUDE FILE ... symbol_bits.incl.pl1 */ 24 2 24 3 dcl ( aliasable_bit initial (72), 24 4 passed_as_arg_bit initial (74), 24 5 set_bit initial (76), 24 6 overlayed_by_builtin_bit initial (87)) fixed bin (15) internal static options (constant); 24 7 24 8 /* END INCLUDE FILE ... symbol_bits.incl.pl1 */ 1070 25 1 /* BEGIN INCLUDE FILE ... system.incl.pl1 */ 25 2 25 3 /* Modified: 25 Apr 1979 by PCK to implemnt 4-bit decimal */ 25 4 25 5 dcl ( max_p_flt_bin_1 initial(27), 25 6 max_p_flt_bin_2 initial(63), 25 7 max_p_fix_bin_1 initial(35), 25 8 max_p_fix_bin_2 initial(71), 25 9 25 10 max_p_dec initial(59), 25 11 max_p_bin_or_dec initial (71), /* max (max_p_fix_bin_2, max_p_dec) */ 25 12 25 13 min_scale initial(-128), 25 14 max_scale initial(+127), 25 15 max_bit_string initial(9437184), 25 16 max_char_string initial(1048576), 25 17 max_area_size initial(262144), 25 18 min_area_size initial(28), 25 19 25 20 max_bit_string_constant initial (253), /* max length of bit literals */ 25 21 max_char_string_constant initial (254), /* max length of character literals */ 25 22 max_identifier_length initial (256), 25 23 max_number_of_dimensions initial (127), 25 24 25 25 max_length_precision initial(24), 25 26 max_offset_precision initial(24), /* 18 bits for word offset + 6 bits for bit offset */ 25 27 25 28 max_words_per_variable initial (262144), 25 29 25 30 bits_per_word initial(36), 25 31 bits_per_double initial(72), 25 32 packed_digits_per_character initial(2), 25 33 characters_per_half initial(2), 25 34 characters_per_word initial(4), 25 35 characters_per_double initial(8), 25 36 25 37 bits_per_character initial(9), 25 38 bits_per_half initial(18), 25 39 bits_per_decimal_digit initial(9), 25 40 bits_per_binary_exponent initial(8), 25 41 bits_per_packed_ptr initial(36), 25 42 words_per_packed_pointer initial(1), 25 43 25 44 words_per_fix_bin_1 initial(1), 25 45 words_per_fix_bin_2 initial(2), 25 46 words_per_flt_bin_1 initial(1), 25 47 words_per_flt_bin_2 initial(2), 25 48 words_per_varying_string_header initial(1), 25 49 words_per_offset initial(1), 25 50 words_per_pointer initial(2), 25 51 words_per_label_var initial(4), 25 52 words_per_entry_var initial(4), 25 53 words_per_file_var initial(4), 25 54 words_per_format initial(4), 25 55 words_per_condition_var initial(6), 25 56 25 57 max_index_register_value initial(262143), 25 58 max_signed_index_register_value initial(131071), 25 59 25 60 max_signed_xreg_precision initial(17), 25 61 max_uns_xreg_precision initial(18), 25 62 25 63 default_area_size initial(1024), 25 64 default_flt_bin_p initial(27), 25 65 default_fix_bin_p initial(17), 25 66 default_flt_dec_p initial(10), 25 67 default_fix_dec_p initial(7)) fixed bin(31) internal static options(constant); 25 68 25 69 dcl bits_per_digit initial(4.5) fixed bin(31,1) internal static options(constant); 25 70 25 71 dcl ( integer_type initial("010000000000000000000100000001100000"b), 25 72 dec_integer_type initial("010000000000000000000100000010100000"b), 25 73 pointer_type initial("000001000000000000000100000000000000"b), 25 74 real_type initial("001000000000000000000100000001100000"b), 25 75 complex_type initial("001000000000000000000100000001010000"b), 25 76 builtin_type initial("000000000000000010000000000000000000"b), 25 77 storage_block_type initial("000000000000100000000000000000000000"b), 25 78 arg_desc_type initial("000000000001000000000000000000000000"b), 25 79 local_label_var_type initial("000000001000000000000100000100001000"b), 25 80 entry_var_type initial("000000000100000000000000000000001000"b), 25 81 bit_type initial("000100000000000000000000000000000000"b), 25 82 char_type initial("000010000000000000000000000000000000"b)) bit(36) aligned int static 25 83 options(constant); 25 84 25 85 /* END INCLUDE FILE ... system.incl.pl1 */ 1071 26 1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */ 26 2 26 3 dcl 1 token based aligned, 26 4 2 node_type bit(9) unaligned, 26 5 2 type bit(9) unaligned, 26 6 2 loc bit(18) unaligned, /* symtab offset for identifiers, "p" flag for constants */ 26 7 2 declaration ptr unaligned, 26 8 2 next ptr unaligned, 26 9 2 size fixed(9), 26 10 2 string char(n refer(token.size)); 26 11 26 12 /* END INCLUDE FILE ... token.incl.pl1 */ 1072 27 1 /* BEGIN INCLUDE FILE ... token_types.incl.pl1 */ 27 2 27 3 dcl ( no_token initial("000000000"b), /* token types */ 27 4 identifier initial("100000000"b), 27 5 isub initial("010000000"b), 27 6 plus initial("001000001"b), 27 7 minus initial("001000010"b), 27 8 asterisk initial("001000011"b), 27 9 slash initial("001000100"b), 27 10 expon initial("001000101"b), 27 11 not initial("001000110"b), 27 12 and initial("001000111"b), 27 13 or initial("001001000"b), 27 14 cat initial("001001001"b), 27 15 eq initial("001001010"b), 27 16 ne initial("001001011"b), 27 17 lt initial("001001100"b), 27 18 gt initial("001001101"b), 27 19 le initial("001001110"b), 27 20 ge initial("001001111"b), 27 21 ngt initial("001010000"b), 27 22 nlt initial("001010001"b), 27 23 assignment initial("001010010"b), 27 24 colon initial("001010011"b), 27 25 semi_colon initial("001010100"b), 27 26 comma initial("001010101"b), 27 27 period initial("001010110"b), 27 28 arrow initial("001010111"b), 27 29 left_parn initial("001011000"b), 27 30 right_parn initial("001011001"b), 27 31 percent initial("001011100"b), 27 32 bit_string initial("000100001"b), 27 33 char_string initial("000100010"b), 27 34 bin_integer initial("000110001"b), 27 35 dec_integer initial("000110011"b), 27 36 fixed_bin initial("000110000"b), 27 37 fixed_dec initial("000110010"b), 27 38 float_bin initial("000110100"b), 27 39 float_dec initial("000110110"b), 27 40 i_bin_integer initial("000111001"b), 27 41 i_dec_integer initial("000111011"b), 27 42 i_fixed_bin initial("000111000"b), 27 43 i_fixed_dec initial("000111010"b), 27 44 i_float_bin initial("000111100"b), 27 45 i_float_dec initial("000111110"b)) bit (9) aligned internal static options (constant); 27 46 27 47 dcl ( is_identifier initial ("100000000"b), /* token type masks */ 27 48 is_isub initial ("010000000"b), 27 49 is_delimiter initial ("001000000"b), 27 50 is_constant initial ("000100000"b), 27 51 is_arith_constant initial ("000010000"b), /* N.B. not really a mask...s/b "000110000"b */ 27 52 is_arithmetic_constant initial ("000110000"b), 27 53 is_imaginary_constant initial ("000111000"b), 27 54 is_float_constant initial ("000110100"b), 27 55 is_decimal_constant initial ("000110010"b), 27 56 is_integral_constant initial ("000110001"b) 27 57 ) bit(9) internal static aligned options(constant); 27 58 27 59 /* END INCLUDE FILE ... token_types.incl.pl1 */ 1073 28 1 /* statement types */ 28 2 28 3 dcl ( unknown_statement initial("000000000"b), 28 4 allocate_statement initial("000000001"b), 28 5 assignment_statement initial("000000010"b), 28 6 begin_statement initial("000000011"b), 28 7 call_statement initial("000000100"b), 28 8 close_statement initial("000000101"b), 28 9 declare_statement initial("000000110"b), 28 10 lock_statement initial("000000111"b), 28 11 delete_statement initial("000001000"b), 28 12 display_statement initial("000001001"b), 28 13 do_statement initial("000001010"b), 28 14 else_clause initial("000001011"b), 28 15 end_statement initial("000001100"b), 28 16 entry_statement initial("000001101"b), 28 17 exit_statement initial("000001110"b), 28 18 format_statement initial("000001111"b), 28 19 free_statement initial("000010000"b), 28 20 get_statement initial("000010001"b), 28 21 goto_statement initial("000010010"b), 28 22 if_statement initial("000010011"b), 28 23 locate_statement initial("000010100"b), 28 24 null_statement initial("000010101"b), 28 25 on_statement initial("000010110"b), 28 26 open_statement initial("000010111"b), 28 27 procedure_statement initial("000011000"b), 28 28 put_statement initial("000011001"b), 28 29 read_statement initial("000011010"b), 28 30 return_statement initial("000011011"b), 28 31 revert_statement initial("000011100"b), 28 32 rewrite_statement initial("000011101"b), 28 33 signal_statement initial("000011110"b), 28 34 stop_statement initial("000011111"b), 28 35 system_on_unit initial("000100000"b), 28 36 unlock_statement initial("000100001"b), 28 37 wait_statement initial("000100010"b), 28 38 write_statement initial("000100011"b), 28 39 default_statement initial("000100100"b), 28 40 continue_statement initial("000100101"b)) bit(9) internal static aligned options(constant); 1074 1075 1076 end expression_semantics; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/31/89 1338.2 expression_semantics.pl1 >spec>install>MR12.3-1066>expression_semantics.pl1 1003 1 10/25/76 1558.8 string_overlay.incl.pl1 >ldd>include>string_overlay.incl.pl1 1054 2 07/21/80 1546.3 semant.incl.pl1 >ldd>include>semant.incl.pl1 2-228 3 07/31/89 1332.6 language_utility.incl.pl1 >spec>install>MR12.3-1066>language_utility.incl.pl1 3-307 4 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 3-325 5 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 3-335 6 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 3-374 7 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 3-386 8 05/06/74 1746.9 source_id_descriptor.incl.pl1 >ldd>include>source_id_descriptor.incl.pl1 1055 9 08/13/81 2043.5 block.incl.pl1 >ldd>include>block.incl.pl1 1056 10 05/03/76 1320.8 block_types.incl.pl1 >ldd>include>block_types.incl.pl1 1057 11 10/25/79 1645.8 boundary.incl.pl1 >ldd>include>boundary.incl.pl1 1058 12 07/31/89 1334.3 builtin_table.incl.pl1 >spec>install>MR12.3-1066>builtin_table.incl.pl1 1059 13 10/25/79 1645.8 cross_reference.incl.pl1 >ldd>include>cross_reference.incl.pl1 1060 14 10/25/79 1645.8 declare_type.incl.pl1 >ldd>include>declare_type.incl.pl1 1061 15 05/06/74 1742.1 label.incl.pl1 >ldd>include>label.incl.pl1 1062 16 08/13/81 2211.5 list.incl.pl1 >ldd>include>list.incl.pl1 1063 17 07/21/80 1546.3 nodes.incl.pl1 >ldd>include>nodes.incl.pl1 1064 18 04/07/83 1635.0 op_codes.incl.pl1 >ldd>include>op_codes.incl.pl1 1065 19 07/21/80 1546.3 operator.incl.pl1 >ldd>include>operator.incl.pl1 1066 20 07/21/80 1546.3 reference.incl.pl1 >ldd>include>reference.incl.pl1 1067 21 07/21/80 1546.3 semantic_bits.incl.pl1 >ldd>include>semantic_bits.incl.pl1 1068 22 04/07/83 1635.0 statement.incl.pl1 >ldd>include>statement.incl.pl1 1069 23 12/07/83 1701.7 symbol.incl.pl1 >ldd>include>symbol.incl.pl1 1070 24 07/21/80 1546.3 symbol_bits.incl.pl1 >ldd>include>symbol_bits.incl.pl1 1071 25 12/07/83 1701.7 system.incl.pl1 >ldd>include>system.incl.pl1 1072 26 09/14/77 1705.7 token.incl.pl1 >ldd>include>token.incl.pl1 1073 27 11/30/78 1227.4 token_types.incl.pl1 >ldd>include>token_types.incl.pl1 1074 28 05/03/76 1320.4 statement_types.incl.pl1 >ldd>include>statement_types.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. LHS_aggregate 000121 automatic bit(1) dcl 36 set ref 158* 184 LHS_in_RHS 12(26) based bit(1) level 2 packed packed unaligned dcl 22-9 set ref 743* LHS_ref 000176 automatic pointer dcl 835 set ref 839* 924 988* LHS_subs 000226 automatic pointer dcl 914 set ref 924* 927 929 948 949 LHS_sym 000200 automatic pointer dcl 835 set ref 840* 846* 849* 917 917 917 917 917 922 988 988 988* RHS_aggregate 0(06) based bit(1) level 2 packed packed unaligned dcl 21-8 set ref 183* RHS_cross_section parameter bit(1) dcl 820 ref 814 917 922 RHS_ref parameter pointer dcl 819 set ref 814 841 843 925 988* RHS_subs 000224 automatic pointer dcl 914 set ref 925* 927 929 949 RHS_sym 000202 automatic pointer dcl 835 set ref 841* 846* 849* 917 917 917 917 922 988 988 988* 992 995 995 995 addr builtin function dcl 41 ref 58 58 59 59 103 152 154 154 158 160 172 178 178 178 181 181 183 183 184 184 186 194 194 197 200 227 249 249 253 253 261 506 554 581 623 635 635 644 649 662 667 697 743 743 746 749 752 777 785 1046 aggregate based bit(1) level 2 in structure "def_this_context" packed packed unaligned dcl 21-27 in procedure "expression_semantics" set ref 158 181* 183 184* 184 227 581 697 785 aggregate 12(19) based bit(1) level 3 in structure "reference" packed packed unaligned dcl 20-3 in procedure "expression_semantics" set ref 493* aggregate based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" set ref 261* 749* 777* aliasable 32(35) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 988 988 aligned 31(21) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 133 allocate 33(02) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 298* 428* 471* allot_var constant bit(9) initial dcl 18-8 ref 227 arg_list 0(01) based bit(1) level 2 packed packed unaligned dcl 21-8 ref 249 623 644 array 2(15) based bit(1) level 2 packed packed unaligned dcl 15-1 ref 759 array_ref 0(09) based bit(1) level 2 packed packed unaligned dcl 20-3 set ref 516 619* 633* 675 726* 726 746 749 776* 843 assign constant bit(9) initial dcl 18-8 ref 113 133 150 249 586 assign_by_name constant bit(9) initial dcl 18-8 ref 106 asterisk constant bit(9) initial dcl 27-3 ref 611 767 967 asterisk_count 000117 automatic fixed bin(15,0) dcl 33 set ref 608* 611* 611 616 633 attributes 31 based structure level 2 dcl 23-3 set ref 368 368 auto 32(09) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 509 b 000114 automatic pointer dcl 31 set ref 324* 324* 326* 377 based 32(10) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 401 551 917 995 binary 31(29) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 356 360* bit 31(03) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 1-17 1-19 1-21 bit_ constant fixed bin(3,0) initial dcl 11-5 ref 1-19 1-24 bit_pointer constant bit(9) initial dcl 18-8 ref 116 141 bits 12(06) based structure level 2 in structure "reference" packed packed unaligned dcl 20-3 in procedure "expression_semantics" bits 13 based structure level 2 in structure "statement" packed packed unaligned dcl 22-9 in procedure "expression_semantics" blk parameter pointer dcl 26 set ref 12 76* 86* 109* 128* 145* 157* 182* 198* 205* 211* 219* 229* 256* 265* 278* 281* 293* 324 328* 411* 461* 536* 544* 577 592* 657* 659* 662* 665* 675* 717* 782* 783* block based structure level 1 dcl 9-5 block_node 4 based pointer level 2 packed packed unaligned dcl 23-3 ref 509 509 575 681 690 bn_format constant bit(9) initial dcl 18-8 ref 84 brother 20 based pointer level 2 packed packed unaligned dcl 23-3 ref 1-13 builtin 31(16) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 23-3 in procedure "expression_semantics" set ref 454* 521 builtin 000022 constant entry external dcl 2-17 in procedure "expression_semantics" ref 461 536 by_compiler 000005 constant bit(3) initial dcl 14-5 set ref 328* 509 by_implication 000011 constant bit(3) initial dcl 14-5 set ref 296* 426* 447* 467* by_name_assignment 0(14) based bit(1) level 2 in structure "def_this_context" packed packed unaligned dcl 21-27 in procedure "expression_semantics" set ref 154* 178* 194* 253* by_name_assignment 0(14) based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" ref 178 194 c_dcl_size 30 based fixed bin(24,0) level 2 dcl 23-3 set ref 368 455* 523 528* c_offset 1 based fixed bin(24,0) level 2 dcl 20-3 set ref 738* 738 791 call_statement constant bit(9) initial dcl 28-3 ref 1046 char 31(04) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 1-17 character_ constant fixed bin(3,0) initial dcl 11-5 ref 1-20 1-21 close_file constant bit(9) initial dcl 18-8 ref 77 compare_expression 000070 constant entry external dcl 3-48 ref 988 compiler_developed 32(35) based structure level 3 packed packed unaligned dcl 23-3 complex 31(31) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 341* constant 32(16) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 329* context parameter bit(36) dcl 21-5 set ref 12 58 59 154 172 178 178 183 194 229* 249 249 251 261 278* 281* 461* 506 536* 544* 554 623 635 635 644 649 657* 662 662* 667 675* 695* 717* 743 743 746 749 752 777 1046 convert 000072 constant entry external dcl 3-60 ref 368 584 convert$to_integer 000074 constant entry external dcl 3-66 ref 683 692 convert$to_target 000076 constant entry external dcl 3-88 ref 370 copy_expression 000100 constant entry external dcl 3-94 ref 123 314 472 497 500 558 565 copy_words constant bit(9) initial dcl 18-8 ref 263 create_cross_reference 000102 constant entry external dcl 3-128 ref 300 430 450 create_list 000104 constant entry external dcl 3-147 ref 667 create_operator 000106 constant entry external dcl 3-152 ref 710 712 create_reference 000110 constant entry external dcl 3-158 ref 96 124 774 create_symbol 000112 constant entry external dcl 3-184 ref 296 328 426 447 467 create_token 000114 constant entry external dcl 3-191 ref 416 cross_reference based structure level 1 dcl 13-3 cross_references 10 based pointer level 2 packed packed unaligned dcl 23-3 set ref 302* 432* 452* cross_section 0(10) based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" set ref 649* 746* cross_section 000123 automatic bit(1) dcl 36 in procedure "expression_semantics" set ref 57* 621* 633* 635 646 662 708 726 743* 767* 772 d 000106 automatic pointer dcl 31 set ref 300* 301 302 303 430* 431 432 433 450* 451 452 453 data_type 31 based structure level 3 packed packed unaligned dcl 23-3 set ref 917 917 dcl_size 24 based pointer level 2 packed packed unaligned dcl 23-3 ref 368 dcl_type 1(19) based bit(3) level 2 packed packed unaligned dcl 23-3 ref 509 decimal 31(28) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 356 356* declare 000024 constant entry external dcl 2-41 ref 297 427 470 def_context based structure level 1 dcl 21-8 def_this_context based structure level 1 dcl 21-27 default 6 based pointer level 2 packed packed unaligned dcl 9-5 ref 326 defaulted 33(15) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 347 defined 32(13) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 310 509 562 623 657 662 675 746 875 917 917 995 defined_reference 000026 constant entry external dcl 2-47 ref 657 662 675 description 1 000126 external static structure array level 2 unaligned dcl 12-19 dimensioned 31(19) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 606 917 do_fun constant bit(9) initial dcl 18-8 ref 195 do_spec constant bit(9) initial dcl 18-8 ref 203 element 1 based pointer array level 2 packed packed unaligned dcl 16-6 ref 416 611 611 766 791 949 949 1016 entry 31(09) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 310 468* 485 667 671 705 equivalence 14 based pointer level 2 packed packed unaligned dcl 23-3 ref 875 875 875 880 errno 000340 automatic fixed bin(15,0) dcl 1044 set ref 1046* 1048* 1050* evaluate_offset 0(04) based bit(1) level 2 packed packed unaligned dcl 21-8 ref 635 662 743 expand_assign 000030 constant entry external dcl 2-62 ref 256 expand_by_name 000032 constant entry external dcl 2-71 ref 109 expand_infix 000034 constant entry external dcl 2-76 ref 281 expand_prefix 000036 constant entry external dcl 2-89 ref 278 expand_primitive 000040 constant entry external dcl 2-97 ref 265 expanded_by_name 13(10) based bit(1) level 3 packed packed unaligned dcl 22-9 ref 154 178 253 expression_semantics 000042 constant entry external dcl 2-105 ref 128 145 157 182 198 205 211 579 681 690 783 father 17 based pointer level 2 in structure "symbol" packed packed unaligned dcl 23-3 in procedure "expression_semantics" ref 992 father 1 based pointer level 2 in structure "block" packed packed unaligned dcl 9-5 in procedure "expression_semantics" ref 377 fixed 31(01) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 337* 352 352* float 31(02) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 335* 352 free_node 000116 constant entry external dcl 3-345 ref 372 488 free_var constant bit(9) initial dcl 18-8 ref 227 function 000046 constant entry external dcl 2-125 ref 717 generic 31(17) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 542 generic_selector 000050 constant entry external dcl 2-134 ref 544 get_edit_trans constant bit(9) initial dcl 18-8 ref 103 get_file constant bit(9) initial dcl 18-8 ref 74 get_list_trans constant bit(9) initial dcl 18-8 ref 103 244 278 i 000236 automatic fixed bin(17,0) dcl 946 in procedure "stars_match" set ref 948* 949 949* i 000116 automatic fixed bin(15,0) dcl 33 in procedure "expression_semantics" set ref 203* 205 205 205* 209* 211 211 211* 444* 445 455* 525* 526 528* 610* 611 611* i 000304 automatic fixed bin(17,0) dcl 1012 in procedure "increment_label_array_counts" set ref 1015* 1016* identifier 000011 constant bit(9) initial dcl 27-3 set ref 290 416* ignore_based 0(08) based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" ref 58 554 752 ignore_based 0(08) based bit(1) level 2 in structure "def_this_context" packed packed unaligned dcl 21-27 in procedure "expression_semantics" set ref 58* index builtin function dcl 41 ref 337 info 11 based structure level 2 packed packed unaligned dcl 20-3 input_tree parameter pointer dcl 26 ref 12 54 integer_type 000001 constant bit(36) initial dcl 25-71 set ref 683* 692* io_data_list_semantics$format_list_semantics 000044 constant entry external dcl 2-120 ref 86 io_semantics 000052 constant entry external dcl 2-148 ref 76 is_arithmetic_constant constant bit(9) initial dcl 27-47 ref 324 324 is_decimal_constant constant bit(9) initial dcl 27-47 ref 356 356 is_float_constant constant bit(9) initial dcl 27-47 ref 335 335 is_imaginary_constant constant bit(9) initial dcl 27-47 ref 341 341 join constant bit(9) initial dcl 18-8 ref 238 244 jump constant bit(9) initial dcl 18-8 ref 244 label based structure level 1 dcl 15-1 label_node constant bit(9) initial dcl 17-5 ref 306 381 477 left_side 0(02) based bit(1) level 2 in structure "def_this_context" packed packed unaligned dcl 21-27 in procedure "expression_semantics" set ref 103* 152* 181* 197* 200* left_side 0(02) based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" ref 506 743 length 6 based pointer level 2 packed packed unaligned dcl 20-3 set ref 310 413 485 500 500* 500* 688 690* 690 692* 692 list based structure level 1 dcl 16-6 list_node constant bit(9) initial dcl 17-5 ref 929 929 loc 0(18) based bit(18) level 2 packed packed unaligned dcl 26-3 ref 330 locate_file constant bit(9) initial dcl 18-8 ref 74 lock_file constant bit(9) initial dcl 18-8 ref 71 74 lookup 000054 constant entry external dcl 2-153 ref 293 411 m parameter fixed bin(15,0) dcl 1029 set ref 1026 1035* misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 23-3 name 1 000126 external static char(14) array level 3 packed packed unaligned dcl 12-19 ref 445 526 negate constant bit(9) initial dcl 18-8 ref 278 next 1 based pointer level 2 packed packed unaligned dcl 13-3 set ref 301* 431* 451* node based structure level 1 dcl 17-27 not_bits constant bit(9) initial dcl 18-8 ref 278 null builtin function dcl 831 in procedure "temp_needed" ref 875 927 927 992 1-11 null builtin function dcl 41 in procedure "expression_semantics" ref 56 61 77 111 141 141 205 211 221 231 256 256 301 310 310 310 317 324 326 328 328 368 401 409 414 421 431 451 457 485 485 485 485 485 497 500 509 551 554 557 560 562 568 570 575 606 618 626 628 651 667 671 678 688 700 705 729 743 762 772 789 792 799 802 1017 1031 number 0(21) based fixed bin(14,0) level 2 in structure "list" packed packed unaligned dcl 16-6 in procedure "expression_semantics" ref 416 610 616 764 948 1015 number 0(21) based fixed bin(14,0) level 2 in structure "operator" packed packed unaligned dcl 19-6 in procedure "expression_semantics" ref 209 number_of_names 000126 external static fixed bin(15,0) level 2 dcl 12-19 ref 444 525 offset 31(06) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 23-3 in procedure "expression_semantics" ref 586 offset 5 based pointer level 2 in structure "reference" packed packed unaligned dcl 20-3 in procedure "expression_semantics" set ref 310 408 409* 457* 485 497 497* 497* 626* 648* 678 681* 681 683* 683 734* 783* 783 789 924 925 op_code 0(09) based bit(9) level 2 packed packed unaligned dcl 19-6 ref 69 133 586 opcode 000120 automatic bit(9) dcl 35 set ref 69* 71 71 74 74 74 74 77 77 84 84 91 103 103 106 113* 116 116 121 141 150 195 203 217 227 227 227 238 238 244 244 244 244 244 249 263 278 278 278 278 278 278 278 open_file constant bit(9) initial dcl 18-8 ref 77 operand 1 based pointer array level 2 packed packed unaligned dcl 19-6 set ref 93 97* 123* 133 133 137* 144 157* 157 162 166 167 182* 182 188 198* 198 205 205* 205 211 211* 211 265 267 268 270* 270 271* 586 711* 713* 714* operator based structure level 1 dcl 19-6 operator_node constant bit(9) initial dcl 17-5 ref 64 133 166 267 586 719 1031 operator_semantics 000056 constant entry external dcl 2-184 ref 219 229 592 other 11(33) based structure level 3 packed packed unaligned dcl 20-3 set ref 740* overlayed 33(11) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 746 p 000110 automatic pointer dcl 31 in procedure "expression_semantics" set ref 96* 97 119* 127* 133 133 133 133* 133 137* 166* 166* 167 169 174 175 265* 267 272 416* 418* 480* 485 485 485 489 492 575* 577* 579* 710* 711 714 766* 767 767 1031* 1033* 1035* p 000100 automatic pointer dcl 1-5 in procedure "string_overlay" set ref 1-10* 1-11 1-12* 1-13* 1-13 packed 33 based bit(1) level 4 packed packed unaligned dcl 23-3 ref 988 988 1-7 param_desc 32(15) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 395 parameter 32(14) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 917 917 995 pds 000122 automatic bit(1) dcl 36 set ref 423* 435 483* 485 495 picture 31(18) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 1-17 pl1_data$builtin_name 000126 external static structure level 1 unaligned dcl 12-19 pl1_stat_$LHS 000010 external static pointer dcl 46 in procedure "expression_semantics" set ref 175* 743 pl1_stat_$LHS 000130 external static pointer dcl 824 in procedure "temp_needed" ref 840 pl1_stat_$LHS_ref 000012 external static pointer dcl 47 in procedure "expression_semantics" set ref 174* pl1_stat_$LHS_ref 000132 external static pointer dcl 824 in procedure "temp_needed" ref 839 pl1_stat_$index 000020 external static fixed bin(15,0) dcl 50 set ref 116 119 596* 596 597 599 628* 628 639* 639 651* 651 700* 700 pl1_stat_$locator 000016 external static pointer array dcl 49 set ref 119 599* pl1_stat_$root 000014 external static pointer dcl 48 ref 296 426 447 467 pointer_type 000000 constant bit(36) initial dcl 25-71 set ref 584* prefix_plus constant bit(9) initial dcl 18-8 ref 244 278 processed 0(13) based bit(1) level 2 in structure "reference" packed packed unaligned dcl 20-3 in procedure "expression_semantics" set ref 397* 401 493* 516 721* 752* 775* 787* processed 0(19) based bit(1) level 2 in structure "operator" packed packed unaligned dcl 19-6 in procedure "expression_semantics" set ref 66 87* 221* 231* 240* 257* 274* 283* 590* 593* 719* prologue_flag 43 based bit(1) level 2 packed packed unaligned dcl 9-5 ref 509 propagate_bit 000060 constant entry external dcl 2-192 ref 506 put_data_sw 0(12) based bit(1) level 2 packed packed unaligned dcl 20-3 set ref 99* 423 437* 483 495* put_data_trans constant bit(9) initial dcl 18-8 ref 91 244 278 put_field constant bit(9) initial dcl 18-8 ref 278 put_field_chk constant bit(9) initial dcl 18-8 ref 278 q 000300 automatic pointer dcl 1011 in procedure "increment_label_array_counts" set ref 1016* 1017 1017 1017 q 000112 automatic pointer dcl 31 in procedure "expression_semantics" set ref 93* 94 96* 97* 99 99 267* 267* 268 270 271 309* 310 310 310 310 314 413* 414 416 416 482* 485 503 551* 557* 558* 564* 565 565* 565 568* 570 572 572* 572 579* 579* 584* 584* 586 586 586 590 592* 592* 593 628 651 700 712* 713 714 715 791* 792 792 792 qualifier 4 based pointer level 2 packed packed unaligned dcl 20-3 set ref 119 127* 310 317* 401* 482 485 503* 551 551 554 558* 560 562 564 575 584* 592* r_parn constant bit(9) initial dcl 18-8 ref 71 84 real 31(30) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 343* ref_count 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 20-3 set ref 316* 494* refer constant bit(9) initial dcl 18-8 ref 116 121 reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 23-3 in procedure "expression_semantics" set ref 309 370 459* 472* 480 554 558 562 564 572 738 739 reference based structure level 1 dcl 20-3 in procedure "expression_semantics" set ref 492* 492 reference_count 7 based fixed bin(17,0) level 2 packed packed unaligned dcl 22-9 set ref 792* 792 802* 802 1017* 1017 reference_node constant bit(9) initial dcl 17-5 ref 99 169 387 565 return_from_empty 0(07) based bit(1) level 2 packed packed unaligned dcl 21-27 ref 160 186 return_value constant bit(9) initial dcl 18-8 ref 217 rewrite_file constant bit(9) initial dcl 18-8 ref 74 root 3 based pointer level 2 packed packed unaligned dcl 22-9 ref 111 s parameter pointer dcl 1-5 in procedure "string_overlay" ref 1-3 1-7 1-8 1-10 1-17 1-17 1-17 1-19 1-21 s 000102 automatic pointer dcl 31 in procedure "expression_semantics" set ref 293* 296* 297* 298 302 306 309 310 310 328* 329 335 337 341 343 345* 347 352 352 352 356 356 356 360 368 368 368 368 370 372* 383* 392* 393 395 411* 426* 427* 428 432 447* 452 454 455 458 459 461* 467* 468 469 470* 471 472 477 480 485 506* 509 509 509 509 509 516 521 523 526 528 533* 536* 542 551 554 558 562 562 564 575 606 623 657 657* 659* 662 662 662* 665* 667 671 675 675 675* 681 690 705 717* 738 739 746 746 749 759 774* 782* 791 802 802 802 806 1014 s1 parameter pointer dcl 869 ref 864 875 875 875 875 880 s1_defined_on_s2 000214 automatic bit(1) dcl 873 set ref 875* 879* 880* 882* 883* 885 s2 parameter pointer dcl 869 ref 864 875 880 semantic_translator$abort 000120 constant entry external dcl 3-446 ref 141 418 533 635 1035 semantic_translator$error 000122 constant entry external dcl 3-450 ref 295 425 466 set_bit 000002 constant fixed bin(15,0) initial dcl 24-3 set ref 506* share_expression 000124 constant entry external dcl 3-454 ref 127 137 shared 0(11) based bit(1) level 2 packed packed unaligned dcl 20-3 set ref 315* 493* simplify_offset 000062 constant entry external dcl 2-212 ref 695 784 size 3 based fixed bin(9,0) level 2 dcl 26-3 ref 337 416 416 445 526 son 21 based pointer level 2 in structure "symbol" packed packed unaligned dcl 23-3 in procedure "expression_semantics" ref 1-10 son 3 based pointer level 2 in structure "block" packed packed unaligned dcl 9-5 in procedure "expression_semantics" ref 296 426 447 467 source_id 0(09) based structure level 2 in structure "statement" packed packed unaligned dcl 22-9 in procedure "expression_semantics" ref 303 433 453 source_id 0(09) based structure level 2 in structure "cross_reference" packed packed unaligned dcl 13-3 in procedure "expression_semantics" set ref 303* 433* 453* star_extents 33(06) based bit(1) level 4 packed packed unaligned dcl 23-3 ref 917 statement 11 based pointer level 2 in structure "label" packed packed unaligned dcl 15-1 in procedure "expression_semantics" ref 791 802 802 802 1014 statement based structure level 1 dcl 22-9 in procedure "expression_semantics" statement_type 12(27) based bit(9) level 2 packed packed unaligned dcl 22-9 ref 1046 std_arg_list 000004 constant bit(9) initial dcl 18-8 set ref 710* std_call 000003 constant bit(9) initial dcl 18-8 set ref 712* std_entry constant bit(9) initial dcl 18-8 ref 227 238 stmnt parameter pointer dcl 26 set ref 12 76* 86* 109* 111 128* 145* 154 157* 178 182* 198* 205* 211* 219* 229* 253 256* 265* 278* 281* 293* 303 411* 433 453 461* 536* 544* 579* 592* 657* 659* 662* 665* 675* 681* 690* 717* 743 782* 783* 1046 storage_class 32(09) based structure level 3 packed packed unaligned dcl 23-3 string 4 based char level 2 in structure "token" dcl 26-3 in procedure "expression_semantics" ref 337 416 416 445 526 string builtin function dcl 831 in procedure "temp_needed" ref 917 917 string builtin function dcl 41 in procedure "expression_semantics" set ref 303* 303 368 368 433* 433 453* 453 740* string_unspec 0(11) based bit(1) level 2 packed packed unaligned dcl 21-8 ref 635 structure 31 based bit(1) level 4 packed packed unaligned dcl 23-3 ref 516 662 675 749 1-8 subs 000104 automatic pointer dcl 31 set ref 56* 408* 421 461* 485 536* 544* 606 610 611 611 616 618* 648 657* 659* 662* 665* 667 667* 671 675* 705 711 729 734 762 764 766 772 782* 799 subscript parameter pointer dcl 962 ref 957 964 967 subscripter 000064 constant entry external dcl 2-216 ref 659 665 782 suppress_cross_ref 0(13) based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" ref 59 suppress_cross_ref 0(13) based bit(1) level 2 in structure "def_this_context" packed packed unaligned dcl 21-27 in procedure "expression_semantics" set ref 59* symbol 3 based pointer level 2 in structure "reference" packed packed unaligned dcl 20-3 in procedure "expression_semantics" set ref 133 175 390 392 401 416 426 445 447 458* 467 586 841 880 symbol based structure level 1 dcl 23-3 in procedure "expression_semantics" symbol_node constant bit(9) initial dcl 17-5 ref 393 572 t 000204 automatic fixed bin(17,0) dcl 837 set ref 986* 1-19 1-19* 1-20* 1-21 1-24 this_context 000124 automatic bit(36) dcl 21-5 set ref 57* 58 59 103 128* 145* 152 154 157* 158 160 178 181 181 182* 183 184 184 186 194 197 198* 200 205* 211* 219* 227 251* 253 253 256* 293* 411* 579* 581 697 783* 785 token based structure level 1 dcl 26-3 in procedure "expression_semantics" token 5 based pointer level 2 in structure "symbol" packed packed unaligned dcl 23-3 in procedure "expression_semantics" ref 526 875 token_node constant bit(9) initial dcl 17-5 ref 94 124 288 390 611 767 875 964 top 0(05) based bit(1) level 2 in structure "def_this_context" packed packed unaligned dcl 21-27 in procedure "expression_semantics" ref 253 top 0(05) based bit(1) level 2 in structure "def_context" packed packed unaligned dcl 21-8 in procedure "expression_semantics" ref 154 172 178 249 667 1046 tree 000100 automatic pointer dcl 31 set ref 54* 61 64 66 69 76* 77* 86* 87 93 97 109* 123* 123 124 124* 124* 127 128* 128* 137 144* 144 145* 145* 157 157 162* 162 166 182 182 188* 188 198 198 205 205 205 209 211 211 211 219* 219* 221 221 229* 229* 231 231 240 256* 256* 257 265 270 271 272* 274 278* 278* 281* 281* 283 288 290 293* 295* 296* 310* 314* 315 316 317 324 330 335 337 341 356 368* 368* 370* 370* 381 383 387 390 392 397 401 401 401 408 409 411* 413 416 423 425* 426 437 445 447 457 458 459 461* 461* 466* 467 472* 482 483 488* 489* 492 493 493 493 494 495 497 497 497 500 500 500 503 516 516 536* 536* 544* 544* 551 551 560 575 584 592 599 619 626 633 635* 648 657* 657* 659* 659* 662* 662* 665* 665* 675 675* 675* 678 681 681 683 683 688 690 690 692 692 695* 713 715* 717* 717* 719 719 721 726 726 734 738 739 740 743* 746 749 752 774* 775 776 782* 782* 783 783 784* 787 789 791 806* 809 1031 1033 type 0(09) based bit(9) level 2 in structure "token" packed packed unaligned dcl 26-3 in procedure "expression_semantics" ref 290 324 335 341 356 611 767 967 type based bit(9) level 2 in structure "node" packed packed unaligned dcl 17-27 in procedure "expression_semantics" ref 64 94 99 124 133 166 169 267 288 306 381 387 390 393 477 565 572 586 611 719 767 875 929 929 964 1031 units 0(14) based fixed bin(3,0) level 2 packed packed unaligned dcl 20-3 set ref 739* 739 validate 000066 constant entry external dcl 2-225 ref 345 variable_arg_list 32(07) based bit(1) level 4 packed packed unaligned dcl 23-3 set ref 469* vector 000302 automatic pointer dcl 1011 set ref 1014* 1015 1016 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 18-8 abs_fun internal static bit(9) initial dcl 18-8 acos_fun internal static bit(9) initial dcl 18-8 acosd_fun internal static bit(9) initial dcl 18-8 add internal static bit(9) initial dcl 18-8 addbitno_fun internal static bit(9) initial dcl 18-8 addcharno_fun internal static bit(9) initial dcl 18-8 addr_fun internal static bit(9) initial dcl 18-8 addr_fun_bits internal static bit(9) initial dcl 18-8 addrel_fun internal static bit(9) initial dcl 18-8 adjust_count 000000 constant entry external dcl 3-20 aliasable_bit internal static fixed bin(15,0) initial dcl 24-3 alloc_semantics 000000 constant entry external dcl 2-7 alloc_semantics$init_only 000000 constant entry external dcl 2-12 allocate_statement internal static bit(9) initial dcl 28-3 allocation_fun internal static bit(9) initial dcl 18-8 allot_auto internal static bit(9) initial dcl 18-8 allot_based internal static bit(9) initial dcl 18-8 allot_ctl internal static bit(9) initial dcl 18-8 and internal static bit(9) initial dcl 27-3 and_bits internal static bit(9) initial dcl 18-8 arg_desc_type internal static bit(36) initial dcl 25-71 array_node internal static bit(9) initial dcl 17-5 arrow internal static bit(9) initial dcl 27-3 asin_fun internal static bit(9) initial dcl 18-8 asind_fun internal static bit(9) initial dcl 18-8 assign_round internal static bit(9) initial dcl 18-8 assign_size_ck internal static bit(9) initial dcl 18-8 assign_zero internal static bit(9) initial dcl 18-8 assignment internal static bit(9) initial dcl 27-3 assignment_statement internal static bit(9) initial dcl 28-3 atan_fun internal static bit(9) initial dcl 18-8 atand_fun internal static bit(9) initial dcl 18-8 b_format internal static bit(9) initial dcl 18-8 baseno_fun internal static bit(9) initial dcl 18-8 baseptr_fun internal static bit(9) initial dcl 18-8 begin_block internal static bit(9) initial dcl 10-1 begin_statement internal static bit(9) initial dcl 28-3 bin_integer internal static bit(9) initial dcl 27-3 binary_to_octal_string 000000 constant entry external dcl 3-38 binary_to_octal_var_string 000000 constant entry external dcl 3-43 bindec 000000 constant entry external dcl 3-23 bindec$vs 000000 constant entry external dcl 3-28 binoct 000000 constant entry external dcl 3-33 bit_string internal static bit(9) initial dcl 27-3 bit_to_char internal static bit(9) initial dcl 18-8 bit_to_word internal static bit(9) initial dcl 18-8 bit_type internal static bit(36) initial dcl 25-71 bitno_fun internal static bit(9) initial dcl 18-8 bits_per_binary_exponent internal static fixed bin(31,0) initial dcl 25-5 bits_per_character internal static fixed bin(31,0) initial dcl 25-5 bits_per_decimal_digit internal static fixed bin(31,0) initial dcl 25-5 bits_per_digit internal static fixed bin(31,1) initial dcl 25-69 bits_per_double internal static fixed bin(31,0) initial dcl 25-5 bits_per_half internal static fixed bin(31,0) initial dcl 25-5 bits_per_packed_ptr internal static fixed bin(31,0) initial dcl 25-5 bits_per_word internal static fixed bin(31,0) initial dcl 25-5 block_node internal static bit(9) initial dcl 17-5 bool_fun internal static bit(9) initial dcl 18-8 bound_ck internal static bit(9) initial dcl 18-8 bound_node internal static bit(9) initial dcl 17-5 builtin_type internal static bit(36) initial dcl 25-71 by_context internal static bit(3) initial dcl 14-5 by_declare internal static bit(3) initial dcl 14-5 by_explicit_context internal static bit(3) initial dcl 14-5 by_name_agg_node internal static bit(9) initial dcl 17-5 byte_fun internal static bit(9) initial dcl 18-8 c_format internal static bit(9) initial dcl 18-8 cat internal static bit(9) initial dcl 27-3 cat_string internal static bit(9) initial dcl 18-8 ceil_fun internal static bit(9) initial dcl 18-8 char_string internal static bit(9) initial dcl 27-3 char_to_word internal static bit(9) initial dcl 18-8 char_type internal static bit(36) initial dcl 25-71 characters_per_double internal static fixed bin(31,0) initial dcl 25-5 characters_per_half internal static fixed bin(31,0) initial dcl 25-5 characters_per_word internal static fixed bin(31,0) initial dcl 25-5 charno_fun internal static bit(9) initial dcl 18-8 check_star_extents 000000 constant entry external dcl 2-27 clock_fun internal static bit(9) initial dcl 18-8 close_statement internal static bit(9) initial dcl 28-3 codeptr_fun internal static bit(9) initial dcl 18-8 colon internal static bit(9) initial dcl 27-3 column_format internal static bit(9) initial dcl 18-8 comma internal static bit(9) initial dcl 27-3 compare_declaration 000000 constant entry external dcl 2-31 complex_fun internal static bit(9) initial dcl 18-8 complex_type internal static bit(36) initial dcl 25-71 conjg_fun internal static bit(9) initial dcl 18-8 constant_length 000000 constant entry external dcl 3-54 context_node internal static bit(9) initial dcl 17-5 context_processor 000000 constant entry external dcl 2-38 continue_statement internal static bit(9) initial dcl 28-3 convert$from_builtin 000000 constant entry external dcl 3-72 convert$to_target_fb 000000 constant entry external dcl 3-82 convert$validate 000000 constant entry external dcl 3-78 copy_expression$copy_sons 000000 constant entry external dcl 3-99 copy_string internal static bit(9) initial dcl 18-8 copy_unique_expression 000000 constant entry external dcl 3-103 cos_fun internal static bit(9) initial dcl 18-8 cosd_fun internal static bit(9) initial dcl 18-8 create_array 000000 constant entry external dcl 3-108 create_block 000000 constant entry external dcl 3-112 create_bound 000000 constant entry external dcl 3-118 create_context 000000 constant entry external dcl 3-122 create_default 000000 constant entry external dcl 3-132 create_identifier 000000 constant entry external dcl 3-136 create_label 000000 constant entry external dcl 3-140 create_statement 000000 constant entry external dcl 3-163 create_statement$prologue 000000 constant entry external dcl 3-171 create_storage 000000 constant entry external dcl 3-179 create_token$init_hash_table 000000 constant entry external dcl 3-197 create_token$protected 000000 constant entry external dcl 3-199 cross_reference_node internal static bit(9) initial dcl 17-5 dec_integer internal static bit(9) initial dcl 27-3 dec_integer_type internal static bit(36) initial dcl 25-71 decbin 000000 constant entry external dcl 3-206 declare_constant 000000 constant entry external dcl 3-211 declare_constant$bit 000000 constant entry external dcl 3-219 declare_constant$char 000000 constant entry external dcl 3-224 declare_constant$desc 000000 constant entry external dcl 3-229 declare_constant$integer 000000 constant entry external dcl 3-234 declare_descriptor 000000 constant entry external dcl 3-239 declare_descriptor$ctl 000000 constant entry external dcl 3-249 declare_descriptor$param 000000 constant entry external dcl 3-259 declare_integer 000000 constant entry external dcl 3-269 declare_picture 000000 constant entry external dcl 3-274 declare_picture_temp 000000 constant entry external dcl 3-279 declare_pointer 000000 constant entry external dcl 3-287 declare_statement internal static bit(9) initial dcl 28-3 declare_structure 000000 constant entry external dcl 2-44 declare_temporary 000000 constant entry external dcl 3-292 decode_node_id 000000 constant entry external dcl 3-300 decode_source_id 000000 constant entry external dcl 3-306 default_area_size internal static fixed bin(31,0) initial dcl 25-5 default_fix_bin_p internal static fixed bin(31,0) initial dcl 25-5 default_fix_dec_p internal static fixed bin(31,0) initial dcl 25-5 default_flt_bin_p internal static fixed bin(31,0) initial dcl 25-5 default_flt_dec_p internal static fixed bin(31,0) initial dcl 25-5 default_node internal static bit(9) initial dcl 17-5 default_statement internal static bit(9) initial dcl 28-3 delete_file internal static bit(9) initial dcl 18-8 delete_statement internal static bit(9) initial dcl 28-3 desc_size internal static bit(9) initial dcl 18-8 digit_ internal static fixed bin(3,0) initial dcl 11-5 digit_to_bit internal static bit(9) initial dcl 18-8 display_statement internal static bit(9) initial dcl 28-3 div internal static bit(9) initial dcl 18-8 do_semantics 000000 constant entry external dcl 2-57 do_statement internal static bit(9) initial dcl 28-3 e_format internal static bit(9) initial dcl 18-8 else_clause internal static bit(9) initial dcl 28-3 empty_area internal static bit(9) initial dcl 18-8 enable_on internal static bit(9) initial dcl 18-8 end_statement internal static bit(9) initial dcl 28-3 entry_statement internal static bit(9) initial dcl 28-3 entry_var_type internal static bit(36) initial dcl 25-71 environmentptr_fun internal static bit(9) initial dcl 18-8 eq internal static bit(9) initial dcl 27-3 equal internal static bit(9) initial dcl 18-8 error 000000 constant entry external dcl 3-314 error$omit_text 000000 constant entry external dcl 3-319 error_ 000000 constant entry external dcl 3-324 error_$finish 000000 constant entry external dcl 3-343 error_$initialize_error 000000 constant entry external dcl 3-341 error_$no_text 000000 constant entry external dcl 3-334 ex_prologue internal static bit(9) initial dcl 18-8 exit_statement internal static bit(9) initial dcl 28-3 exp internal static bit(9) initial dcl 18-8 exp_fun internal static bit(9) initial dcl 18-8 expand_initial 000000 constant entry external dcl 2-84 expon internal static bit(9) initial dcl 27-3 external_procedure internal static bit(9) initial dcl 10-1 f_format internal static bit(9) initial dcl 18-8 fill_refer 000000 constant entry external dcl 2-113 fixed_bin internal static bit(9) initial dcl 27-3 fixed_dec internal static bit(9) initial dcl 27-3 float_bin internal static bit(9) initial dcl 27-3 float_dec internal static bit(9) initial dcl 27-3 floor_fun internal static bit(9) initial dcl 18-8 format_statement internal static bit(9) initial dcl 28-3 format_value_node internal static bit(9) initial dcl 17-5 fortran_read internal static bit(9) initial dcl 18-8 fortran_write internal static bit(9) initial dcl 18-8 free_based internal static bit(9) initial dcl 18-8 free_ctl internal static bit(9) initial dcl 18-8 free_statement internal static bit(9) initial dcl 28-3 ftn_file_manip internal static bit(9) initial dcl 18-8 ftn_trans_loop internal static bit(9) initial dcl 18-8 ge internal static bit(9) initial dcl 27-3 get_array_size 000000 constant entry external dcl 3-348 get_data_trans internal static bit(9) initial dcl 18-8 get_size 000000 constant entry external dcl 3-352 get_statement internal static bit(9) initial dcl 28-3 get_string internal static bit(9) initial dcl 18-8 goto_statement internal static bit(9) initial dcl 28-3 greater_or_equal internal static bit(9) initial dcl 18-8 greater_than internal static bit(9) initial dcl 18-8 gt internal static bit(9) initial dcl 27-3 half_ internal static fixed bin(3,0) initial dcl 11-5 half_to_word internal static bit(9) initial dcl 18-8 i_bin_integer internal static bit(9) initial dcl 27-3 i_dec_integer internal static bit(9) initial dcl 27-3 i_fixed_bin internal static bit(9) initial dcl 27-3 i_fixed_dec internal static bit(9) initial dcl 27-3 i_float_bin internal static bit(9) initial dcl 27-3 i_float_dec internal static bit(9) initial dcl 27-3 if_statement internal static bit(9) initial dcl 28-3 imag_fun internal static bit(9) initial dcl 18-8 index_after_fun internal static bit(9) initial dcl 18-8 index_before_fun internal static bit(9) initial dcl 18-8 index_fun internal static bit(9) initial dcl 18-8 index_rev_fun internal static bit(9) initial dcl 18-8 internal_procedure internal static bit(9) initial dcl 10-1 io_data_list_semantics 000000 constant entry external dcl 2-143 is_arith_constant internal static bit(9) initial dcl 27-47 is_constant internal static bit(9) initial dcl 27-47 is_delimiter internal static bit(9) initial dcl 27-47 is_identifier internal static bit(9) initial dcl 27-47 is_integral_constant internal static bit(9) initial dcl 27-47 is_isub internal static bit(9) initial dcl 27-47 isub internal static bit(9) initial dcl 27-3 jump_false internal static bit(9) initial dcl 18-8 jump_if_eq internal static bit(9) initial dcl 18-8 jump_if_ge internal static bit(9) initial dcl 18-8 jump_if_gt internal static bit(9) initial dcl 18-8 jump_if_le internal static bit(9) initial dcl 18-8 jump_if_lt internal static bit(9) initial dcl 18-8 jump_if_ne internal static bit(9) initial dcl 18-8 jump_true internal static bit(9) initial dcl 18-8 l_parn internal static bit(9) initial dcl 18-8 label_array_element_node internal static bit(9) initial dcl 17-5 le internal static bit(9) initial dcl 27-3 left_parn internal static bit(9) initial dcl 27-3 length_fun internal static bit(9) initial dcl 18-8 less_or_equal internal static bit(9) initial dcl 18-8 less_than internal static bit(9) initial dcl 18-8 line_format internal static bit(9) initial dcl 18-8 local_label_var_type internal static bit(36) initial dcl 25-71 locate_statement internal static bit(9) initial dcl 28-3 lock_fun internal static bit(9) initial dcl 18-8 lock_statement internal static bit(9) initial dcl 28-3 log10_fun internal static bit(9) initial dcl 18-8 log2_fun internal static bit(9) initial dcl 18-8 log_fun internal static bit(9) initial dcl 18-8 loop internal static bit(9) initial dcl 18-8 lt internal static bit(9) initial dcl 27-3 machine_state_node internal static bit(9) initial dcl 17-5 make_desc internal static bit(9) initial dcl 18-8 make_non_quick 000000 constant entry external dcl 2-162 match_arguments 000000 constant entry external dcl 2-166 max_area_size internal static fixed bin(31,0) initial dcl 25-5 max_bit_string internal static fixed bin(31,0) initial dcl 25-5 max_bit_string_constant internal static fixed bin(31,0) initial dcl 25-5 max_block_number internal static fixed bin(17,0) initial dcl 9-74 max_char_string internal static fixed bin(31,0) initial dcl 25-5 max_char_string_constant internal static fixed bin(31,0) initial dcl 25-5 max_fun internal static bit(9) initial dcl 18-8 max_identifier_length internal static fixed bin(31,0) initial dcl 25-5 max_index_register_value internal static fixed bin(31,0) initial dcl 25-5 max_length_precision internal static fixed bin(31,0) initial dcl 25-5 max_list_elements internal static fixed bin(17,0) initial dcl 16-12 max_number_of_dimensions internal static fixed bin(31,0) initial dcl 25-5 max_number_of_operands internal static fixed bin(15,0) initial dcl 19-15 max_offset_precision internal static fixed bin(31,0) initial dcl 25-5 max_p_bin_or_dec internal static fixed bin(31,0) initial dcl 25-5 max_p_dec internal static fixed bin(31,0) initial dcl 25-5 max_p_fix_bin_1 internal static fixed bin(31,0) initial dcl 25-5 max_p_fix_bin_2 internal static fixed bin(31,0) initial dcl 25-5 max_p_flt_bin_1 internal static fixed bin(31,0) initial dcl 25-5 max_p_flt_bin_2 internal static fixed bin(31,0) initial dcl 25-5 max_scale internal static fixed bin(31,0) initial dcl 25-5 max_signed_index_register_value internal static fixed bin(31,0) initial dcl 25-5 max_signed_xreg_precision internal static fixed bin(31,0) initial dcl 25-5 max_uns_xreg_precision internal static fixed bin(31,0) initial dcl 25-5 max_words_per_variable internal static fixed bin(31,0) initial dcl 25-5 merge_attributes 000000 constant entry external dcl 3-355 min_area_size internal static fixed bin(31,0) initial dcl 25-5 min_fun internal static bit(9) initial dcl 18-8 min_scale internal static fixed bin(31,0) initial dcl 25-5 minus internal static bit(9) initial dcl 27-3 mod2_ internal static fixed bin(3,0) initial dcl 11-5 mod4_ internal static fixed bin(3,0) initial dcl 11-5 mod_bit internal static bit(9) initial dcl 18-8 mod_byte internal static bit(9) initial dcl 18-8 mod_fun internal static bit(9) initial dcl 18-8 mod_half internal static bit(9) initial dcl 18-8 mod_word internal static bit(9) initial dcl 18-8 mult internal static bit(9) initial dcl 18-8 n automatic fixed bin(15,0) dcl 33 ne internal static bit(9) initial dcl 27-3 ngt internal static bit(9) initial dcl 27-3 nlt internal static bit(9) initial dcl 27-3 no_token internal static bit(9) initial dcl 27-3 nop internal static bit(9) initial dcl 18-8 not internal static bit(9) initial dcl 27-3 not_equal internal static bit(9) initial dcl 18-8 null_statement internal static bit(9) initial dcl 28-3 off_fun internal static bit(9) initial dcl 18-8 offset_adder 000000 constant entry external dcl 2-172 on_statement internal static bit(9) initial dcl 28-3 on_unit internal static bit(9) initial dcl 10-1 open_statement internal static bit(9) initial dcl 28-3 optimizer 000000 constant entry external dcl 3-361 or internal static bit(9) initial dcl 27-3 or_bits internal static bit(9) initial dcl 18-8 overlayed_by_builtin_bit internal static fixed bin(15,0) initial dcl 24-3 pack internal static bit(9) initial dcl 18-8 packed_digits_per_character internal static fixed bin(31,0) initial dcl 25-5 page_format internal static bit(9) initial dcl 18-8 param_desc_ptr internal static bit(9) initial dcl 18-8 param_ptr internal static bit(9) initial dcl 18-8 parse_error 000000 constant entry external dcl 3-364 parse_error$no_text 000000 constant entry external dcl 3-368 passed_as_arg_bit internal static fixed bin(15,0) initial dcl 24-3 percent internal static bit(9) initial dcl 27-3 period internal static bit(9) initial dcl 27-3 picture_format internal static bit(9) initial dcl 18-8 pl1_error_print$listing_segment 000000 constant entry external dcl 3-384 pl1_error_print$write_out 000000 constant entry external dcl 3-372 pl1_mod_fun internal static bit(9) initial dcl 18-8 pl1_print$for_lex 000000 constant entry external dcl 3-418 pl1_print$non_varying 000000 constant entry external dcl 3-398 pl1_print$non_varying_nl 000000 constant entry external dcl 3-402 pl1_print$string_pointer 000000 constant entry external dcl 3-406 pl1_print$string_pointer_nl 000000 constant entry external dcl 3-410 pl1_print$unaligned_nl 000000 constant entry external dcl 3-414 pl1_print$varying 000000 constant entry external dcl 3-392 pl1_print$varying_nl 000000 constant entry external dcl 3-395 plus internal static bit(9) initial dcl 27-3 procedure_statement internal static bit(9) initial dcl 28-3 ptr_fun internal static bit(9) initial dcl 18-8 put_control internal static bit(9) initial dcl 18-8 put_edit_trans internal static bit(9) initial dcl 18-8 put_file internal static bit(9) initial dcl 18-8 put_list_trans internal static bit(9) initial dcl 18-8 put_statement internal static bit(9) initial dcl 28-3 put_string internal static bit(9) initial dcl 18-8 r_format internal static bit(9) initial dcl 18-8 range_ck internal static bit(9) initial dcl 18-8 rank_fun internal static bit(9) initial dcl 18-8 read_file internal static bit(9) initial dcl 18-8 read_statement internal static bit(9) initial dcl 28-3 real_fun internal static bit(9) initial dcl 18-8 real_type internal static bit(36) initial dcl 25-71 record_io internal static bit(9) initial dcl 18-8 refer_extent 000000 constant entry external dcl 3-426 rel_fun internal static bit(9) initial dcl 18-8 repeat_fun internal static bit(9) initial dcl 18-8 reserve$clear 000000 constant entry external dcl 3-430 reserve$declare_lib 000000 constant entry external dcl 3-434 reserve$read_lib 000000 constant entry external dcl 3-439 return_bits internal static bit(9) initial dcl 18-8 return_statement internal static bit(9) initial dcl 28-3 return_string internal static bit(9) initial dcl 18-8 return_words internal static bit(9) initial dcl 18-8 reverse_fun internal static bit(9) initial dcl 18-8 revert_on internal static bit(9) initial dcl 18-8 revert_statement internal static bit(9) initial dcl 28-3 rewrite_statement internal static bit(9) initial dcl 28-3 right_parn internal static bit(9) initial dcl 27-3 root_block internal static bit(9) initial dcl 10-1 round_fun internal static bit(9) initial dcl 18-8 search_fun internal static bit(9) initial dcl 18-8 search_rev_fun internal static bit(9) initial dcl 18-8 segno_fun internal static bit(9) initial dcl 18-8 semantic_translator 000000 constant entry external dcl 3-444 semantic_translator$call_es 000000 constant entry external dcl 2-196 semi_colon internal static bit(9) initial dcl 27-3 setbitno_fun internal static bit(9) initial dcl 18-8 setcharno_fun internal static bit(9) initial dcl 18-8 sf_par_node internal static bit(9) initial dcl 17-5 sign_fun internal static bit(9) initial dcl 18-8 signal_on internal static bit(9) initial dcl 18-8 signal_statement internal static bit(9) initial dcl 28-3 simplify_expression 000000 constant entry external dcl 2-205 sin_fun internal static bit(9) initial dcl 18-8 sind_fun internal static bit(9) initial dcl 18-8 skip_format internal static bit(9) initial dcl 18-8 slash internal static bit(9) initial dcl 27-3 source_node internal static bit(9) initial dcl 17-5 sqrt_fun internal static bit(9) initial dcl 18-8 stack_ptr internal static bit(9) initial dcl 18-8 stackbaseptr_fun internal static bit(9) initial dcl 18-8 stackframeptr_fun internal static bit(9) initial dcl 18-8 stacq_fun internal static bit(9) initial dcl 18-8 statement_node internal static bit(9) initial dcl 17-5 std_return internal static bit(9) initial dcl 18-8 stop internal static bit(9) initial dcl 18-8 stop_statement internal static bit(9) initial dcl 28-3 storage_block_type internal static bit(36) initial dcl 25-71 stream_prep internal static bit(9) initial dcl 18-8 sub internal static bit(9) initial dcl 18-8 system_on_unit internal static bit(9) initial dcl 28-3 t automatic fixed bin(15,0) dcl 33 tan_fun internal static bit(9) initial dcl 18-8 tand_fun internal static bit(9) initial dcl 18-8 temporary_node internal static bit(9) initial dcl 17-5 terminate_trans internal static bit(9) initial dcl 18-8 token_to_binary 000000 constant entry external dcl 3-459 translate_fun internal static bit(9) initial dcl 18-8 trunc_fun internal static bit(9) initial dcl 18-8 unknown_statement internal static bit(9) initial dcl 28-3 unlock_file internal static bit(9) initial dcl 18-8 unlock_statement internal static bit(9) initial dcl 28-3 unpack internal static bit(9) initial dcl 18-8 vclock_fun internal static bit(9) initial dcl 18-8 verify_fun internal static bit(9) initial dcl 18-8 verify_ltrim_fun internal static bit(9) initial dcl 18-8 verify_rev_fun internal static bit(9) initial dcl 18-8 verify_rtrim_fun internal static bit(9) initial dcl 18-8 wait_statement internal static bit(9) initial dcl 28-3 word_ internal static fixed bin(3,0) initial dcl 11-5 word_to_mod2 internal static bit(9) initial dcl 18-8 word_to_mod4 internal static bit(9) initial dcl 18-8 word_to_mod8 internal static bit(9) initial dcl 18-8 wordno_fun internal static bit(9) initial dcl 18-8 words_per_condition_var internal static fixed bin(31,0) initial dcl 25-5 words_per_entry_var internal static fixed bin(31,0) initial dcl 25-5 words_per_file_var internal static fixed bin(31,0) initial dcl 25-5 words_per_fix_bin_1 internal static fixed bin(31,0) initial dcl 25-5 words_per_fix_bin_2 internal static fixed bin(31,0) initial dcl 25-5 words_per_flt_bin_1 internal static fixed bin(31,0) initial dcl 25-5 words_per_flt_bin_2 internal static fixed bin(31,0) initial dcl 25-5 words_per_format internal static fixed bin(31,0) initial dcl 25-5 words_per_label_var internal static fixed bin(31,0) initial dcl 25-5 words_per_offset internal static fixed bin(31,0) initial dcl 25-5 words_per_packed_pointer internal static fixed bin(31,0) initial dcl 25-5 words_per_pointer internal static fixed bin(31,0) initial dcl 25-5 words_per_varying_string_header internal static fixed bin(31,0) initial dcl 25-5 write_file internal static bit(9) initial dcl 18-8 write_statement internal static bit(9) initial dcl 28-3 x_format internal static bit(9) initial dcl 18-8 xor_bits internal static bit(9) initial dcl 18-8 NAMES DECLARED BY EXPLICIT CONTEXT. call_builtin 003025 constant label dcl 536 ref 529 copy_ref 002537 constant label dcl 480 ref 438 cross_section_overlap 005040 constant entry internal dcl 892 ref 852 defined_on 004771 constant entry internal dcl 864 ref 846 849 expression_semantics 000033 constant entry external dcl 12 fail 005473 constant label dcl 1-27 ref 1-7 1-12 1-17 1-21 1-24 ignore_default_attempt 002003 constant label dcl 372 ref 330 347 increment_label_array_counts 005476 constant entry internal dcl 1008 ref 778 796 is_star 005224 constant entry internal dcl 957 ref 949 949 neither_array_nor_entry 005556 constant entry internal dcl 1041 ref 671 799 not_io 000224 constant label dcl 106 ref 71 print 005531 constant entry internal dcl 1026 ref 169 247 509 554 560 581 597 697 708 764 785 794 1050 process_label 004440 constant label dcl 759 ref 306 384 477 process_ref_sons 004021 constant label dcl 678 ref 623 process_reference 002675 constant label dcl 506 ref 319 398 405 441 ret 004676 constant label dcl 809 ref 61 66 81 88 111 130 146 163 190 224 234 241 258 275 285 375 378 387 393 462 519 539 545 654 723 755 779 set_aggregate_bit 004323 constant label dcl 726 ref 516 631 641 stars_match 005160 constant entry internal dcl 941 ref 931 string_overlay 005366 constant entry internal dcl 1-3 ref 988 988 1-12 string_overlay_possible 005247 constant entry internal dcl 983 ref 857 temp_needed 004702 constant entry internal dcl 814 ref 743 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6370 6524 5701 6400 Length 7610 5701 134 1047 466 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME expression_semantics 342 external procedure is an external procedure. temp_needed internal procedure shares stack frame of external procedure expression_semantics. defined_on internal procedure shares stack frame of external procedure expression_semantics. cross_section_overlap internal procedure shares stack frame of external procedure expression_semantics. stars_match internal procedure shares stack frame of external procedure expression_semantics. is_star internal procedure shares stack frame of external procedure expression_semantics. string_overlay_possible internal procedure shares stack frame of external procedure expression_semantics. string_overlay 76 internal procedure calls itself recursively. increment_label_array_counts internal procedure shares stack frame of external procedure expression_semantics. print internal procedure shares stack frame of external procedure expression_semantics. neither_array_nor_entry internal procedure shares stack frame of external procedure expression_semantics. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME expression_semantics 000100 tree expression_semantics 000102 s expression_semantics 000104 subs expression_semantics 000106 d expression_semantics 000110 p expression_semantics 000112 q expression_semantics 000114 b expression_semantics 000116 i expression_semantics 000117 asterisk_count expression_semantics 000120 opcode expression_semantics 000121 LHS_aggregate expression_semantics 000122 pds expression_semantics 000123 cross_section expression_semantics 000124 this_context expression_semantics 000176 LHS_ref temp_needed 000200 LHS_sym temp_needed 000202 RHS_sym temp_needed 000204 t temp_needed 000214 s1_defined_on_s2 defined_on 000224 RHS_subs cross_section_overlap 000226 LHS_subs cross_section_overlap 000236 i stars_match 000300 q increment_label_array_counts 000302 vector increment_label_array_counts 000304 i increment_label_array_counts 000340 errno neither_array_nor_entry string_overlay 000100 p string_overlay THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_char_temp unpk_to_pk cat_realloc_chars call_ext_out_desc call_ext_out call_int_this call_int_other return_mac shorten_stack ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. builtin compare_expression convert convert$to_integer convert$to_target copy_expression create_cross_reference create_list create_operator create_reference create_symbol create_token declare defined_reference expand_assign expand_by_name expand_infix expand_prefix expand_primitive expression_semantics free_node function generic_selector io_data_list_semantics$format_list_semantics io_semantics lookup operator_semantics propagate_bit semantic_translator$abort semantic_translator$error share_expression simplify_offset subscripter validate THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_data$builtin_name pl1_stat_$LHS pl1_stat_$LHS pl1_stat_$LHS_ref pl1_stat_$LHS_ref pl1_stat_$index pl1_stat_$locator pl1_stat_$root LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000026 54 000040 56 000044 57 000046 58 000050 59 000054 61 000060 64 000064 66 000071 69 000074 71 000100 74 000105 76 000117 77 000131 81 000140 84 000141 86 000146 87 000160 88 000162 91 000163 93 000165 94 000167 96 000173 97 000203 99 000207 103 000215 106 000224 109 000227 111 000243 113 000251 116 000253 119 000262 121 000267 123 000272 124 000303 127 000317 128 000333 130 000353 133 000354 137 000374 139 000407 141 000410 144 000426 145 000431 146 000451 150 000452 152 000455 154 000457 157 000472 158 000517 160 000522 162 000525 163 000527 166 000530 167 000537 169 000543 172 000551 174 000561 175 000564 178 000566 181 000603 182 000607 183 000634 184 000642 186 000644 188 000647 190 000651 192 000652 194 000653 195 000660 197 000663 198 000665 200 000712 203 000714 205 000727 208 000760 209 000771 211 001003 214 001034 217 001036 219 001041 221 001061 224 001067 227 001070 229 001104 231 001124 234 001132 238 001133 240 001141 241 001143 244 001144 247 001162 249 001166 251 001177 253 001201 256 001215 257 001240 258 001242 261 001243 263 001245 265 001250 267 001274 268 001304 270 001310 271 001314 272 001315 274 001317 275 001321 278 001322 281 001361 283 001400 285 001402 288 001403 290 001405 293 001413 295 001436 296 001451 297 001472 298 001501 300 001504 301 001513 302 001516 303 001520 306 001524 309 001530 310 001533 314 001555 315 001567 316 001571 317 001574 319 001577 324 001600 326 001612 328 001616 329 001636 330 001641 335 001644 337 001655 341 001672 343 001703 345 001705 347 001714 352 001720 356 001725 360 001741 368 001743 370 001766 372 002003 375 002012 377 002013 378 002016 381 002017 383 002021 384 002022 387 002023 390 002025 392 002033 393 002035 395 002041 397 002044 398 002046 401 002047 405 002057 408 002060 409 002062 411 002064 413 002107 414 002112 416 002116 418 002173 421 002207 423 002213 425 002217 426 002232 427 002256 428 002265 430 002270 431 002277 432 002302 433 002304 435 002310 437 002312 438 002314 441 002315 444 002316 445 002327 447 002342 450 002365 451 002374 452 002377 453 002401 454 002405 455 002407 457 002411 458 002414 459 002415 461 002416 462 002441 464 002442 466 002444 467 002457 468 002503 469 002506 470 002510 471 002517 472 002522 477 002533 480 002537 482 002542 483 002545 485 002551 488 002600 489 002607 490 002611 492 002612 493 002616 494 002624 495 002626 497 002633 500 002652 503 002672 506 002675 509 002713 516 002737 519 002751 521 002752 523 002756 525 002760 526 002771 528 003004 529 003007 531 003010 533 003012 536 003025 539 003051 542 003052 544 003055 545 003077 551 003100 554 003112 557 003130 558 003133 560 003145 562 003156 564 003166 565 003170 567 003206 568 003207 570 003211 572 003215 575 003224 577 003234 579 003240 581 003260 584 003267 586 003306 590 003325 592 003327 593 003355 596 003357 597 003361 599 003370 606 003376 608 003410 610 003411 611 003423 614 003437 616 003441 618 003446 619 003450 621 003452 623 003453 626 003463 628 003466 631 003475 633 003476 635 003511 639 003536 641 003541 644 003542 646 003550 648 003553 649 003556 651 003560 654 003567 657 003570 659 003620 660 003641 662 003642 665 003703 667 003724 669 003752 671 003753 675 003763 678 004021 681 004025 683 004057 688 004077 690 004103 692 004135 695 004155 697 004167 700 004176 705 004205 708 004215 710 004224 711 004241 712 004244 713 004261 714 004264 715 004266 717 004267 719 004311 721 004320 723 004322 726 004323 729 004327 734 004333 738 004336 739 004342 740 004346 743 004350 746 004405 749 004421 752 004432 755 004437 759 004440 762 004444 764 004450 766 004461 767 004464 772 004477 774 004506 775 004517 776 004521 777 004523 778 004526 779 004527 782 004530 783 004552 784 004600 785 004613 787 004622 789 004624 791 004630 792 004635 794 004647 795 004653 796 004654 797 004655 799 004656 802 004663 806 004675 809 004676 814 004702 839 004704 840 004710 841 004713 843 004717 846 004722 849 004733 852 004744 857 004755 860 004766 864 004771 875 004773 879 005021 880 005023 882 005032 883 005034 885 005035 892 005040 917 005042 922 005103 924 005111 925 005114 927 005120 929 005133 931 005146 935 005156 941 005160 948 005162 949 005173 951 005216 953 005220 957 005224 964 005226 967 005235 970 005244 983 005247 986 005251 988 005252 992 005344 995 005353 1000 005362 1 3 005365 1 7 005373 1 8 005401 1 10 005404 1 11 005406 1 12 005412 1 13 005426 1 14 005431 1 15 005432 1 17 005436 1 19 005446 1 20 005456 1 21 005461 1 23 005465 1 24 005466 1 25 005470 1 27 005473 1008 005476 1014 005477 1015 005502 1016 005513 1017 005515 1019 005526 1021 005530 1026 005531 1031 005533 1033 005542 1035 005544 1037 005555 1041 005556 1046 005557 1048 005574 1050 005576 1052 005600 ----------------------------------------------------------- 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