COMPILATION LISTING OF SEGMENT mrpg_generate_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 02/14/84 0849.0 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /**** format: ind3,ll80,initcol6,indattr,^inddcls,dclind4,idind16 */ 12 /**** format: struclvlind2,^ifthenstmt,^ifthendo,^ifthen,^indnoniterdo */ 13 /**** format: ^inditerdo,^indnoniterend,^indthenelse,case,^indproc,^indend */ 14 /**** format: ^delnl,^insnl,comcol41,^indcom,^indblkcom,linecom,^indcomtxt */ 15 16 mrpg_generate_: proc (atreeptr, ename, aifp, code); 17 18 dcl atreeptr ptr, 19 ename char (32), 20 aifp ptr, /* pointer to source segment */ 21 code fixed bin (35); 22 23 P_skip, P_stop, P_bool_char, P_bool_dec, P_char_bool, P_char_dec, 24 P_dec_bool, P_dec_char, P_int, P_if = "0"b; 25 failed = 0; 26 tree_ptr = atreeptr; 27 if stop_sw then signal condition (stop_mrpg); 28 if db_sw then do; 29 call ioa_ ("table ^p ^p", table.b, table.e); 30 optr = table.b; 31 do while (optr ^= null ()); 32 call mrpg_dump_$list ((optr), 3); 33 optr = optr -> symtab.next; 34 end; 35 call ioa_ ("^/parm_pos ^p ^p ^i", 36 parm_pos.b, parm_pos.e, ppos_ct); 37 if (parm_pos.b ^= null ()) 38 then call mrpg_dump_$all (parm_pos.b, 0); 39 call ioa_ ("^/parm_key ^p ^p ^i", 40 parm_key.b, parm_key.e, pkey_ct); 41 if (parm_key.b ^= null ()) 42 then call mrpg_dump_$all (parm_key.b, 0); 43 call ioa_ ("^/parm_check ^p ^p", 44 parm_check.b, parm_check.e); 45 if (parm_check.b ^= null ()) 46 then call mrpg_dump_$all (parm_check.b, 0); 47 call ioa_ ("^/input ^p ^p", input.b, input.e); 48 if (input.b ^= null ()) 49 then call mrpg_dump_$all (input.b, 0); 50 call ioa_ ("^/input_check ^p ^p", 51 input_check.b, input_check.e); 52 if (input_check.b ^= null ()) 53 then call mrpg_dump_$all (input_check.b, 0); 54 call ioa_ ("^/rec_str,res_siz ^i ^i", rec_str, res_siz); 55 call ioa_ ("^/from ^p", from); 56 if (from ^= null ()) 57 then call mrpg_dump_$all (from, 0); 58 call ioa_ ("^/local ^p ^p", local.b, local.e); 59 if (local.b ^= null ()) 60 then call mrpg_dump_$all (local.b, 0); 61 call ioa_ ("^/report ^p ^p", tree.report.b, tree.report.e); 62 if (tree.report.b ^= null ()) 63 then call mrpg_dump_$all (tree.report.b, 0); 64 call ioa_ ("^/exec ^p ^p", exec.b, exec.e); 65 if (exec.b ^= null ()) 66 then call mrpg_dump_$all (exec.b, 0); 67 end; 68 err_sw = "0"b; 69 70 do symtabptr = table.b 71 repeat (symtabptr -> symtab.next) 72 while (symtabptr ^= null ()); 73 daptr = symtab.use.b; 74 if (symtab.type = "ID") 75 then if (datum.type = "SY") 76 then do; 77 call mrpg_error_ (3, (datum.line), 78 "Undeclared variable ""^a"".", symtab.data); 79 err_sw = "1"b; 80 end; 81 end; 82 83 if err_sw 84 then do; 85 code = 1; 86 return; 87 end; 88 macname = "macro"; 89 90 /* call macro_$library (macname, mrpg, code); */ 91 if (code ^= 0) 92 then return; 93 name = before (ename, ".mrpg"); 94 call get_seg_ptr_ (name || ".pl1", "010101"b, bc, optr, code); 95 on condition (cleanup) begin; 96 call macro_$free (db_sw); 97 call release_seg_ptr_ (optr, 0, code); 98 end; 99 ose = 0; 100 dcl err_sw bit (1); 101 dcl version char (32) int static options (constant) 102 init ("mrpg 1.1b of Oct 26, 1983"); 103 dcl dname char (168); 104 dcl dnamel fixed bin; 105 dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), 106 fixed bin (35)); 107 108 call hcs_$fs_get_path_name (aifp, dname, dnamel, " ", 0); 109 110 argl.p (1) = addr (version); 111 argl.l (1) = length (version); 112 113 argl.p (2) = addr (dname); 114 argl.l (2) = dnamel; 115 116 argl.p (3) = addrel (addr (name), 1); 117 argl.l (3) = length (name); 118 119 vtemp = ""; 120 if (from ^= null ()) 121 then call regen (from); 122 argl.p (4) = addrel (addr (vtemp), 1); 123 argl.l (4) = length (vtemp); 124 125 argct = 5; 126 ds (5) = rec_str; 127 call number; 128 129 argct = 6; 130 ds (6) = res_siz; 131 call number; 132 133 argct = 7; 134 argl.l (7) = 1; 135 if db_sw | lg_sw 136 then argl.p (7) = addr (digit (1)); 137 else argl.p (7) = addr (digit (0)); 138 139 argct = 8; 140 ds (argct) = ppos_ct + pkey_ct; 141 call number; 142 143 macname = "proc"; 144 call macro; 145 146 /* process parameters */ 147 148 if (ppos_ct > 0) 149 | (pkey_ct > 0) 150 then do; 151 ds (1) = ppos_ct; 152 ds (2) = pkey_ct; 153 154 argct = 1; 155 call number; 156 157 argct = 2; 158 call number; 159 160 macname = "parm_begin"; 161 argct = 2; 162 call macro; 163 164 macname = "parm_check"; 165 166 max_name = 0; 167 dflt_sw = "0"b; 168 paptr = parm_key.b; 169 do i = ppos_ct + 1 to ppos_ct + pkey_ct, -1, 1 to ppos_ct; 170 if (i = -1) 171 then do; 172 argct = 0; 173 paptr = parm_pos.b; 174 end; 175 else do; 176 srefptr = param.sym; 177 symtabptr = symref.sym; 178 argl.p (1) = addr (symtab.data); 179 argl.l (1) = symtab.leng; 180 max_name = max (max_name, symtab.leng); 181 182 argct = 2; 183 ds (argct) = i; 184 call number; 185 186 argct = 3; 187 if (param.kind = Bool) 188 then ds (argct) = -1; 189 else ds (argct) = param.leng; 190 call number; 191 192 atptr = param.attr.b; 193 do while (atptr ^= null ()); 194 if (attr.type = "KY") 195 then do; 196 argct = argct + 1; 197 srefptr = attr.sym; 198 symtabptr = symref.sym; 199 argl.p (argct) = addr (symtab.data); 200 argl.l (argct) = symtab.leng; 201 end; 202 else dflt_sw = "1"b; 203 atptr = attr.next; 204 end; 205 paptr = param.next; 206 end; 207 208 call macro; 209 end; 210 211 if dflt_sw 212 then do; 213 macname = "parm_default"; 214 paptr = parm_key.b; 215 do i = ppos_ct + 1 to ppos_ct + pkey_ct, -1, 1 to ppos_ct; 216 if (i = -1) 217 then do; 218 paptr = parm_pos.b; 219 end; 220 else do; 221 srefptr = param.sym; 222 symtabptr = symref.sym; 223 argl.p (1) = addr (symtab.data); 224 argl.l (1) = symtab.leng; 225 226 argct = 2; 227 ds (argct) = i; 228 call number; 229 230 argct = 3; 231 if (param.kind = Bool) 232 then ds (argct) = -1; 233 else ds (argct) = param.leng; 234 call number; 235 236 atptr = param.attr.b; 237 do while (atptr ^= null ()); 238 if (attr.type = "DV") 239 then do; 240 argct = 4; 241 call expr (attr.sym, argl.p (4), argl.l (4)); 242 call macro; 243 atptr = null (); 244 end; 245 else atptr = attr.next; 246 end; 247 paptr = param.next; 248 end; 249 end; 250 end; 251 252 argct = 1; 253 ds (argct) = max_name; 254 call number; 255 argct = 1; 256 macname = "parm_end"; 257 call macro; 258 end; 259 260 261 /* process local declaration */ 262 macname = "local"; 263 do daptr = tree.local.b 264 repeat (datum.next) 265 while (daptr ^= null ()); 266 267 LINE = datum.line; 268 argl.l (1) = 4; 269 argl.p (1) = addr (LINE); 270 dcl LINE pic "zzz9"; 271 srefptr = datum.sym; 272 symtabptr = symref.sym; 273 if (index (symtab.data, ".") = 0) 274 then do; 275 argl.p (2) = addr (symtab.data); 276 argl.l (2) = symtab.leng; 277 278 if (datum.kind = Set) 279 | (datum.kind = Table) 280 | (datum.kind = Tablev) 281 then do; 282 if (symtab.use.b = symtab.use.e) 283 then call mrpg_error_ (1, (datum.line), 284 """^a"" is not referenced.", symtab.data); 285 else do; 286 if (datum.datal.b -> opn.op = n_n) 287 then do; 288 argl.p (3), argl.p (4) = addr (t_n); 289 argl.l (3), argl.l (4) = length (t_n); 290 end; 291 else if (datum.datal.b -> opn.op = n_s) 292 then do; 293 argl.p (3) = addr (t_n); 294 argl.l (3) = length (t_n); 295 argl.p (4) = addr (t_c); 296 argl.l (4) = length (t_c) - 3; 297 end; 298 else if (datum.datal.b -> opn.op = s_n) 299 then do; 300 argl.p (3) = addr (t_c); 301 argl.l (3) = length (t_c) - 3; 302 argl.p (4) = addr (t_n); 303 argl.l (4) = length (t_n); 304 end; 305 else do; 306 argl.p (3), argl.p (4) = addr (t_c); 307 argl.l (3), argl.l (4) = length (t_c) - 3; 308 end; 309 if (datum.kind = Set) 310 then argct = 3; 311 else argct = 4; 312 if (datum.kind = Tablev) 313 then argl.l (4) = argl.l (4) + 3; 314 macname = "table"; 315 316 call macro; 317 318 argct = 1; 319 do opptr = datum.datal.b 320 repeat (opn.next) 321 while (opptr ^= null ()); 322 symtabptr = opn.op1 -> symref.sym; 323 argl.p (1) = addr (symtab.data); 324 argl.l (1) = symtab.leng; 325 if (opn.op2 ^= null ()) 326 then do; 327 argct = 2; 328 symtabptr = opn.op2 -> symref.sym; 329 argl.p (2) = addr (symtab.data); 330 argl.l (2) = symtab.leng; 331 end; 332 call macro; 333 end; 334 argct = 0; 335 call macro; 336 macname = "local"; 337 end; 338 end; 339 else do; 340 argct = 3; 341 ds (argct) = datum.pos; 342 call number; 343 344 argl.p (4) = addrel (addr (kind_char (datum.kind)), 1); 345 argl.l (4) = length (kind_char (datum.kind)); 346 347 argct = 5; 348 ds (argct) = datum.leng; 349 call number; 350 351 call expr (datum.datal.b, argl.p (6), argl.l (6)); 352 353 argct = 6; 354 call macro; 355 end; 356 end; 357 end; 358 359 /* process report specifications */ 360 dcl digit (0:9) char (1) int static init ( 361 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"); 362 363 do repptr = tree.report.b 364 repeat (report.next) 365 while (repptr ^= null ()); 366 do pt = "PF1", "PH1", "ON0", "BR0", "DFn", "RF1", "RH1", "DHn", "DTn"; 367 rc = substr (pt, 3, 1); 368 substr (pt, 3, 1) = " "; 369 macname = "report"; 370 argl.p (1) = addr (pt); 371 argl.l (1) = 2; 372 if (pt = "PF") 373 then do; 374 srefptr = report.sym; 375 symtabptr = symref.sym; 376 argl.p (2) = addr (symtab.data); 377 argl.l (2) = symtab.leng; 378 379 argct = 3; 380 ds (argct) = report.pw; 381 call number; 382 383 argct = 4; 384 ds (argct) = report.pl; 385 call number; 386 387 argct = 5; 388 ds (argct) = report.minl; 389 call number; 390 391 argct = 6; 392 ds (argct) = report.maxl; 393 call number; 394 end; 395 if (rc ^= "n") /* PF, PH, ON, BR, RF, RH */ 396 then call macro; 397 398 if (rc ^= "0") /* PF, PH, DF, RF, RH, DH, DT */ 399 then do partptr = report.part.b 400 repeat (part.next) 401 while (partptr ^= null ()); 402 if (part.type = pt) 403 then do; 404 if (rc = "n") /* DF, DH, DT */ 405 then do; 406 srefptr = part.sym; 407 symtabptr = symref.sym; 408 argct = 2; 409 if (pt = "DT") 410 then do; 411 argl.p (2) = addr (symtab.data); 412 argl.l (2) = symtab.leng; 413 414 argct = 3; 415 ds (argct) = part.maxl; 416 call number; 417 end; 418 else do; 419 i = 0; 420 do srefptr = report.brlist.b 421 repeat (symref.next) 422 while (srefptr ^= null ()); 423 i = i + 1; 424 if (symref.sym = symtabptr) 425 then goto br_found; 426 end; 427 /* error */ 428 br_found: 429 ds (argct) = i; 430 call number; 431 end; 432 433 if (part.ctl ^= null ()) 434 then do; 435 argct = 4; 436 call expr (part.ctl, argl.p (4), argl.l (4)); 437 end; 438 macname = "report"; 439 argl.p (1) = addr (pt); 440 argl.l (1) = 2; 441 call macro; 442 end; 443 call put_part; 444 end; 445 end; 446 if (pt = "ON") 447 then do; 448 macname = "on"; 449 argct = 4; 450 do valptr = report.onlist.b 451 repeat (value.next) 452 while (valptr ^= null ()); 453 argl.l (1) = 2; 454 argl.p (1) = addr (value.type); 455 456 vtemp = ""; 457 call expr (value.ctl, argl.p (3), argl.l (3)); 458 459 argl.p (2) = addr (argl.p (3) -> car (argl.l (3) + 1)); 460 call regen (value.sym); 461 argl.l (2) = length (vtemp) - argl.l (3); 462 463 ds (argct) = value.numb; 464 call number; 465 466 call macro; 467 end; 468 end; 469 470 if (pt = "BR") 471 then do; 472 macname = "break"; 473 i = 0; 474 do srefptr = report.brlist.b 475 repeat (symref.next) 476 while (srefptr ^= null ()); 477 symtabptr = symref.sym; 478 daptr = symtab.use.b; 479 argl.p (1) = addr (symtab.data); 480 argl.l (1) = symtab.leng; 481 482 i = i + 1; 483 argct = 2; 484 ds (argct) = i; 485 call number; 486 487 argl.p (3) = addrel (addr (kind_char (datum.kind)), 1); 488 argl.l (3) = length (kind_char (datum.kind)); 489 490 argct = 4; 491 ds (argct) = datum.leng; 492 call number; 493 494 call macro; 495 end; 496 end; 497 end; 498 499 macname = "report"; 500 argl.p (1) = addr (digit (9)); 501 argl.l (1) = 1; 502 503 argct = 1; 504 call macro; 505 506 end; 507 /* process input declaration */ 508 macname = "input"; 509 argct = 0; 510 call macro; 511 512 macname = "input_field"; 513 do daptr = tree.input.b 514 repeat (datum.next) 515 while (daptr ^= null ()); 516 517 LINE = datum.line; 518 argl.l (1) = 4; 519 argl.p (1) = addr (LINE); 520 srefptr = datum.sym; 521 if (srefptr ^= null ()) 522 then do; 523 symtabptr = symref.sym; 524 argl.p (2) = addr (symtab.data); 525 argl.l (2) = symtab.leng; 526 end; 527 else do; 528 argl.p (2) = addr (digit (0)); 529 argl.l (2) = 0; 530 end; 531 532 argct = 3; 533 ds (argct) = datum.pos; 534 call number; 535 536 argl.p (4) = addrel (addr (kind_char (datum.kind)), 1); 537 argl.l (4) = length (kind_char (datum.kind)); 538 539 argct = 5; 540 ds (argct) = datum.leng; 541 call number; 542 543 vtemp = ""; 544 call expr (datum.datal.b, argl.p (6), argl.l (6)); 545 546 argct = 6; 547 call macro; 548 end; 549 /* process executable */ 550 551 macname = "exec"; 552 argct = 0; 553 call macro; 554 555 call stmt_exp (tree.exec.b); 556 557 macname = "exec"; 558 argct = 0; 559 call macro; 560 561 argct = 6; 562 argl.p (1) = addr (I_day); 563 if tree.day 564 then argl.l (1) = 5; 565 else argl.l (1) = 0; 566 567 argl.p (2) = addr (I_hhmmss); 568 if tree.hhmmss 569 then argl.l (2) = 8; 570 else argl.l (2) = 0; 571 572 argl.p (3) = addr (I_mmddyy); 573 if tree.mmddyy 574 then argl.l (3) = 8; 575 else argl.l (3) = 0; 576 577 argl.p (4) = addr (I_month); 578 if tree.month 579 then argl.l (4) = 7; 580 else argl.l (4) = 0; 581 582 argl.p (5) = addr (I_yyddd); 583 if tree.yyddd 584 then argl.l (5) = 7; 585 else argl.l (5) = 0; 586 587 vtemp = ""; 588 if P_skip 589 then vtemp = vtemp || "&let P_skip=1&;"; 590 if P_stop 591 then vtemp = vtemp || "&let P_stop=1&;"; 592 if P_bool_char 593 then vtemp = vtemp || "&let P_bool_char=1&;"; 594 if P_bool_dec 595 then vtemp = vtemp || "&let P_bool_dec=1&;"; 596 if P_char_bool 597 then vtemp = vtemp || "&let P_char_bool=1&;"; 598 if P_char_dec 599 then vtemp = vtemp || "&let P_char_dec=1&;"; 600 if P_dec_bool 601 then vtemp = vtemp || "&let P_dec_bool=1&;"; 602 if P_dec_char 603 then vtemp = vtemp || "&let P_dec_char=1&;"; 604 if P_int 605 then vtemp = vtemp || "&let P_int=1&;"; 606 if P_if 607 then vtemp = vtemp || "&let P_if=1&;"; 608 argl.p (6) = addrel (addr (vtemp), 1); 609 argl.l (6) = length (vtemp); 610 611 macname = "end"; 612 call macro; 613 exit: 614 call macro_$free (db_sw); 615 call release_seg_ptr_ (optr, ose * 9, code); 616 if (failed ^= 0) 617 then call mrpg_error_ (failed, 0, "Unable to complete translation"); 618 code = failed; 619 return; 620 stmt_exp: proc (stmtp); 621 622 dcl stmtp ptr unal; 623 dcl tp ptr; 624 625 do stmtptr = stmtp 626 repeat (stmt.next) 627 while (stmtptr ^= null ()); 628 tp = stmtptr; 629 if (stmt.type = "IF") 630 then do; 631 macname = "if"; 632 argct = 1; 633 ds (argct) = 1; 634 call number; 635 636 argct = 2; 637 call expr (stmt.ref1.b, argl.p (2), argl.l (2)); 638 639 call macro; 640 call stmt_exp (tp -> stmt.ref2.b); 641 if (tp -> stmt.ref3.b ^= null ()) 642 then do; 643 macname = "if"; 644 argct = 1; 645 ds (argct) = 2; 646 call number; 647 call macro; 648 649 call stmt_exp (tp -> stmt.ref3.b); 650 end; 651 macname = "if"; 652 argct = 1; 653 ds (argct) = 3; 654 call number; 655 call macro; 656 end; 657 else if (stmt.type = ":=") 658 | (stmt.type = "=:") 659 then do; 660 macname = "assign"; 661 argct = 4; 662 663 srefptr = stmt.ref1.b; 664 symtabptr = symref.sym; 665 argl.p (1) = addr (symtab.data); 666 argl.l (1) = symtab.leng; 667 668 vtemp = ""; 669 call expr (stmt.ref2.b, argl.p (2), argl.l (2)); 670 671 argl.l (3) = 2; 672 argl.p (3) = addr (stmt.type); 673 674 ds (argct) = symref.line; 675 call number; 676 677 call macro; 678 end; 679 else if (stmt.type = "PR") 680 then do; 681 macname = "print"; 682 argct = 1; 683 684 srefptr = stmt.ref1.b; 685 symtabptr = symref.sym; 686 argl.p (1) = addr (symtab.data); 687 argl.l (1) = symtab.leng; 688 689 call macro; 690 end; 691 else if (stmt.type = "SR") 692 | (stmt.type = "SU") 693 | (stmt.type = "HD") 694 then do; 695 macname = "sort"; 696 argct = 1; 697 argl.l (1) = 2; 698 argl.p (1) = addr (stmt.type); 699 700 call macro; 701 702 argct = 4; 703 do atptr = stmt.ref2.b 704 repeat (attr.next) 705 while (atptr ^= null ()), 706 stmt.ref1.b 707 repeat (attr.next) 708 while (atptr ^= null ()); 709 dcl A char (1) int static init ("A"); 710 dcl D char (1) int static init ("D"); 711 argl.p (1) = addr (A); 712 if (attr.type = "KY") 713 then do; 714 if attr.des 715 then argl.p (1) = addr (D); 716 argl.l (1) = 1; 717 srefptr = attr.sym; 718 end; 719 else do; 720 argl.l (1) = 0; 721 srefptr = atptr; 722 end; 723 if (symref.type ^= "SY") 724 then do; 725 call mrpg_error_ (3, (symref.line), "SORT/HOLD fields cannot be expressions."); 726 end; 727 else do; 728 symtabptr = symref.sym; 729 argl.l (2) = symtab.leng; 730 argl.p (2) = addr (symtab.data); 731 732 daptr = symtab.use.b; 733 argl.p (3) = addrel (addr (kind_char (datum.kind)), 1); 734 argl.l (3) = length (kind_char (datum.kind)); 735 736 argct = 4; 737 ds (argct) = datum.leng; 738 call number; 739 740 call macro; 741 end; 742 end; 743 argct = 0; 744 call macro; 745 end; 746 else if (stmt.type = "BG") 747 then do; 748 macname = "bg"; 749 argct = 1; 750 ds (argct) = 1; 751 call number; 752 call macro; 753 754 call stmt_exp (tp -> stmt.ref1.b); 755 call stmt_exp (tp -> stmt.ref2.b); 756 macname = "bg"; 757 argct = 1; 758 ds (argct) = 2; 759 call number; 760 call macro; 761 call stmt_exp (tp -> stmt.ref3.b); 762 macname = "bg"; 763 argct = 1; 764 ds (argct) = 3; 765 call number; 766 call macro; 767 768 end; 769 else if (stmt.type = "NT") 770 then ; 771 else do; 772 call mrpg_error_ (3, 0, "Invalid stmt.type ""^a""", stmt.type); 773 end; 774 stmtptr = tp; 775 776 end; 777 end stmt_exp; 778 put_part: proc; 779 780 dcl tptr ptr; 781 782 do linptr = part.lines.b 783 repeat (lines.next) 784 while (linptr ^= null ()); 785 argl.p (1) = addr (digit (1)); 786 argl.l (1) = 1; 787 788 argct = 2; 789 ds (argct) = lines.number; 790 call number; 791 792 call expr (lines.ctl, argl.p (3), argl.l (3)); 793 794 argct = 3; 795 macname = "line"; 796 call macro; 797 798 do fldptr = lines.field.b 799 repeat (field.next) 800 while (fldptr ^= null ()); 801 do stmtptr = field.let.b 802 repeat (stmt.next) 803 while (stmtptr ^= null ()); 804 vtemp = ""; 805 tptr = stmtptr; 806 exec_loop: 807 if (tptr -> stmt.type = "IF") 808 then do; 809 macname = "if"; 810 811 argct = 1; 812 call expr (tptr -> stmt.ref1.b, argl.p (1), argl.l (1)); 813 814 call macro; 815 stmtptr = tptr -> stmt.ref2.b; 816 goto exec_loop; 817 end; 818 else if (tptr -> stmt.type = ":=") 819 | (tptr -> stmt.type = "=:") 820 then do; 821 macname = "assign"; 822 argct = 4; 823 824 srefptr = tptr -> stmt.ref1.b; 825 symtabptr = symref.sym; 826 argl.p (1) = addr (symtab.data); 827 argl.l (1) = symtab.leng; 828 829 call expr (tptr -> stmt.ref2.b, argl.p (2), argl.l (2)); 830 831 argl.l (3) = 2; 832 argl.p (3) = addr (tptr -> stmt.type); 833 834 ds (argct) = symref.line; 835 call number; 836 837 call macro; 838 end; 839 else if (tptr -> stmt.type = "cP") 840 then do; 841 macname = "picture"; 842 goto pic_edit; 843 end; 844 else if (tptr -> stmt.type = "cE") 845 then do; 846 macname = "edit"; 847 pic_edit: 848 argct = 3; 849 850 srefptr = tptr -> stmt.ref1.b; 851 symtabptr = symref.sym; 852 argl.p (1) = addr (symtab.data); 853 argl.l (1) = symtab.leng; 854 855 call expr (tptr -> stmt.ref2.b, argl.p (2), argl.l (2)); 856 857 srefptr = tptr -> stmt.ref2.e; 858 symtabptr = symref.sym; 859 argl.p (3) = addr (symtab.data); 860 argl.l (3) = symtab.leng; 861 862 call macro; 863 end; 864 else do; 865 call mrpg_error_ (2, 0, "Unknown stmt.type ""^a""", tptr -> stmt.type); 866 end; 867 end; 868 P_ctl = "000000000"; 869 valptr = field.value.b; 870 srefptr = value.sym; 871 symtabptr = symref.sym; 872 argl.p (1) = addr (symtab.data); 873 argl.l (1) = symtab.leng; 874 875 if (symtab.type = "ID") 876 then do; 877 daptr = symtab.use.b; 878 argct = 2; 879 ds (argct) = datum.kind; 880 call number; 881 882 argct = 3; 883 ds (argct) = datum.leng; 884 call number; 885 if (datum.kind = Decimal) 886 then do; 887 P.numeric = "1"; 888 if (field.align = 0) 889 then P.space = "1"; 890 end; 891 end; 892 else do; 893 argct = 2; 894 if (symtab.type = "NU") 895 then do; 896 ds (argct) = Decimal; 897 P.numeric = "1"; 898 if (field.align = 0) 899 then P.right = "1"; 900 end; 901 else do; 902 ds (argct) = Char; 903 end; 904 call number; 905 906 argl.l (3) = 1; 907 argl.p (3) = addr (digit (0)); 908 end; 909 910 argct = 4; 911 ds (argct) = field.col; 912 call number; 913 914 argct = 5; 915 ds (argct) = field.leng; 916 call number; 917 if (field.leng = 0) & (symtab.type ^= "ST") 918 then P.space = "1"; 919 920 argct = 6; 921 dcl P_ctl char (9); 922 dcl 1 P defined (P_ctl), 923 2 (bsp, left, center, right, align, numeric, space) char (1); 924 if field.bsp 925 then P.bsp = "1"; 926 if (field.align >= 8) & (field.align <= 11) 927 then substr (P_ctl, field.align - 6, 1) = "1"; 928 argl.l (6) = 9; 929 argl.p (6) = addr (P_ctl); 930 931 argct = 7; 932 argl.l (7) = 1; 933 argl.p (7) = addr (field.alch); 934 935 /* take care of fill(1:2) */ /* */ 936 937 macname = "value"; 938 call macro; 939 end; 940 macname = "line"; 941 argct = 1; 942 943 argl.p (1) = addr (digit (2)); 944 argl.l (1) = 1; 945 946 call macro; 947 end; 948 949 end put_part; 950 number: proc; 951 952 dcl i fixed bin; 953 954 i = index (reverse (ds (argct)), " "); 955 argl.p (argct) = addr (substr (ds (argct), 10 - i, 1)); 956 argl.l (argct) = i - 1; 957 958 end number; 959 macro: proc; 960 961 call macro_ ("mrpg_lib", "mrpg", macname, optr, ose, 962 addr (argl), argct, msg, codeptr (macro), code); 963 if (code ^= 0) 964 then do; 965 if (code = error_table_$translation_failed) 966 | (code = error_table_$badsyntax) 967 then do; 968 failed = 2; 969 code = 0; 970 end; 971 if (code = error_table_$translation_aborted) 972 then do; 973 ose = 0; 974 failed = 3; 975 call com_err_ (code, "mrpg", "^a", msg); 976 goto exit; 977 end; 978 call ioa_ ("^a", msg); 979 code = 0; 980 end; 981 982 end macro; 983 expr: proc (axptr, rptr, rlen); 984 985 dcl axptr ptr unal, /* pointer to node to expand */ 986 rptr ptr, /* pointer to argument (OUT) */ 987 rlen fixed bin; /* length of argument */ 988 dcl xptr ptr; 989 990 vtemp = ""; 991 xptr = axptr; 992 if (xptr ^= null ()) 993 then do; 994 call regen ((xptr)); 995 end; 996 rptr = addrel (addr (vtemp), 1); 997 rlen = length (vtemp); 998 return; 999 1000 /* note that only 1 expr of this kind can used in one macro call */ 1001 1002 end expr; 1003 1004 dcl P_skip bit (1); 1005 dcl P_stop bit (1); 1006 dcl P_bool_char bit (1); 1007 dcl P_bool_dec bit (1); 1008 dcl P_char_bool bit (1); 1009 dcl P_char_dec bit (1); 1010 dcl P_dec_bool bit (1); 1011 dcl P_dec_char bit (1); 1012 dcl P_int bit (1); 1013 dcl P_if bit (1); 1014 regen: proc (xptr); 1015 1016 dcl xptr ptr unal; 1017 1018 if (xptr -> stmt.type = "VL") 1019 then do; 1020 call regen (xptr -> value.sym); 1021 return; 1022 end; 1023 if (xptr -> stmt.type = "SY") 1024 then do; 1025 call regen (xptr -> symref.sym); 1026 return; 1027 end; 1028 1029 if (xptr -> stmt.type = "ID") 1030 | (xptr -> stmt.type = "NU") 1031 | (xptr -> stmt.type = "ST") 1032 then do; 1033 vtemp = vtemp || xptr -> symtab.data; 1034 return; 1035 end; 1036 1037 if (xptr -> stmt.type = "OP") 1038 then do; 1039 1040 /* Level => ( op1 .I_level <= op2 ) */ 1041 if (xptr -> opn.op = Level) 1042 then do; 1043 vtemp = vtemp || "("; 1044 call regen (xptr -> opn.op1); 1045 vtemp = vtemp || ".I_level <= "; 1046 call regen (xptr -> opn.op2); 1047 vtemp = vtemp || ")"; 1048 return; 1049 end; 1050 1051 1052 /* Beg => (before ( op1 , op2 ) = "") */ 1053 if (xptr -> opn.op = Beg) 1054 then do; 1055 vtemp = vtemp || "(before ("; 1056 call regen (xptr -> opn.op1); 1057 vtemp = vtemp || ","; 1058 call regen (xptr -> opn.op2); 1059 vtemp = vtemp || ") = """")"; 1060 return; 1061 end; 1062 1063 1064 /* Nbeg => (before ( op1 , op2 ) ^= "") */ 1065 if (xptr -> opn.op = Nbeg) 1066 then do; 1067 vtemp = vtemp || "(before ("; 1068 call regen (xptr -> opn.op1); 1069 vtemp = vtemp || ","; 1070 call regen (xptr -> opn.op2); 1071 vtemp = vtemp || ") ^= """")"; 1072 return; 1073 end; 1074 1075 1076 /* End => (before ( reverse( op1 ) , reverse( op2 ) ) = "") */ 1077 if (xptr -> opn.op = End) 1078 then do; 1079 vtemp = vtemp || "(before (reverse ("; 1080 call regen (xptr -> opn.op1); 1081 vtemp = vtemp || "), reverse ("; 1082 call regen (xptr -> opn.op2); 1083 vtemp = vtemp || ")) = """")"; 1084 return; 1085 end; 1086 1087 1088 /* Nend => (before ( reverse( op1 ) , reverse( op2 ) ) ^= "") */ 1089 if (xptr -> opn.op = Nend) 1090 then do; 1091 vtemp = vtemp || "(before (reverse ("; 1092 call regen (xptr -> opn.op1); 1093 vtemp = vtemp || "), reverse ("; 1094 call regen (xptr -> opn.op2); 1095 vtemp = vtemp || ")) ^= """")"; 1096 return; 1097 end; 1098 1099 1100 /* Cont => (index ( op1 , op2 ) ^= 0) */ 1101 if (xptr -> opn.op = Cont) 1102 then do; 1103 vtemp = vtemp || "(index ("; 1104 call regen (xptr -> opn.op1); 1105 vtemp = vtemp || ","; 1106 call regen (xptr -> opn.op2); 1107 vtemp = vtemp || ") ^= 0)"; 1108 return; 1109 end; 1110 1111 1112 /* Ncont => (index ( op1 , op2 ) = 0) */ 1113 if (xptr -> opn.op = Ncont) 1114 then do; 1115 vtemp = vtemp || "(index ("; 1116 call regen (xptr -> opn.op1); 1117 vtemp = vtemp || ","; 1118 call regen (xptr -> opn.op2); 1119 vtemp = vtemp || ") = 0)"; 1120 return; 1121 end; 1122 1123 1124 /* Begw => (before ( op1 ||" " , op2 ||" " ) = "") */ 1125 if (xptr -> opn.op = Beg) 1126 then do; 1127 vtemp = vtemp || "(before ("; 1128 call regen (xptr -> opn.op1); 1129 vtemp = vtemp || "||"" "", "; 1130 call regen (xptr -> opn.op2); 1131 vtemp = vtemp || "||"" "") = """")"; 1132 return; 1133 end; 1134 1135 1136 /* Nbegw => (before ( op1 ||" " , op2 ||" " ) ^= "") */ 1137 if (xptr -> opn.op = Nbeg) 1138 then do; 1139 vtemp = vtemp || "(before ("; 1140 call regen (xptr -> opn.op1); 1141 vtemp = vtemp || "||"" "", "; 1142 call regen (xptr -> opn.op2); 1143 vtemp = vtemp || "||"" "") ^= """")"; 1144 return; 1145 end; 1146 1147 1148 /* Endw => (before ( reverse( " "|| op1 ) , reverse( " "|| op2 ) ) = "") */ 1149 if (xptr -> opn.op = End) 1150 then do; 1151 vtemp = vtemp || "(before (reverse ( "" ""||"; 1152 call regen (xptr -> opn.op1); 1153 vtemp = vtemp || "), reverse ( "" ""||"; 1154 call regen (xptr -> opn.op2); 1155 vtemp = vtemp || ")) = """")"; 1156 return; 1157 end; 1158 1159 1160 /* Nendw => (before ( reverse( " "|| op1 ) , reverse( op2 ) ) ^= "") */ 1161 if (xptr -> opn.op = Nend) 1162 then do; 1163 vtemp = vtemp || "(before (reverse ( "" ""||"; 1164 call regen (xptr -> opn.op1); 1165 vtemp = vtemp || "), reverse ( "" ""||"; 1166 call regen (xptr -> opn.op2); 1167 vtemp = vtemp || ")) ^= """")"; 1168 return; 1169 end; 1170 1171 1172 /* Contw => (index ( " "|| op1 ||" " , " "|| op2 ||" " ) = 0) */ 1173 if (xptr -> opn.op = Cont) 1174 then do; 1175 vtemp = vtemp || "(index ( "" ""||"; 1176 call regen (xptr -> opn.op1); 1177 vtemp = vtemp || "||"" "", "" ""||"; 1178 call regen (xptr -> opn.op2); 1179 vtemp = vtemp || "||"" "") = 0)"; 1180 return; 1181 end; 1182 1183 1184 /* Ncontw => (index ( " "|| op1 ||" " , op2 ) ^= 0) */ 1185 if (xptr -> opn.op = Ncont) 1186 then do; 1187 vtemp = vtemp || "(index ( "" ""||"; 1188 call regen (xptr -> opn.op1); 1189 vtemp = vtemp || "||"" "", "" ""||"; 1190 call regen (xptr -> opn.op2); 1191 vtemp = vtemp || "||"" "") ^= 0)"; 1192 return; 1193 end; 1194 1195 1196 /* In => op1 ( op2 ) */ 1197 if (xptr -> opn.op = In) 1198 then do; 1199 call regen (xptr -> opn.op1); 1200 vtemp = vtemp || "("; 1201 call regen (xptr -> opn.op2); 1202 vtemp = vtemp || ")"; 1203 return; 1204 end; 1205 1206 1207 /* Nin => ^ op1 ( op2 ) */ 1208 if (xptr -> opn.op = Nin) 1209 then do; 1210 vtemp = vtemp || "^"; 1211 call regen (xptr -> opn.op1); 1212 vtemp = vtemp || "("; 1213 call regen (xptr -> opn.op2); 1214 vtemp = vtemp || ")"; 1215 return; 1216 end; 1217 1218 /* Skip => if ( op1 ) then call P_skip( op2 ); */ 1219 if (xptr -> opn.op = Skip) 1220 then do; 1221 vtemp = vtemp || "if ("; 1222 call regen (xptr -> opn.op1); 1223 P_skip = "1"b; 1224 vtemp = vtemp || ") then call P_skip("; 1225 call regen (xptr -> opn.op2); 1226 vtemp = vtemp || ");"; 1227 return; 1228 end; 1229 1230 1231 /* Stop => if ( op1 ) then call P_stop( op2 ); */ 1232 if (xptr -> opn.op = Stop) 1233 then do; 1234 vtemp = vtemp || "if ("; 1235 call regen (xptr -> opn.op1); 1236 P_stop = "1"b; 1237 vtemp = vtemp || ") then call P_stop("; 1238 call regen (xptr -> opn.op2); 1239 vtemp = vtemp || ");"; 1240 return; 1241 end; 1242 1243 1244 /* Tran => op1 ( op2 ) */ 1245 if (xptr -> opn.op = Tran) 1246 then do; 1247 call regen (xptr -> opn.op1); 1248 vtemp = vtemp || "("; 1249 call regen (xptr -> opn.op2); 1250 vtemp = vtemp || ")"; 1251 return; 1252 end; 1253 1254 1255 /* n_s => n_s */ 1256 if (xptr -> opn.op = n_s) 1257 then do; 1258 vtemp = vtemp || "n_s"; 1259 return; 1260 end; 1261 1262 1263 /* s_n => s_n */ 1264 if (xptr -> opn.op = s_n) 1265 then do; 1266 vtemp = vtemp || "s_n"; 1267 return; 1268 end; 1269 1270 1271 /* s_s => s_s */ 1272 if (xptr -> opn.op = s_s) 1273 then do; 1274 vtemp = vtemp || "s_s"; 1275 return; 1276 end; 1277 1278 1279 /* b_c => P_bool_char( op1 ) */ 1280 if (xptr -> opn.op = b_c) 1281 then do; 1282 P_bool_char = "1"b; 1283 vtemp = vtemp || "P_bool_char("; 1284 call regen (xptr -> opn.op1); 1285 vtemp = vtemp || ")"; 1286 return; 1287 end; 1288 1289 1290 /* b_d => P_bool_dec( op1 ) */ 1291 if (xptr -> opn.op = b_d) 1292 then do; 1293 P_bool_dec = "1"b; 1294 vtemp = vtemp || "P_bool_dec("; 1295 call regen (xptr -> opn.op1); 1296 vtemp = vtemp || ")"; 1297 return; 1298 end; 1299 1300 1301 /* c_b => P_char_bool( op1 ) */ 1302 if (xptr -> opn.op = c_b) 1303 then do; 1304 P_char_bool = "1"b; 1305 vtemp = vtemp || "P_char_bool(("; 1306 call regen (xptr -> opn.op1); 1307 vtemp = vtemp || "))"; 1308 return; 1309 end; 1310 1311 1312 /* c_d => convert(F_d20, op1 ) */ 1313 if (xptr -> opn.op = c_d) 1314 then do; 1315 vtemp = vtemp || "convert(F_d20,"; 1316 call regen (xptr -> opn.op1); 1317 vtemp = vtemp || ")"; 1318 return; 1319 end; 1320 1321 1322 /* d_b => P_dec_bool( op1) */ 1323 if (xptr -> opn.op = d_b) 1324 then do; 1325 P_dec_bool = "1"b; 1326 vtemp = vtemp || "P_dec_bool("; 1327 call regen (xptr -> opn.op1); 1328 vtemp = vtemp || ")"; 1329 return; 1330 end; 1331 1332 1333 /* d_c => P_dec_char */ 1334 /* ( op1 ) */ 1335 if (xptr -> opn.op = d_c) 1336 then do; 1337 P_dec_char = "1"b; 1338 vtemp = vtemp || "P_dec_char("; 1339 call regen (xptr -> opn.op1); 1340 vtemp = vtemp || ")"; 1341 return; 1342 end; 1343 1344 1345 /* If => P_if( op1 , op2 , op3 ) */ 1346 if (xptr -> opn.op = If) 1347 then do; 1348 P_if = "1"b; 1349 vtemp = vtemp || "P_if ("; 1350 call regen (xptr -> opn.op1); 1351 vtemp = vtemp || ","; 1352 if (xptr -> opn.op2 = null ()) 1353 then vtemp = vtemp || """"""; 1354 else call regen (xptr -> opn.op2); 1355 vtemp = vtemp || ","; 1356 if (xptr -> opn.op3 = null ()) 1357 then vtemp = vtemp || """"""; 1358 else call regen (xptr -> opn.op3); 1359 vtemp = vtemp || ")"; 1360 return; 1361 end; 1362 1363 1364 1365 /* Pnum => P_int( op1 .I_page) */ 1366 if (xptr -> opn.op = Pnum) 1367 then do; 1368 vtemp = vtemp || "P_int ("; 1369 call regen (xptr -> opn.op1); 1370 vtemp = vtemp || ".I_page)"; 1371 return; 1372 end; 1373 1374 1375 /* Func => op1 ( op2 ) */ 1376 if (xptr -> opn.op = Func) 1377 then do; 1378 call regen (xptr -> opn.op1); 1379 vtemp = vtemp || "("; 1380 call regen (xptr -> opn.op2); 1381 vtemp = vtemp || ")"; 1382 return; 1383 end; 1384 1385 1386 /* Paren => ( op1 ) */ 1387 if (xptr -> opn.op = Paren) 1388 then do; 1389 vtemp = vtemp || "("; 1390 call regen (xptr -> opn.op1); 1391 vtemp = vtemp || ")"; 1392 return; 1393 end; 1394 1395 1396 /* Add => op1 + op2 */ 1397 if (xptr -> opn.op = Add) 1398 then do; 1399 if (xptr -> opn.op1 ^= null ()) 1400 then call regen (xptr -> opn.op1); 1401 vtemp = vtemp || "+"; 1402 call regen (xptr -> opn.op2); 1403 return; 1404 end; 1405 1406 1407 /* Sub => op1 - op2 */ 1408 if (xptr -> opn.op = Sub) 1409 then do; 1410 if (xptr -> opn.op1 ^= null ()) 1411 then call regen (xptr -> opn.op1); 1412 vtemp = vtemp || "-"; 1413 call regen (xptr -> opn.op2); 1414 return; 1415 end; 1416 1417 1418 /* Mul => op1 * op2 */ 1419 if (xptr -> opn.op = Mul) 1420 then do; 1421 call regen (xptr -> opn.op1); 1422 vtemp = vtemp || "*"; 1423 call regen (xptr -> opn.op2); 1424 return; 1425 end; 1426 1427 1428 /* Div => op1 / op2 */ 1429 if (xptr -> opn.op = Div) 1430 then do; 1431 call regen (xptr -> opn.op1); 1432 vtemp = vtemp || "/"; 1433 call regen (xptr -> opn.op2); 1434 return; 1435 end; 1436 1437 1438 /* Rpt => copy( op1 , op2 ) */ 1439 if (xptr -> opn.op = Rpt) 1440 then do; 1441 vtemp = vtemp || "copy("; 1442 call regen (xptr -> opn.op1); 1443 vtemp = vtemp || ","; 1444 call regen (xptr -> opn.op2); 1445 vtemp = vtemp || ")"; 1446 return; 1447 end; 1448 1449 1450 /* Cat => op1 || op2 */ 1451 if (xptr -> opn.op = Cat) 1452 then do; 1453 call regen (xptr -> opn.op1); 1454 vtemp = vtemp || "||"; 1455 call regen (xptr -> opn.op2); 1456 return; 1457 end; 1458 1459 1460 /* EQ => op1 = op2 */ 1461 if (xptr -> opn.op = EQ) 1462 then do; 1463 call regen (xptr -> opn.op1); 1464 vtemp = vtemp || "="; 1465 call regen (xptr -> opn.op2); 1466 return; 1467 end; 1468 1469 1470 /* NE => op1 ^= op2 */ 1471 if (xptr -> opn.op = NE) 1472 then do; 1473 call regen (xptr -> opn.op1); 1474 vtemp = vtemp || "^="; 1475 call regen (xptr -> opn.op2); 1476 return; 1477 end; 1478 1479 1480 /* LE => op1 <= op2 */ 1481 if (xptr -> opn.op = LE) 1482 then do; 1483 call regen (xptr -> opn.op1); 1484 vtemp = vtemp || "<="; 1485 call regen (xptr -> opn.op2); 1486 return; 1487 end; 1488 1489 1490 /* GE => op1 >= op2 */ 1491 if (xptr -> opn.op = GE) 1492 then do; 1493 call regen (xptr -> opn.op1); 1494 vtemp = vtemp || ">="; 1495 call regen (xptr -> opn.op2); 1496 return; 1497 end; 1498 1499 1500 /* LT => op1 < op2 */ 1501 if (xptr -> opn.op = LT) 1502 then do; 1503 call regen (xptr -> opn.op1); 1504 vtemp = vtemp || "<"; 1505 call regen (xptr -> opn.op2); 1506 return; 1507 end; 1508 1509 1510 /* GT => op1 > op2 */ 1511 if (xptr -> opn.op = GT) 1512 then do; 1513 call regen (xptr -> opn.op1); 1514 vtemp = vtemp || ">"; 1515 call regen (xptr -> opn.op2); 1516 return; 1517 end; 1518 1519 1520 /* Not => ^ op2 */ 1521 if (xptr -> opn.op = Not) 1522 then do; 1523 vtemp = vtemp || "^"; 1524 call regen (xptr -> opn.op2); 1525 return; 1526 end; 1527 1528 1529 /* And => op1 & op2 */ 1530 if (xptr -> opn.op = And) 1531 then do; 1532 call regen (xptr -> opn.op1); 1533 vtemp = vtemp || "&"; 1534 call regen (xptr -> opn.op2); 1535 return; 1536 end; 1537 1538 1539 /* Substr => substr( op1, op2, op3) */ 1540 if (xptr -> opn.op = Substr) 1541 then do; 1542 vtemp = vtemp || " substr("; 1543 call regen (xptr -> opn.op1); 1544 vtemp = vtemp || ","; 1545 call regen (xptr -> opn.op2); 1546 if (xptr -> opn.op3 ^= null ()) 1547 then do; 1548 vtemp = vtemp || ","; 1549 call regen (xptr -> opn.op3); 1550 end; 1551 vtemp = vtemp || ")"; 1552 return; 1553 end; 1554 1555 /* Or => op1 | op2 */ 1556 if (xptr -> opn.op = Or) 1557 then do; 1558 call regen (xptr -> opn.op1); 1559 vtemp = vtemp || "|"; 1560 call regen (xptr -> opn.op2); 1561 return; 1562 end; 1563 1564 1565 end; 1566 1567 vtemp = vtemp || " 1568 <> 1569 "; 1570 1571 end regen; 1572 1573 dcl (mrpg_dump_, mrpg_dump_$list, mrpg_dump_$all) entry (ptr unal, fixed bin); 1574 1575 dcl I_day char (8) int static init ("I_DAY"); 1576 dcl I_hhmmss char (8) int static init ("I_HHMMSS"); 1577 dcl I_mmddyy char (8) int static init ("I_MMDDYY"); 1578 dcl I_month char (8) int static init ("I_MONTH"); 1579 dcl I_yyddd char (8) int static init ("I_YYDDD"); 1580 dcl vtemp char (512) var; 1581 dcl car (2000) char (1) unal based; 1582 dcl name char (32) var; 1583 dcl mrpg_error_ entry options (variable); 1584 dcl get_seg_ptr_ entry (char (*), bit (6) aligned, fixed bin (24), ptr, fixed bin (35)); 1585 dcl release_seg_ptr_ entry (ptr, fixed bin (24), fixed bin (35)); 1586 dcl bc fixed bin (24); 1587 dcl pt char (3); 1588 dcl rc char (1); 1589 dcl dflt_sw bit (1); 1590 dcl msg char (1000) var; 1591 dcl failed fixed bin; 1592 dcl com_err_ entry options (variable); 1593 dcl macname char (32) var; 1594 dcl ds (24) pic "(7)-9"; 1595 dcl cleanup condition; 1596 dcl ose fixed bin (24); 1597 dcl optr ptr; 1598 dcl i fixed bin; 1599 dcl argct fixed bin; 1600 dcl max_name fixed bin; 1601 dcl error_table_$badsyntax fixed bin (35) ext static; 1602 dcl error_table_$translation_aborted fixed bin (35) ext static; 1603 dcl error_table_$translation_failed fixed bin (35) ext static; 1604 dcl ioa_ entry options (variable); 1605 dcl macro_$free entry (bit (1)); 1606 dcl mrpg entry; 1607 dcl stop_mrpg condition; 1608 dcl t_n char (13) int static options (constant) init ("float dec(20)"); 1609 dcl t_c char (14) int static options (constant) init ("char(&leng)var"); 1 1 /* BEGIN INCLUDE FILE ..... macro.incl.pl1 ..... 03/03/77 J Falksen */ 1 2 1 3 dcl 1 argl (24), /* argument list */ 1 4 2 p ptr, /* pointer to string */ 1 5 2 l fixed bin; /* length of string */ 1 6 1 7 dcl macro_ entry (char (32) var, char (32) var, char (32) var, ptr, 1 8 fixed bin (24), ptr, fixed bin, char (1000) var, ptr, 1 9 fixed bin (35)); 1 10 dcl macro_$expand entry (char (32) var, char (32) var, char (32) var, ptr, 1 11 fixed bin (24), ptr, fixed bin, char (1000) var, ptr, 1 12 fixed bin (24), fixed bin (35)); 1 13 1 14 /* END INCLUDE FILE ..... macro.incl.pl1 ..... */ 1610 2 1 /* BEGIN INCLUDE FILE ..... rgl_tree.incl.pl1 ..... 12/14/76 J Falksen */ 2 2 2 3 dcl space area based(area_ptr); 2 4 dcl area_ptr ptr; 2 5 2 6 dcl tree_ptr ptr; 2 7 dcl 1 tree based(tree_ptr), 2 8 2 table, /* symbol table */ 2 9 3 (b,e) ptr unal, 2 10 2 parm_pos like tree.table, /* positional parameter dcl */ 2 11 2 ppos_ct fixed bin, 2 12 2 parm_key like tree.table, /* keyword parameter dcl */ 2 13 2 pkey_ct fixed bin, 2 14 2 parm_check like tree.table, /* STOP list, after all parms processed */ 2 15 2 input like tree.table, /* input declaration */ 2 16 2 input_check like tree.table,/* STOP/SKIP list, record level */ 2 17 2 rec_str fixed bin(17)unal, /* -2 STREAM, -1 RECORD, >0 RECORD n */ 2 18 2 res_siz fixed bin(17)unal, /* size of record area to set aside */ 2 19 2 from ptr unal, /* FILE | ATTACH */ 2 20 2 local like tree.table, /* local declaration list */ 2 21 2 report like tree.table, /* report description list */ 2 22 2 phase0 like tree.table, 2 23 2 hold like tree.table, /* hold list */ 2 24 2 exec like tree.table, /* executable list */ 2 25 2 sourcep ptr unal, /* pointer to source segment */ 2 26 2 bits, 2 27 3 mmddyy bit(1)unal, 2 28 3 yyddd bit(1)unal, 2 29 3 month bit(1)unal, 2 30 3 day bit(1)unal, 2 31 3 hhmmss bit(1)unal, 2 32 3 filler bit(31)unal; 2 33 2 34 dcl symtabptr ptr; 2 35 dcl 1 symtab based(symtabptr), 2 36 2 hdr, /* "ID" | "NU" | "ST" */ 2 37 3 type char(2)unal, 2 38 3 fill bit(90)unal, 2 39 3 next ptr unal, 2 40 2 use like tree.table, /* list of usage of this symbol */ 2 41 2 leng fixed bin(24), /* length of data */ 2 42 2 data char(symbol_leng refer(symtab.leng)); /* symbol data */ 2 43 dcl symbol_leng fixed bin(24); 2 44 2 45 dcl daptr ptr; 2 46 dcl 1 datum based(daptr), 2 47 2 hdr like stmt.hdr, /* "DC", "IN" */ 2 48 2 kind fixed bin(17)unal, /* kind of field */ 2 49 2 leng fixed bin(17)unal, 2 50 2 pos fixed bin, /* IN position */ 2 51 2 check like tree.table, /* SKIP/STOP list, field level */ 2 52 2 datal like tree.table; 2 53 2 54 dcl srefptr ptr; 2 55 dcl 1 symref based(srefptr), 2 56 2 hdr like stmt.hdr, /* "SY" */ 2 57 2 kind fixed bin(17)unal; 2 58 2 59 dcl opptr ptr; 2 60 dcl 1 opn based(opptr), 2 61 2 hdr like stmt.hdr, /* "OP" */ 2 62 2 op fixed bin(17)unal, /* operation */ 2 63 2 kind fixed bin(17)unal, 2 64 2 op1 ptr unal, /* first operand */ 2 65 2 op2 ptr unal, /* second operand, if any */ 2 66 2 op3 ptr unal; /* third operand, if any */ 2 67 2 68 dcl headptr ptr; 2 69 dcl 1 head based(headptr), 2 70 2 hdr like stmt.hdr, /* "HD" */ 2 71 2 list like tree.table; 2 72 2 73 dcl repptr ptr; 2 74 dcl 1 report based(repptr), 2 75 2 hdr like stmt.hdr, /* "RP" */ 2 76 2 pw fixed bin(24), /* PAGEWIDTH */ 2 77 2 pl fixed bin(24), /* PAGELENGTH */ 2 78 2 minl fixed bin(24), /* MINLINE */ 2 79 2 maxl fixed bin(24), /* MAXLINE */ 2 80 2 onlist like tree.table, /* ON list */ 2 81 2 brlist like tree.table, /* BREAK list */ 2 82 2 part like tree.table; /* part list */ 2 83 2 84 dcl partptr ptr; 2 85 dcl 1 part based(partptr), 2 86 2 hdr like stmt.hdr, /* "RH", "PH", "DH", "DT", "DF", "PF", "RF" */ 2 87 2 maxl fixed bin, 2 88 2 ctl ptr unal, /* IF */ 2 89 2 lines like tree.table; /* line list */ 2 90 2 91 dcl linptr ptr; 2 92 dcl 1 lines based(linptr), 2 93 2 hdr like stmt.hdr, /* "LN" */ 2 94 2 number fixed bin(17)unal, /* <0 absolute line, >0 relative line */ 2 95 2 ctl ptr unal, /* IF */ 2 96 2 field like tree.table; /* field list */ 2 97 2 98 dcl fldptr ptr; 2 99 dcl 1 field based(fldptr), 2 100 2 hdr like stmt.hdr, /* "FD" */ 2 101 2 value like tree.table, /* value list */ 2 102 2 let like tree.table, /* LET list */ 2 103 2 kind fixed bin(17)unal, /* kind of field */ 2 104 2 align fixed bin(17)unal, /* alignment of field */ 2 105 2 alch char(1)unal, /* align character */ 2 106 2 bsp bit(1)unal, 2 107 2 XXX bit(26)unal, 2 108 2 fill(2) fixed bin(17)unal, /* fill indents */ 2 109 2 col fixed bin(24), /* COLUMN */ 2 110 2 leng fixed bin(24), /* length of field or mask */ 2 111 2 data ptr unal; /* mask */ 2 112 2 113 dcl valptr ptr; 2 114 dcl 1 value based(valptr), 2 115 2 hdr like stmt.hdr, /* "VL", "FL", "SW", "AT" */ 2 116 2 numb fixed bin(24), 2 117 2 ctl ptr unal; /* if control */ 2 118 2 119 dcl atptr ptr; 2 120 dcl 1 attr based(atptr), 2 121 2 hdr like stmt.hdr, /* "DV" | "KY" */ 2 122 2 attr, 2 123 3 asc bit(1)unal, /* ASCending key */ 2 124 3 des bit(1)unal, /* DEScending key */ 2 125 3 fill bit(16)unal; 2 126 2 127 dcl paptr ptr; 2 128 dcl 1 param based(paptr), 2 129 2 hdr like stmt.hdr, /* "PM" */ 2 130 2 kind fixed bin(17)unal, 2 131 2 attr like tree.table, /* attribute (default and keyword) list */ 2 132 2 check like tree.table, /* STOP list, parameter level */ 2 133 2 leng fixed bin(24); 2 134 2 135 dcl stmtptr ptr; 2 136 dcl 1 stmt based(stmtptr), 2 137 2 hdr, /* "IF", ":=" "=:", "PR", "HD", "SR", "SU" */ 2 138 3 type char(2)unal, 2 139 3 line fixed bin(17)unal, /* beginning line number */ 2 140 3 bchar fixed bin(24), /* beginning character in file */ 2 141 3 echar fixed bin(24), /* ending character in file */ 2 142 3 next ptr unal, /* link to next element */ 2 143 3 sym ptr unal, /* pointer to symbol table entry (if any) */ 2 144 3 usage ptr unal, /* pointer to next symbol usage */ 2 145 2 ref1 like tree.table, 2 146 2 ref2 like tree.table, 2 147 2 ref3 like tree.table; 2 148 2 149 dcl Bool fixed bin int static init( 1); 2 150 dcl Char fixed bin int static init( 2); 2 151 dcl Chard fixed bin int static init( 3); 2 152 dcl Integer fixed bin int static init( 4); 2 153 dcl Decimal fixed bin int static init( 5); 2 154 dcl Pic fixed bin int static init( 6); 2 155 dcl Charn fixed bin int static init( 7); 2 156 dcl Edit fixed bin int static init( 14); 2 157 dcl Left fixed bin int static init( 8); 2 158 dcl Center fixed bin int static init( 9); 2 159 dcl Right fixed bin int static init( 10); 2 160 dcl Fill fixed bin int static init( 12); 2 161 dcl Align fixed bin int static init( 11); 2 162 dcl Fold fixed bin int static init( 13); 2 163 dcl Table fixed bin int static init( 15); 2 164 dcl Tablev fixed bin int static init( 16); 2 165 dcl Set fixed bin int static init( 17); 2 166 dcl DecSpec fixed bin int static init( 18); 2 167 dcl Tabled fixed bin int static init( 19); 2 168 2 169 dcl kind_char(0:19) char(16)var int static init( 2 170 "-default-", 2 171 "bit", 2 172 "char", 2 173 "var char", 2 174 "fixed bin", 2 175 "float dec(20)", 2 176 "picture", 2 177 "varying char", 2 178 " LEFT", 2 179 " CENTER", 2 180 " RIGHT", 2 181 " ALIGN", 2 182 " FILL", 2 183 " FOLD", 2 184 " EDIT", 2 185 "TABLE", 2 186 "TABLEV", 2 187 "SET", 2 188 "dec(20)float", 2 189 "TABLED" ); 2 190 2 191 /* operation codes */ 2 192 dcl Add fixed bin int static init(1); 2 193 dcl And fixed bin int static init(2); 2 194 dcl Cat fixed bin int static init(3); 2 195 dcl Div fixed bin int static init(4); 2 196 dcl EQ fixed bin int static init(5); 2 197 dcl GE fixed bin int static init(6); 2 198 dcl GT fixed bin int static init(7); 2 199 dcl LE fixed bin int static init(8); 2 200 dcl LT fixed bin int static init(9); 2 201 dcl Mul fixed bin int static init(10); 2 202 dcl NE fixed bin int static init(11); 2 203 dcl Not fixed bin int static init(12); 2 204 dcl Or fixed bin int static init(13); 2 205 dcl Paren fixed bin int static init(14); 2 206 dcl Rpt fixed bin int static init(15); 2 207 dcl Sub fixed bin int static init(16); 2 208 dcl Func fixed bin int static init(17); 2 209 dcl Pnum fixed bin int static init(18); 2 210 dcl Level fixed bin int static init(19); 2 211 dcl Beg fixed bin int static init(20); 2 212 dcl End fixed bin int static init(21); 2 213 dcl Cont fixed bin int static init(22); 2 214 dcl Nbeg fixed bin int static init(23); 2 215 dcl Nend fixed bin int static init(24); 2 216 dcl Ncont fixed bin int static init(25); 2 217 dcl Begw fixed bin int static init(26); 2 218 dcl Endw fixed bin int static init(27); 2 219 dcl Contw fixed bin int static init(28); 2 220 dcl Nbegw fixed bin int static init(29); 2 221 dcl Nendw fixed bin int static init(30); 2 222 dcl Ncontw fixed bin int static init(31); 2 223 dcl In fixed bin int static init(32); 2 224 dcl Nin fixed bin int static init(33); 2 225 dcl Skip fixed bin int static init(34); 2 226 dcl Stop fixed bin int static init(35); 2 227 dcl n_n fixed bin int static init(36); 2 228 dcl n_s fixed bin int static init(37); 2 229 dcl s_n fixed bin int static init(38); 2 230 dcl s_s fixed bin int static init(39); 2 231 dcl b_c fixed bin int static init(40); 2 232 dcl b_d fixed bin int static init(41); 2 233 dcl c_b fixed bin int static init(42); 2 234 dcl c_d fixed bin int static init(43); 2 235 dcl d_b fixed bin int static init(44); 2 236 dcl d_c fixed bin int static init(45); 2 237 dcl Tran fixed bin int static init(46); 2 238 dcl Substr fixed bin int static init(47); 2 239 dcl If fixed bin int static init(48); 2 240 2 241 dcl op_char(0:48) char(8)var int static init( 2 242 "-BAD-", 2 243 "Add", 2 244 "And", 2 245 "Cat", 2 246 "Div", 2 247 "EQ", 2 248 "GE", 2 249 "GT", 2 250 "LE", 2 251 "LT", 2 252 "Mul", 2 253 "NE", 2 254 "Not", 2 255 "Or", 2 256 "Paren", 2 257 "Rpt", 2 258 "Sub", 2 259 "Func", 2 260 "Pnum", 2 261 "Level", 2 262 "Beg", 2 263 "End", 2 264 "Cont", 2 265 "Nbeg", 2 266 "Nend", 2 267 "Ncont", 2 268 "Begw", 2 269 "Endw", 2 270 "Contw", 2 271 "Nbegw", 2 272 "Nendw", 2 273 "Ncontw", 2 274 "In", 2 275 "Nin", 2 276 "Skip", 2 277 "Stop", 2 278 "n_n", 2 279 "n_s", 2 280 "s_n", 2 281 "s_s", 2 282 "b_c", 2 283 "b_d", 2 284 "c_b", 2 285 "c_d", 2 286 "d_b", 2 287 "d_c", 2 288 "Tran", 2 289 "Substr", 2 290 "If" ); 2 291 2 292 /* END INCLUDE FILE ..... rgl_tree.incl.pl1 ..... */ 1611 1612 dcl (db_sw, lg_sw, stop_sw) bit (1) int static init ("0"b); 1613 dcl execptr ptr; 1614 dbn: entry; db_sw = "1"b; return; 1615 lgn: entry; lg_sw = "1"b; return; 1616 stopn: entry; stop_sw = "1"b; return; 1617 stopf: entry; stop_sw = "0"b; return; 1618 lgf: entry; lg_sw = "0"b; return; 1619 dbf: entry; db_sw = "0"b; return; 1620 dcl (addr, addrel, before, index, length, max, null, reverse, string, substr) builtin; 1621 end mrpg_generate_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 02/14/84 0844.1 mrpg_generate_.pl1 >special_ldd>on>6591>mrpg_generate_.pl1 1610 1 11/08/83 0855.9 macro.incl.pl1 >ldd>include>macro.incl.pl1 1611 2 11/08/83 0855.9 mrpg_tree.incl.pl1 >ldd>include>mrpg_tree.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. A 000175 internal static char(1) initial unaligned dcl 709 set ref 711 Add constant fixed bin(17,0) initial dcl 2-192 ref 1397 And constant fixed bin(17,0) initial dcl 2-193 ref 1530 Beg constant fixed bin(17,0) initial dcl 2-211 ref 1053 1125 Bool constant fixed bin(17,0) initial dcl 2-149 ref 187 231 Cat constant fixed bin(17,0) initial dcl 2-194 ref 1451 Char 013300 constant fixed bin(17,0) initial dcl 2-150 ref 902 Cont constant fixed bin(17,0) initial dcl 2-213 ref 1101 1173 D 000176 internal static char(1) initial unaligned dcl 710 set ref 714 Decimal 013277 constant fixed bin(17,0) initial dcl 2-153 ref 885 896 Div constant fixed bin(17,0) initial dcl 2-195 ref 1429 EQ constant fixed bin(17,0) initial dcl 2-196 ref 1461 End constant fixed bin(17,0) initial dcl 2-212 ref 1077 1149 Func constant fixed bin(17,0) initial dcl 2-208 ref 1376 GE constant fixed bin(17,0) initial dcl 2-197 ref 1491 GT constant fixed bin(17,0) initial dcl 2-198 ref 1511 I_day 000014 internal static char(8) initial unaligned dcl 1575 set ref 562 I_hhmmss 000016 internal static char(8) initial unaligned dcl 1576 set ref 567 I_mmddyy 000020 internal static char(8) initial unaligned dcl 1577 set ref 572 I_month 000022 internal static char(8) initial unaligned dcl 1578 set ref 577 I_yyddd 000024 internal static char(8) initial unaligned dcl 1579 set ref 582 If constant fixed bin(17,0) initial dcl 2-239 ref 1346 In constant fixed bin(17,0) initial dcl 2-223 ref 1197 LE constant fixed bin(17,0) initial dcl 2-199 ref 1481 LINE 000154 automatic picture(4) unaligned dcl 270 set ref 267* 269 517* 519 LT constant fixed bin(17,0) initial dcl 2-200 ref 1501 Level constant fixed bin(17,0) initial dcl 2-210 ref 1041 Mul constant fixed bin(17,0) initial dcl 2-201 ref 1419 NE constant fixed bin(17,0) initial dcl 2-202 ref 1471 Nbeg constant fixed bin(17,0) initial dcl 2-214 ref 1065 1137 Ncont constant fixed bin(17,0) initial dcl 2-216 ref 1113 1185 Nend constant fixed bin(17,0) initial dcl 2-215 ref 1089 1161 Nin constant fixed bin(17,0) initial dcl 2-224 ref 1208 Not constant fixed bin(17,0) initial dcl 2-203 ref 1521 Or constant fixed bin(17,0) initial dcl 2-204 ref 1556 P defined structure level 1 packed unaligned dcl 922 P_bool_char 000157 automatic bit(1) unaligned dcl 1006 set ref 23* 592 1282* P_bool_dec 000160 automatic bit(1) unaligned dcl 1007 set ref 23* 594 1293* P_char_bool 000161 automatic bit(1) unaligned dcl 1008 set ref 23* 596 1304* P_char_dec 000162 automatic bit(1) unaligned dcl 1009 set ref 23* 598 P_ctl 001332 automatic char(9) unaligned dcl 921 set ref 868* 887* 887 888* 888 897* 897 898* 898 917* 917 924* 924 926* 929 P_dec_bool 000163 automatic bit(1) unaligned dcl 1010 set ref 23* 600 1325* P_dec_char 000164 automatic bit(1) unaligned dcl 1011 set ref 23* 602 1337* P_if 000166 automatic bit(1) unaligned dcl 1013 set ref 23* 606 1348* P_int 000165 automatic bit(1) unaligned dcl 1012 set ref 23* 604 P_skip 000155 automatic bit(1) unaligned dcl 1004 set ref 23* 588 1223* P_stop 000156 automatic bit(1) unaligned dcl 1005 set ref 23* 590 1236* Paren constant fixed bin(17,0) initial dcl 2-205 ref 1387 Pnum constant fixed bin(17,0) initial dcl 2-209 ref 1366 Rpt constant fixed bin(17,0) initial dcl 2-206 ref 1439 Set constant fixed bin(17,0) initial dcl 2-165 ref 278 309 Skip constant fixed bin(17,0) initial dcl 2-225 ref 1219 Stop constant fixed bin(17,0) initial dcl 2-226 ref 1232 Sub constant fixed bin(17,0) initial dcl 2-207 ref 1408 Substr constant fixed bin(17,0) initial dcl 2-238 ref 1540 Table constant fixed bin(17,0) initial dcl 2-163 ref 278 Tablev constant fixed bin(17,0) initial dcl 2-164 ref 278 312 Tran constant fixed bin(17,0) initial dcl 2-237 ref 1245 addr builtin function dcl 1620 ref 110 113 116 122 135 137 178 199 223 269 275 288 293 295 300 302 306 323 329 344 370 376 411 439 454 459 479 487 500 519 524 528 536 562 567 572 577 582 608 665 672 686 698 711 714 730 733 785 826 832 852 859 872 907 929 933 943 955 961 961 996 addrel builtin function dcl 1620 ref 116 122 344 487 536 608 733 996 aifp parameter pointer dcl 18 set ref 16 108* alch 13 based char(1) level 2 packed unaligned dcl 2-99 set ref 933 align 12(18) based fixed bin(17,0) level 2 packed unaligned dcl 2-99 ref 888 898 926 926 926 argct 001105 automatic fixed bin(17,0) dcl 1599 set ref 125* 129* 133* 139* 140 154* 157* 161* 172* 182* 183 186* 187 189 196* 196 199 200 226* 227 230* 231 233 240* 252* 253 255* 309* 311* 318* 327* 334* 340* 341 347* 348 353* 379* 380 383* 384 387* 388 391* 392 408* 414* 415 428 435* 449* 463 483* 484 490* 491 503* 509* 532* 533 539* 540 546* 552* 558* 561* 632* 633 636* 644* 645 652* 653 661* 674 682* 696* 702* 736* 737 743* 749* 750 757* 758 763* 764 788* 789 794* 811* 822* 834 847* 878* 879 882* 883 893* 896 902 910* 911 914* 915 920* 931* 941* 954 955 955 956 961* argl 001116 automatic structure array level 1 unaligned dcl 1-3 set ref 961 961 atptr 001302 automatic pointer dcl 2-119 set ref 192* 193 194 197 203* 203 236* 237 238 241 243* 245* 245 703* 703 712 714 717 721* 742 742 742* atreeptr parameter pointer dcl 18 ref 16 26 attr 6(18) based structure level 2 in structure "param" packed unaligned dcl 2-128 in procedure "mrpg_generate_" attr 6 based structure level 2 in structure "attr" packed unaligned dcl 2-120 in procedure "mrpg_generate_" attr based structure level 1 unaligned dcl 2-120 in procedure "mrpg_generate_" axptr parameter pointer unaligned dcl 985 ref 983 991 b 14 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 50* 52 52* b 7(18) based pointer level 3 in structure "lines" packed unaligned dcl 2-92 in procedure "mrpg_generate_" ref 798 b 10 based pointer level 3 in structure "field" packed unaligned dcl 2-99 in procedure "mrpg_generate_" ref 801 b 10 based pointer level 3 in structure "part" packed unaligned dcl 2-85 in procedure "mrpg_generate_" ref 782 b 16 based pointer level 3 in structure "report" packed unaligned dcl 2-74 in procedure "mrpg_generate_" ref 398 b 6 based pointer level 3 in structure "field" packed unaligned dcl 2-99 in procedure "mrpg_generate_" ref 869 b 5 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 39* 41 41* 168 214 b 30 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 64* 65 65* 555* b 10 based pointer level 3 in structure "stmt" packed unaligned dcl 2-136 in procedure "mrpg_generate_" set ref 640* 669* 703 755* 815 829* 855* b 10 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 43* 45 45* b 12 based pointer level 3 in structure "stmt" packed unaligned dcl 2-136 in procedure "mrpg_generate_" set ref 641 649* 761* b 12 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 47* 48 48* 513 b 6(18) based pointer level 3 in structure "param" packed unaligned dcl 2-128 in procedure "mrpg_generate_" ref 192 236 b 2 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 35* 37 37* 173 218 b 22 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 61* 62 62* 363 b 12 based pointer level 3 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" set ref 286 291 298 319 351* 544* b 6 based pointer level 3 in structure "stmt" packed unaligned dcl 2-136 in procedure "mrpg_generate_" set ref 637* 663 684 703 754* 812* 824 850 b 12 based pointer level 3 in structure "report" packed unaligned dcl 2-74 in procedure "mrpg_generate_" ref 450 b 20 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 58* 59 59* 263 b 4 based pointer level 3 in structure "symtab" packed unaligned dcl 2-35 in procedure "mrpg_generate_" ref 73 282 478 732 877 b 14 based pointer level 3 in structure "report" packed unaligned dcl 2-74 in procedure "mrpg_generate_" ref 420 474 b based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 29* 30 70 b_c constant fixed bin(17,0) initial dcl 2-231 ref 1280 b_d constant fixed bin(17,0) initial dcl 2-232 ref 1291 bc 000401 automatic fixed bin(24,0) dcl 1586 set ref 94* before builtin function dcl 1620 ref 93 bits 33 based structure level 2 packed unaligned dcl 2-7 brlist 14 based structure level 2 packed unaligned dcl 2-74 bsp 13(09) based bit(1) level 2 in structure "field" packed unaligned dcl 2-99 in procedure "mrpg_generate_" ref 924 bsp defined char(1) level 2 in structure "P" packed unaligned dcl 922 in procedure "put_part" set ref 924* c_b constant fixed bin(17,0) initial dcl 2-233 ref 1302 c_d constant fixed bin(17,0) initial dcl 2-234 ref 1313 car based char(1) array unaligned dcl 1581 set ref 459 cleanup 001072 stack reference condition dcl 1595 ref 95 code parameter fixed bin(35,0) dcl 18 set ref 16 85* 91 94* 97* 615* 618* 961* 963 965 965 969* 971 975* 979* col 15 based fixed bin(24,0) level 2 dcl 2-99 ref 911 com_err_ 000214 constant entry external dcl 1592 ref 975 ctl 6(18) based pointer level 2 in structure "lines" packed unaligned dcl 2-92 in procedure "mrpg_generate_" set ref 792* ctl 7 based pointer level 2 in structure "part" packed unaligned dcl 2-85 in procedure "mrpg_generate_" set ref 433 436* ctl 7 based pointer level 2 in structure "value" packed unaligned dcl 2-114 in procedure "mrpg_generate_" set ref 457* d_b constant fixed bin(17,0) initial dcl 2-235 ref 1323 d_c constant fixed bin(17,0) initial dcl 2-236 ref 1335 daptr 001262 automatic pointer dcl 2-45 set ref 73* 74 77 263* 263* 267 271 278 278 278 282 286 291 298 309 312 319 341 344 345 348 351* 357 478* 487 488 491 513* 513* 517 520 533 536 537 540 544* 548 732* 733 734 737 877* 879 883 885 data 7 based char level 2 packed unaligned dcl 2-35 set ref 77* 178 199 223 273 275 282* 323 329 376 411 479 524 665 686 730 826 852 859 872 1033 datal 12 based structure level 2 packed unaligned dcl 2-46 datum based structure level 1 unaligned dcl 2-46 day 33(03) based bit(1) level 3 packed unaligned dcl 2-7 ref 563 db_sw 000172 internal static bit(1) initial unaligned dcl 1612 set ref 28 96* 135 613* 1614* 1619* des 6(01) based bit(1) level 3 packed unaligned dcl 2-120 ref 714 dflt_sw 000404 automatic bit(1) unaligned dcl 1589 set ref 167* 202* 211 digit 000010 internal static char(1) initial array unaligned dcl 360 set ref 135 137 500 528 785 907 943 dname 000101 automatic char(168) unaligned dcl 103 set ref 108* 113 dnamel 000153 automatic fixed bin(17,0) dcl 104 set ref 108* 114 ds 001012 automatic picture(8) array unaligned dcl 1594 set ref 126* 130* 140* 151* 152* 183* 187* 189* 227* 231* 233* 253* 341* 348* 380* 384* 388* 392* 415* 428* 463* 484* 491* 533* 540* 633* 645* 653* 674* 737* 750* 758* 764* 789* 834* 879* 883* 896* 902* 911* 915* 954 955 e 21 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 58* e 23 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 61* e 15 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 50* e 6 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 39* e 11 based pointer level 3 in structure "stmt" packed unaligned dcl 2-136 in procedure "mrpg_generate_" ref 857 e 11 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 43* e 3 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 35* e 5 based pointer level 3 in structure "symtab" packed unaligned dcl 2-35 in procedure "mrpg_generate_" ref 282 e 13 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 47* e 31 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 64* e 1 based pointer level 3 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" set ref 29* ename parameter char(32) unaligned dcl 18 ref 16 93 err_sw 000100 automatic bit(1) unaligned dcl 100 set ref 68* 79* 83 error_table_$badsyntax 000216 external static fixed bin(35,0) dcl 1601 ref 965 error_table_$translation_aborted 000220 external static fixed bin(35,0) dcl 1602 ref 971 error_table_$translation_failed 000222 external static fixed bin(35,0) dcl 1603 ref 965 exec 30 based structure level 2 packed unaligned dcl 2-7 failed 001000 automatic fixed bin(17,0) dcl 1591 set ref 25* 616 616* 618 968* 974* field 7(18) based structure level 2 in structure "lines" packed unaligned dcl 2-92 in procedure "mrpg_generate_" field based structure level 1 unaligned dcl 2-99 in procedure "mrpg_generate_" fldptr 001276 automatic pointer dcl 2-98 set ref 798* 798* 801 869 888 898 911 915 917 924 926 926 926 933* 939 from 17 based pointer level 2 packed unaligned dcl 2-7 set ref 55* 56 56* 120 120* get_seg_ptr_ 000210 constant entry external dcl 1584 ref 94 hcs_$fs_get_path_name 000200 constant entry external dcl 105 ref 108 hdr based structure level 2 in structure "symref" unaligned dcl 2-55 in procedure "mrpg_generate_" hdr based structure level 2 in structure "datum" unaligned dcl 2-46 in procedure "mrpg_generate_" hdr based structure level 2 in structure "part" unaligned dcl 2-85 in procedure "mrpg_generate_" hdr based structure level 2 in structure "lines" unaligned dcl 2-92 in procedure "mrpg_generate_" hdr based structure level 2 in structure "value" unaligned dcl 2-114 in procedure "mrpg_generate_" hdr based structure level 2 in structure "stmt" unaligned dcl 2-136 in procedure "mrpg_generate_" hdr based structure level 2 in structure "field" unaligned dcl 2-99 in procedure "mrpg_generate_" hdr based structure level 2 in structure "opn" unaligned dcl 2-60 in procedure "mrpg_generate_" hdr based structure level 2 in structure "attr" unaligned dcl 2-120 in procedure "mrpg_generate_" hdr based structure level 2 in structure "param" unaligned dcl 2-128 in procedure "mrpg_generate_" hdr based structure level 2 in structure "report" unaligned dcl 2-74 in procedure "mrpg_generate_" hdr based structure level 2 in structure "symtab" packed unaligned dcl 2-35 in procedure "mrpg_generate_" hhmmss 33(04) based bit(1) level 3 packed unaligned dcl 2-7 ref 568 i 000100 automatic fixed bin(17,0) dcl 952 in procedure "number" set ref 954* 955 956 i 001104 automatic fixed bin(17,0) dcl 1598 in procedure "mrpg_generate_" set ref 169* 170 183* 215* 216 227* 419* 423* 423 428 473* 482* 482 484 index builtin function dcl 1620 ref 273 954 input 12 based structure level 2 packed unaligned dcl 2-7 input_check 14 based structure level 2 packed unaligned dcl 2-7 ioa_ 000224 constant entry external dcl 1604 ref 29 35 39 43 47 50 54 55 58 61 64 978 kind 6 based fixed bin(17,0) level 2 in structure "param" packed unaligned dcl 2-128 in procedure "mrpg_generate_" ref 187 231 kind 6 based fixed bin(17,0) level 2 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" ref 278 278 278 309 312 344 345 487 488 536 537 733 734 879 885 kind_char 000026 internal static varying char(16) initial array dcl 2-169 set ref 344 345 487 488 536 537 733 734 l 2 001116 automatic fixed bin(17,0) array level 2 dcl 1-3 set ref 111* 114* 117* 123* 134* 179* 200* 224* 241* 268* 276* 289* 289* 294* 296* 301* 303* 307* 307* 312* 312 324* 330* 345* 351* 371* 377* 412* 436* 440* 453* 457* 459 461* 461 480* 488* 501* 518* 525* 529* 537* 544* 563* 565* 568* 570* 573* 575* 578* 580* 583* 585* 609* 637* 666* 669* 671* 687* 697* 716* 720* 729* 734* 786* 792* 812* 827* 829* 831* 853* 855* 860* 873* 906* 928* 932* 944* 956* leng 13 based fixed bin(24,0) level 2 in structure "param" dcl 2-128 in procedure "mrpg_generate_" ref 189 233 leng 16 based fixed bin(24,0) level 2 in structure "field" dcl 2-99 in procedure "mrpg_generate_" ref 915 917 leng 6 based fixed bin(24,0) level 2 in structure "symtab" dcl 2-35 in procedure "mrpg_generate_" ref 77 77 178 179 180 199 200 223 224 273 275 276 282 282 323 324 329 330 376 377 411 412 479 480 524 525 665 666 686 687 729 730 826 827 852 853 859 860 872 873 1033 leng 6(18) based fixed bin(17,0) level 2 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" ref 348 491 540 737 883 length builtin function dcl 1620 ref 111 117 123 289 294 296 301 303 307 345 461 488 537 609 734 997 let 10 based structure level 2 packed unaligned dcl 2-99 lg_sw 000173 internal static bit(1) initial unaligned dcl 1612 set ref 135 1615* 1618* line 0(18) based fixed bin(17,0) level 3 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" ref 77 267 282 517 line 0(18) based fixed bin(17,0) level 3 in structure "symref" packed unaligned dcl 2-55 in procedure "mrpg_generate_" ref 674 725 834 lines based structure level 1 unaligned dcl 2-92 in procedure "mrpg_generate_" lines 10 based structure level 2 in structure "part" packed unaligned dcl 2-85 in procedure "mrpg_generate_" linptr 001274 automatic pointer dcl 2-91 set ref 782* 782* 789 792 798* 947 local 20 based structure level 2 packed unaligned dcl 2-7 macname 001001 automatic varying char(32) dcl 1593 set ref 88* 143* 160* 164* 213* 256* 262* 314* 336* 369* 438* 448* 472* 499* 508* 512* 551* 557* 611* 631* 643* 651* 660* 681* 695* 748* 756* 762* 795* 809* 821* 841* 846* 937* 940* 961* macro_ 000230 constant entry external dcl 1-7 ref 961 macro_$free 000226 constant entry external dcl 1605 ref 96 613 max builtin function dcl 1620 ref 180 max_name 001106 automatic fixed bin(17,0) dcl 1600 set ref 166* 180* 180 253 maxl 6 based fixed bin(17,0) level 2 in structure "part" dcl 2-85 in procedure "mrpg_generate_" ref 415 maxl 11 based fixed bin(24,0) level 2 in structure "report" dcl 2-74 in procedure "mrpg_generate_" ref 392 minl 10 based fixed bin(24,0) level 2 dcl 2-74 ref 388 mmddyy 33 based bit(1) level 3 packed unaligned dcl 2-7 ref 573 month 33(02) based bit(1) level 3 packed unaligned dcl 2-7 ref 578 mrpg_dump_$all 000204 constant entry external dcl 1573 ref 37 41 45 48 52 56 59 62 65 mrpg_dump_$list 000202 constant entry external dcl 1573 ref 32 mrpg_error_ 000206 constant entry external dcl 1583 ref 77 282 616 725 772 865 msg 000405 automatic varying char(1000) dcl 1590 set ref 961* 975* 978* n_n constant fixed bin(17,0) initial dcl 2-227 ref 286 n_s constant fixed bin(17,0) initial dcl 2-228 ref 291 1256 name 000370 automatic varying char(32) dcl 1582 set ref 93* 94 116 117 next 3 based pointer level 3 in structure "param" packed unaligned dcl 2-128 in procedure "mrpg_generate_" ref 205 247 next 3 based pointer level 3 in structure "symtab" packed unaligned dcl 2-35 in procedure "mrpg_generate_" ref 33 81 next 3 based pointer level 3 in structure "symref" packed unaligned dcl 2-55 in procedure "mrpg_generate_" ref 426 495 next 3 based pointer level 3 in structure "value" packed unaligned dcl 2-114 in procedure "mrpg_generate_" ref 467 next 3 based pointer level 3 in structure "opn" packed unaligned dcl 2-60 in procedure "mrpg_generate_" ref 333 next 3 based pointer level 3 in structure "field" packed unaligned dcl 2-99 in procedure "mrpg_generate_" ref 939 next 3 based pointer level 3 in structure "stmt" packed unaligned dcl 2-136 in procedure "mrpg_generate_" ref 776 867 next 3 based pointer level 3 in structure "attr" packed unaligned dcl 2-120 in procedure "mrpg_generate_" ref 203 245 742 742 next 3 based pointer level 3 in structure "part" packed unaligned dcl 2-85 in procedure "mrpg_generate_" ref 445 next 3 based pointer level 3 in structure "lines" packed unaligned dcl 2-92 in procedure "mrpg_generate_" ref 947 next 3 based pointer level 3 in structure "report" packed unaligned dcl 2-74 in procedure "mrpg_generate_" ref 506 next 3 based pointer level 3 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" ref 357 548 null builtin function dcl 1620 ref 31 37 41 45 48 52 56 59 62 65 70 120 193 237 243 263 319 325 363 398 420 433 450 474 513 521 625 641 703 742 782 798 801 992 1352 1356 1399 1410 1546 numb 6 based fixed bin(24,0) level 2 dcl 2-114 ref 463 number 6 based fixed bin(17,0) level 2 packed unaligned dcl 2-92 ref 789 numeric 1(09) defined char(1) level 2 packed unaligned dcl 922 set ref 887* 897* onlist 12 based structure level 2 packed unaligned dcl 2-74 op 6 based fixed bin(17,0) level 2 packed unaligned dcl 2-60 ref 286 291 298 1041 1053 1065 1077 1089 1101 1113 1125 1137 1149 1161 1173 1185 1197 1208 1219 1232 1245 1256 1264 1272 1280 1291 1302 1313 1323 1335 1346 1366 1376 1387 1397 1408 1419 1429 1439 1451 1461 1471 1481 1491 1501 1511 1521 1530 1540 1556 op1 7 based pointer level 2 packed unaligned dcl 2-60 set ref 322 1044* 1056* 1068* 1080* 1092* 1104* 1116* 1128* 1140* 1152* 1164* 1176* 1188* 1199* 1211* 1222* 1235* 1247* 1284* 1295* 1306* 1316* 1327* 1339* 1350* 1369* 1378* 1390* 1399 1399* 1410 1410* 1421* 1431* 1442* 1453* 1463* 1473* 1483* 1493* 1503* 1513* 1532* 1543* 1558* op2 10 based pointer level 2 packed unaligned dcl 2-60 set ref 325 328 1046* 1058* 1070* 1082* 1094* 1106* 1118* 1130* 1142* 1154* 1166* 1178* 1190* 1201* 1213* 1225* 1238* 1249* 1352 1354* 1380* 1402* 1413* 1423* 1433* 1444* 1455* 1465* 1475* 1485* 1495* 1505* 1515* 1524* 1534* 1545* 1560* op3 11 based pointer level 2 packed unaligned dcl 2-60 set ref 1356 1358* 1546 1549* opn based structure level 1 unaligned dcl 2-60 opptr 001266 automatic pointer dcl 2-59 set ref 319* 319* 322 325 328* 333 optr 001102 automatic pointer dcl 1597 set ref 30* 31 32 33* 33 94* 97* 615* 961* ose 001100 automatic fixed bin(24,0) dcl 1596 set ref 99* 615 961* 973* p 001116 automatic pointer array level 2 dcl 1-3 set ref 110* 113* 116* 122* 135* 137* 178* 199* 223* 241* 269* 275* 288* 288* 293* 295* 300* 302* 306* 306* 323* 329* 344* 351* 370* 376* 411* 436* 439* 454* 457* 459* 459 479* 487* 500* 519* 524* 528* 536* 544* 562* 567* 572* 577* 582* 608* 637* 665* 669* 672* 686* 698* 711* 714* 730* 733* 785* 792* 812* 826* 829* 832* 852* 855* 859* 872* 907* 929* 933* 943* 955* paptr 001304 automatic pointer dcl 2-127 set ref 168* 173* 176 187 189 192 205* 205 214* 218* 221 231 233 236 247* 247 param based structure level 1 unaligned dcl 2-128 parm_check 10 based structure level 2 packed unaligned dcl 2-7 parm_key 5 based structure level 2 packed unaligned dcl 2-7 parm_pos 2 based structure level 2 packed unaligned dcl 2-7 part based structure level 1 unaligned dcl 2-85 in procedure "mrpg_generate_" part 16 based structure level 2 in structure "report" packed unaligned dcl 2-74 in procedure "mrpg_generate_" partptr 001272 automatic pointer dcl 2-84 set ref 398* 398* 402 406 415 433 436* 445 782 pkey_ct 7 based fixed bin(17,0) level 2 dcl 2-7 set ref 39* 140 148 152 169 215 pl 7 based fixed bin(24,0) level 2 dcl 2-74 ref 384 pos 7 based fixed bin(17,0) level 2 dcl 2-46 ref 341 533 ppos_ct 4 based fixed bin(17,0) level 2 dcl 2-7 set ref 35* 140 148 151 169 169 169 215 215 215 pt 000402 automatic char(3) unaligned dcl 1587 set ref 366* 367 368* 370 372 402 409 439 446 470* pw 6 based fixed bin(24,0) level 2 dcl 2-74 ref 380 rc 000403 automatic char(1) unaligned dcl 1588 set ref 367* 395 398 404 rec_str 16 based fixed bin(17,0) level 2 packed unaligned dcl 2-7 set ref 54* 126 ref1 6 based structure level 2 packed unaligned dcl 2-136 ref2 10 based structure level 2 packed unaligned dcl 2-136 ref3 12 based structure level 2 packed unaligned dcl 2-136 release_seg_ptr_ 000212 constant entry external dcl 1585 ref 97 615 report based structure level 1 unaligned dcl 2-74 in procedure "mrpg_generate_" report 22 based structure level 2 in structure "tree" packed unaligned dcl 2-7 in procedure "mrpg_generate_" repptr 001270 automatic pointer dcl 2-73 set ref 363* 363* 374 380 384 388 392 398 420 450 474* 506 res_siz 16(18) based fixed bin(17,0) level 2 packed unaligned dcl 2-7 set ref 54* 130 reverse builtin function dcl 1620 ref 954 right 0(27) defined char(1) level 2 packed unaligned dcl 922 set ref 898* rlen parameter fixed bin(17,0) dcl 985 set ref 983 997* rptr parameter pointer dcl 985 set ref 983 996* s_n constant fixed bin(17,0) initial dcl 2-229 ref 298 1264 s_s constant fixed bin(17,0) initial dcl 2-230 ref 1272 space 1(18) defined char(1) level 2 packed unaligned dcl 922 set ref 888* 917* srefptr 001264 automatic pointer dcl 2-54 set ref 176* 177 197* 198 221* 222 271* 272 374* 375 406* 407 420* 420* 424* 426 474* 474* 477* 495 520* 521 523 663* 664 674 684* 685 717* 721* 723 725 728 824* 825 834 850* 851 857* 858 870* 871 stmt based structure level 1 unaligned dcl 2-136 stmtp parameter pointer unaligned dcl 622 ref 620 625 stmtptr 001306 automatic pointer dcl 2-135 set ref 625* 625* 628 629 637 657 657 663 669 672 679 684 691 691 691 698 703 703 746 769 772 774* 776 801* 801* 805 815* 867 stop_mrpg 001110 stack reference condition dcl 1607 ref 27 stop_sw 000174 internal static bit(1) initial unaligned dcl 1612 set ref 27 1616* 1617* substr builtin function dcl 1620 set ref 367 368* 926* 955 sym 4 based pointer level 3 in structure "param" packed unaligned dcl 2-128 in procedure "mrpg_generate_" ref 176 221 sym 4 based pointer level 3 in structure "part" packed unaligned dcl 2-85 in procedure "mrpg_generate_" ref 406 sym 4 based pointer level 3 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" ref 271 520 sym 4 based pointer level 3 in structure "value" packed unaligned dcl 2-114 in procedure "mrpg_generate_" set ref 460* 870 1020* sym 4 based pointer level 3 in structure "symref" packed unaligned dcl 2-55 in procedure "mrpg_generate_" set ref 177 198 222 272 322 328 375 407 424 477 523 664 685 728 825 851 858 871 1025* sym 4 based pointer level 3 in structure "attr" packed unaligned dcl 2-120 in procedure "mrpg_generate_" set ref 197 241* 717 sym 4 based pointer level 3 in structure "report" packed unaligned dcl 2-74 in procedure "mrpg_generate_" ref 374 symref based structure level 1 unaligned dcl 2-55 symtab based structure level 1 unaligned dcl 2-35 symtabptr 001260 automatic pointer dcl 2-34 set ref 70* 70* 73 74 77* 81 177* 178 179 180 198* 199 200 222* 223 224 272* 273 275 276 282 282 282 322* 323 324 328* 329 330 375* 376 377 407* 411 412 424 477* 478 479 480 523* 524 525 664* 665 666 685* 686 687 728* 729 730 732 825* 826 827 851* 852 853 858* 859 860 871* 872 873 875 877 894 917 t_c 000000 constant char(14) initial unaligned dcl 1609 set ref 295 296 300 301 306 307 t_n 000004 constant char(13) initial unaligned dcl 1608 set ref 288 289 293 294 302 303 table based structure level 2 packed unaligned dcl 2-7 tp 000100 automatic pointer dcl 623 set ref 628* 640 641 649 754 755 761 774 tptr 001330 automatic pointer dcl 780 set ref 805* 806 812 815 818 818 824 829 832 839 844 850 855 857 865 tree based structure level 1 unaligned dcl 2-7 tree_ptr 001256 automatic pointer dcl 2-6 set ref 26* 29 29 30 35 35 35 37 37 39 39 39 41 41 43 43 45 45 47 47 48 48 50 50 52 52 54 54 55 56 56 58 58 59 59 61 61 62 62 64 64 65 65 70 120 120 126 130 140 140 148 148 151 152 168 169 169 169 169 173 214 215 215 215 215 218 263 363 513 555 563 568 573 578 583 type based char(2) level 3 in structure "symref" packed unaligned dcl 2-55 in procedure "mrpg_generate_" ref 723 type based char(2) level 3 in structure "symtab" packed unaligned dcl 2-35 in procedure "mrpg_generate_" ref 74 875 894 917 type based char(2) level 3 in structure "value" packed unaligned dcl 2-114 in procedure "mrpg_generate_" set ref 454 type based char(2) level 3 in structure "stmt" packed unaligned dcl 2-136 in procedure "mrpg_generate_" set ref 629 657 657 672 679 691 691 691 698 746 769 772* 806 818 818 832 839 844 865* 1018 1023 1029 1029 1029 1037 type based char(2) level 3 in structure "attr" packed unaligned dcl 2-120 in procedure "mrpg_generate_" ref 194 238 712 type based char(2) level 3 in structure "part" packed unaligned dcl 2-85 in procedure "mrpg_generate_" ref 402 type based char(2) level 3 in structure "datum" packed unaligned dcl 2-46 in procedure "mrpg_generate_" ref 74 use 4 based structure level 2 packed unaligned dcl 2-35 valptr 001300 automatic pointer dcl 2-113 set ref 450* 450* 454 457 460 463* 467 869* 870 value based structure level 1 unaligned dcl 2-114 in procedure "mrpg_generate_" value 6 based structure level 2 in structure "field" packed unaligned dcl 2-99 in procedure "mrpg_generate_" version 000010 constant char(32) initial unaligned dcl 101 set ref 110 111 vtemp 000167 automatic varying char(512) dcl 1580 set ref 119* 122 123 456* 461 543* 587* 588* 588 590* 590 592* 592 594* 594 596* 596 598* 598 600* 600 602* 602 604* 604 606* 606 608 609 668* 804* 990* 996 997 1033* 1033 1043* 1043 1045* 1045 1047* 1047 1055* 1055 1057* 1057 1059* 1059 1067* 1067 1069* 1069 1071* 1071 1079* 1079 1081* 1081 1083* 1083 1091* 1091 1093* 1093 1095* 1095 1103* 1103 1105* 1105 1107* 1107 1115* 1115 1117* 1117 1119* 1119 1127* 1127 1129* 1129 1131* 1131 1139* 1139 1141* 1141 1143* 1143 1151* 1151 1153* 1153 1155* 1155 1163* 1163 1165* 1165 1167* 1167 1175* 1175 1177* 1177 1179* 1179 1187* 1187 1189* 1189 1191* 1191 1200* 1200 1202* 1202 1210* 1210 1212* 1212 1214* 1214 1221* 1221 1224* 1224 1226* 1226 1234* 1234 1237* 1237 1239* 1239 1248* 1248 1250* 1250 1258* 1258 1266* 1266 1274* 1274 1283* 1283 1285* 1285 1294* 1294 1296* 1296 1305* 1305 1307* 1307 1315* 1315 1317* 1317 1326* 1326 1328* 1328 1338* 1338 1340* 1340 1349* 1349 1351* 1351 1352* 1352 1355* 1355 1356* 1356 1359* 1359 1368* 1368 1370* 1370 1379* 1379 1381* 1381 1389* 1389 1391* 1391 1401* 1401 1412* 1412 1422* 1422 1432* 1432 1441* 1441 1443* 1443 1445* 1445 1454* 1454 1464* 1464 1474* 1474 1484* 1484 1494* 1494 1504* 1504 1514* 1514 1523* 1523 1533* 1533 1542* 1542 1544* 1544 1548* 1548 1551* 1551 1559* 1559 1567* 1567 xptr parameter pointer unaligned dcl 1016 in procedure "regen" ref 1014 1018 1020 1023 1025 1029 1029 1029 1033 1037 1041 1044 1046 1053 1056 1058 1065 1068 1070 1077 1080 1082 1089 1092 1094 1101 1104 1106 1113 1116 1118 1125 1128 1130 1137 1140 1142 1149 1152 1154 1161 1164 1166 1173 1176 1178 1185 1188 1190 1197 1199 1201 1208 1211 1213 1219 1222 1225 1232 1235 1238 1245 1247 1249 1256 1264 1272 1280 1284 1291 1295 1302 1306 1313 1316 1323 1327 1335 1339 1346 1350 1352 1354 1356 1358 1366 1369 1376 1378 1380 1387 1390 1397 1399 1399 1402 1408 1410 1410 1413 1419 1421 1423 1429 1431 1433 1439 1442 1444 1451 1453 1455 1461 1463 1465 1471 1473 1475 1481 1483 1485 1491 1493 1495 1501 1503 1505 1511 1513 1515 1521 1524 1530 1532 1534 1540 1543 1545 1546 1549 1556 1558 1560 xptr 000100 automatic pointer dcl 988 in procedure "expr" set ref 991* 992 994 yyddd 33(01) based bit(1) level 3 packed unaligned dcl 2-7 ref 583 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Align internal static fixed bin(17,0) initial dcl 2-161 Begw internal static fixed bin(17,0) initial dcl 2-217 Center internal static fixed bin(17,0) initial dcl 2-158 Chard internal static fixed bin(17,0) initial dcl 2-151 Charn internal static fixed bin(17,0) initial dcl 2-155 Contw internal static fixed bin(17,0) initial dcl 2-219 DecSpec internal static fixed bin(17,0) initial dcl 2-166 Edit internal static fixed bin(17,0) initial dcl 2-156 Endw internal static fixed bin(17,0) initial dcl 2-218 Fill internal static fixed bin(17,0) initial dcl 2-160 Fold internal static fixed bin(17,0) initial dcl 2-162 Integer internal static fixed bin(17,0) initial dcl 2-152 Left internal static fixed bin(17,0) initial dcl 2-157 Nbegw internal static fixed bin(17,0) initial dcl 2-220 Ncontw internal static fixed bin(17,0) initial dcl 2-222 Nendw internal static fixed bin(17,0) initial dcl 2-221 Pic internal static fixed bin(17,0) initial dcl 2-154 Right internal static fixed bin(17,0) initial dcl 2-159 Tabled internal static fixed bin(17,0) initial dcl 2-167 area_ptr automatic pointer dcl 2-4 execptr automatic pointer dcl 1613 head based structure level 1 unaligned dcl 2-69 headptr automatic pointer dcl 2-68 macro_$expand 000000 constant entry external dcl 1-10 mrpg 000000 constant entry external dcl 1606 mrpg_dump_ 000000 constant entry external dcl 1573 op_char internal static varying char(8) initial array dcl 2-241 space based area(1024) dcl 2-3 string builtin function dcl 1620 symbol_leng automatic fixed bin(24,0) dcl 2-43 NAMES DECLARED BY EXPLICIT CONTEXT. br_found 003601 constant label dcl 428 ref 424 dbf 005077 constant entry external dcl 1619 dbn 005017 constant entry external dcl 1614 exec_loop 006227 constant label dcl 806 ref 816 exit 004735 constant label dcl 613 set ref 976 expr 007260 constant entry internal dcl 983 ref 241 351 436 457 544 637 669 792 812 829 855 lgf 005066 constant entry external dcl 1618 lgn 005031 constant entry external dcl 1615 macro 007103 constant entry internal dcl 959 ref 144 162 208 242 257 316 332 335 354 395 441 466 494 504 510 547 553 559 612 639 647 655 677 689 700 740 744 752 760 766 796 814 837 862 938 946 961 961 mrpg_generate_ 000560 constant entry external dcl 16 number 007035 constant entry internal dcl 950 ref 127 131 141 155 158 184 190 228 234 254 342 349 381 385 389 393 416 430 464 485 492 534 541 634 646 654 675 738 751 759 765 790 835 880 884 904 912 916 pic_edit 006374 constant label dcl 847 ref 842 put_part 006105 constant entry internal dcl 778 ref 443 regen 007325 constant entry internal dcl 1014 ref 120 460 994 1020 1025 1044 1046 1056 1058 1068 1070 1080 1082 1092 1094 1104 1106 1116 1118 1128 1130 1140 1142 1152 1154 1164 1166 1176 1178 1188 1190 1199 1201 1211 1213 1222 1225 1235 1238 1247 1249 1284 1295 1306 1316 1327 1339 1350 1354 1358 1369 1378 1380 1390 1399 1402 1410 1413 1421 1423 1431 1433 1442 1444 1453 1455 1463 1465 1473 1475 1483 1485 1493 1495 1503 1505 1513 1515 1524 1532 1534 1543 1545 1549 1558 1560 stmt_exp 005111 constant entry internal dcl 620 ref 555 640 649 754 755 761 stopf 005055 constant entry external dcl 1617 stopn 005043 constant entry external dcl 1616 NAME DECLARED BY CONTEXT OR IMPLICATION. codeptr builtin function ref 961 961 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 13602 14034 13331 13612 Length 14330 13331 232 260 251 170 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mrpg_generate_ 858 external procedure is an external procedure. on unit on line 95 78 on unit stmt_exp 116 internal procedure calls itself recursively. put_part internal procedure shares stack frame of external procedure mrpg_generate_. number 68 internal procedure is called by several nonquick procedures. macro 112 internal procedure is called by several nonquick procedures. expr 74 internal procedure is called by several nonquick procedures. regen 76 internal procedure calls itself recursively. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 digit mrpg_generate_ 000014 I_day mrpg_generate_ 000016 I_hhmmss mrpg_generate_ 000020 I_mmddyy mrpg_generate_ 000022 I_month mrpg_generate_ 000024 I_yyddd mrpg_generate_ 000026 kind_char mrpg_generate_ 000172 db_sw mrpg_generate_ 000173 lg_sw mrpg_generate_ 000174 stop_sw mrpg_generate_ 000175 A stmt_exp 000176 D stmt_exp STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME expr 000100 xptr expr mrpg_generate_ 000100 err_sw mrpg_generate_ 000101 dname mrpg_generate_ 000153 dnamel mrpg_generate_ 000154 LINE mrpg_generate_ 000155 P_skip mrpg_generate_ 000156 P_stop mrpg_generate_ 000157 P_bool_char mrpg_generate_ 000160 P_bool_dec mrpg_generate_ 000161 P_char_bool mrpg_generate_ 000162 P_char_dec mrpg_generate_ 000163 P_dec_bool mrpg_generate_ 000164 P_dec_char mrpg_generate_ 000165 P_int mrpg_generate_ 000166 P_if mrpg_generate_ 000167 vtemp mrpg_generate_ 000370 name mrpg_generate_ 000401 bc mrpg_generate_ 000402 pt mrpg_generate_ 000403 rc mrpg_generate_ 000404 dflt_sw mrpg_generate_ 000405 msg mrpg_generate_ 001000 failed mrpg_generate_ 001001 macname mrpg_generate_ 001012 ds mrpg_generate_ 001100 ose mrpg_generate_ 001102 optr mrpg_generate_ 001104 i mrpg_generate_ 001105 argct mrpg_generate_ 001106 max_name mrpg_generate_ 001116 argl mrpg_generate_ 001256 tree_ptr mrpg_generate_ 001260 symtabptr mrpg_generate_ 001262 daptr mrpg_generate_ 001264 srefptr mrpg_generate_ 001266 opptr mrpg_generate_ 001270 repptr mrpg_generate_ 001272 partptr mrpg_generate_ 001274 linptr mrpg_generate_ 001276 fldptr mrpg_generate_ 001300 valptr mrpg_generate_ 001302 atptr mrpg_generate_ 001304 paptr mrpg_generate_ 001306 stmtptr mrpg_generate_ 001330 tptr put_part 001332 P_ctl put_part number 000100 i number stmt_exp 000100 tp stmt_exp THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs unpk_to_pk call_ext_out_desc call_ext_out call_int_this call_int_other return tra_ext signal enable shorten_stack ext_entry int_entry set_cs_eis index_before_cs THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ get_seg_ptr_ hcs_$fs_get_path_name ioa_ macro_ macro_$free mrpg_dump_$all mrpg_dump_$list mrpg_error_ release_seg_ptr_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badsyntax error_table_$translation_aborted error_table_$translation_failed LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 16 000553 23 000565 25 000577 26 000600 27 000604 28 000611 29 000615 30 000642 31 000644 32 000650 33 000665 34 000670 35 000671 37 000724 39 000742 41 000772 43 001010 45 001037 47 001055 48 001104 50 001122 52 001146 54 001164 55 001212 56 001234 58 001252 59 001301 61 001317 62 001346 64 001364 65 001412 68 001430 70 001431 73 001440 74 001443 77 001453 79 001515 81 001517 83 001523 85 001525 86 001530 88 001531 91 001535 93 001540 94 001556 95 001627 96 001644 97 001652 98 001670 99 001671 108 001672 110 001727 111 001731 113 001733 114 001735 116 001737 117 001743 119 001745 120 001746 122 001761 123 001765 125 001767 126 001771 127 002004 129 002011 130 002013 131 002027 133 002033 134 002035 135 002037 137 002052 139 002054 140 002056 141 002074 143 002100 144 002104 148 002110 151 002115 152 002124 154 002133 155 002135 157 002141 158 002143 160 002147 161 002154 162 002156 164 002162 166 002167 167 002170 168 002171 169 002174 170 002211 172 002214 173 002215 174 002220 176 002221 177 002224 178 002226 179 002230 180 002232 182 002236 183 002240 184 002251 186 002255 187 002257 189 002274 190 002306 192 002312 193 002322 194 002326 196 002332 197 002333 198 002336 199 002340 200 002344 201 002347 202 002350 203 002352 204 002355 205 002356 208 002361 209 002365 211 002412 213 002414 214 002421 215 002424 216 002441 218 002444 219 002447 221 002450 222 002453 223 002455 224 002457 226 002461 227 002463 228 002474 230 002500 231 002502 233 002517 234 002531 236 002535 237 002545 238 002552 240 002556 241 002560 242 002573 243 002577 244 002601 245 002602 246 002605 247 002606 249 002611 252 002636 253 002640 254 002651 255 002655 256 002657 257 002663 262 002667 263 002673 267 002702 268 002715 269 002717 271 002721 272 002724 273 002726 275 002740 276 002742 278 002744 282 002756 286 003021 288 003027 289 003033 290 003036 291 003037 293 003041 294 003043 295 003045 296 003047 297 003051 298 003052 300 003054 301 003056 302 003060 303 003062 304 003064 306 003065 307 003071 309 003074 311 003102 312 003104 314 003111 316 003115 318 003121 319 003123 322 003132 323 003136 324 003140 325 003142 327 003146 328 003150 329 003153 330 003155 332 003157 333 003163 334 003167 335 003170 336 003174 338 003200 340 003201 341 003203 342 003214 344 003220 345 003231 347 003233 348 003235 349 003253 351 003260 353 003273 354 003275 357 003301 363 003305 366 003314 367 003320 368 003324 369 003326 370 003332 371 003334 372 003336 374 003346 375 003351 376 003353 377 003355 379 003357 380 003361 381 003373 383 003377 384 003401 385 003413 387 003417 388 003421 389 003433 391 003437 392 003441 393 003453 395 003457 398 003466 402 003500 404 003511 406 003514 407 003517 408 003521 409 003523 411 003533 412 003535 414 003537 415 003541 416 003553 417 003557 419 003560 420 003561 423 003570 424 003571 426 003576 428 003601 430 003613 433 003617 435 003623 436 003625 438 003637 439 003643 440 003645 441 003647 443 003653 445 003654 446 003660 448 003670 449 003674 450 003676 453 003706 454 003710 456 003712 457 003713 459 003726 460 003732 461 003741 463 003744 464 003757 466 003763 467 003767 470 003773 472 004003 473 004007 474 004010 477 004020 478 004023 479 004025 480 004027 482 004031 483 004032 484 004034 485 004045 487 004051 488 004062 490 004064 491 004066 492 004104 494 004111 495 004115 497 004121 499 004172 500 004176 501 004203 503 004205 504 004206 506 004212 508 004216 509 004222 510 004223 512 004227 513 004234 517 004244 518 004257 519 004261 520 004263 521 004266 523 004272 524 004274 525 004276 526 004300 528 004301 529 004304 532 004305 533 004307 534 004321 536 004325 537 004336 539 004340 540 004342 541 004360 543 004365 544 004366 546 004401 547 004403 548 004407 551 004413 552 004417 553 004420 555 004424 557 004433 558 004437 559 004440 561 004444 562 004446 563 004451 565 004460 567 004461 568 004463 570 004471 572 004472 573 004474 575 004502 577 004503 578 004505 580 004513 582 004514 583 004516 585 004524 587 004525 588 004526 590 004542 592 004556 594 004572 596 004606 598 004622 600 004636 602 004652 604 004666 606 004702 608 004716 609 004722 611 004724 612 004730 613 004735 615 004744 616 004763 618 005012 619 005015 1614 005016 1614 005024 1614 005027 1615 005030 1615 005036 1615 005041 1616 005042 1616 005050 1616 005053 1617 005054 1617 005062 1617 005064 1618 005065 1618 005073 1618 005075 1619 005076 1619 005104 1619 005107 620 005110 625 005116 628 005133 629 005135 631 005142 632 005146 633 005150 634 005156 636 005163 637 005166 639 005202 640 005207 641 005217 643 005223 644 005230 645 005232 646 005240 647 005245 649 005252 651 005262 652 005267 653 005271 654 005277 655 005304 656 005311 657 005312 660 005316 661 005322 663 005324 664 005326 665 005330 666 005332 668 005334 669 005335 671 005351 672 005354 674 005356 675 005375 677 005402 678 005407 679 005410 681 005412 682 005416 684 005420 685 005422 686 005424 687 005426 689 005430 690 005435 691 005436 695 005444 696 005450 697 005452 698 005454 700 005456 702 005463 703 005466 711 005501 712 005505 714 005511 716 005517 717 005521 718 005523 720 005524 721 005525 723 005527 725 005533 726 005564 728 005565 729 005570 730 005572 732 005574 733 005576 734 005605 736 005607 737 005611 738 005627 740 005635 742 005642 743 005672 744 005673 745 005700 746 005701 748 005703 749 005707 750 005711 751 005717 752 005724 754 005731 755 005741 756 005751 757 005756 758 005760 759 005766 760 005773 761 006000 762 006010 763 006015 764 006017 765 006025 766 006032 768 006037 769 006040 772 006043 774 006075 776 006100 777 006104 778 006105 782 006106 785 006116 786 006123 788 006125 789 006127 790 006145 792 006151 794 006166 795 006170 796 006174 798 006200 801 006214 804 006224 805 006225 806 006227 809 006234 811 006240 812 006242 814 006255 815 006261 816 006264 818 006265 821 006271 822 006275 824 006277 825 006302 826 006304 827 006306 829 006310 831 006323 832 006325 834 006327 835 006346 837 006352 838 006356 839 006357 841 006361 842 006365 844 006366 846 006370 847 006374 850 006376 851 006401 852 006403 853 006405 855 006407 857 006422 858 006425 859 006427 860 006431 862 006433 863 006437 865 006440 867 006472 868 006476 869 006503 870 006506 871 006510 872 006512 873 006514 875 006516 877 006523 878 006525 879 006527 880 006544 882 006550 883 006552 884 006571 885 006575 887 006602 888 006604 891 006613 893 006614 894 006616 896 006620 897 006631 898 006633 900 006642 902 006643 904 006654 906 006660 907 006662 910 006665 911 006667 912 006701 914 006705 915 006707 916 006721 917 006725 920 006736 924 006740 926 006745 928 006761 929 006763 931 006765 932 006767 933 006771 937 006773 938 006777 939 007003 940 007007 941 007013 943 007015 944 007022 946 007023 947 007027 949 007033 950 007034 954 007042 955 007060 956 007075 958 007100 959 007102 961 007110 963 007160 965 007164 968 007171 969 007173 971 007174 973 007177 974 007200 975 007202 976 007232 978 007235 979 007253 982 007256 983 007257 990 007265 991 007267 992 007276 994 007302 996 007312 997 007320 998 007323 1014 007324 1018 007332 1020 007346 1021 007355 1023 007356 1025 007360 1026 007367 1029 007370 1033 007376 1034 007411 1037 007412 1041 007414 1043 007421 1044 007431 1045 007440 1046 007453 1047 007470 1048 007500 1053 007501 1055 007503 1056 007516 1057 007525 1058 007535 1059 007552 1060 007565 1065 007566 1067 007570 1068 007603 1069 007612 1070 007622 1071 007637 1072 007652 1077 007653 1079 007655 1080 007670 1081 007677 1082 007712 1083 007727 1084 007742 1089 007743 1091 007745 1092 007760 1093 007767 1094 010002 1095 010017 1096 010032 1101 010033 1103 010035 1104 010050 1105 010057 1106 010067 1107 010104 1108 010117 1113 010120 1115 010122 1116 010135 1117 010144 1118 010154 1119 010171 1120 010204 1125 010205 1127 010207 1128 010222 1129 010231 1130 010244 1131 010261 1132 010274 1137 010275 1139 010277 1140 010312 1141 010321 1142 010334 1143 010351 1144 010364 1149 010365 1151 010367 1152 010402 1153 010411 1154 010424 1155 010441 1156 010454 1161 010455 1163 010457 1164 010472 1165 010501 1166 010514 1167 010531 1168 010544 1173 010545 1175 010547 1176 010562 1177 010571 1178 010604 1179 010621 1180 010634 1185 010635 1187 010637 1188 010652 1189 010661 1190 010674 1191 010711 1192 010724 1197 010725 1199 010727 1200 010736 1201 010746 1202 010763 1203 010773 1208 010774 1210 010776 1211 011006 1212 011015 1213 011025 1214 011042 1215 011052 1219 011053 1221 011055 1222 011070 1223 011077 1224 011102 1225 011114 1226 011131 1227 011144 1232 011145 1234 011147 1235 011162 1236 011171 1237 011174 1238 011206 1239 011223 1240 011236 1245 011237 1247 011241 1248 011250 1249 011260 1250 011275 1251 011305 1256 011306 1258 011310 1259 011323 1264 011324 1266 011326 1267 011341 1272 011342 1274 011344 1275 011357 1280 011360 1282 011362 1283 011365 1284 011377 1285 011406 1286 011416 1291 011417 1293 011421 1294 011424 1295 011436 1296 011445 1297 011455 1302 011456 1304 011460 1305 011463 1306 011475 1307 011504 1308 011517 1313 011520 1315 011522 1316 011535 1317 011544 1318 011554 1323 011555 1325 011557 1326 011562 1327 011574 1328 011603 1329 011613 1335 011614 1337 011616 1338 011621 1339 011633 1340 011642 1341 011652 1346 011653 1348 011655 1349 011660 1350 011672 1351 011701 1352 011711 1354 011736 1355 011745 1356 011755 1358 012002 1359 012011 1360 012021 1366 012022 1368 012024 1369 012037 1370 012046 1371 012061 1376 012062 1378 012064 1379 012073 1380 012103 1381 012120 1382 012130 1387 012131 1389 012133 1390 012143 1391 012152 1392 012162 1397 012163 1399 012165 1401 012177 1402 012207 1403 012224 1408 012225 1410 012227 1412 012241 1413 012251 1414 012266 1419 012267 1421 012271 1422 012300 1423 012310 1424 012325 1429 012326 1431 012330 1432 012337 1433 012347 1434 012364 1439 012365 1441 012367 1442 012402 1443 012411 1444 012421 1445 012436 1446 012446 1451 012447 1453 012451 1454 012460 1455 012473 1456 012510 1461 012511 1463 012513 1464 012522 1465 012532 1466 012547 1471 012550 1473 012552 1474 012561 1475 012574 1476 012611 1481 012612 1483 012614 1484 012623 1485 012636 1486 012653 1491 012654 1493 012656 1494 012665 1495 012700 1496 012715 1501 012716 1503 012720 1504 012727 1505 012737 1506 012754 1511 012755 1513 012757 1514 012766 1515 012776 1516 013013 1521 013014 1523 013016 1524 013026 1525 013035 1530 013036 1532 013040 1533 013047 1534 013057 1535 013074 1540 013075 1542 013077 1543 013112 1544 013121 1545 013131 1546 013146 1548 013157 1549 013167 1551 013176 1552 013206 1556 013207 1558 013211 1559 013220 1560 013230 1561 013245 1567 013246 1571 013261 ----------------------------------------------------------- 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