COMPILATION LISTING OF SEGMENT attribute_parse Compiled by: Multics PL/I Compiler, Release 33c, of October 25, 1990 Compiled at: ACTC Technologies Inc. Compiled on: 92-04-24_1123.97_Fri_mdt Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 4* * * 5* * Copyright, (C) Honeywell Bull Inc., 1988 * 6* * * 7* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 8* * * 9* * Copyright (c) 1972 by Massachusetts Institute of * 10* * Technology and Honeywell Information Systems, Inc. * 11* * * 12* *********************************************************** */ 13 14 15 16 17 /****^ HISTORY COMMENTS: 18* 1) change(88-01-26,RWaters), approve(88-01-26,MCR7724), audit(88-02-05,Huen), 19* install(88-02-16,MR12.2-1024): 20* Expand the uses of options (constant) variables. 21* 2) change(88-02-22,RWaters), approve(88-02-22,PBF7724), audit(88-02-25,Huen), 22* install(88-03-08,MR12.2-1034): 23* Limit options(constant) expansions. 24* 3) change(89-02-28,RWaters), approve(89-02-28,MCR8069), audit(89-09-07,Vu), 25* install(89-09-19,MR12.3-1068): 26* Moved code from validate.pl1 to get_scale() to correctly diagnose 27* illegal scale values. 28* 4) change(89-09-27,RWaters), approve(89-09-27,MCR8068), audit(89-09-27,Vu), 29* install(89-10-02,MR12.3-1080): 30* Fixed so that it doesn't flag duplicate attributes as fatal errors. 31* 5) change(91-01-18,Blackmore), approve(91-01-18,MCR8234), 32* audit(91-12-05,Huen), install(92-04-24,MR12.5-1011): 33* Change dcls of 'constant_token' and 'defer_constant_token_list' entries 34* for the constant reference resolution fix. 35* END HISTORY COMMENTS */ 36 37 38 /* format: style3,^indattr,ifthendo,ifthen,^indnoniterdo,indproc,^elsestmt,dclind9,idind23 */ 39 attribute_parse: 40 procedure (cblock, sp, k, in_generic); 41 42 /* This procedure is called to parse the attributes occuring in 43* declare statements, in the returns( ) entry( ) attributes, 44* and in the when( ) clause of the generic( ) attribute. 45* Note that this procedure must be called with k (the index into 46* the token_list) pointing to the token immediately before the 47* attributes (if any). When it returns, k will have been advanced 48* past any|all attributes, and will be on a comma, right_paren, 49* or semi_colon. */ 50 51 /* Modified 780629 by PG for unsigned */ 52 /* Modified 780807 by PG to fix 1652 (diagnose > 127 dimensions) */ 53 /* Modified 780824 by RAB to fix 1776 (unsigned & signed not diagnosed as nonstandard) */ 54 /* Modified 830427 by BIM for ptr options (packed) */ 55 /* Modified 880128 by RW to fix 1994 and 2186 */ 56 /* Modified 890307 by RW to correctly test scale values in get_scale() */ 57 58 59 /* parameters */ 60 61 dcl ( 62 cblock ptr, 63 sp ptr, 64 k fixed bin (15), 65 in_generic bit (1) aligned 66 ) parameter; 67 68 /* automatic */ 69 70 dcl (p, q, p1, p2) ptr; 71 dcl (i, letterx, ndims) fixed bin; 72 dcl type bit (9) aligned; 73 dcl word char (11); 74 dcl (defined_parn, first_time, star) bit (1) aligned; 75 76 /* builtins */ 77 78 dcl (binary, null, string, substr, unspec) builtin; 79 80 /* external static */ 81 82 dcl pl1_stat_$one ptr external static; 83 dcl pl1_stat_$check_ansi bit (1) aligned ext static; 84 85 /* internal static */ 86 87 dcl action_index (82) fixed bin (8) unal internal static initial (0, 88 /* aligned */ 89 2, /* area */ 90 0, /* auto */ 91 0, /* automatic */ 92 4, /* based */ 93 3, /* bin */ 94 3, /* binary */ 95 2, /* bit */ 96 0, /* builtin */ 97 2, /* char */ 98 2, /* character */ 99 3, /* complex */ 100 0, /* cond */ 101 0, /* condition */ 102 0, /* constant */ 103 0, /* controlled */ 104 3, /* cplx */ 105 0, /* ctl */ 106 3, /* dec */ 107 3, /* decimal */ 108 8, /* def */ 109 8, /* defined */ 110 16, /* dim */ 111 16, /* dimension */ 112 0, /* direct */ 113 12, /* entry */ 114 10, /* env */ 115 10, /* environment */ 116 0, /* ext */ 117 0, /* external */ 118 0, /* file */ 119 3, /* fixed */ 120 3, /* float */ 121 0, /* format */ 122 15, /* generic */ 123 9, /* init */ 124 9, /* initial */ 125 0, /* input */ 126 0, /* int */ 127 0, /* internal */ 128 18, /* irred */ 129 18, /* irreducible */ 130 0, /* keyed */ 131 13, /* label */ 132 14, /* like */ 133 0, /* local */ 134 0, /* member */ 135 0, /* nonvar */ 136 0, /* nonvarying */ 137 5, /* offset */ 138 17, /* options */ 139 0, /* output */ 140 0, /* parameter */ 141 0, /* parm */ 142 6, /* pic */ 143 6, /* picture */ 144 0, /* pointer */ 145 7, /* pos */ 146 7, /* position */ 147 3, /* prec */ 148 3, /* precision */ 149 0, /* print */ 150 0, /* ptr */ 151 3, /* real */ 152 0, /* record */ 153 18, /* red */ 154 18, /* reducible */ 155 11, /* returns */ 156 0, /* seql */ 157 0, /* sequential */ 158 18, /* signed */ 159 0, /* static */ 160 0, /* stream */ 161 0, /* structure */ 162 0, /* unal */ 163 0, /* unaligned */ 164 18, /* uns */ 165 18, /* unsigned */ 166 0, /* update */ 167 0, /* var */ 168 0, /* variable */ 169 0 /* varying */); 170 171 dcl constant_token entry (ptr, ptr, bit (9) aligned, bit (9) aligned) returns (bit (9)); 172 dcl defer_constant_token_list entry (ptr, fixed bin, bit (9) aligned); 173 174 /* program */ 175 176 p = sp; /* copy parameter into automatic */ 177 first_time = "1"b; 178 go to next; 179 ck_parn: 180 if t_table.type ^= right_parn then 181 call print (11); 182 next: 183 k = k + 1; 184 find_type: 185 if token_list (k) = null then 186 call print (7); 187 type = t_table.type; 188 action (0): 189 test: 190 if (type = comma) | (type = semi_colon) | (type = right_parn) then do; 191 sp = p; /* assign to parameter */ 192 193 if p -> symbol.varying then do; 194 p -> symbol.aligned = "1"b; 195 p -> symbol.unaligned = "0"b; 196 end; 197 198 return; 199 end; 200 if first_time then do; 201 first_time = "0"b; 202 if type = left_parn then 203 go to action (16); 204 end; 205 if type ^= identifier then 206 call print (7); 207 word = t_table.string; 208 letterx = binary (unspec (substr (word, 1, 1)), 9); 209 do i = index_given_letter (letterx) by 1 while (keyword (i) < word); 210 end; 211 212 if keyword (i) = word then do; 213 substr (string (p -> symbol.attributes), bit_index (i), 1) = "1"b; 214 k = k + 1; 215 type = t_table.type; 216 go to action (action_index (i)); 217 end; 218 219 call print (7); 220 action (1): 221 call print (8); 222 return; 223 action (2): /* get size of strings or areas */ 224 if type ^= left_parn then 225 go to test; 226 k = k + 1; 227 228 p -> symbol.dcl_size = refer_exp (); 229 if p -> symbol.dcl_size = null then 230 call print (12); 231 go to ck_parn; 232 action (3): /* get arithmetic precision */ 233 if type ^= left_parn then 234 go to test; 235 p -> symbol.precision = "1"b; 236 k = k + 1; 237 if constant_token (cblock, token_list (k), "777"b3, dec_integer) ^= dec_integer then 238 call print (15); 239 p -> symbol.c_dcl_size = token_to_binary (token_list (k)); 240 if p -> symbol.c_dcl_size = 0 then 241 call print (490); 242 k = k + 1; 243 if in_generic then 244 if t_table.type = colon then do; 245 k = k + 1; 246 if constant_token (cblock, token_list (k), "777"b3, dec_integer) ^= dec_integer then 247 call print (15); 248 p -> symbol.pic_size = token_to_binary (token_list (k)); 249 k = k + 1; 250 end; 251 else 252 p -> symbol.pic_size = p -> symbol.c_dcl_size; 253 if t_table.type = comma then do; 254 p -> symbol.scale = get_scale (); 255 p -> symbol.fixed = "1"b; 256 if in_generic then 257 if t_table.type = colon then 258 p -> symbol.pic_scale = get_scale (); 259 else 260 p -> symbol.pic_scale = p -> symbol.scale; 261 end; 262 go to ck_parn; 263 action (4): /* process the based attribute */ 264 if type ^= left_parn then 265 go to test; 266 k = k + 1; 267 p -> symbol.reference -> reference.qualifier = reference_parse (k, cblock); 268 if p -> symbol.reference -> reference.qualifier = null then 269 call print (18); 270 if p -> symbol.reference -> reference.qualifier -> node.type = token_node then 271 call context ((p -> symbol.reference -> reference.qualifier), cblock, pointer_context); 272 go to ck_parn; 273 action (5): /* process the offset attribute */ 274 if type ^= left_parn then 275 go to test; 276 k = k + 1; 277 p -> symbol.general = reference_parse (k, cblock); 278 if p -> symbol.general = null then 279 call print (17); 280 if p -> symbol.general -> node.type = token_node then 281 call context ((p -> symbol.general), cblock, area_context); 282 go to ck_parn; 283 action (6): /* process the picture attribute */ 284 if type ^= char_string then 285 go to test; 286 p -> symbol.general = token_list (k); 287 go to next; 288 action (7): /* process the position attribute */ 289 if type ^= left_parn then 290 go to test; 291 k = k + 1; 292 p -> symbol.initial = expression_parse (k, cblock); 293 if p -> symbol.initial = null then 294 call print (26); 295 go to ck_parn; 296 action (8): /* process the defined attribute */ 297 defined_parn = "0"b; 298 if type = left_parn then do; 299 defined_parn = "1"b; 300 k = k + 1; 301 end; 302 p -> symbol.equivalence = reference_parse (k, cblock); 303 if p -> symbol.equivalence = null then 304 call print (24); 305 if defined_parn then 306 go to ck_parn; 307 else 308 go to find_type; 309 action (9): /* process the initial attribute */ 310 if type ^= left_parn then 311 go to test; 312 if p -> symbol.initial ^= null then 313 call print (19); 314 p -> symbol.initial = initial_list (p); 315 if p -> symbol.initial = null then 316 call print (20); 317 go to find_type; 318 319 action (10): /* environment */ 320 if type ^= left_parn then 321 go to test; 322 k = k + 1; 323 if t_table.string = "interactive" then 324 p -> symbol.interactive = "1"b; 325 else if t_table.string = "stringvalue" then 326 p -> symbol.stringvalue = "1"b; 327 else 328 call print (193); 329 k = k + 1; 330 if pl1_stat_$check_ansi then 331 call parse_error (355, token_list (k - 3)); 332 go to ck_parn; 333 334 action (11): /* process the returns attribute */ 335 if type ^= left_parn then 336 go to test; 337 q = descriptor_parse (cblock, 338 create_token (p -> symbol.token -> t_table.string || "[return_value]", identifier), k); 339 if q ^= null then do; 340 if q -> list.element (2) ^= null then 341 call print (22); 342 p -> symbol.dcl_size, q = q -> list.element (1); 343 q -> symbol.passed_as_arg = "1"b; 344 end; 345 go to ck_parn; 346 347 action (12): /* process the entry attribute */ 348 if type ^= left_parn then 349 go to test; 350 p -> symbol.general = 351 descriptor_parse (cblock, create_token (p -> symbol.token -> t_table.string || "[param", identifier), k); 352 if p -> symbol.general = null then do; /* entry() -- add wart: a zero list node to prevent defaulting */ 353 /* this wart will be removed by validate after defaulting is complete */ 354 355 p -> symbol.general = create_list (0); 356 end; 357 go to ck_parn; 358 359 action (13): /* process the label attribute */ 360 if type ^= left_parn then 361 go to test; 362 363 call print (6); 364 365 nxt: 366 k = k + 1; 367 if t_table.type ^= identifier then 368 call print (21); 369 k = k + 1; 370 if t_table.type = comma then 371 go to nxt; 372 go to ck_parn; 373 374 action (14): /* process the like attribute */ 375 p -> symbol.general = reference_parse (k, cblock); 376 if p -> symbol.general = null then 377 call print (25); 378 cblock -> block.like_attribute = "1"b; 379 go to find_type; 380 action (15): /* process the generic attribute */ 381 if t_table.type ^= left_parn then 382 go to test; 383 q = null; 384 next_entry: 385 k = k + 1; 386 p1 = create_list (3); 387 p1 -> list.element (1) = reference_parse (k, cblock); 388 if p1 -> list.element (1) = null then 389 call print (13); 390 if t_table.string ^= "when" then 391 call print (13); 392 k = k + 1; 393 if t_table.type ^= left_parn then 394 call print (13); 395 p1 -> list.element (2) = descriptor_parse (null, null, k); 396 if t_table.type ^= right_parn then 397 call print (13); 398 k = k + 1; 399 p1 -> list.element (3) = null; 400 if q ^= null then 401 p2 -> list.element (3) = p1; 402 else 403 q = p1; 404 p2 = p1; 405 if t_table.type = comma then 406 go to next_entry; 407 p -> symbol.general = q; 408 go to ck_parn; 409 action (16): /* process the dimension attribute */ 410 if t_table.type ^= left_parn then 411 go to test; 412 p -> symbol.dimensioned = "1"b; 413 p -> symbol.array = create_array (); 414 ndims = 0; 415 next_b: 416 ndims = ndims + 1; 417 k = k + 1; 418 p1 = pl1_stat_$one; 419 p2 = refer_exp (); 420 if p2 = null then 421 call print (9); 422 if ^star then 423 if t_table.type = colon then do; 424 k = k + 1; 425 p1 = p2; 426 p2 = refer_exp (); 427 if p2 = null then 428 call print (9); 429 end; 430 else 431 ; 432 else 433 p1 = p2; 434 435 if ndims <= max_number_of_dimensions then do; 436 q = create_bound (); 437 q -> bound.next = p -> symbol.array -> array.bounds; 438 p -> symbol.array -> array.bounds = q; 439 q -> bound.lower = p1; 440 q -> bound.upper = p2; 441 end; 442 if t_table.type = comma then 443 go to next_b; 444 445 if ndims > max_number_of_dimensions then do; 446 call parse_error (372, p); 447 ndims = max_number_of_dimensions; 448 end; 449 p -> symbol.array -> array.own_number_of_dimensions = ndims; 450 if t_table.type ^= right_parn then 451 call print (10); 452 go to next; 453 454 action (17): /* options */ 455 if type ^= left_parn then 456 go to test; 457 k = k + 1; 458 if t_table.string = "variable" then 459 p -> symbol.variable_arg_list = "1"b; 460 else if t_table.string = "constant" then 461 p -> symbol.alloc_in_text = "1"b; 462 else if t_table.string = "packed" then 463 p -> symbol.explicit_packed = "1"b; 464 else 465 call print (192); 466 k = k + 1; 467 if pl1_stat_$check_ansi then 468 call parse_error (355, token_list (k - 3)); 469 go to ck_parn; 470 471 action (18): /* nonstandard attributes */ 472 if pl1_stat_$check_ansi then 473 call parse_error (354, token_list (k - 1)); 474 go to test; 475 476 /* Internal procedures */ 477 478 get_scale: 479 proc () returns (fixed bin (7) unaligned); 480 481 dcl temp fixed bin; 482 483 k = k + 1; 484 call defer_constant_token_list (cblock, (k), right_parn); 485 p1 = expression_parse (k, cblock); 486 if p1 = null then 487 call print (15); 488 if p1 -> node.type ^= token_node then 489 call print (15); 490 if p1 -> t_table.type ^= dec_integer then 491 call print (15); 492 temp = token_to_binary (p1); 493 494 /* This code yanked from validate.pl1. We have to test "temp" before it 495*gets stuffed into a fixed bin(7) variable upon returning. 496**/ 497 if temp < min_scale then do; 498 call parse_error (222, (p -> symbol.token)); 499 return (min_scale); 500 end; 501 else if temp > max_scale then do; 502 call parse_error (222, (p -> symbol.token)); 503 return (max_scale); 504 end; 505 506 return (temp); 507 508 end get_scale; 509 510 refer_exp: 511 proc () returns (ptr); 512 513 dcl (p1, p2) ptr; 514 515 star = "0"b; 516 if t_table.type = asterisk then do; 517 p1 = token_list (k); 518 star, p -> symbol.star_extents = "1"b; 519 k = k + 1; 520 go to exit; 521 end; 522 call defer_constant_token_list (cblock, (k), right_parn); 523 p1 = expression_parse (k, cblock); 524 if p1 = null then 525 go to fail; 526 if p1 -> node.type = token_node then 527 if p1 -> t_table.type ^= dec_integer then 528 p -> symbol.exp_extents = "1"b; 529 else 530 ; 531 else 532 p -> symbol.exp_extents = "1"b; 533 if t_table.string ^= "refer" then 534 go to exit; 535 k = k + 1; 536 p -> symbol.exp_extents, p -> symbol.refer_extents = "1"b; 537 if t_table.type ^= left_parn then 538 go to fail; 539 k = k + 1; 540 p2 = p1; 541 p1 = create_operator (refer, 2); 542 p1 -> operand (1) = p2; 543 p1 -> operand (2) = reference_parse (k, cblock); 544 if p1 -> operand (2) = null then 545 go to fail; 546 if p1 -> operand (2) -> node.type = reference_node then do; 547 if p1 -> operand (2) -> reference.qualifier ^= null then 548 call declare_parse$abort (138, (p1 -> operand (2))); 549 if p1 -> operand (2) -> reference.offset ^= null then 550 call declare_parse$abort (138, (p1 -> operand (2))); 551 end; 552 if t_table.type ^= right_parn then 553 go to fail; 554 k = k + 1; 555 556 exit: 557 return (p1); 558 fail: 559 return (null); 560 end; 561 562 initial_list: 563 proc (sym_ptr) returns (ptr); 564 565 dcl (ap, factor, value, p1, p2) ptr; 566 dcl something_parsed bit (1) aligned; 567 dcl sym_ptr ptr; 568 569 p2 = null; 570 do while ("1"b); 571 something_parsed = "0"b; 572 k = k + 1; 573 if t_table.type = left_parn then do; 574 k = k + 1; 575 if ^(sym_ptr -> symbol.ptr | sym_ptr -> symbol.offset | sym_ptr -> symbol.area 576 | sym_ptr -> symbol.label | sym_ptr -> symbol.entry | sym_ptr -> symbol.file) then 577 call defer_constant_token_list (cblock, (k), right_parn); 578 factor = expression_parse (k, cblock); 579 if factor = null then 580 go to fail; 581 if t_table.type ^= right_parn then 582 go to fail; 583 k = k + 1; 584 something_parsed = "1"b; 585 end; 586 else 587 factor = pl1_stat_$one; 588 if t_table.type = asterisk then do; 589 value = null; 590 k = k + 1; 591 end; 592 else do; 593 if t_table.type = left_parn then do; 594 if ^(sym_ptr -> symbol.ptr | sym_ptr -> symbol.offset | sym_ptr -> symbol.area 595 | sym_ptr -> symbol.label | sym_ptr -> symbol.entry | sym_ptr -> symbol.file) then 596 call defer_constant_token_list (cblock, (k), right_parn); 597 value = initial_list (sym_ptr); 598 if value = null then 599 go to fail; 600 end; 601 else if something_parsed & (t_table.type = right_parn | t_table.type = comma) then do; 602 value = factor; 603 factor = pl1_stat_$one; 604 end; 605 else do; 606 if ^(sym_ptr -> symbol.ptr | sym_ptr -> symbol.offset | sym_ptr -> symbol.area 607 | sym_ptr -> symbol.label | sym_ptr -> symbol.entry | sym_ptr -> symbol.file) then 608 call defer_constant_token_list (cblock, (k), right_parn); 609 value = expression_parse (k, cblock); 610 if value = null then 611 go to fail; 612 end; 613 end; 614 p1 = create_list (3); 615 p1 -> list.element (1) = factor; 616 p1 -> list.element (2) = value; 617 p1 -> list.element (3) = null; 618 if p2 = null then 619 ap = p1; 620 else 621 p2 -> list.element (3) = p1; 622 p2 = p1; 623 if t_table.type = right_parn then do; 624 k = k + 1; 625 return (ap); 626 end; 627 if t_table.type ^= comma then 628 go to fail; 629 end; 630 fail: 631 return (null); 632 end initial_list; 633 634 print: 635 proc (m); 636 637 dcl m fixed bin (15); 638 639 sp = p; /* assign to parameter */ 640 call declare_parse$abort (m, (p -> symbol.token)); 641 end print; 642 1 1 /* BEGIN INCLUDE FILE parse.incl.pl1 */ 1 2 1 3 1 4 /****^ HISTORY COMMENTS: 1 5* 1) change(91-01-09,Blackmore), approve(91-01-09,MCR8234), 1 6* audit(91-12-05,Huen), install(92-04-24,MR12.5-1011): 1 7* Change entry points for 'lex', 'lex$write_last_line', and 1 8* 'statement_type', for constant reference resolution fix. 1 9* END HISTORY COMMENTS */ 1 10 1 11 declare attribute_parse entry(ptr,ptr,fixed bin(15),bit(1) aligned); 1 12 /* parameter 1: (input) block node ptr */ 1 13 /* parameter 2: (input) symbol node ptr */ 1 14 /* parameter 3: (in/out) token index */ 1 15 /* parameter 4: (input) called while doing generic */ 1 16 1 17 declare context entry(ptr,ptr,fixed bin(15)); 1 18 /* parameter 1: (input) usually token node ptr */ 1 19 /* parameter 2: (input) block node ptr */ 1 20 /* parameter 3: (input) context type */ 1 21 1 22 declare data_list_parse entry(fixed bin(15),ptr,ptr) 1 23 returns(bit(1) aligned); 1 24 /* parameter 1: (in/out) token index */ 1 25 /* parameter 2: (input) block node ptr */ 1 26 /* parameter 3: (output) data list parse tree ptr */ 1 27 /* return: (output) valid parse bit */ 1 28 1 29 declare declare_label entry(ptr,ptr,ptr,bit(3) aligned); 1 30 /* parameter 1: (input) block node ptr */ 1 31 /* parameter 2: (input) statement node ptr */ 1 32 /* parameter 3: (input) label list ptr or null */ 1 33 /* parameter 4: (input) declare type */ 1 34 1 35 declare declare_parse entry(fixed bin(15),ptr,ptr); 1 36 /* parameter 1: (input) token index */ 1 37 /* parameter 2: (input) block node ptr */ 1 38 /* parameter 3: (input) label list ptr or null */ 1 39 1 40 declare declare_parse$abort entry(fixed bin(15),ptr); 1 41 /* parameter 1: (input) error number */ 1 42 /* parameter 2: (input) any node ptr */ 1 43 1 44 declare default_parse entry(fixed bin(15),ptr,ptr); 1 45 /* parameter 1: (input) token index */ 1 46 /* parameter 2: (input) block node ptr */ 1 47 /* parameter 3: (input) label list ptr or null */ 1 48 1 49 declare descriptor_parse entry(ptr,ptr,fixed bin(15)) 1 50 returns(ptr); 1 51 /* parameter 1: (input) block node ptr */ 1 52 /* parameter 2: (input) token node ptr or null */ 1 53 /* parameter 3: (in/out) token index */ 1 54 /* return: (output) symbol node ptr */ 1 55 1 56 declare do_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 57 bit(1) aligned,bit(1) aligned,bit(1) aligned); 1 58 /* parameter 1: (in/out) token index */ 1 59 /* parameter 2: (input) label list ptr or null */ 1 60 /* parameter 3: (input) conditions */ 1 61 /* parameter 4: (input) father block node ptr */ 1 62 /* parameter 5: (output) end ptr */ 1 63 /* parameter 6: (input) entry bit */ 1 64 /* parameter 7: (input) return bit */ 1 65 /* parameter 8: (input) iterative do bit */ 1 66 1 67 declare evaluate entry(bit(9) aligned,ptr,ptr) returns(ptr); 1 68 /* parameter 1: (input) opcode */ 1 69 /* parameter 2: (input) left operand (token ptr) */ 1 70 /* parameter 3: (input) right operand (token ptr) */ 1 71 /* return: (output) ptr to result node */ 1 72 1 73 declare expression_parse entry(fixed bin(15),ptr) 1 74 returns(ptr); 1 75 /* parameter 1: (in/out) token index */ 1 76 /* parameter 2: (input) block node ptr */ 1 77 /* return: (output) expression parse tree ptr */ 1 78 1 79 declare format_list_parse entry(fixed bin(15),ptr,ptr,ptr) 1 80 returns(bit(1) aligned); 1 81 /* parameter 1: (in/out) token index */ 1 82 /* parameter 2: (input) block node ptr */ 1 83 /* parameter 3: (input) statement node ptr */ 1 84 /* parameter 4: (output) format list parse tree ptr */ 1 85 /* return: (output) valid parse bit */ 1 86 1 87 declare if_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 88 bit(1) aligned); 1 89 /* parameter 1: (in/out) token index */ 1 90 /* parameter 2: (input) label list ptr or null */ 1 91 /* parameter 3: (input) conditions */ 1 92 /* parameter 4: (input) father block node ptr */ 1 93 /* parameter 5: (input) end ptr */ 1 94 /* parameter 6: (output) valid parse bit */ 1 95 1 96 declare io_statement_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 97 bit(1) aligned,bit(9) aligned); 1 98 /* parameter 1: (in/out) token index */ 1 99 /* parameter 2: (input) label list ptr or null */ 1 100 /* parameter 3: (input) conditions */ 1 101 /* parameter 4: (input) father block node ptr */ 1 102 /* parameter 5: (output) end ptr */ 1 103 /* parameter 6: (output) valid parse bit */ 1 104 /* parameter 7: (output) statement type */ 1 105 1 106 declare lex entry(ptr); 1 107 /* parameter 1: (input) block node ptr */ 1 108 1 109 declare lex$write_last_line entry(ptr); 1 110 /* parameter 1: (input) block node ptr */ 1 111 1 112 declare lex$initialize_lex entry(ptr,fixed bin(15)); 1 113 /* parameter 1: (input) ptr to source */ 1 114 /* parameter 2: (input) length of source (chars) */ 1 115 1 116 declare on_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr); 1 117 /* parameter 1: (in/out) token index */ 1 118 /* parameter 2: (input) label list ptr or null */ 1 119 /* parameter 3: (input) conditions */ 1 120 /* parameter 4: (input) father block node ptr */ 1 121 /* parameter 5: (output) end ptr (set to null) */ 1 122 1 123 declare on_parse$revert entry(fixed bin(15),ptr,ptr); 1 124 /* parameter 1: (input) token index */ 1 125 /* parameter 2: (input) statement node ptr */ 1 126 /* parameter 3: (input) block node ptr */ 1 127 1 128 declare parse entry(ptr,ptr,fixed bin(15)); 1 129 /* parameter 1: (output) root ptr */ 1 130 /* parameter 2 (input) source ptr */ 1 131 /* parameter 3: (input) source length */ 1 132 1 133 declare procedure_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr, 1 134 bit(9) aligned,bit(1) aligned); 1 135 /* parameter 1: (in/out) token index */ 1 136 /* parameter 2: (input) label list ptr or null */ 1 137 /* parameter 3: (input) conditions */ 1 138 /* parameter 4: (input) father block node ptr */ 1 139 /* parameter 5: (output) end ptr */ 1 140 /* parameter 6: (input) block type */ 1 141 /* parameter 7: (input) no return statement bit */ 1 142 1 143 declare process_entry entry(fixed bin(15),bit(9) aligned,ptr,ptr,bit(12) aligned); 1 144 /* parameter 1: (in/out) token index */ 1 145 /* parameter 2: (input) statement type */ 1 146 /* parameter 3: (input) block node ptr */ 1 147 /* parameter 4: (input) label list ptr or null */ 1 148 /* parameter 5: (input) conditions */ 1 149 1 150 declare reference_parse entry(fixed bin(15),ptr) 1 151 returns(ptr); 1 152 /* parameter 1: (in/out) token index */ 1 153 /* parameter 2: (input) block node ptr */ 1 154 /* return: (output) reference parse tree ptr */ 1 155 1 156 declare reserve$rename_parse entry(fixed bin(15)) returns(bit(1) aligned); 1 157 /* parameter 1: (in/out) token index */ 1 158 /* return: (output) success bit */ 1 159 1 160 declare statement_parse entry(fixed bin(15),ptr,bit(12) aligned,ptr,fixed bin(15)); 1 161 /* parameter 1: (in/out) token index */ 1 162 /* parameter 2: (input) label list ptr or null */ 1 163 /* parameter 3: (input) conditions */ 1 164 /* parameter 4: (input) block node ptr */ 1 165 /* parameter 5: (input) statement type */ 1 166 1 167 declare statement_type entry(ptr,fixed bin(15),ptr,bit(12) aligned) 1 168 returns(fixed bin(15)); 1 169 /* parameter 1: (input) block node ptr */ 1 170 /* parameter 2: (in/out) token index */ 1 171 /* parameter 3: (output) label list ptr or null */ 1 172 /* parameter 4: (output) conditions */ 1 173 /* return: (output) statement type */ 1 174 2 1 /****^ ********************************************************* 2 2* * * 2 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 2 4* * * 2 5* ********************************************************* */ 2 6 2 7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */ 2 8 2 9 2 10 /****^ HISTORY COMMENTS: 2 11* 1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu), 2 12* install(89-07-31,MR12.3-1066): 2 13* Removed the obsolete parameter source_line from the dcl of error_(). 2 14* END HISTORY COMMENTS */ 2 15 2 16 /* Modified: 6 Jun 1979 by PG to add rank and byte 2 17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 2 18* */ 2 19 2 20 declare adjust_count entry(pointer); 2 21 /* parameter 1: (input) any node pointer */ 2 22 2 23 declare bindec entry(fixed bin(31)) reducible 2 24 returns(character(12) aligned); 2 25 /* parameter 1: (input) bin value */ 2 26 /* return: (output) character value with blanks */ 2 27 2 28 declare bindec$vs entry(fixed bin(31)) reducible 2 29 returns(character(12) aligned varying); 2 30 /* parameter 1: (input) binary value */ 2 31 /* return: (output) char value without blanks */ 2 32 2 33 declare binoct entry(fixed bin(31)) reducible 2 34 returns(char(12) aligned); 2 35 /* parameter 1: (input) binary value */ 2 36 /* return: (output) char value with blanks */ 2 37 2 38 declare binary_to_octal_string entry(fixed bin(31)) reducible 2 39 returns(char(12) aligned); 2 40 /* parameter 1: (input) binary value */ 2 41 /* return: (output) right-aligned char value */ 2 42 2 43 declare binary_to_octal_var_string entry(fixed bin(31)) reducible 2 44 returns(char(12) varying aligned); 2 45 /* parameter 1: (input) binary value */ 2 46 /* returns: (output) char value without blanks */ 2 47 2 48 declare compare_expression entry(pointer,pointer) reducible 2 49 returns(bit(1) aligned); 2 50 /* parameter 1: (input) any node pointer */ 2 51 /* parameter 2: (input) any node pointer */ 2 52 /* return: (output) compare bit */ 2 53 2 54 declare constant_length entry (pointer, fixed bin (71)) 2 55 returns (bit (1) aligned); 2 56 /* parameter 1: (input) reference node pointer */ 2 57 /* parameter 2: (input) value of constant length */ 2 58 /* return: (output) "1"b if constant length */ 2 59 2 60 declare convert entry(pointer,bit(36) aligned) 2 61 returns(pointer); 2 62 /* parameter 1: (input) any node pointer */ 2 63 /* parameter 2: (input) target type */ 2 64 /* return: (output) target value tree pointer */ 2 65 2 66 declare convert$to_integer entry(pointer,bit(36)aligned) 2 67 returns(pointer); 2 68 /* parameter 1: (input) any node pointer */ 2 69 /* parameter 2: (input) target type */ 2 70 /* return: (output) target value tree pointer */ 2 71 2 72 declare convert$from_builtin entry(pointer,bit(36) aligned) 2 73 returns(pointer); 2 74 /* parameter 1: (input) any node pointer */ 2 75 /* parameter 2: (input) target type */ 2 76 /* return: (output) target value tree pointer */ 2 77 2 78 declare convert$validate entry(pointer,pointer); 2 79 /* parameter 1: (input) source value tree pointer */ 2 80 /* parameter 2: (input) target reference node pointer */ 2 81 2 82 declare convert$to_target_fb entry(pointer,pointer) 2 83 returns(pointer); 2 84 /* parameter 1: (input) source value tree pointer */ 2 85 /* parameter 2: (input) target reference node pointer */ 2 86 /* return: (output) target value tree pointer */ 2 87 2 88 declare convert$to_target entry(pointer,pointer) 2 89 returns(pointer); 2 90 /* parameter 1: (input) source value tree pointer */ 2 91 /* parameter 2: (input) target reference node pointer */ 2 92 /* return: (output) target value tree pointer */ 2 93 2 94 declare copy_expression entry(pointer unaligned) 2 95 returns(pointer); 2 96 /* parameter 1: (input) any node pointer */ 2 97 /* return: (output) any node pointer */ 2 98 2 99 declare copy_expression$copy_sons entry(pointer,pointer); 2 100 /* parameter 1: (input) father symbol node pointer */ 2 101 /* parameter 2: (input) stepfather symbol node ptr */ 2 102 2 103 declare copy_unique_expression entry(pointer) 2 104 returns(pointer); 2 105 /* parameter 1: (input) any node pointer */ 2 106 /* return: (output) any node pointer */ 2 107 2 108 declare create_array entry() 2 109 returns(pointer); 2 110 /* return: (output) array node pointer */ 2 111 2 112 declare create_block entry(bit(9) aligned,pointer) 2 113 returns(pointer); 2 114 /* parameter 1: (input) block type */ 2 115 /* parameter 2: (input) father block node pointer */ 2 116 /* return: (output) block node pointer */ 2 117 2 118 declare create_bound entry() 2 119 returns(pointer); 2 120 /* return: (output) bound node pointer */ 2 121 2 122 declare create_context entry(pointer,pointer) 2 123 returns(pointer); 2 124 /* parameter 1: (input) block node pointer */ 2 125 /* parameter 2: (input) token pointer */ 2 126 /* return: (output) context node pointer */ 2 127 2 128 declare create_cross_reference entry() 2 129 returns(pointer); 2 130 /* return: (output) cross reference node pointer */ 2 131 2 132 declare create_default entry 2 133 returns(pointer); 2 134 /* return: (output) default node pointer */ 2 135 2 136 declare create_identifier entry() 2 137 returns(pointer); 2 138 /* return: (output) token node pointer */ 2 139 2 140 declare create_label entry(pointer,pointer,bit(3) aligned) 2 141 returns(pointer); 2 142 /* parameter 1: (input) block node pointer */ 2 143 /* parameter 2: (input) token node pointer */ 2 144 /* parameter 3: (input) declare type */ 2 145 /* return: (output) label node pointer */ 2 146 2 147 declare create_list entry(fixed bin(15)) 2 148 returns(pointer); 2 149 /* parameter 1: (input) number of list elements */ 2 150 /* return: (output) list node pointer */ 2 151 2 152 declare create_operator entry(bit(9) aligned,fixed bin(15)) 2 153 returns(pointer); 2 154 /* parameter 1: (input) operator type */ 2 155 /* parameter 2: (input) number of operands */ 2 156 /* return: (output) operator node pointer */ 2 157 2 158 declare create_reference entry(pointer) 2 159 returns(pointer); 2 160 /* parameter 1: (input) symbol node pointer */ 2 161 /* return: (output) reference node pointer */ 2 162 2 163 declare create_statement entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 2 164 returns(pointer); 2 165 /* parameter 1: (input) statement type */ 2 166 /* parameter 2: (input) block node pointer */ 2 167 /* parameter 3: (input) label node pointer */ 2 168 /* parameter 4: (input) conditions */ 2 169 /* return: (output) statement node pointer */ 2 170 2 171 declare create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 2 172 returns(pointer); 2 173 /* parameter 1: (input) statement type */ 2 174 /* parameter 2: (input) block node pointer */ 2 175 /* parameter 3: (input) label node pointer */ 2 176 /* parameter 4: (input) conditions */ 2 177 /* return: (output) statement node pointer */ 2 178 2 179 declare create_storage entry(fixed bin(15)) 2 180 returns(pointer); 2 181 /* parameter 1: (input) number of words */ 2 182 /* return: (output) storage block pointer */ 2 183 2 184 declare create_symbol entry(pointer,pointer,bit(3) aligned) 2 185 returns(pointer); 2 186 /* parameter 1: (input) block node pointer */ 2 187 /* parameter 2: (input) token node pointer */ 2 188 /* parameter 3: (input) declare type */ 2 189 /* return: (output) symbol node pointer */ 2 190 2 191 declare create_token entry (character (*), bit (9) aligned) 2 192 returns (ptr); 2 193 /* parameter 1: (input) token string */ 2 194 /* parameter 2: (input) token type */ 2 195 /* return: (output) token node ptr */ 2 196 2 197 declare create_token$init_hash_table entry (); 2 198 2 199 declare create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned) 2 200 returns (ptr); 2 201 /* parameter 1: (input) token string */ 2 202 /* parameter 2: (input) token type */ 2 203 /* parameter 3: (input) protected flag */ 2 204 /* return: (output) token node ptr */ 2 205 2 206 declare decbin entry(character(*) aligned) reducible 2 207 returns(fixed bin(31)); 2 208 /* parameter 1: (input) decimal character string */ 2 209 /* return: (output) binary value */ 2 210 2 211 declare declare_constant entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15)) 2 212 returns(pointer); 2 213 /* parameter 1: (input) value */ 2 214 /* parameter 2: (input) type */ 2 215 /* parameter 3: (input) size */ 2 216 /* parameter 4: (input) scale */ 2 217 /* return: (output) reference node pointer */ 2 218 2 219 declare declare_constant$bit entry(bit(*) aligned) 2 220 returns(pointer); 2 221 /* parameter 1: (input) bit */ 2 222 /* return: (output) reference node pointer */ 2 223 2 224 declare declare_constant$char entry(character(*) aligned) 2 225 returns(pointer); 2 226 /* parameter 1: (input) character */ 2 227 /* return: (output) reference node pointer */ 2 228 2 229 declare declare_constant$desc entry(bit(*) aligned) 2 230 returns(pointer); 2 231 /* parameter 1: (input) descriptor bit value */ 2 232 /* return: (output) reference node pointer */ 2 233 2 234 declare declare_constant$integer entry(fixed bin(31)) /* note...should really be fixed bin(24) */ 2 235 returns(pointer); 2 236 /* parameter 1: (input) integer */ 2 237 /* return: (output) reference node pointer */ 2 238 2 239 declare declare_descriptor entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 240 returns(pointer); 2 241 /* parameter 1: (input) block node pointer */ 2 242 /* parameter 2: (input) statement node pointer */ 2 243 /* parameter 3: (input) symbol node pointer */ 2 244 /* parameter 4: (input) loc pointer */ 2 245 /* parameter 5: (input) array descriptor bit 2 246* cross_section bit */ 2 247 /* return: (output) reference node pointer */ 2 248 2 249 declare declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 250 returns(pointer); 2 251 /* parameter 1: (input) block node pointer */ 2 252 /* parameter 2: (input) statement node pointer */ 2 253 /* parameter 3: (input) symbol node pointer */ 2 254 /* parameter 4: (input) loc pointer */ 2 255 /* parameter 5: (input) array descriptor bit 2 256* cross_section bit */ 2 257 /* return: (output) reference node pointer */ 2 258 2 259 declare declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 260 returns(pointer); 2 261 /* parameter 1: (input) block node pointer */ 2 262 /* parameter 2: (input) statement node pointer */ 2 263 /* parameter 3: (input) symbol node pointer */ 2 264 /* parameter 4: (input) loc pointer */ 2 265 /* parameter 5: (input) array descriptor bit 2 266* cross_section bit */ 2 267 /* return: (output) reference node pointer */ 2 268 2 269 declare declare_integer entry(pointer) 2 270 returns(pointer); 2 271 /* parameter 1: (input) block node pointer */ 2 272 /* return: (output) reference node pointer */ 2 273 2 274 declare declare_picture entry(char(*)aligned,pointer,fixed bin(15)); 2 275 /* parameter 1: (input) picture string */ 2 276 /* parameter 2: (input) symbol node pointer */ 2 277 /* parameter 3: (output) error code, if any */ 2 278 2 279 declare declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned) 2 280 returns(pointer); 2 281 /* parameter 1: (input) picture string */ 2 282 /* parameter 2: (input) scalefactor of picture */ 2 283 /* parameter 3: (input) ="1"b => complex picture */ 2 284 /* parameter 4: (input) ="1"b => unaligned temp */ 2 285 /* return: (output) reference node pointer */ 2 286 2 287 declare declare_pointer entry(pointer) 2 288 returns(pointer); 2 289 /* parameter 1: (input) block node pointer */ 2 290 /* return: (output) reference node pointer */ 2 291 2 292 declare declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer) 2 293 returns(pointer); 2 294 /* parameter 1: (input) type */ 2 295 /* parameter 2: (input) precision */ 2 296 /* parameter 3: (input) scale */ 2 297 /* parameter 4: (input) length */ 2 298 /* return: (output) reference node pointer */ 2 299 2 300 declare decode_node_id entry(pointer,bit(1) aligned) 2 301 returns(char(120) varying); 2 302 /* parameter 1: (input) node pointer */ 2 303 /* parameter 2: (input) ="1"b => capitals */ 2 304 /* return: (output) source line id */ 2 305 2 306 declare decode_source_id entry( 3 1 1 structure unaligned, 3 2 2 /* file_number */ bit(8), 3 3 2 /* line_number */ bit(14), 3 4 2 /* stmt_number */ bit(5), 2 307 2 308 bit(1) aligned) 2 309 returns(char(120) varying); 2 310 /* parameter 1: (input) source id */ 2 311 /* parameter 2: (input) ="1"b => capitals */ 2 312 /* return: (output) source line id */ 2 313 2 314 declare error entry(fixed bin(15),pointer,pointer); 2 315 /* parameter 1: (input) error number */ 2 316 /* parameter 2: (input) statement node pointer or null*/ 2 317 /* parameter 3: (input) token node pointer */ 2 318 2 319 declare error$omit_text entry(fixed bin(15),pointer,pointer); 2 320 /* parameter 1: (input) error number */ 2 321 /* parameter 2: (input) statement node pointer or null*/ 2 322 /* parameter 3: (input) token node pointer */ 2 323 2 324 declare error_ entry(fixed bin(15), 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), 2 325 2 326 pointer,fixed bin(8),fixed bin(23),fixed bin(11)); 2 327 /* parameter 1: (input) error number */ 2 328 /* parameter 2: (input) statement id */ 2 329 /* parameter 3: (input) any node pointer */ 2 330 /* parameter 4: (input) source segment */ 2 331 /* parameter 5: (input) source starting character */ 2 332 /* parameter 6: (input) source length */ 2 333 2 334 declare error_$no_text 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), 2 335 2 336 pointer); 2 337 /* parameter 1: (input) error number */ 2 338 /* parameter 2: (input) statement id */ 2 339 /* parameter 3: (input) any node pointer */ 2 340 2 341 declare error_$initialize_error entry(); 2 342 2 343 declare error_$finish entry(); 2 344 2 345 declare free_node entry(pointer); 2 346 /* parameter 1: any node pointer */ 2 347 2 348 declare get_array_size entry(pointer,fixed bin(3)); 2 349 /* parameter 1: (input) symbol node pointer */ 2 350 /* parameter 2: (input) units */ 2 351 2 352 declare get_size entry(pointer); 2 353 /* parameter 1: (input) symbol node pointer */ 2 354 2 355 declare merge_attributes external entry(pointer,pointer) 2 356 returns(bit(1) aligned); 2 357 /* parameter 1: (input) target symbol node pointer */ 2 358 /* parameter 2: (input) source symbol node pointer */ 2 359 /* return: (output) "1"b if merge was unsuccessful */ 2 360 2 361 declare optimizer entry(pointer); 2 362 /* parameter 1: (input) root pointer */ 2 363 2 364 declare parse_error entry(fixed bin(15),pointer); 2 365 /* parameter 1: (input) error number */ 2 366 /* parameter 2: (input) any node pointer */ 2 367 2 368 declare parse_error$no_text entry(fixed bin(15),pointer); 2 369 /* parameter 1: (input) error number */ 2 370 /* parameter 2: (input) any node pointer */ 2 371 2 372 declare pl1_error_print$write_out 2 373 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), 2 374 2 375 pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15)); 2 376 /* parameter 1: (input) error number */ 2 377 /* parameter 2: (input) statement identification */ 2 378 /* parameter 3: (input) any node pointer */ 2 379 /* parameter 4: (input) source segment */ 2 380 /* parameter 5: (input) source character index */ 2 381 /* parameter 6: (input) source length */ 2 382 /* parameter 7: (input) source line */ 2 383 2 384 declare pl1_error_print$listing_segment 2 385 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), 2 386 2 387 pointer); 2 388 /* parameter 1: (input) error number */ 2 389 /* parameter 2: (input) statement identification */ 2 390 /* parameter 3: (input) token node pointer */ 2 391 2 392 declare pl1_print$varying entry(character(*) aligned varying); 2 393 /* parameter 1: (input) string */ 2 394 2 395 declare pl1_print$varying_nl entry(character(*) aligned varying); 2 396 /* parameter 1: (input) string */ 2 397 2 398 declare pl1_print$non_varying entry(character(*) aligned,fixed bin(31)); 2 399 /* parameter 1: (input) string */ 2 400 /* parameter 2: (input) string length or 0 */ 2 401 2 402 declare pl1_print$non_varying_nl entry(character(*) aligned,fixed bin(31)); 2 403 /* parameter 1: (input) string */ 2 404 /* parameter 2: (input) string length or 0 */ 2 405 2 406 declare pl1_print$string_pointer entry(pointer,fixed bin(31)); 2 407 /* parameter 1: (input) string pointer */ 2 408 /* parameter 2: (input) string size */ 2 409 2 410 declare pl1_print$string_pointer_nl entry(pointer,fixed bin(31)); 2 411 /* parameter 1: (input) string pointer */ 2 412 /* parameter 2: (input) string length or 0 */ 2 413 2 414 declare pl1_print$unaligned_nl entry(character(*) unaligned,fixed bin(31)); 2 415 /* parameter 1: (input) string */ 2 416 /* parameter 2: (input) length */ 2 417 2 418 declare pl1_print$for_lex entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned); 2 419 /* parameter 1: (input) ptr to base of source segment */ 2 420 /* parameter 2: (input) line number */ 2 421 /* parameter 3: (input) starting offset in source seg */ 2 422 /* parameter 4: (input) number of chars to copy */ 2 423 /* parameter 5: (input) ON iff shd print line number */ 2 424 /* parameter 6: (input) ON iff line begins in comment */ 2 425 2 426 declare refer_extent entry(pointer,pointer); 2 427 /* parameter 1: (input/output) null,ref node,op node pointer */ 2 428 /* parameter 2: (input) null,ref node,op node pointer */ 2 429 2 430 declare reserve$clear entry() 2 431 returns(pointer); 2 432 /* return: (output) pointer */ 2 433 2 434 declare reserve$declare_lib entry(fixed bin(15)) 2 435 returns(pointer); 2 436 /* parameter 1: (input) builtin function number */ 2 437 /* return: (output) pointer */ 2 438 2 439 declare reserve$read_lib entry(fixed bin(15)) 2 440 returns(pointer); 2 441 /* parameter 1: (input) builtin function number */ 2 442 /* return: (output) pointer */ 2 443 2 444 declare semantic_translator entry(); 2 445 2 446 declare semantic_translator$abort entry(fixed bin(15),pointer); 2 447 /* parameter 1: (input) error number */ 2 448 /* parameter 2: (input) any node pointer */ 2 449 2 450 declare semantic_translator$error entry(fixed bin(15),pointer); 2 451 /* parameter 1: (input) error number */ 2 452 /* parameter 2: (input) any node pointer */ 2 453 2 454 declare share_expression entry(ptr) 2 455 returns(ptr); 2 456 /* parameter 1: (input) usually operator node pointer */ 2 457 /* return: (output) tree pointer or null */ 2 458 2 459 declare token_to_binary entry(ptr) reducible 2 460 returns(fixed bin(31)); 2 461 /* parameter 1: (input) token node pointer */ 2 462 /* return: (output) converted binary value */ 2 463 2 464 /* END INCLUDE FILE ... language_utility.incl.pl1 */ 1 175 1 176 /* END INCLUDE FILE parse.incl.pl1 */ 643 644 8 1 dcl 1 array based aligned, 8 2 2 node_type bit(9) unaligned, 8 3 2 reserved bit(34) unaligned, 8 4 2 number_of_dimensions fixed(7) unaligned, 8 5 2 own_number_of_dimensions fixed(7) unaligned, 8 6 2 element_boundary fixed(3) unaligned, 8 7 2 size_units fixed(3) unaligned, 8 8 2 offset_units fixed(3) unaligned, 8 9 2 interleaved bit(1) unaligned, 8 10 2 c_element_size fixed(24), 8 11 2 c_element_size_bits fixed(24), 8 12 2 c_virtual_origin fixed(24), 8 13 2 element_size ptr unaligned, 8 14 2 element_size_bits ptr unaligned, 8 15 2 virtual_origin ptr unaligned, 8 16 2 symtab_virtual_origin ptr unaligned, 8 17 2 symtab_element_size ptr unaligned, 8 18 2 bounds ptr unaligned, 8 19 2 element_descriptor ptr unaligned; 8 20 8 21 dcl 1 bound based aligned, 8 22 2 node_type bit(9), 8 23 2 c_lower fixed(24), 8 24 2 c_upper fixed(24), 8 25 2 c_multiplier fixed(24), 8 26 2 c_desc_multiplier fixed(24), 8 27 2 lower ptr unaligned, 8 28 2 upper ptr unaligned, 8 29 2 multiplier ptr unaligned, 8 30 2 desc_multiplier ptr unaligned, 8 31 2 symtab_lower ptr unaligned, 8 32 2 symtab_upper ptr unaligned, 8 33 2 symtab_multiplier ptr unaligned, 8 34 2 next ptr unaligned; 645 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 */ 646 10 1 dcl ( pointer_context initial(6), 10 2 area_context initial(8), 10 3 file_name_context initial(11), 10 4 condition_context initial(15), 10 5 parameter_context initial(20)) fixed bin(15) internal static options(constant); 647 11 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 11 2 11 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 11 4 11 5 11 6 dcl 1 list based aligned, 11 7 2 node_type bit(9) unaligned, 11 8 2 reserved bit(12) unaligned, 11 9 2 number fixed(14) unaligned, 11 10 2 element dimension(n refer(list.number)) ptr unaligned; 11 11 11 12 dcl max_list_elements fixed bin(17) internal static options (constant) 11 13 init(16383); 11 14 11 15 /* END INCLUDE FILE ... list.incl.pl1 */ 648 12 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 12 2 12 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 12 4 12 5 dcl ( block_node initial("000000001"b), 12 6 statement_node initial("000000010"b), 12 7 operator_node initial("000000011"b), 12 8 reference_node initial("000000100"b), 12 9 token_node initial("000000101"b), 12 10 symbol_node initial("000000110"b), 12 11 context_node initial("000000111"b), 12 12 array_node initial("000001000"b), 12 13 bound_node initial("000001001"b), 12 14 format_value_node initial("000001010"b), 12 15 list_node initial("000001011"b), 12 16 default_node initial("000001100"b), 12 17 machine_state_node initial("000001101"b), 12 18 source_node initial("000001110"b), 12 19 label_node initial("000001111"b), 12 20 cross_reference_node initial("000010000"b), 12 21 sf_par_node initial("000010001"b), 12 22 temporary_node initial("000010010"b), 12 23 label_array_element_node initial("000010011"b), 12 24 by_name_agg_node initial("000010100"b)) 12 25 bit(9) internal static aligned options(constant); 12 26 12 27 dcl 1 node based aligned, 12 28 2 type unal bit(9), 12 29 2 source_id unal structure, 12 30 3 file_number bit(8), 12 31 3 line_number bit(14), 12 32 3 statement_number bit(5); 12 33 12 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 649 13 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 13 2 13 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 13 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 13 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 13 6 /* Modified: 26 July 82 BIM wordno, segno */ 13 7 13 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 13 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 13 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 13 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 13 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 13 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 13 14 13 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 13 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 13 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 13 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 13 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 13 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 13 21 13 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 13 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 13 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 13 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 13 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 13 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 13 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 13 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 13 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 13 31 13 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 13 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 13 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 13 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 13 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 13 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 13 38 13 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 13 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 13 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 13 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 13 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 13 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 13 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 13 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 13 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 13 48 13 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 13 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 13 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 13 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 13 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 13 54 return_string initial("001100110"b), /* return string opnd(1) */ 13 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 13 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 13 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 13 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 13 59 std_return initial("001101011"b), /* return -no arguments- */ 13 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 13 61 free_ctl initial("001101101"b), /* free opnd(1) */ 13 62 stop initial("001101110"b), /* stop - terminate run unit */ 13 63 13 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 13 65* opnd(2) <- opnd(3) / 36 */ 13 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 13 67* opnd(2) <- opnd(3) / 4 */ 13 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 13 69* opnd(2) <- opnd(3) / 2 */ 13 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 13 71 13 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 13 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 13 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 13 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 13 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 13 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 13 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 13 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 13 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 13 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 13 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 13 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 13 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 13 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 13 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 13 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 13 88 13 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 13 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 13 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 13 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 13 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 13 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 13 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 13 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 13 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 13 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 13 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 13 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 13 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 13 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 13 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 13 104 13 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 13 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 13 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 13 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 13 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 13 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 13 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 13 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 13 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 13 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 13 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 13 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 13 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 13 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 13 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 13 120 13 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 13 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 13 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 13 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 13 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 13 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 13 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 13 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 13 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 13 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 13 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 13 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 13 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 13 134 13 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 13 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 13 137 13 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 13 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 13 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 13 141* opnd(2) is the file name 13 142* opnd(3) is the block */ 13 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 13 144* opnd(2) is the file name */ 13 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 13 146* opnd(2) is the file name */ 13 147 13 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 13 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 13 150* opnd(3) is old value, (4) is new value. */ 13 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 13 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 13 153 13 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 13 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 13 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 13 157* opnd(5) is the list */ 13 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 13 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 13 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 13 161 13 162 r_parn initial("011110001"b), /* format op code */ 13 163 l_parn initial("011110010"b), 13 164 r_format initial("011110011"b), 13 165 c_format initial("011110100"b), 13 166 f_format initial("011110101"b), 13 167 e_format initial("011110110"b), 13 168 b_format initial("011110111"b), 13 169 a_format initial("011111000"b), 13 170 x_format initial("011111001"b), 13 171 skip_format initial("011111010"b), 13 172 column_format initial("011111011"b), 13 173 page_format initial("011111100"b), 13 174 line_format initial("011111101"b), 13 175 picture_format initial("011111110"b), 13 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 13 177 13 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 13 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 13 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 13 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 13 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 13 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 13 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 13 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 13 186 record_io initial("100001000"b), /* perform record io operation */ 13 187 fortran_read initial("100001001"b), /* A complete read statement */ 13 188 fortran_write initial("100001010"b), /* A complete write statement */ 13 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 13 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 13 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 13 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 13 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 13 194 13 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 13 196 /* They are processed by the semantic translator. */ 13 197 13 198 return_value initial("100010010"b), /* return(opnd(1)) */ 13 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 13 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 13 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 13 202 /* opnd(3) is skip, opnd(4) is list */ 13 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 13 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 13 205 /* opnd(3) is skip,opnd(4) is line */ 13 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 13 207 open_file initial("100011001"b), 13 208 close_file initial("100011010"b), 13 209 read_file initial("100011011"b), 13 210 write_file initial("100011100"b), 13 211 locate_file initial("100011101"b), 13 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 13 213 /* opnd(2) is control variable ref */ 13 214 /* opnd(3) is specification operator */ 13 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 13 216 /* repeat opnd(4) while opnd(5) */ 13 217 /* opnd(6) is next specification */ 13 218 13 219 rewrite_file initial("100100000"b), 13 220 delete_file initial("100100001"b), 13 221 unlock_file initial("100100010"b), 13 222 lock_file initial("100100011"b), 13 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 13 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 13 225 nop initial("100100111"b), /* no-op */ 13 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 13 227 13 228 /* These operators are produced by the semantic translator in processing the math 13 229* builtin functions and are used as input to the code generator */ 13 230 13 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 13 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 13 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 13 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 13 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 13 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 13 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 13 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 13 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 13 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 13 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 13 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 13 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 13 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 13 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 13 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 13 247 13 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 13 249 13 250 bit(9) aligned internal static options(constant); 13 251 13 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 650 14 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 14 2 14 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 14 4 14 5 /* format: style3 */ 14 6 dcl 1 operator based aligned, 14 7 2 node_type bit (9) unaligned, 14 8 2 op_code bit (9) unaligned, 14 9 2 shared bit (1) unaligned, 14 10 2 processed bit (1) unaligned, 14 11 2 optimized bit (1) unaligned, 14 12 2 number fixed (14) unaligned, 14 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 14 14 14 15 dcl max_number_of_operands 14 16 fixed bin (15) int static options (constant) initial (32767); 14 17 14 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 651 15 1 /* BEGIN INCLUDE FILE ... pl1_attribute_table.incl.pl1 */ 15 2 15 3 /* Modified 780628 by PG for unsigned */ 15 4 /* Modified 830426 by BIM for options (packed) on pointers */ 15 5 15 6 dcl index_given_letter (97:122) fixed bin (8) unal internal static 15 7 initial (1, 5, 10, 19, 26, 31, 35, 83, 36, 83, 43, /* A-K */ 15 8 44, 47, 48, 50, 53, 83, 64, 69, 83, 75, 80, (4)83); /* L-Z */ 15 9 15 10 dcl keyword (83) char (11) aligned internal static initial ( 15 11 "aligned", "area", "auto", "automatic", "based", "bin", 15 12 "binary", "bit", "builtin", "char", "character", "complex", 15 13 "cond", "condition", "constant", "controlled", "cplx", "ctl", 15 14 "dec", "decimal", "def", "defined", "dim", "dimension", 15 15 "direct", "entry", "env", "environment", "ext", "external", 15 16 "file", "fixed", "float", "format", "generic", "init", 15 17 "initial", "input", "int", "internal", "irred", "irreducible", 15 18 "keyed", "label", "like", "local", "member", "nonvar", 15 19 "nonvarying", "offset", "options", "output", "parameter", "parm", 15 20 "pic", "picture", "pointer", "pos", "position", "prec", 15 21 "precision", "print", "ptr", "real", "record", "red", 15 22 "reducible", "returns", "seql", "sequential", "signed", "static", 15 23 "stream", "structure", "unal", "unaligned", "uns", "unsigned", 15 24 "update", "var", "variable", "varying", "~"); 15 25 15 26 dcl system_keyword (15) char (16) aligned internal static initial ( 15 27 "aliasable", "arg-descriptor", "interactive", "options-constant", 15 28 "options-variable", "parameter-desc", "reserved-1", "reserved-2", 15 29 "reserved-3", "reserved-4", "return-value", "stringvalue", 15 30 "storage-block", "temporary", "options-packed"); 15 31 15 32 dcl bit_index (82) fixed bin (8) unal internal static initial ( 15 33 22, /* aligned */ 8, /* area */ 46, /* auto */ 46, /* automatic */ 47, /* based */ 30, /* bin */ 15 34 30, /* binary */ 4, /* bit */ 17, /* builtin */ 5, /* char */ 5, /* character */ 32, /* complex */ 15 35 15, /* cond */ 15, /* condition */ 53, /* constant */ 49, /* controlled */ 32, /* cplx */ 49, /* ctl */ 15 36 29, /* dec */ 29, /* decimal */ 50, /* def */ 50, /* defined */ 20, /* dim */ 20, /* dimension */ 15 37 64, /* direct */ 10, /* entry */ 71, /* env */ 71, /* environment */ 39, /* ext */ 39, /* external */ 15 38 11, /* file */ 2, /* fixed */ 3, /* float */ 16, /* format */ 18, /* generic */ 21, /* init */ 15 39 21, /* initial */ 57, /* input */ 38, /* int */ 38, /* internal */ 35, /* irred */ 35, /* irreducible */ 15 40 69, /* keyed */ 9, /* label */ 40, /* like */ 28, /* local */ 41, /* member */ 42, /* nonvar */ 15 41 42, /* nonvarying */ 7, /* offset */ 43, /* options */ 58, /* output */ 51, /* parameter */ 51, /* parm */ 15 42 19, /* pic */ 19, /* picture */ 6, /* pointer */ 37, /* pos */ 37, /* position */ 26, /* prec */ 15 43 26, /* precision */ 56, /* print */ 6, /* ptr */ 31, /* real */ 62, /* record */ 34, /* red */ 15 44 34, /* reducible */ 36, /* returns */ 63, /* seql */ 63, /* sequential */ 24, /* signed */ 48, /* static */ 15 45 60, /* stream */ 1, /* structure */ 23, /* unal */ 23, /* unaligned */ 25, /* uns */ 25, /* unsigned */ 15 46 59, /* update */ 27, /* var */ 33, /* variable */ 27 /* varying */); 15 47 15 48 dcl system_bit_index (15) fixed bin (8) unal internal static initial ( 15 49 72, /* aliasable */ 12, /* arg-descriptor */ 65, /* env(interactive) */ 15 50 45, /* options(constant) */ 44, /* options(variable) */ 52, /* param-desc */ 15 51 61, /* reserved-1 */ 66, /* reserved-2 */ 67, /* reserved-3 */ 15 52 70, /* reserved-4 */ 55, /* return-value */ 68, /* env(stringvalue) */ 15 53 13, /* storage-block */ 54, /* temporary */ 14 /* options-variable */); 15 54 15 55 dcl incompatable (72) bit (72) aligned internal static initial ( 15 56 /* 111111111122222222223333333333444444444455555555556666666666777 15 57* 123456789012345678901234567890123456789012345678901234567890123456789012 15 58* ------------------------------------------------------------------------ */ 15 59 "011111111111101111101001111111110111000001010000000010011111011110011010"b, /* 1 structure */ 15 60 "101111111111101111100000001100000111100101010000000000011111011110011010"b, /* 2 fixed */ 15 61 "110111111111101111100000101100000111100101010000000000011111011110011010"b, /* 3 float */ 15 62 "111011111111101111100001110111110111000100010000000000011111011110011010"b, /* 4 bit */ 15 63 "111101111111101111100001110111110111000100010000000000011111011110011010"b, /* 5 character */ 15 64 "111110111111101111100001111111110111100101010000000010011111011110011010"b, /* 6 ptr */ 15 65 "111111011111101111100001111111110111100101010000000010011111011110011010"b, /* 7 offset */ 15 66 "111111101111101111100001111111110111100101010000000010011111011110011010"b, /* 8 area */ 15 67 "111111110111101111100001111011110111100101010000000000011111011110011010"b, /* 9 label */ 15 68 "111111111011101111100001111111110000100101000000000000011111011110011010"b, /* 10 entry */ 15 69 "111111111101101111100001111111110111100101010000000000000000000000000000"b, /* 11 file */ 15 70 "111111111110101111111111111111111111111111111111111101111111011110011010"b, /* 12 arg-descriptor */ 15 71 "111111111111001111111111111111111111111111111111111101111111011110011010"b, /* 13 storage-block */ 15 72 "111110111111101111100001111111110111100101010000000010011111011110011010"b, /* 14 options-packed */ 15 73 "111111111111100111111111111111111111110111111111111111111111011110011010"b, /* 15 condition */ 15 74 "111111111111101011100001111011110111100101010000000000011111011110011010"b, /* 16 format */ 15 75 "111111111111101101111111111111111111101111111111111111111111011110011010"b, /* 17 builtin */ 15 76 "111111111111101110111111111111111111101111111111111111111111011110011010"b, /* 18 generic */ 15 77 "111111111111101111000001111111000111000101010000000010011111011110011010"b, /* 19 picture */ 15 78 "000000000001101011000000000000000000000000000000000000011111011110011010"b, /* 20 dimension */ 15 79 "100000000001101011000000000000000000100100000000011111111111011110011010"b, /* 21 initial */ 15 80 "000000000001101011000010000000000000000000000000000010011111011110011010"b, /* 22 aligned */ 15 81 "000000000001101011000100000000000000000000000000000010011111011110011010"b, /* 23 unaligned */ 15 82 "100111111111101111100000101100000111100101010000000000011111011110011010"b, /* 24 signed */ 15 83 "101111111111101111100001001110010111100101010000000000011111011110011010"b, /* 25 unsigned */ 15 84 "100111111111101111100000001100000111100101010000000000011111011110011010"b, /* 26 precision */ 15 85 "111001111111101111100001110111110111100101010000000010011111011110011010"b, /* 27 varying */ 15 86 "111111110111101011100001111011110111100101010000000010011111011110011010"b, /* 28 local */ 15 87 "100111111111101111100000101101000111100101010000000000011111011110011010"b, /* 29 decimal */ 15 88 "100111111111101111100000001110000111100101010000000000011111011110011010"b, /* 30 binary */ 15 89 "100111111111101111000000001100010111100101010000000000011111011110011010"b, /* 31 real */ 15 90 "100111111111101111000000101100100111100101010000000000011111011110011010"b, /* 32 cplx */ 15 91 "000000000001101011000000000000000000000000000000000110011111011110011010"b, /* 33 variable */ 15 92 "111111111011101111100001111111110010100101000000000000011111011110011010"b, /* 34 reducible */ 15 93 "111111111011101111100001111111110100100101000000000000011111011110011010"b, /* 35 irreducible */ 15 94 "111111111011101111100001111111110000100101000000000000011111011110011010"b, /* 36 returns */ 15 95 "011001111111101111001001111111110111001010111111101111111111011110011010"b, /* 37 position */ 15 96 "000000000001101000000000000000000000001000000000000100000000000000000000"b, /* 38 internal */ 15 97 "000000000001100011000000000000000000110010001110011101100000000000000000"b, /* 39 external */ 15 98 "011111111111101111101001111111110111000001010000000010011111011110011010"b, /* 40 like */ 15 99 "000000000001101011000000000000000000101000001111111011111111011110011010"b, /* 41 member */ 15 100 "111001111111101111100001111111110111000100010000000010011111011110011010"b, /* 42 nonvarying */ 15 101 "000000000001101011000000000000000000100000000000000000011111011110011010"b, /* 43 options */ 15 102 "111111111011101111100001111111110000100101000000000000011111011110011010"b, /* 44 options-variable */ 15 103 "000000000001101011000000000000000000101010000110111111111111011110011010"b, /* 45 options-constant */ 15 104 "000000000001101011000000000000000000101010001011111111111111011110011010"b, /* 46 automatic */ 15 105 "000000000001101011000000000000000000101010001101111111111111011110011010"b, /* 47 based */ 15 106 "000000000001101011000000000000000000100010000110111111111111011110011010"b, /* 48 static */ 15 107 "000000000001101011000000000000000000100010001111011111111111011110011010"b, /* 49 ctl */ 15 108 "000000000001101011001000000000000000001010001111101111111111011110011010"b, /* 50 defined */ 15 109 "000000000001101011001000000000000000101010001111110111111111011110011010"b, /* 51 parm */ 15 110 "000000000001101011001000000000001000111000001111111011111111011110011010"b, /* 52 parameter-desc */ 15 111 "100001110000001011101110001100001000100111001111111101100000000000000000"b, /* 53 constant */ 15 112 "000000000001101011001000000000000000101010001111111110111111011110011010"b, /* 54 temporary */ 15 113 "000000000001101011001000000000000000101010001111111111011111011110011010"b, /* 55 return-value */ 15 114 "111111111101101111111111111111111111100111111111111101101010011100011000"b, /* 56 print */ 15 115 "111111111101101111111111111111111111100111111111111101110110000010000000"b, /* 57 input */ 15 116 "111111111101101111111111111111111111100111111111111101101010000000000000"b, /* 58 output */ 15 117 "111111111101101111111111111111111111100111111111111101111101000010000000"b, /* 59 update */ 15 118 "111111111101101111111111111111111111100111111111111101100010011100011000"b, /* 60 stream */ 15 119 "000000000000000000000000000000000000000000000000000000000000000000000000"b, /* 61 reserved-1 */ 15 120 "111111111101101111111111111111111111100111111111111101110001000010000000"b, /* 62 record */ 15 121 "111111111101101111111111111111111111100111111111111101110001000110000000"b, /* 63 sequential */ 15 122 "111111111101101111111111111111111111100111111111111101110001001010000000"b, /* 64 direct */ 15 123 "111111111101101111111111111111111111100111111111111101101010011100011000"b, /* 65 interactive */ 15 124 "000000000000000000000000000000000000000000000000000000000000000000000000"b, /* 66 reserved-2 */ 15 125 "000000000000000000000000000000000000000000000000000000000000000000000000"b, /* 67 reserved-3 */ 15 126 "111111111101101111111111111111111111100111111111111101110001000010000000"b, /* 68 stringvalue */ 15 127 "111111111101101111111111111111111111100111111111111101110001000010000000"b, /* 69 keyed */ 15 128 "000000000000000000000000000000000000000000000000000000000000000000000000"b, /* 70 reserved-4 */ 15 129 "111111111101101111111111111111111111100111111111111101100000000000000000"b, /* 71 environment */ 15 130 "000000000000000000000000000000000000000000000000000000000000000000000000"b); /* 72 aliasable */ 15 131 /* ------------------------------------------------------------------------ 15 132* 111111111122222222223333333333444444444455555555556666666666777 15 133* 123456789012345678901234567890123456789012345678901234567890123456789012 */ 15 134 15 135 /* END INCLUDE FILE ... pl1_attribute_table.incl.pl1 */ 652 16 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 16 2 16 3 dcl 1 reference based aligned, 16 4 2 node_type bit(9) unaligned, 16 5 2 array_ref bit(1) unaligned, 16 6 2 varying_ref bit(1) unaligned, 16 7 2 shared bit(1) unaligned, 16 8 2 put_data_sw bit(1) unaligned, 16 9 2 processed bit(1) unaligned, 16 10 2 units fixed(3) unaligned, 16 11 2 ref_count fixed(17) unaligned, 16 12 2 c_offset fixed(24), 16 13 2 c_length fixed(24), 16 14 2 symbol ptr unaligned, 16 15 2 qualifier ptr unaligned, 16 16 2 offset ptr unaligned, 16 17 2 length ptr unaligned, 16 18 2 subscript_list ptr unaligned, 16 19 /* these fields are used by the 645 code generator */ 16 20 2 address structure unaligned, 16 21 3 base bit(3), 16 22 3 offset bit(15), 16 23 3 op bit(9), 16 24 3 no_address bit(1), 16 25 3 inhibit bit(1), 16 26 3 ext_base bit(1), 16 27 3 tag bit(6), 16 28 2 info structure unaligned, 16 29 3 address_in structure, 16 30 4 b dimension(0:7) bit(1), 16 31 4 storage bit(1), 16 32 3 value_in structure, 16 33 4 a bit(1), 16 34 4 q bit(1), 16 35 4 aq bit(1), 16 36 4 string_aq bit(1), 16 37 4 complex_aq bit(1), 16 38 4 decimal_aq bit(1), 16 39 4 b dimension(0:7) bit(1), 16 40 4 storage bit(1), 16 41 4 indicators bit(1), 16 42 4 x dimension(0:7) bit(1), 16 43 3 other structure, 16 44 4 big_offset bit(1), 16 45 4 big_length bit(1), 16 46 4 modword_in_offset bit(1), 16 47 2 data_type fixed(5) unaligned, 16 48 2 bits structure unaligned, 16 49 3 padded_ref bit(1), 16 50 3 aligned_ref bit(1), 16 51 3 long_ref bit(1), 16 52 3 forward_ref bit(1), 16 53 3 ic_ref bit(1), 16 54 3 temp_ref bit(1), 16 55 3 defined_ref bit(1), 16 56 3 evaluated bit(1), 16 57 3 allocate bit(1), 16 58 3 allocated bit(1), 16 59 3 aliasable bit(1), 16 60 3 even bit(1), 16 61 3 perm_address bit(1), 16 62 3 aggregate bit(1), 16 63 3 hit_zero bit(1), 16 64 3 dont_save bit(1), 16 65 3 fo_in_qual bit(1), 16 66 3 hard_to_load bit(1), 16 67 2 relocation bit(12) unaligned, 16 68 2 more_bits structure unaligned, 16 69 3 substr bit(1), 16 70 3 padded_for_store_ref bit(1), 16 71 3 aligned_for_store_ref bit(1), 16 72 3 mbz bit(15), 16 73 2 store_ins bit(18) unaligned; 16 74 16 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 653 17 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 17 2 17 3 dcl 1 symbol based aligned, 17 4 2 node_type bit(9) unal, 17 5 2 source_id structure unal, 17 6 3 file_number bit(8), 17 7 3 line_number bit(14), 17 8 3 statement_number bit(5), 17 9 2 location fixed(18) unal unsigned, 17 10 2 allocated bit(1) unal, 17 11 2 dcl_type bit(3) unal, 17 12 2 reserved bit(6) unal, 17 13 2 pix unal, 17 14 3 pic_fixed bit(1) unal, 17 15 3 pic_float bit(1) unal, 17 16 3 pic_char bit(1) unal, 17 17 3 pic_scale fixed(7) unal, 17 18 3 pic_size fixed(7) unal, 17 19 2 level fixed(8) unal, 17 20 2 boundary fixed(3) unal, 17 21 2 size_units fixed(3) unal, 17 22 2 scale fixed(7) unal, 17 23 2 runtime bit(18) unal, 17 24 2 runtime_offset bit(18) unal, 17 25 2 block_node ptr unal, 17 26 2 token ptr unal, 17 27 2 next ptr unal, 17 28 2 multi_use ptr unal, 17 29 2 cross_references ptr unal, 17 30 2 initial ptr unal, 17 31 2 array ptr unal, 17 32 2 descriptor ptr unal, 17 33 2 equivalence ptr unal, 17 34 2 reference ptr unal, 17 35 2 general ptr unal, 17 36 2 father ptr unal, 17 37 2 brother ptr unal, 17 38 2 son ptr unal, 17 39 2 word_size ptr unal, 17 40 2 bit_size ptr unal, 17 41 2 dcl_size ptr unal, 17 42 2 symtab_size ptr unal, 17 43 2 c_word_size fixed(24), 17 44 2 c_bit_size fixed(24), 17 45 2 c_dcl_size fixed(24), 17 46 17 47 2 attributes structure aligned, 17 48 3 data_type structure unal, 17 49 4 structure bit(1) , 17 50 4 fixed bit(1), 17 51 4 float bit(1), 17 52 4 bit bit(1), 17 53 4 char bit(1), 17 54 4 ptr bit(1), 17 55 4 offset bit(1), 17 56 4 area bit(1), 17 57 4 label bit(1), 17 58 4 entry bit(1), 17 59 4 file bit(1), 17 60 4 arg_descriptor bit(1), 17 61 4 storage_block bit(1), 17 62 4 explicit_packed bit(1), /* options(packed) */ 17 63 4 condition bit(1), 17 64 4 format bit(1), 17 65 4 builtin bit(1), 17 66 4 generic bit(1), 17 67 4 picture bit(1), 17 68 17 69 3 misc_attributes structure unal, 17 70 4 dimensioned bit(1), 17 71 4 initialed bit(1), 17 72 4 aligned bit(1), 17 73 4 unaligned bit(1), 17 74 4 signed bit(1), 17 75 4 unsigned bit(1), 17 76 4 precision bit(1), 17 77 4 varying bit(1), 17 78 4 local bit(1), 17 79 4 decimal bit(1), 17 80 4 binary bit(1), 17 81 4 real bit(1), 17 82 4 complex bit(1), 17 83 4 variable bit(1), 17 84 4 reducible bit(1), 17 85 4 irreducible bit(1), 17 86 4 returns bit(1), 17 87 4 position bit(1), 17 88 4 internal bit(1), 17 89 4 external bit(1), 17 90 4 like bit(1), 17 91 4 member bit(1), 17 92 4 non_varying bit(1), 17 93 4 options bit(1), 17 94 4 variable_arg_list bit(1), /* options(variable) */ 17 95 4 alloc_in_text bit(1), /* options(constant) */ 17 96 17 97 3 storage_class structure unal, 17 98 4 auto bit(1), 17 99 4 based bit(1), 17 100 4 static bit(1), 17 101 4 controlled bit(1), 17 102 4 defined bit(1), 17 103 4 parameter bit(1), 17 104 4 param_desc bit(1), 17 105 4 constant bit(1), 17 106 4 temporary bit(1), 17 107 4 return_value bit(1), 17 108 17 109 3 file_attributes structure unal, 17 110 4 print bit(1), 17 111 4 input bit(1), 17 112 4 output bit(1), 17 113 4 update bit(1), 17 114 4 stream bit(1), 17 115 4 reserved_1 bit(1), 17 116 4 record bit(1), 17 117 4 sequential bit(1), 17 118 4 direct bit(1), 17 119 4 interactive bit(1), /* env(interactive) */ 17 120 4 reserved_2 bit(1), 17 121 4 reserved_3 bit(1), 17 122 4 stringvalue bit(1), /* env(stringvalue) */ 17 123 4 keyed bit(1), 17 124 4 reserved_4 bit(1), 17 125 4 environment bit(1), 17 126 17 127 3 compiler_developed structure unal, 17 128 4 aliasable bit(1), 17 129 4 packed bit(1), 17 130 4 passed_as_arg bit(1), 17 131 4 allocate bit(1), 17 132 4 set bit(1), 17 133 4 exp_extents bit(1), 17 134 4 refer_extents bit(1), 17 135 4 star_extents bit(1), 17 136 4 isub bit(1), 17 137 4 put_in_symtab bit(1), 17 138 4 contiguous bit(1), 17 139 4 put_data bit(1), 17 140 4 overlayed bit(1), 17 141 4 error bit(1), 17 142 4 symtab_processed bit(1), 17 143 4 overlayed_by_builtin bit(1), 17 144 4 defaulted bit(1), 17 145 4 connected bit(1); 17 146 17 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 654 18 1 /* BEGIN INCLUDE FILE ... system.incl.pl1 */ 18 2 18 3 /* Modified: 25 Apr 1979 by PCK to implemnt 4-bit decimal */ 18 4 18 5 dcl ( max_p_flt_bin_1 initial(27), 18 6 max_p_flt_bin_2 initial(63), 18 7 max_p_fix_bin_1 initial(35), 18 8 max_p_fix_bin_2 initial(71), 18 9 18 10 max_p_dec initial(59), 18 11 max_p_bin_or_dec initial (71), /* max (max_p_fix_bin_2, max_p_dec) */ 18 12 18 13 min_scale initial(-128), 18 14 max_scale initial(+127), 18 15 max_bit_string initial(9437184), 18 16 max_char_string initial(1048576), 18 17 max_area_size initial(262144), 18 18 min_area_size initial(28), 18 19 18 20 max_bit_string_constant initial (253), /* max length of bit literals */ 18 21 max_char_string_constant initial (254), /* max length of character literals */ 18 22 max_identifier_length initial (256), 18 23 max_number_of_dimensions initial (127), 18 24 18 25 max_length_precision initial(24), 18 26 max_offset_precision initial(24), /* 18 bits for word offset + 6 bits for bit offset */ 18 27 18 28 max_words_per_variable initial (262144), 18 29 18 30 bits_per_word initial(36), 18 31 bits_per_double initial(72), 18 32 packed_digits_per_character initial(2), 18 33 characters_per_half initial(2), 18 34 characters_per_word initial(4), 18 35 characters_per_double initial(8), 18 36 18 37 bits_per_character initial(9), 18 38 bits_per_half initial(18), 18 39 bits_per_decimal_digit initial(9), 18 40 bits_per_binary_exponent initial(8), 18 41 bits_per_packed_ptr initial(36), 18 42 words_per_packed_pointer initial(1), 18 43 18 44 words_per_fix_bin_1 initial(1), 18 45 words_per_fix_bin_2 initial(2), 18 46 words_per_flt_bin_1 initial(1), 18 47 words_per_flt_bin_2 initial(2), 18 48 words_per_varying_string_header initial(1), 18 49 words_per_offset initial(1), 18 50 words_per_pointer initial(2), 18 51 words_per_label_var initial(4), 18 52 words_per_entry_var initial(4), 18 53 words_per_file_var initial(4), 18 54 words_per_format initial(4), 18 55 words_per_condition_var initial(6), 18 56 18 57 max_index_register_value initial(262143), 18 58 max_signed_index_register_value initial(131071), 18 59 18 60 max_signed_xreg_precision initial(17), 18 61 max_uns_xreg_precision initial(18), 18 62 18 63 default_area_size initial(1024), 18 64 default_flt_bin_p initial(27), 18 65 default_fix_bin_p initial(17), 18 66 default_flt_dec_p initial(10), 18 67 default_fix_dec_p initial(7)) fixed bin(31) internal static options(constant); 18 68 18 69 dcl bits_per_digit initial(4.5) fixed bin(31,1) internal static options(constant); 18 70 18 71 dcl ( integer_type initial("010000000000000000000100000001100000"b), 18 72 dec_integer_type initial("010000000000000000000100000010100000"b), 18 73 pointer_type initial("000001000000000000000100000000000000"b), 18 74 real_type initial("001000000000000000000100000001100000"b), 18 75 complex_type initial("001000000000000000000100000001010000"b), 18 76 builtin_type initial("000000000000000010000000000000000000"b), 18 77 storage_block_type initial("000000000000100000000000000000000000"b), 18 78 arg_desc_type initial("000000000001000000000000000000000000"b), 18 79 local_label_var_type initial("000000001000000000000100000100001000"b), 18 80 entry_var_type initial("000000000100000000000000000000001000"b), 18 81 bit_type initial("000100000000000000000000000000000000"b), 18 82 char_type initial("000010000000000000000000000000000000"b)) bit(36) aligned int static 18 83 options(constant); 18 84 18 85 /* END INCLUDE FILE ... system.incl.pl1 */ 655 19 1 dcl pl1_stat_$token_list_ptr ptr external static; /* pointer to token list */ 19 2 dcl token_list(token_list_length) ptr based(token_list_pointer); 19 3 dcl token_list_pointer ptr initial(pl1_stat_$token_list_ptr); /* for efficiency only */ 19 4 dcl token_list_length fixed(15) internal static initial(3000) options(constant); 19 5 19 6 dcl 1 pl1_stat_$statement_id external static, 19 7 2 file_number bit(8), 19 8 2 line_number bit(14), 19 9 2 statement_number bit(5); 19 10 19 11 dcl 1 t_table based(token_list(k)) aligned, 19 12 2 node_type bit(9) unaligned, 19 13 2 type bit(9) unaligned, 19 14 2 loc bit(18) unaligned, 19 15 2 declaration ptr unaligned, 19 16 2 next ptr unaligned, 19 17 2 size fixed(9), 19 18 2 string char(n refer(t_table.size)); 656 20 1 /* BEGIN INCLUDE FILE ... token_types.incl.pl1 */ 20 2 20 3 dcl ( no_token initial("000000000"b), /* token types */ 20 4 identifier initial("100000000"b), 20 5 isub initial("010000000"b), 20 6 plus initial("001000001"b), 20 7 minus initial("001000010"b), 20 8 asterisk initial("001000011"b), 20 9 slash initial("001000100"b), 20 10 expon initial("001000101"b), 20 11 not initial("001000110"b), 20 12 and initial("001000111"b), 20 13 or initial("001001000"b), 20 14 cat initial("001001001"b), 20 15 eq initial("001001010"b), 20 16 ne initial("001001011"b), 20 17 lt initial("001001100"b), 20 18 gt initial("001001101"b), 20 19 le initial("001001110"b), 20 20 ge initial("001001111"b), 20 21 ngt initial("001010000"b), 20 22 nlt initial("001010001"b), 20 23 assignment initial("001010010"b), 20 24 colon initial("001010011"b), 20 25 semi_colon initial("001010100"b), 20 26 comma initial("001010101"b), 20 27 period initial("001010110"b), 20 28 arrow initial("001010111"b), 20 29 left_parn initial("001011000"b), 20 30 right_parn initial("001011001"b), 20 31 percent initial("001011100"b), 20 32 bit_string initial("000100001"b), 20 33 char_string initial("000100010"b), 20 34 bin_integer initial("000110001"b), 20 35 dec_integer initial("000110011"b), 20 36 fixed_bin initial("000110000"b), 20 37 fixed_dec initial("000110010"b), 20 38 float_bin initial("000110100"b), 20 39 float_dec initial("000110110"b), 20 40 i_bin_integer initial("000111001"b), 20 41 i_dec_integer initial("000111011"b), 20 42 i_fixed_bin initial("000111000"b), 20 43 i_fixed_dec initial("000111010"b), 20 44 i_float_bin initial("000111100"b), 20 45 i_float_dec initial("000111110"b)) bit (9) aligned internal static options (constant); 20 46 20 47 dcl ( is_identifier initial ("100000000"b), /* token type masks */ 20 48 is_isub initial ("010000000"b), 20 49 is_delimiter initial ("001000000"b), 20 50 is_constant initial ("000100000"b), 20 51 is_arith_constant initial ("000010000"b), /* N.B. not really a mask...s/b "000110000"b */ 20 52 is_arithmetic_constant initial ("000110000"b), 20 53 is_imaginary_constant initial ("000111000"b), 20 54 is_float_constant initial ("000110100"b), 20 55 is_decimal_constant initial ("000110010"b), 20 56 is_integral_constant initial ("000110001"b) 20 57 ) bit(9) internal static aligned options(constant); 20 58 20 59 /* END INCLUDE FILE ... token_types.incl.pl1 */ 657 658 end /* attribute_parse */; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/24/92 1041.3 attribute_parse.pl1 >spec>install>MR12.5-1011>attribute_parse.pl1 643 1 04/24/92 1056.9 parse.incl.pl1 >spec>install>MR12.5-1011>parse.incl.pl1 1-175 2 08/01/89 1339.9 language_utility.incl.pl1 >ldd>incl>language_utility.incl.pl1 2-307 3 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-325 4 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-335 5 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-374 6 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-386 7 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 645 8 05/06/74 1841.6 array.incl.pl1 >ldd>incl>array.incl.pl1 646 9 08/13/81 2143.5 block.incl.pl1 >ldd>incl>block.incl.pl1 647 10 05/03/76 1420.8 context_codes.incl.pl1 >ldd>incl>context_codes.incl.pl1 648 11 08/13/81 2311.5 list.incl.pl1 >ldd>incl>list.incl.pl1 649 12 07/21/80 1646.3 nodes.incl.pl1 >ldd>incl>nodes.incl.pl1 650 13 04/07/83 1735.0 op_codes.incl.pl1 >ldd>incl>op_codes.incl.pl1 651 14 07/21/80 1646.3 operator.incl.pl1 >ldd>incl>operator.incl.pl1 652 15 12/07/83 1800.1 pl1_attribute_table.incl.pl1 >ldd>incl>pl1_attribute_table.incl.pl1 653 16 07/21/80 1646.3 reference.incl.pl1 >ldd>incl>reference.incl.pl1 654 17 12/07/83 1801.7 symbol.incl.pl1 >ldd>incl>symbol.incl.pl1 655 18 12/07/83 1801.7 system.incl.pl1 >ldd>incl>system.incl.pl1 656 19 09/14/77 1805.7 token_list.incl.pl1 >ldd>incl>token_list.incl.pl1 657 20 11/30/78 1327.4 token_types.incl.pl1 >ldd>incl>token_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. action_index 000453 constant fixed bin(8,0) initial array packed unaligned dcl 87 ref 216 aligned 31(21) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 194* alloc_in_text 32(08) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 460* ap 000100 automatic pointer dcl 565 set ref 618* 625 area 31(07) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 575 594 606 area_context 000504 constant fixed bin(15,0) initial dcl 10-1 set ref 280* array 12 based pointer level 2 in structure "symbol" packed packed unaligned dcl 17-3 in procedure "attribute_parse" set ref 413* 437 438 449 array based structure level 1 dcl 8-1 in procedure "attribute_parse" asterisk constant bit(9) initial dcl 20-3 ref 516 588 attributes 31 based structure level 2 dcl 17-3 set ref 213 binary builtin function dcl 78 ref 208 bit_index 000025 constant fixed bin(8,0) initial array packed unaligned dcl 15-32 ref 213 block based structure level 1 dcl 9-5 bound based structure level 1 dcl 8-21 bounds 12 based pointer level 2 packed packed unaligned dcl 8-1 set ref 437 438* c_dcl_size 30 based fixed bin(24,0) level 2 dcl 17-3 set ref 239* 240 251 cblock parameter pointer dcl 61 set ref 39 237* 246* 267* 270* 277* 280* 292* 302* 337* 350* 374* 378 387* 484* 485* 522* 523* 543* 575* 578* 594* 606* 609* char_string constant bit(9) initial dcl 20-3 ref 283 colon constant bit(9) initial dcl 20-3 ref 243 256 422 comma constant bit(9) initial dcl 20-3 ref 188 253 370 405 442 601 627 compiler_developed 32(35) based structure level 3 packed packed unaligned dcl 17-3 constant_token 000014 constant entry external dcl 171 ref 237 246 context 000020 constant entry external dcl 1-17 ref 270 280 create_array 000032 constant entry external dcl 2-108 ref 413 create_bound 000034 constant entry external dcl 2-118 ref 436 create_list 000036 constant entry external dcl 2-147 ref 355 386 614 create_operator 000040 constant entry external dcl 2-152 ref 541 create_token 000042 constant entry external dcl 2-191 ref 337 337 350 350 data_type 31 based structure level 3 packed packed unaligned dcl 17-3 dcl_size 24 based pointer level 2 packed packed unaligned dcl 17-3 set ref 228* 229 342* dec_integer 000023 constant bit(9) initial dcl 20-3 set ref 237* 237 246* 246 490 526 declare_parse$abort 000022 constant entry external dcl 1-40 ref 547 549 640 defer_constant_token_list 000016 constant entry external dcl 172 ref 484 522 575 594 606 defined_parn 000117 automatic bit(1) dcl 74 set ref 296* 299* 305 descriptor_parse 000024 constant entry external dcl 1-49 ref 337 350 395 dimensioned 31(19) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 412* element 1 based pointer array level 2 packed packed unaligned dcl 11-6 set ref 340 342 387* 388 395* 399* 400* 615* 616* 617* 620* entry 31(09) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 575 594 606 equivalence 14 based pointer level 2 packed packed unaligned dcl 17-3 set ref 302* 303 exp_extents 33(04) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 526* 531* 536* explicit_packed 31(13) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 462* expression_parse 000026 constant entry external dcl 1-73 ref 292 485 523 578 609 factor 000102 automatic pointer dcl 565 set ref 578* 579 586* 602 603* 615 file 31(10) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 575 594 606 file_attributes 32(19) based structure level 3 packed packed unaligned dcl 17-3 first_time 000120 automatic bit(1) dcl 74 set ref 177* 200 201* fixed 31(01) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 255* general 16 based pointer level 2 packed packed unaligned dcl 17-3 set ref 277* 278 280 280 286* 350* 352 355* 374* 376 407* i 000110 automatic fixed bin(17,0) dcl 71 set ref 209* 209* 212 213 216 identifier 000505 constant bit(9) initial dcl 20-3 set ref 205 337* 337* 350* 350* 367 in_generic parameter bit(1) dcl 61 ref 39 243 256 index_given_letter 000443 constant fixed bin(8,0) initial array packed unaligned dcl 15-6 ref 209 initial 11 based pointer level 2 packed packed unaligned dcl 17-3 set ref 292* 293 312 314* 315 interactive 32(28) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 323* k parameter fixed bin(15,0) dcl 61 set ref 39 179 182* 182 184 187 207 214* 214 215 226* 226 236* 236 237 239 242* 242 243 245* 245 246 248 249* 249 253 256 266* 266 267* 276* 276 277* 286 291* 291 292* 300* 300 302* 322* 322 323 325 329* 329 330 337* 350* 365* 365 367 369* 369 370 374* 380 384* 384 387* 390 392* 392 393 395* 396 398* 398 405 409 417* 417 422 424* 424 442 450 457* 457 458 460 462 466* 466 467 471 483* 483 484 485* 516 517 519* 519 522 523* 533 535* 535 537 539* 539 543* 552 554* 554 572* 572 573 574* 574 575 578* 581 583* 583 588 590* 590 593 594 601 601 606 609* 623 624* 624 627 keyword 000052 constant char(11) initial array dcl 15-10 ref 209 212 label 31(08) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 575 594 606 left_parn constant bit(9) initial dcl 20-3 ref 202 223 232 263 273 288 298 309 319 334 347 359 380 393 409 454 537 573 593 letterx 000111 automatic fixed bin(17,0) dcl 71 set ref 208* 209 like_attribute 24(21) based bit(1) level 2 packed packed unaligned dcl 9-5 set ref 378* list based structure level 1 dcl 11-6 lower 5 based pointer level 2 packed packed unaligned dcl 8-21 set ref 439* m parameter fixed bin(15,0) dcl 637 set ref 634 640* max_number_of_dimensions constant fixed bin(31,0) initial dcl 18-5 ref 435 445 447 max_scale constant fixed bin(31,0) initial dcl 18-5 ref 501 503 min_scale 004010 constant fixed bin(31,0) initial dcl 18-5 ref 497 499 misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 17-3 ndims 000112 automatic fixed bin(17,0) dcl 71 set ref 414* 415* 415 435 445 447* 449 next 14 based pointer level 2 packed packed unaligned dcl 8-21 set ref 437* node based structure level 1 dcl 12-27 null builtin function dcl 78 ref 184 229 268 278 293 303 312 315 339 340 352 376 383 388 395 395 395 395 399 400 420 427 486 524 544 547 549 558 569 579 589 598 610 617 618 630 offset 31(06) based bit(1) level 4 in structure "symbol" packed packed unaligned dcl 17-3 in procedure "attribute_parse" ref 575 594 606 offset 5 based pointer level 2 in structure "reference" packed packed unaligned dcl 16-3 in procedure "attribute_parse" ref 549 operand 1 based pointer array level 2 packed packed unaligned dcl 14-6 set ref 542* 543* 544 546 547 547 549 549 operator based structure level 1 dcl 14-6 own_number_of_dimensions 1(15) based fixed bin(7,0) level 2 packed packed unaligned dcl 8-1 set ref 449* p 000100 automatic pointer dcl 70 set ref 176* 191 193 194 195 213 228 229 235 239 240 248 251 251 254 255 256 259 259 267 268 270 270 277 278 280 280 286 292 293 302 303 312 314 314* 315 323 325 337 337 342 350 350 350 352 355 374 376 407 412 413 437 438 446* 449 458 460 462 498 502 518 526 531 536 536 639 640 p1 000104 automatic pointer dcl 70 in procedure "attribute_parse" set ref 386* 387 388 395 399 400 402 404 418* 425* 432* 439 485* 486 488 490 492* p1 000142 automatic pointer dcl 513 in procedure "refer_exp" set ref 517* 523* 524 526 526 540 541* 542 543 544 546 547 547 549 549 556 p1 000106 automatic pointer dcl 565 in procedure "initial_list" set ref 614* 615 616 617 618 620 622 p2 000106 automatic pointer dcl 70 in procedure "attribute_parse" set ref 400 404* 419* 420 425 426* 427 432 440 p2 000110 automatic pointer dcl 565 in procedure "initial_list" set ref 569* 618 620 622* p2 000144 automatic pointer dcl 513 in procedure "refer_exp" set ref 540* 542 parse_error 000044 constant entry external dcl 2-364 ref 330 446 467 471 498 502 passed_as_arg 33(01) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 343* pic_scale 1(31) based fixed bin(7,0) level 3 packed packed unaligned dcl 17-3 set ref 256* 259* pic_size 2(03) based fixed bin(7,0) level 3 packed packed unaligned dcl 17-3 set ref 248* 251* pix 1(28) based structure level 2 packed packed unaligned dcl 17-3 pl1_stat_$check_ansi 000012 external static bit(1) dcl 83 ref 330 467 471 pl1_stat_$one 000010 external static pointer dcl 82 ref 418 586 603 pl1_stat_$token_list_ptr 000050 external static pointer dcl 19-1 ref 19-3 pointer_context 000501 constant fixed bin(15,0) initial dcl 10-1 set ref 270* precision 31(25) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 235* ptr 31(05) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 575 594 606 q 000102 automatic pointer dcl 70 set ref 337* 339 340 342 342* 343 383* 400 402* 407 436* 437 438 439 440 qualifier 4 based pointer level 2 packed packed unaligned dcl 16-3 set ref 267* 268 270 270 547 refer 000452 constant bit(9) initial dcl 13-8 set ref 541* refer_extents 33(05) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 536* reference based structure level 1 dcl 16-3 in procedure "attribute_parse" reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 17-3 in procedure "attribute_parse" ref 267 268 270 270 reference_node constant bit(9) initial dcl 12-5 ref 546 reference_parse 000030 constant entry external dcl 1-150 ref 267 277 302 374 387 543 right_parn 000024 constant bit(9) initial dcl 20-3 set ref 179 188 396 450 484* 522* 552 575* 581 594* 601 606* 623 scale 2(28) based fixed bin(7,0) level 2 packed packed unaligned dcl 17-3 set ref 254* 259 semi_colon constant bit(9) initial dcl 20-3 ref 188 size 3 based fixed bin(9,0) level 2 dcl 19-11 ref 207 323 325 337 337 350 350 390 458 460 462 533 something_parsed 000112 automatic bit(1) dcl 566 set ref 571* 584* 601 sp parameter pointer dcl 61 set ref 39 176 191* 639* star 000121 automatic bit(1) dcl 74 set ref 422 515* 518* star_extents 33(06) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 518* string 4 based char level 2 in structure "t_table" dcl 19-11 in procedure "attribute_parse" ref 207 323 325 337 337 350 350 390 458 460 462 533 string builtin function dcl 78 in procedure "attribute_parse" ref 213 stringvalue 32(31) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 325* substr builtin function dcl 78 set ref 208 213* sym_ptr parameter pointer dcl 567 set ref 562 575 575 575 575 575 575 594 594 594 594 594 594 597* 606 606 606 606 606 606 symbol based structure level 1 dcl 17-3 t_table based structure level 1 dcl 19-11 temp 000132 automatic fixed bin(17,0) dcl 481 set ref 492* 497 501 506 token 5 based pointer level 2 packed packed unaligned dcl 17-3 ref 337 337 350 350 498 502 640 token_list based pointer array dcl 19-2 set ref 179 184 187 207 215 237* 239* 243 246* 248* 253 256 286 323 325 330* 367 370 380 390 393 396 405 409 422 442 450 458 460 462 467* 471* 516 517 533 537 552 573 581 588 593 601 601 623 627 token_list_pointer 000122 automatic pointer initial dcl 19-3 set ref 179 184 187 207 215 237 239 243 246 248 253 256 286 323 325 330 367 370 380 390 393 396 405 409 422 442 450 458 460 462 467 471 19-3* 516 517 533 537 552 573 581 588 593 601 601 623 627 token_node constant bit(9) initial dcl 12-5 ref 270 280 488 526 token_to_binary 000046 constant entry external dcl 2-459 ref 239 248 492 type 000113 automatic bit(9) dcl 72 in procedure "attribute_parse" set ref 187* 188 188 188 202 205 215* 223 232 263 273 283 288 298 309 319 334 347 359 454 type based bit(9) level 2 in structure "node" packed packed unaligned dcl 12-27 in procedure "attribute_parse" ref 270 280 488 526 546 type 0(09) based bit(9) level 2 in structure "t_table" packed packed unaligned dcl 19-11 in procedure "attribute_parse" ref 179 187 215 243 253 256 367 370 380 393 396 405 409 422 442 450 490 516 526 537 552 573 581 588 593 601 601 623 627 unaligned 31(22) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 195* unspec builtin function dcl 78 ref 208 upper 6 based pointer level 2 packed packed unaligned dcl 8-21 set ref 440* value 000104 automatic pointer dcl 565 set ref 589* 597* 598 602* 609* 610 616 variable_arg_list 32(07) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 458* varying 31(26) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 193 word 000114 automatic char(11) packed unaligned dcl 73 set ref 207* 208 209 212 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. a_format internal static bit(9) initial dcl 13-8 abs_fun internal static bit(9) initial dcl 13-8 acos_fun internal static bit(9) initial dcl 13-8 acosd_fun internal static bit(9) initial dcl 13-8 add internal static bit(9) initial dcl 13-8 addbitno_fun internal static bit(9) initial dcl 13-8 addcharno_fun internal static bit(9) initial dcl 13-8 addr_fun internal static bit(9) initial dcl 13-8 addr_fun_bits internal static bit(9) initial dcl 13-8 addrel_fun internal static bit(9) initial dcl 13-8 adjust_count 000000 constant entry external dcl 2-20 allocation_fun internal static bit(9) initial dcl 13-8 allot_auto internal static bit(9) initial dcl 13-8 allot_based internal static bit(9) initial dcl 13-8 allot_ctl internal static bit(9) initial dcl 13-8 allot_var internal static bit(9) initial dcl 13-8 and internal static bit(9) initial dcl 20-3 and_bits internal static bit(9) initial dcl 13-8 arg_desc_type internal static bit(36) initial dcl 18-71 array_node internal static bit(9) initial dcl 12-5 arrow internal static bit(9) initial dcl 20-3 asin_fun internal static bit(9) initial dcl 13-8 asind_fun internal static bit(9) initial dcl 13-8 assign internal static bit(9) initial dcl 13-8 assign_by_name internal static bit(9) initial dcl 13-8 assign_round internal static bit(9) initial dcl 13-8 assign_size_ck internal static bit(9) initial dcl 13-8 assign_zero internal static bit(9) initial dcl 13-8 assignment internal static bit(9) initial dcl 20-3 atan_fun internal static bit(9) initial dcl 13-8 atand_fun internal static bit(9) initial dcl 13-8 attribute_parse 000000 constant entry external dcl 1-11 b_format internal static bit(9) initial dcl 13-8 baseno_fun internal static bit(9) initial dcl 13-8 baseptr_fun internal static bit(9) initial dcl 13-8 bin_integer internal static bit(9) initial dcl 20-3 binary_to_octal_string 000000 constant entry external dcl 2-38 binary_to_octal_var_string 000000 constant entry external dcl 2-43 bindec 000000 constant entry external dcl 2-23 bindec$vs 000000 constant entry external dcl 2-28 binoct 000000 constant entry external dcl 2-33 bit_pointer internal static bit(9) initial dcl 13-8 bit_string internal static bit(9) initial dcl 20-3 bit_to_char internal static bit(9) initial dcl 13-8 bit_to_word internal static bit(9) initial dcl 13-8 bit_type internal static bit(36) initial dcl 18-71 bitno_fun internal static bit(9) initial dcl 13-8 bits_per_binary_exponent internal static fixed bin(31,0) initial dcl 18-5 bits_per_character internal static fixed bin(31,0) initial dcl 18-5 bits_per_decimal_digit internal static fixed bin(31,0) initial dcl 18-5 bits_per_digit internal static fixed bin(31,1) initial dcl 18-69 bits_per_double internal static fixed bin(31,0) initial dcl 18-5 bits_per_half internal static fixed bin(31,0) initial dcl 18-5 bits_per_packed_ptr internal static fixed bin(31,0) initial dcl 18-5 bits_per_word internal static fixed bin(31,0) initial dcl 18-5 block_node internal static bit(9) initial dcl 12-5 bn_format internal static bit(9) initial dcl 13-8 bool_fun internal static bit(9) initial dcl 13-8 bound_ck internal static bit(9) initial dcl 13-8 bound_node internal static bit(9) initial dcl 12-5 builtin_type internal static bit(36) initial dcl 18-71 by_name_agg_node internal static bit(9) initial dcl 12-5 byte_fun internal static bit(9) initial dcl 13-8 c_format internal static bit(9) initial dcl 13-8 cat internal static bit(9) initial dcl 20-3 cat_string internal static bit(9) initial dcl 13-8 ceil_fun internal static bit(9) initial dcl 13-8 char_to_word internal static bit(9) initial dcl 13-8 char_type internal static bit(36) initial dcl 18-71 characters_per_double internal static fixed bin(31,0) initial dcl 18-5 characters_per_half internal static fixed bin(31,0) initial dcl 18-5 characters_per_word internal static fixed bin(31,0) initial dcl 18-5 charno_fun internal static bit(9) initial dcl 13-8 clock_fun internal static bit(9) initial dcl 13-8 close_file internal static bit(9) initial dcl 13-8 codeptr_fun internal static bit(9) initial dcl 13-8 column_format internal static bit(9) initial dcl 13-8 compare_expression 000000 constant entry external dcl 2-48 complex_fun internal static bit(9) initial dcl 13-8 complex_type internal static bit(36) initial dcl 18-71 condition_context internal static fixed bin(15,0) initial dcl 10-1 conjg_fun internal static bit(9) initial dcl 13-8 constant_length 000000 constant entry external dcl 2-54 context_node internal static bit(9) initial dcl 12-5 convert 000000 constant entry external dcl 2-60 convert$from_builtin 000000 constant entry external dcl 2-72 convert$to_integer 000000 constant entry external dcl 2-66 convert$to_target 000000 constant entry external dcl 2-88 convert$to_target_fb 000000 constant entry external dcl 2-82 convert$validate 000000 constant entry external dcl 2-78 copy_expression 000000 constant entry external dcl 2-94 copy_expression$copy_sons 000000 constant entry external dcl 2-99 copy_string internal static bit(9) initial dcl 13-8 copy_unique_expression 000000 constant entry external dcl 2-103 copy_words internal static bit(9) initial dcl 13-8 cos_fun internal static bit(9) initial dcl 13-8 cosd_fun internal static bit(9) initial dcl 13-8 create_block 000000 constant entry external dcl 2-112 create_context 000000 constant entry external dcl 2-122 create_cross_reference 000000 constant entry external dcl 2-128 create_default 000000 constant entry external dcl 2-132 create_identifier 000000 constant entry external dcl 2-136 create_label 000000 constant entry external dcl 2-140 create_reference 000000 constant entry external dcl 2-158 create_statement 000000 constant entry external dcl 2-163 create_statement$prologue 000000 constant entry external dcl 2-171 create_storage 000000 constant entry external dcl 2-179 create_symbol 000000 constant entry external dcl 2-184 create_token$init_hash_table 000000 constant entry external dcl 2-197 create_token$protected 000000 constant entry external dcl 2-199 cross_reference_node internal static bit(9) initial dcl 12-5 data_list_parse 000000 constant entry external dcl 1-22 dec_integer_type internal static bit(36) initial dcl 18-71 decbin 000000 constant entry external dcl 2-206 declare_constant 000000 constant entry external dcl 2-211 declare_constant$bit 000000 constant entry external dcl 2-219 declare_constant$char 000000 constant entry external dcl 2-224 declare_constant$desc 000000 constant entry external dcl 2-229 declare_constant$integer 000000 constant entry external dcl 2-234 declare_descriptor 000000 constant entry external dcl 2-239 declare_descriptor$ctl 000000 constant entry external dcl 2-249 declare_descriptor$param 000000 constant entry external dcl 2-259 declare_integer 000000 constant entry external dcl 2-269 declare_label 000000 constant entry external dcl 1-29 declare_parse 000000 constant entry external dcl 1-35 declare_picture 000000 constant entry external dcl 2-274 declare_picture_temp 000000 constant entry external dcl 2-279 declare_pointer 000000 constant entry external dcl 2-287 declare_temporary 000000 constant entry external dcl 2-292 decode_node_id 000000 constant entry external dcl 2-300 decode_source_id 000000 constant entry external dcl 2-306 default_area_size internal static fixed bin(31,0) initial dcl 18-5 default_fix_bin_p internal static fixed bin(31,0) initial dcl 18-5 default_fix_dec_p internal static fixed bin(31,0) initial dcl 18-5 default_flt_bin_p internal static fixed bin(31,0) initial dcl 18-5 default_flt_dec_p internal static fixed bin(31,0) initial dcl 18-5 default_node internal static bit(9) initial dcl 12-5 default_parse 000000 constant entry external dcl 1-44 delete_file internal static bit(9) initial dcl 13-8 desc_size internal static bit(9) initial dcl 13-8 digit_to_bit internal static bit(9) initial dcl 13-8 div internal static bit(9) initial dcl 13-8 do_fun internal static bit(9) initial dcl 13-8 do_parse 000000 constant entry external dcl 1-56 do_spec internal static bit(9) initial dcl 13-8 e_format internal static bit(9) initial dcl 13-8 empty_area internal static bit(9) initial dcl 13-8 enable_on internal static bit(9) initial dcl 13-8 entry_var_type internal static bit(36) initial dcl 18-71 environmentptr_fun internal static bit(9) initial dcl 13-8 eq internal static bit(9) initial dcl 20-3 equal internal static bit(9) initial dcl 13-8 error 000000 constant entry external dcl 2-314 error$omit_text 000000 constant entry external dcl 2-319 error_ 000000 constant entry external dcl 2-324 error_$finish 000000 constant entry external dcl 2-343 error_$initialize_error 000000 constant entry external dcl 2-341 error_$no_text 000000 constant entry external dcl 2-334 evaluate 000000 constant entry external dcl 1-67 ex_prologue internal static bit(9) initial dcl 13-8 exp internal static bit(9) initial dcl 13-8 exp_fun internal static bit(9) initial dcl 13-8 expon internal static bit(9) initial dcl 20-3 f_format internal static bit(9) initial dcl 13-8 file_name_context internal static fixed bin(15,0) initial dcl 10-1 fixed_bin internal static bit(9) initial dcl 20-3 fixed_dec internal static bit(9) initial dcl 20-3 float_bin internal static bit(9) initial dcl 20-3 float_dec internal static bit(9) initial dcl 20-3 floor_fun internal static bit(9) initial dcl 13-8 format_list_parse 000000 constant entry external dcl 1-79 format_value_node internal static bit(9) initial dcl 12-5 fortran_read internal static bit(9) initial dcl 13-8 fortran_write internal static bit(9) initial dcl 13-8 free_based internal static bit(9) initial dcl 13-8 free_ctl internal static bit(9) initial dcl 13-8 free_node 000000 constant entry external dcl 2-345 free_var internal static bit(9) initial dcl 13-8 ftn_file_manip internal static bit(9) initial dcl 13-8 ftn_trans_loop internal static bit(9) initial dcl 13-8 ge internal static bit(9) initial dcl 20-3 get_array_size 000000 constant entry external dcl 2-348 get_data_trans internal static bit(9) initial dcl 13-8 get_edit_trans internal static bit(9) initial dcl 13-8 get_file internal static bit(9) initial dcl 13-8 get_list_trans internal static bit(9) initial dcl 13-8 get_size 000000 constant entry external dcl 2-352 get_string internal static bit(9) initial dcl 13-8 greater_or_equal internal static bit(9) initial dcl 13-8 greater_than internal static bit(9) initial dcl 13-8 gt internal static bit(9) initial dcl 20-3 half_to_word internal static bit(9) initial dcl 13-8 i_bin_integer internal static bit(9) initial dcl 20-3 i_dec_integer internal static bit(9) initial dcl 20-3 i_fixed_bin internal static bit(9) initial dcl 20-3 i_fixed_dec internal static bit(9) initial dcl 20-3 i_float_bin internal static bit(9) initial dcl 20-3 i_float_dec internal static bit(9) initial dcl 20-3 if_parse 000000 constant entry external dcl 1-87 imag_fun internal static bit(9) initial dcl 13-8 incompatable internal static bit(72) initial array dcl 15-55 index_after_fun internal static bit(9) initial dcl 13-8 index_before_fun internal static bit(9) initial dcl 13-8 index_fun internal static bit(9) initial dcl 13-8 index_rev_fun internal static bit(9) initial dcl 13-8 integer_type internal static bit(36) initial dcl 18-71 io_statement_parse 000000 constant entry external dcl 1-96 is_arith_constant internal static bit(9) initial dcl 20-47 is_arithmetic_constant internal static bit(9) initial dcl 20-47 is_constant internal static bit(9) initial dcl 20-47 is_decimal_constant internal static bit(9) initial dcl 20-47 is_delimiter internal static bit(9) initial dcl 20-47 is_float_constant internal static bit(9) initial dcl 20-47 is_identifier internal static bit(9) initial dcl 20-47 is_imaginary_constant internal static bit(9) initial dcl 20-47 is_integral_constant internal static bit(9) initial dcl 20-47 is_isub internal static bit(9) initial dcl 20-47 isub internal static bit(9) initial dcl 20-3 join internal static bit(9) initial dcl 13-8 jump internal static bit(9) initial dcl 13-8 jump_false internal static bit(9) initial dcl 13-8 jump_if_eq internal static bit(9) initial dcl 13-8 jump_if_ge internal static bit(9) initial dcl 13-8 jump_if_gt internal static bit(9) initial dcl 13-8 jump_if_le internal static bit(9) initial dcl 13-8 jump_if_lt internal static bit(9) initial dcl 13-8 jump_if_ne internal static bit(9) initial dcl 13-8 jump_true internal static bit(9) initial dcl 13-8 l_parn internal static bit(9) initial dcl 13-8 label_array_element_node internal static bit(9) initial dcl 12-5 label_node internal static bit(9) initial dcl 12-5 le internal static bit(9) initial dcl 20-3 length_fun internal static bit(9) initial dcl 13-8 less_or_equal internal static bit(9) initial dcl 13-8 less_than internal static bit(9) initial dcl 13-8 lex 000000 constant entry external dcl 1-106 lex$initialize_lex 000000 constant entry external dcl 1-112 lex$write_last_line 000000 constant entry external dcl 1-109 line_format internal static bit(9) initial dcl 13-8 list_node internal static bit(9) initial dcl 12-5 local_label_var_type internal static bit(36) initial dcl 18-71 locate_file internal static bit(9) initial dcl 13-8 lock_file internal static bit(9) initial dcl 13-8 lock_fun internal static bit(9) initial dcl 13-8 log10_fun internal static bit(9) initial dcl 13-8 log2_fun internal static bit(9) initial dcl 13-8 log_fun internal static bit(9) initial dcl 13-8 loop internal static bit(9) initial dcl 13-8 lt internal static bit(9) initial dcl 20-3 machine_state_node internal static bit(9) initial dcl 12-5 make_desc internal static bit(9) initial dcl 13-8 max_area_size internal static fixed bin(31,0) initial dcl 18-5 max_bit_string internal static fixed bin(31,0) initial dcl 18-5 max_bit_string_constant internal static fixed bin(31,0) initial dcl 18-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 18-5 max_char_string_constant internal static fixed bin(31,0) initial dcl 18-5 max_fun internal static bit(9) initial dcl 13-8 max_identifier_length internal static fixed bin(31,0) initial dcl 18-5 max_index_register_value internal static fixed bin(31,0) initial dcl 18-5 max_length_precision internal static fixed bin(31,0) initial dcl 18-5 max_list_elements internal static fixed bin(17,0) initial dcl 11-12 max_number_of_operands internal static fixed bin(15,0) initial dcl 14-15 max_offset_precision internal static fixed bin(31,0) initial dcl 18-5 max_p_bin_or_dec internal static fixed bin(31,0) initial dcl 18-5 max_p_dec internal static fixed bin(31,0) initial dcl 18-5 max_p_fix_bin_1 internal static fixed bin(31,0) initial dcl 18-5 max_p_fix_bin_2 internal static fixed bin(31,0) initial dcl 18-5 max_p_flt_bin_1 internal static fixed bin(31,0) initial dcl 18-5 max_p_flt_bin_2 internal static fixed bin(31,0) initial dcl 18-5 max_signed_index_register_value internal static fixed bin(31,0) initial dcl 18-5 max_signed_xreg_precision internal static fixed bin(31,0) initial dcl 18-5 max_uns_xreg_precision internal static fixed bin(31,0) initial dcl 18-5 max_words_per_variable internal static fixed bin(31,0) initial dcl 18-5 merge_attributes 000000 constant entry external dcl 2-355 min_area_size internal static fixed bin(31,0) initial dcl 18-5 min_fun internal static bit(9) initial dcl 13-8 minus internal static bit(9) initial dcl 20-3 mod_bit internal static bit(9) initial dcl 13-8 mod_byte internal static bit(9) initial dcl 13-8 mod_fun internal static bit(9) initial dcl 13-8 mod_half internal static bit(9) initial dcl 13-8 mod_word internal static bit(9) initial dcl 13-8 mult internal static bit(9) initial dcl 13-8 ne internal static bit(9) initial dcl 20-3 negate internal static bit(9) initial dcl 13-8 ngt internal static bit(9) initial dcl 20-3 nlt internal static bit(9) initial dcl 20-3 no_token internal static bit(9) initial dcl 20-3 nop internal static bit(9) initial dcl 13-8 not internal static bit(9) initial dcl 20-3 not_bits internal static bit(9) initial dcl 13-8 not_equal internal static bit(9) initial dcl 13-8 off_fun internal static bit(9) initial dcl 13-8 on_parse 000000 constant entry external dcl 1-116 on_parse$revert 000000 constant entry external dcl 1-123 open_file internal static bit(9) initial dcl 13-8 operator_node internal static bit(9) initial dcl 12-5 optimizer 000000 constant entry external dcl 2-361 or internal static bit(9) initial dcl 20-3 or_bits internal static bit(9) initial dcl 13-8 pack internal static bit(9) initial dcl 13-8 packed_digits_per_character internal static fixed bin(31,0) initial dcl 18-5 page_format internal static bit(9) initial dcl 13-8 param_desc_ptr internal static bit(9) initial dcl 13-8 param_ptr internal static bit(9) initial dcl 13-8 parameter_context internal static fixed bin(15,0) initial dcl 10-1 parse 000000 constant entry external dcl 1-128 parse_error$no_text 000000 constant entry external dcl 2-368 percent internal static bit(9) initial dcl 20-3 period internal static bit(9) initial dcl 20-3 picture_format internal static bit(9) initial dcl 13-8 pl1_error_print$listing_segment 000000 constant entry external dcl 2-384 pl1_error_print$write_out 000000 constant entry external dcl 2-372 pl1_mod_fun internal static bit(9) initial dcl 13-8 pl1_print$for_lex 000000 constant entry external dcl 2-418 pl1_print$non_varying 000000 constant entry external dcl 2-398 pl1_print$non_varying_nl 000000 constant entry external dcl 2-402 pl1_print$string_pointer 000000 constant entry external dcl 2-406 pl1_print$string_pointer_nl 000000 constant entry external dcl 2-410 pl1_print$unaligned_nl 000000 constant entry external dcl 2-414 pl1_print$varying 000000 constant entry external dcl 2-392 pl1_print$varying_nl 000000 constant entry external dcl 2-395 pl1_stat_$statement_id external static structure level 1 packed packed unaligned dcl 19-6 plus internal static bit(9) initial dcl 20-3 pointer_type internal static bit(36) initial dcl 18-71 prefix_plus internal static bit(9) initial dcl 13-8 procedure_parse 000000 constant entry external dcl 1-133 process_entry 000000 constant entry external dcl 1-143 ptr_fun internal static bit(9) initial dcl 13-8 put_control internal static bit(9) initial dcl 13-8 put_data_trans internal static bit(9) initial dcl 13-8 put_edit_trans internal static bit(9) initial dcl 13-8 put_field internal static bit(9) initial dcl 13-8 put_field_chk internal static bit(9) initial dcl 13-8 put_file internal static bit(9) initial dcl 13-8 put_list_trans internal static bit(9) initial dcl 13-8 put_string internal static bit(9) initial dcl 13-8 r_format internal static bit(9) initial dcl 13-8 r_parn internal static bit(9) initial dcl 13-8 range_ck internal static bit(9) initial dcl 13-8 rank_fun internal static bit(9) initial dcl 13-8 read_file internal static bit(9) initial dcl 13-8 real_fun internal static bit(9) initial dcl 13-8 real_type internal static bit(36) initial dcl 18-71 record_io internal static bit(9) initial dcl 13-8 refer_extent 000000 constant entry external dcl 2-426 rel_fun internal static bit(9) initial dcl 13-8 repeat_fun internal static bit(9) initial dcl 13-8 reserve$clear 000000 constant entry external dcl 2-430 reserve$declare_lib 000000 constant entry external dcl 2-434 reserve$read_lib 000000 constant entry external dcl 2-439 reserve$rename_parse 000000 constant entry external dcl 1-156 return_bits internal static bit(9) initial dcl 13-8 return_string internal static bit(9) initial dcl 13-8 return_value internal static bit(9) initial dcl 13-8 return_words internal static bit(9) initial dcl 13-8 reverse_fun internal static bit(9) initial dcl 13-8 revert_on internal static bit(9) initial dcl 13-8 rewrite_file internal static bit(9) initial dcl 13-8 round_fun internal static bit(9) initial dcl 13-8 search_fun internal static bit(9) initial dcl 13-8 search_rev_fun internal static bit(9) initial dcl 13-8 segno_fun internal static bit(9) initial dcl 13-8 semantic_translator 000000 constant entry external dcl 2-444 semantic_translator$abort 000000 constant entry external dcl 2-446 semantic_translator$error 000000 constant entry external dcl 2-450 setbitno_fun internal static bit(9) initial dcl 13-8 setcharno_fun internal static bit(9) initial dcl 13-8 sf_par_node internal static bit(9) initial dcl 12-5 share_expression 000000 constant entry external dcl 2-454 sign_fun internal static bit(9) initial dcl 13-8 signal_on internal static bit(9) initial dcl 13-8 sin_fun internal static bit(9) initial dcl 13-8 sind_fun internal static bit(9) initial dcl 13-8 skip_format internal static bit(9) initial dcl 13-8 slash internal static bit(9) initial dcl 20-3 source_node internal static bit(9) initial dcl 12-5 sqrt_fun internal static bit(9) initial dcl 13-8 stack_ptr internal static bit(9) initial dcl 13-8 stackbaseptr_fun internal static bit(9) initial dcl 13-8 stackframeptr_fun internal static bit(9) initial dcl 13-8 stacq_fun internal static bit(9) initial dcl 13-8 statement_node internal static bit(9) initial dcl 12-5 statement_parse 000000 constant entry external dcl 1-160 statement_type 000000 constant entry external dcl 1-167 std_arg_list internal static bit(9) initial dcl 13-8 std_call internal static bit(9) initial dcl 13-8 std_entry internal static bit(9) initial dcl 13-8 std_return internal static bit(9) initial dcl 13-8 stop internal static bit(9) initial dcl 13-8 storage_block_type internal static bit(36) initial dcl 18-71 stream_prep internal static bit(9) initial dcl 13-8 sub internal static bit(9) initial dcl 13-8 symbol_node internal static bit(9) initial dcl 12-5 system_bit_index internal static fixed bin(8,0) initial array packed unaligned dcl 15-48 system_keyword internal static char(16) initial array dcl 15-26 tan_fun internal static bit(9) initial dcl 13-8 tand_fun internal static bit(9) initial dcl 13-8 temporary_node internal static bit(9) initial dcl 12-5 terminate_trans internal static bit(9) initial dcl 13-8 token_list_length internal static fixed bin(15,0) initial dcl 19-4 translate_fun internal static bit(9) initial dcl 13-8 trunc_fun internal static bit(9) initial dcl 13-8 unlock_file internal static bit(9) initial dcl 13-8 unpack internal static bit(9) initial dcl 13-8 vclock_fun internal static bit(9) initial dcl 13-8 verify_fun internal static bit(9) initial dcl 13-8 verify_ltrim_fun internal static bit(9) initial dcl 13-8 verify_rev_fun internal static bit(9) initial dcl 13-8 verify_rtrim_fun internal static bit(9) initial dcl 13-8 word_to_mod2 internal static bit(9) initial dcl 13-8 word_to_mod4 internal static bit(9) initial dcl 13-8 word_to_mod8 internal static bit(9) initial dcl 13-8 wordno_fun internal static bit(9) initial dcl 13-8 words_per_condition_var internal static fixed bin(31,0) initial dcl 18-5 words_per_entry_var internal static fixed bin(31,0) initial dcl 18-5 words_per_file_var internal static fixed bin(31,0) initial dcl 18-5 words_per_fix_bin_1 internal static fixed bin(31,0) initial dcl 18-5 words_per_fix_bin_2 internal static fixed bin(31,0) initial dcl 18-5 words_per_flt_bin_1 internal static fixed bin(31,0) initial dcl 18-5 words_per_flt_bin_2 internal static fixed bin(31,0) initial dcl 18-5 words_per_format internal static fixed bin(31,0) initial dcl 18-5 words_per_label_var internal static fixed bin(31,0) initial dcl 18-5 words_per_offset internal static fixed bin(31,0) initial dcl 18-5 words_per_packed_pointer internal static fixed bin(31,0) initial dcl 18-5 words_per_pointer internal static fixed bin(31,0) initial dcl 18-5 words_per_varying_string_header internal static fixed bin(31,0) initial dcl 18-5 write_file internal static bit(9) initial dcl 13-8 x_format internal static bit(9) initial dcl 13-8 xor_bits internal static bit(9) initial dcl 13-8 NAMES DECLARED BY EXPLICIT CONTEXT. action 000000 constant label array(0:18) dcl 188 ref 202 216 attribute_parse 000553 constant entry external dcl 39 ck_parn 000572 constant label dcl 179 ref 231 262 272 282 295 305 332 345 357 372 408 469 exit 003347 constant label dcl 556 ref 520 533 fail 003716 constant label dcl 630 in procedure "initial_list" ref 579 581 598 610 627 fail 003353 constant label dcl 558 in procedure "refer_exp" ref 524 537 544 552 find_type 000611 constant label dcl 184 ref 307 317 379 get_scale 002674 constant entry internal dcl 478 ref 254 256 initial_list 003360 constant entry internal dcl 562 ref 314 597 next 000607 constant label dcl 182 ref 178 287 452 next_b 002411 constant label dcl 415 ref 442 next_entry 002170 constant label dcl 384 ref 405 nxt 002077 constant label dcl 365 ref 370 print 003722 constant entry internal dcl 634 ref 179 184 205 219 220 229 237 240 246 268 278 293 303 312 315 327 340 363 367 376 388 390 393 396 420 427 450 464 486 488 490 refer_exp 003065 constant entry internal dcl 510 ref 228 419 426 test 000635 constant label dcl 188 ref 223 232 263 273 283 288 309 319 334 347 359 380 409 454 474 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4236 4310 4011 4246 Length 5120 4011 52 574 225 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME attribute_parse 198 external procedure is an external procedure. get_scale internal procedure shares stack frame of external procedure attribute_parse. refer_exp internal procedure shares stack frame of external procedure attribute_parse. initial_list 85 internal procedure calls itself recursively. print internal procedure shares stack frame of external procedure attribute_parse. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME attribute_parse 000100 p attribute_parse 000102 q attribute_parse 000104 p1 attribute_parse 000106 p2 attribute_parse 000110 i attribute_parse 000111 letterx attribute_parse 000112 ndims attribute_parse 000113 type attribute_parse 000114 word attribute_parse 000117 defined_parn attribute_parse 000120 first_time attribute_parse 000121 star attribute_parse 000122 token_list_pointer attribute_parse 000132 temp get_scale 000142 p1 refer_exp 000144 p2 refer_exp initial_list 000100 ap initial_list 000102 factor initial_list 000104 value initial_list 000106 p1 initial_list 000110 p2 initial_list 000112 something_parsed initial_list THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp 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. constant_token context create_array create_bound create_list create_operator create_token declare_parse$abort defer_constant_token_list descriptor_parse expression_parse parse_error reference_parse token_to_binary THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_stat_$check_ansi pl1_stat_$one pl1_stat_$token_list_ptr LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 39 000546 19 3 000560 176 000563 177 000567 178 000571 179 000572 182 000607 184 000611 187 000625 188 000635 191 000644 193 000647 194 000652 195 000654 198 000656 200 000657 201 000661 202 000662 205 000665 207 000674 208 000705 209 000710 210 000730 212 000732 213 000733 214 000747 215 000751 216 000761 219 000770 220 000774 222 001000 223 001001 226 001004 228 001005 229 001012 231 001021 232 001022 235 001025 236 001027 237 001030 239 001063 240 001103 242 001110 243 001112 245 001126 246 001127 248 001162 249 001205 250 001207 251 001210 253 001216 254 001227 255 001240 256 001243 259 001271 262 001300 263 001301 266 001304 267 001305 268 001325 270 001336 272 001363 273 001364 276 001367 277 001370 278 001406 280 001415 282 001442 283 001443 286 001446 287 001451 288 001452 291 001455 292 001456 293 001474 295 001503 296 001504 298 001505 299 001510 300 001512 302 001513 303 001531 305 001540 307 001542 309 001543 312 001546 314 001555 315 001570 317 001577 319 001600 322 001603 323 001604 325 001620 327 001627 329 001633 330 001635 332 001655 334 001656 337 001661 339 001736 340 001743 342 001753 343 001760 345 001762 347 001763 350 001766 352 002046 355 002052 357 002067 359 002070 363 002073 365 002077 367 002101 369 002115 370 002117 372 002127 374 002130 376 002146 378 002155 379 002162 380 002163 383 002166 384 002170 386 002172 387 002205 388 002224 390 002233 392 002251 393 002253 395 002267 396 002313 398 002330 399 002332 400 002335 402 002344 404 002345 405 002346 407 002356 408 002361 409 002362 412 002373 413 002376 414 002410 415 002411 417 002412 418 002414 419 002420 420 002422 422 002432 424 002445 425 002446 426 002450 427 002452 430 002462 432 002463 435 002465 436 002470 437 002477 438 002504 439 002507 440 002511 442 002513 445 002524 446 002527 447 002542 449 002544 450 002552 452 002567 454 002570 457 002573 458 002574 460 002610 462 002617 464 002626 466 002632 467 002634 469 002654 471 002655 474 002673 478 002674 483 002676 484 002700 485 002715 486 002731 488 002741 490 002751 492 002762 497 002775 498 002777 499 003015 501 003025 502 003027 503 003045 506 003055 510 003065 515 003067 516 003070 517 003102 518 003105 519 003112 520 003113 522 003114 523 003131 524 003145 526 003151 529 003165 531 003166 533 003171 535 003203 536 003204 537 003211 539 003220 540 003221 541 003223 542 003240 543 003243 544 003262 546 003265 547 003272 549 003312 552 003335 554 003346 556 003347 558 003353 562 003357 569 003365 570 003367 571 003370 572 003371 573 003374 574 003405 575 003406 578 003431 579 003446 581 003452 583 003464 584 003465 585 003467 586 003470 588 003474 589 003505 590 003507 591 003510 593 003511 594 003513 597 003536 598 003550 600 003554 601 003555 602 003564 603 003566 604 003572 606 003573 609 003616 610 003633 614 003637 615 003652 616 003655 617 003657 618 003661 620 003667 622 003671 623 003672 624 003706 625 003707 627 003713 629 003715 630 003716 634 003722 639 003724 640 003727 641 003743 ----------------------------------------------------------- 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